黑马程序员-IO流 01

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------

IO(Input  Output)流
IO流用来处理设备之间的数据传输
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中
流按操作数据分为两种：字节流与字符流。
    通用：字节流，字符流基于字节流
流按流向分为：输入流，输出流。
1. IO流常用基类(父类)
字节流的抽象基类：
InputStream ，OutputStream。
字符流的抽象基类：
Reader ， Writer。
注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
    Reader的子类FileReader
 
close和flush区别？
flush刷新后，流可以继续使用，close刷新后，会将流关闭。
2.字符流
 专门处理字符数据，文本数据
2.1字符流——创建文件
   创建流对象，建立数据存放文件。如果有，就直接覆盖
FileWriter fw = new FileWriter(“Test.txt”);
   调用流对象的写入方法，将数据写入流，流在机器的内存中
fw.write(“text”);
   关闭流资源，并将流中的数据清空到文件中。
fw.close();
不写close方法会有什么结果呢？
如果想在原有文件上继续加入新的数据呢？FileWriter fw = new FileWriter(“Test.txt”,true);
 
2.2 字符流——读取文件
    建立一个流对象，将已存在的一个文件加载进流。
FileReader fr = new FileReader(“Test.txt”);
    创建一个临时存放数据的数组。
char[] ch = new char[1024];
    调用流对象的读取方法将流中的数据读入到数组中。
fr.read(ch);
思考：
在加载文件时候是否是将文件全部加载进流
为什么定义数组，要定义多大呢？
 
注意：
定义文件路径时，可以用“/”或者“\\”。
在创建一个文件时，如果目录下有同名文件将被覆盖。
在读取文件时，必须保证该文件已存在，否则出异常。
 练习：Reader中FileReader的应用
import java.io.*;  
class FileReaderDemo  {  
                    //创建一个文件读取流对象，和指定名称的文件相关联。  
                   //要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException 
                   FileReader fr = new FileReader("demo.txt");  
                   //调用读取流对象的read方法。  
                   //read():一次读一个字符。而且会自动往下读。  
                    
                   int ch = 0;  
                   while((ch=fr.read())!=-1)  {  
                            System.out.println("ch="+(char)ch); 
                   }               
                   fr.close();  
         }  
}  
/* 
第二种方式：通过字符数组进行读取。 
*/  
import java.io.*;  
class FileReaderDemo2  {  
         public static void main(String[] args) throws IOException  {  
                   FileReader fr = new FileReader("demo.txt");   
                   //定义一个字符数组。用于存储读到字符。  
                   //该read(char[])返回的是读到字符个数。  
                   char[]buf = new char[1024];  
   
                   int num = 0;  
                   while((num=fr.read(buf))!=-1)  {  //将读取到字符存入数组，返回读取的字符数，如果到达流的末尾返回-1
                            System.out.println(newString(buf,0,num));  
                   }   
                   fr.close();  
         }  
}  

3. IO异常的标准处理方式
import java.io.*;
class FileWriterDemo1 
{
	public static void main(String[] args) 
	{
//try外，声明变量，try内建立对象
		FileWriter fw = null;
		FileWriter fw1 = null;
		try{
		 fw = new FileWriter("demo.txt");
		 fw1 = new FileWriter("demo1.txt");
		 fw.write("sssss");
		 fw.flush();
 
		 fw1.write("kkkk");
		 fw1.flush();
		}catch(IOException e){
		   e.printStackTrace() ;
		}finally{
			try{
			  if(fw!=null)
			  fw.close();
			}catch(IOException e){
				 e.printStackTrace() ;
			}
 
			try{
			   if(fw1!=null)
				   fw1.close();
			}catch(IOException e){
				e.printStackTrace() ;
			}
		}	
	}
} 

4.字符流复制文本文件
练习：将C盘一个文本文件复制到D盘（两种方法）
 
/* 
复制的原理： 
其实就是将C盘下的文件数据存储到D盘的一个文件中。 
步骤： 
1，在D盘创建一个文件。用于存储C盘文件中的数据。 
2，定义读取流和C盘文件关联。 
3，通过不断的读写完成数据存储。 
4，关闭资源。 
*/    
import java.io.*;  
class CopyText  {  
         publicstatic void main(String[] args) throws IOException {  
                   copy_2( );  
         }  
 
         public static void copy_2()  {  
                   FileWriter fw = null;  
                   FileReader fr = null;  
                   try  {  
                            fw= new FileWriter("SystemDemo_copy.txt");  
                            fr= new FileReader("SystemDemo.java");  
   
                            char[] buf = new char[1024];  
   
                            int len = 0;  
                            while((len=fr.read(buf))!=-1)  {  
                                     fw.write(buf,0,len);  
                            }  
                   }  
                   catch(IOException e) {  
                            throw new RuntimeException("读写失败");   
                   }  
                   finally  {  
                            if(fr!=null)  
                                     try   {  
                                               fr.close();  
                                     }  
                                     catch(IOException e)  {  
                                     }  
                            if(fw!=null)  
                                     try   {  
                                               fw.close();  
                                     }  
                                     catch(IOException e) {  
                                     }  
                   }  
         }  
   
         //从C盘读一个字符，就往D盘写一个字符。  
         public static void copy_1( )throws IOException {  
                   //创建目的地。  
                   FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");  
   
                   //与已有文件关联。  
                   FileReader fr = new FileReader("RuntimeDemo.java");  
   
                   int ch = 0;  
   
                   while((ch=fr.read())!=-1)  {  
                            fw.write(ch);  
                   }  
                   fw.close();  
                   fr.close();  
         }  
}  

5.字符流的缓冲区 
  |-- BufferedWriter 提高流的操作效率
     |-- 构造方法，传递一个字符输出流对象
     |-- 自己的方法 newLine()写一个换行，跨平台性
  |-- BufferedReader
     |-- 构造方法，传递一个字符输入流对象
     |-- 自己的方法 readLine()读取文本一行，返回字符串，没有换行符号，文件结尾返回null
练习：通过缓冲区复制一个.java文件
 
import java.io.*; 
class CopyTextByBuf  {  
         public static void main(String[] args)   {  
                   BufferedReader bufr = null;  
                   BufferedWriter bufw = null;  
   
                 try   {  
                bufr=newBufferedReader(newFileReader("BufferedWriterDemo.java"));  
                bufw= new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));  
   
                            String line = null;   
                            while((line=bufr.readLine())!=null)   {  
                                     bufw.write(line);  
                                     bufw.newLine();  
                                     bufw.flush();  
                            }  
                   }  
                   catch(IOException e) {  
                            throw new RuntimeException("读写失败");  
                   }  
                   finally  {  
                            try  {  
                                     if(bufr!=null)  
                                               bufr.close();  
                            }  
                            catch(IOException e)  {  
                                     throw new RuntimeException("读取关闭失败");  
                            }  
                            try {  
                                     if(bufw!=null)  
                                               bufw.close();  
                            }  
                            catch(IOException e)  {  
                                     throw new RuntimeException("写入关闭失败");  
                            }  
                   }  
         }  
}  

6.装饰设计模式
    当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么自定义的该类称为装饰类。
装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。
class Person{
	public void eat(){
		System.out.println("人要吃饭");
	}
}
class NewPerson{
//扩展一下原有的人的吃饭功能
//如果没有原有的人的吃饭的功能，这个类独立存在就没有意义了
//出现增强了原有人类的吃饭的功能， 装饰类：增强原有对象中的功能
//设计思想，解决原有对象中功能不够，不能修改源码，采用一个装饰类，增强功能
	private Person p;
	NewPerson(Person p){ this.p = p;}
	public void newEat(){
		System.out.println("开胃小点心");
		p.eat();
		System.out.println("水果");
		System.out.println("吸烟");
	}
}
public class Demo {
	public static void main(String[] args) {
		NewPerson np = new NewPerson(new Person());
		np.newEat();
	}
}

问题：继承和装饰设计思想有什么区别
 *   继承是面向对象三大特征之一
 *   装饰：设计模式，解决实际的问题的
 
 * 继承的思想，解决一下IO流的问题
  abstract Reader
   文本输入流  TextReader(功能要扩展的话)
       搞一个类继承TextReader覆盖调用读取的方法
      
   音频输入流  AudioReader
       继承AudioReader 覆盖调用读取的方法
     
   动画输入流  MayaReader
       继承 MayaReader 覆盖调用读取的方法
     
   网络输入流 NetReader
       继承 NetReader  覆盖调用读取的方法
 
以上内容分析发现了一个问题，这个继承体系太大，过于臃肿，学习不容易，使用也不容易
===========================================================
 * 装饰设计思想，解决一下IO流的问题
abstract Reader
   文本输入流  TextReader
     
   音频输入流  AudioReader    
     
   动画输入流  MayaReader
      
   网络输入流 NetReader
 *  BufferedReader(Reader r) extends Reader 
提高的Reader类的读取功能read方法
这写功能read方法，会被所有的子类继承，并使用 
BufferedReader（Reader r)中只要传入read的子类就可以，多态的应用
这样分析后，继承体系，简洁明了，容易学习，容易使用
练习：
模拟一个readLine方法
读取需要Reader类中的read()方法读取
import java.io.*;
public class MyReadLineDemo {
//定义Reader对象
	private Reader r;
//构造方法，对Reader对象进行赋值操作,传递的是Reader类型的子类对象
	public MyReadLineDemo(Reader r){ this.r = r;}
//开始模拟readLine
	public String myReadLine()throws IOException{
//定义一个字符串的缓冲区
		StringBuilder sb = new StringBuilder();
		int length = 0 ;
		while((length = r.read())!=-1){
//读取后的字符，赋值给了length变量
			if( length == '\r')
				continue;
			if( length == '\n')//这一行结束了
				return sb.toString();
//两次if都不成立，说明有效字符，存储到缓冲区
			sb.append((char)length);
		}
		if(sb.length()!=0)
			return sb.toString();
		return null;
	}
	public void myClose()throws IOException{ r.close();}
 
}
public class MyReadLineTest {
	public static void main(String[] args) throws IOException{
		MyReadLineDemo my = new MyReadLineDemo(new FileReader("c:\\buffered.txt"));
		String line = null;
		while((line = my.myReadLine())!=null){
			System.out.println(line);
		}
		my.myClose();
	}
}
----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------