java4android32-34Java的io流

本集主要内容.
里面很多很多的类,
java io系统,用了一个很巧妙的设计模式.
         1.I/O操作的目标.
         2.I/O的分类方法.
         3.读取文件和写入文件的方法.
1.I/O操作的目标
 从数据源当中读取数据,以及将数据写入到数据目的地当中.
 
 I/O流向
 

 所谓的输入输出是个方向的问题,
 所谓的方向,必须有一个参照物的物体.
 相对于java应用程序本身.  

 IO的分类.
 第一种分法:
 1.输入流
 2.输出流.
 第二种分法
 1.字节流.
 2.字符流.
 第三种分法
 1.节点流
 2.处理流.
在java的世界里面,所有的东西都是对象.
输入,输出流都是对象.

要有对象,先有类
I/O当中的核心类.
  抽象类  
这4个类是处理字节流核心类,字符流核心类下节课介绍.

         核心类的核心方法
         InputStream 
            intread(byte[] b, int off , int len)
         OutputStream  
           void write(byte[] b ,int off ,in len);      
          

//第一步骤:导入类;
import java.io.*;

class Test{
	public static void main(String args[]){
		//声明输入流引用    
		FileInputStream fis = null;
		//声明输出流引用
		FileOutputStream fos = null;
		try{
		    //生成代表输入流的对象.
			fis = new FileInputStream("g:/srclxm/from.txt");
			//生成代表输出流的对象
			 fos = new FileOutputStream("g:/srclxm/to.txt");
			//生成一个字节数组
			byte [] buffer  = new byte[100];
			//调用输入流对象的read方法,读取数据
			//fis.read(buffer,0,buffer.length);
			int temp =fis.read(buffer,0,buffer.length); 
			fos.write(buffer,0,temp);
			//for(int i = 0; i < buffer.length; i++){
			//	System.out.println(buffer[i]);
				String s = new String(buffer);
				//调用一个String对象的 trim方法,将会去除掉这个字符串
				//的首尾空格和空字符.
				s = s.trim();
	     		<span style="white-space:pre">	</span>System.out.println(s);
				}
		}
		catch(Exception e){
			 System.out.println(e);
			}
		}
}

 总结:
          1. I/O系统的主要目标是为了对数据进行读写操作.
          2.数据的流向以java程序为参照物

          3.I/O流可以有三种分类方法.

          4.read方法和writer方法.        

本集主要内容

         1.大文件的读写方法
         2.字符流的使用方法

import java.io.*;
class Test{
	public static void main(String argsp[]){
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try{
			fis = new FileInputStream("E:/marschen/fileop/form.txt");
			fos = new FileOutputStream("E:/marschen/fileop/to.txt");
			byte [] buffer = new byte[1024];
			while(true){
				int temp = fis.read(buffer,0,buffer.length);
				if(-1 == temp){
					break;
				}
				fos.write(buffer,0,temp);
			}
		}
		catch(Exception e){
			System.out.println(e);
		}		
		finally{
			try{
				fis.close();
				fos.close();
			}
			catch(Exception e){
				System.out.println(e);
			}
	    }
	}
}

//字符流:读写文件时,以字符为基础
//字符输入流:Reader  <----FileReader  int read(char [] c,int off,int len);
//字符输出流:Writer  <----FileWriter  int write(char [] c,int off,int len);

import java.io.*;

public class TestChar{
	public static void main(String args[]){
		FileReader fr = null;
		FileWriter fw = null;
		try{
			fr = new FileReader("E:/marschen/fileop/form.txt");
			fw = new FileWriter("E:/marschen/fileop/to.txt");
			char [] buffer = new char[100];
			int temp = fr.read(buffer,0,buffer.length);
			fw.write(buffer,0,temp);
			/*for(int i = 0; i < buffer.length; i++)
			{
				System.out.println(buffer[i]);
			}*/
    	}
	    catch(Exception e){
	    	System.out.println(e);
	     		
	    }
	    finally{
	    	try{
	    		fr.close();
	    		fw.close(); 
	    	}	
	        catch(Exception e){
	        	System.out.println(e);
	        }
	     }
	}
}

 总结,大文件读写,创建一个数组,用一个循环,每次从文件中读取一部分放入数组
        这个循环当读写到文件尾部的时候,停.

        最后,要记得 file.close();

主要内容

  1.处理流使用实例.
  2. 装饰者模式(Decorator)
  3. 节点流与处理流之间的关系
   
  BufferdReader介绍
    public String raadLine()
            throwsIOException
  Reads a line of text. A line is condsidered to be berminated by any on e of a line 
   

import java.io.*;

class Test{
	public static void main(String args[]){
		FileReader fileReader = null;
		BufferedReader bufferedReader = null;
		try{
			fileReader = new FileReader("E:/marschen/fileop/form.txt");
			bufferedReader = new BufferedReader(fileReader);
			//String line = bufferedReader.readLine();
			//System.out.println(line);
		    String line = null;
			while(true){
				line = bufferedReader.readLine();
				if(line == null){
					break;
				}
				System.out.println(line);
			}
		}
		catch(Exception e){
			System.out.println(e);
		}
		finally{
			try{
				bufferedReader.close();
				fileReader.close();
			}
			catch(Exception e ){
				System.out.println(e);
			}
		}
	}
}

装饰者模式(Decorator) 下面通过5个类来说明 Worker类, Carpenter类,Plumber类, AWorker类,TestWorker类

Worker类, 

 //接口
 interface Worker{ 
	public void doSomeWork();
 }

Carpenter类,

//木匠
class Carpenter implements Worker{
	public void doSomeWork(){
		System.out.println("修门窗");
	}
}

Plumber类, 

//水管工
class Plumber implements Worker{ //实现Worker
	public void doSomeWork(){
		System.out.println("修水管");
	}
}

AWorker类

//水管工
class AWorker implements Worker{ //实现Worker
	public void doSomeWork(){
		System.out.println("修水管");
	}
}

TestWorker类

class TestWorker{
	public static void main(String args[]){
	//生成一个A公司水管工对象
	Plumber plumber = new Plumber();//先生成一个水管工
	AWorker aWorker = new AWorker(plumber); //再生一个A公司员工,并且
	aWorker.doSomeWork();                   //把水管工传入
	
	//生成一个A公司木匠对象
	Carpenter carpenter = new Carpenter();//先生成一个木匠
	AWorker aWorker2 = new AWorker(carpenter);//再生一个A公司员工,并且
	aWorker2.doSomeWork();                       //把木匠传入
	}
}

总结

使用装饰者模式.
不使用继承.
处理流  BufferedReader     相当于工人     是装饰者
节点流  FileReader         相当于水管工   被装饰者.
被装饰者要作为对象传到装饰者里面去.
BufferedReader 可以装饰 读取文件,
                       还可以读取键盘
                       还可以读取网络.                    
处理流是给节点流添加功能
处理流还有很多,比如压缩流,管道流,,,,,,都是在节点流基础上扩展的.在上面添加一些新功能.