思维导图-------java-IO流知识结构梳理

基类文件流 的使用

开始   2018年8月10日16:37:41

结束   2018年8月10日18:24:19

package 面向对象;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.nio.CharBuffer;

public class readfile {
	public static void main(String[] args) throws IOException {
		
//	注释中的是用字节流FileInputStream读取文件
//		FileInputStream fis=null;
//		
//			//创建字节输出流
//			fis=new FileInputStream("E:/Workspaces/MyEclipse 10/yidong/src/面向对象/a.txt");
//		
//			byte[] b=new byte[1024];
//			int hasread=0;
//			while((hasread=fis.read(b))!=-1)
//			{
//				System.out.println(new String(b,0,hasread));
//			
//			
//		}
//	}
//
//		下面是用FileReader读取文件
		FileReader fis=null;
		fis=new FileReader("E:/Workspaces/MyEclipse 10/yidong/src/面向对象/a.txt");
		int length=0;
		
		char[] b=new char[3];
//		read方法返回的是数组长度
//		FileInputStream和FileReader进行文件的读写并没有什么区别，只是操作单元不同而且。FileInputStream和FileReader进行文件的读写并没有什么区别，只是操作单元不同
//		特别注意不能用int数组接收字符流所以二者的数组类型不一样
		while((length=fis.read(b))!=-1)
		{
			System.out.println(length);
//			System.out.println(new String(b,0,length));
		}
		fis.close();
	}
	

}

思维导图

这是文件的读取  FileInputStream和FileReader用法基本相同

同理                    FileOuputStrewam和FileWriter也基本相同 （接收数组不同 字节流与字符流的区别） 如下例

package 面向对象;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.nio.CharBuffer;

public class readfile {
	public static void main(String[] args) throws IOException {
     FileInputStream fis=null;
     FileOutputStream fos=null;
//     创建字节输入流和输出流 文件不存在会自定创建
     fis=new FileInputStream("E:/Workspaces/MyEclipse 10/yidong/src/面向对象/a.txt");
     fos=new FileOutputStream("E:/Workspaces/MyEclipse 10/yidong/src/面向对象/c.txt");
     byte[] b=new byte[1024];
     int length=0;
//     循环读取数据
     while((length=fis.read(b))!=-1)
     {
//    	 把读取到的数据写入文件输出流
    	 fos.write(b);
     }
     fis.close();
     fos.close();
		
	}

}

缓冲流

public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("C:/Users/Mrzhang/javaEE/基础课/javaSE-30/a.txt");
        BufferedReader bufr = new BufferedReader(fr);
        String line = null;

        while((line = bufr.readLine()) != null) {
            System.out.println(line);
        }

        fr.close();
        bufr.close();
    }

字符缓冲流：
  1: BufferedReader： 带有缓冲区的字符输入流。 
   特点： 
   （1）自带缓冲区  就是提高了效率。
   （2）readLine() 一次读取一行。 
   
   构造器： 
    new BufferedReader(Reader reader);//使用该缓冲流，需要先准备一个reader类的实现类对象。 
    
 API方法： 
    readLine(); 一次读取一行的方法。 
    
  2: BufferedWriter： 带有缓冲区的字符输出流 
  特点： 
   （1）带有缓冲区， 就是提高了效率。
   （2）newLine()  ; 提供了换行符 新方法。  \r\n
   
  BufferedReader ： readLine方法， 一次读取一行数据。 
 
  readLine：原理： 
    一次读取一行数据，本质上，调用了FileReader类 read();方法 一次读取一个字符。 
    当读取单换行符号的时候，将整行的数据返回到内存。 
 
 //自定义一个带有缓冲区的类，提供一个方法， 一次读取一行。  模拟： BufferedReader类。
 
  对某个类的某个方法进行功能性的增强。可以使用装饰设计模式。 带有缓冲区的字节读取流：
     带有缓冲区的字节输入流：    BufferedInputStream
     特点： 
        （1）提供了一个缓冲区， 提高了字节的读的效率。  
     
  
    带有缓冲区的字节输出流。   BufferedOutputStream
      （1）提供了一个缓冲区，提高了字节的写的效率。 
   
   
 总结： 实现一个文件的copy  到底使用什么流？ 
  （1）分析： 操作的对象，是字符还是字节。 
                        明确使用的流对象。
                        
  （2）明确来源：  文件， 键盘录入。 
            明确目的：  文件， 控制台。 
            
 （3）是否需要提高效率， 使用带有缓冲区的流对其进行包装。

public class MediaCopy {
	public static void main(String[] args) {
		long start= System.currentTimeMillis(); 
		
		BufferedInputStream bis= null; 
		BufferedOutputStream bos=null; 
		
		//初始化： 
		try {
			bis= new BufferedInputStream(new FileInputStream("C:/Users/Mrzhang/javaEE/HTML-06/CSS-01/（一）css样式表.wmv"));
	        bos= new BufferedOutputStream(new FileOutputStream("C:/Users/Mrzhang/javaEE/javaSE-07/javaSE-32/copy.wmv"));
	        
	        int num=0; 
	        while((num=bis.read())!=-1){
	        	bos.write(num); 
	        }
	        
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			if(bis!=null){
				try {
					bis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(bos!=null){
				try {
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		long end= System.currentTimeMillis(); 
		System.out.println("消耗的时间："+(end-start));// 86,612,0 82.5
		
		
		
	}
}

视频都等多媒体文件 的读取用字节流

转换流的使用

 

nputStreamReader  

       作用： 可以将一个字节流转换成一个字符流。 
       构造器： 
        new InputStreamReader(InputStream in ); 将一个字节流转换成一个字符流。 
        new InputStreamReader(InputStream in, String charsetName) 流进行转换的时候，可以指定字符集。。
    
   OutputStreamWriter: 
           作用： 将一个字节输出流转换成一个字符输出流
        new OutputStreamWriter(OutputStream out ); 将一个字节流转换成一个字符流。 
        new OutputStreamWriter(OutputStream in, String charsetName) 流进行转换的时候，可以指定字符集。

import java.io.IOException;
import java.io.InputStream;

/*
 * 演示System.in
 * 模拟了键盘录入： 
 *   每次可以读取一行的数据。  
 *   当读取到换行符号的时候， 这一行返回。 
 *   定义一个结束标志。  当录入over的时候，键盘录入结束。 
 *   
 *   一次读取一个字节。 
 *  -------
 *   一次读取一行数据。   BufferedReader 类： （1）带有缓冲区。 （2）提供了一个新的方法： readLine(); 一次读取一行数据。  
 *   
 */
public class ReadIn {
	public static void main(String[] args) throws IOException {
		InputStream in= System.in; 
		
		// 调用方法： 
		//int num= in.read(); //一次读取一个字节。-1
		
	    //定义一个容器： 
		StringBuilder sb= new StringBuilder(); 
		while(true){
			int ch= in.read();
			if(ch==13){
				continue; 
			}
			if(ch==10){
				String s= sb.toString(); //sb当中的内容转换成字符串。 
				
				//定义一个结束标志： 
				if("over".equals(s)){
					break; 
				}
				
				System.out.println(s.toUpperCase());//读取完成一行，将一行的数据 转换成大写。 
				
//				sb= new StringBuilder(); //创建很多对象。 
				sb.delete(0, sb.length()); 
				
			}else
			   sb.append((char)ch); 
		}
		
		
		
		/*int num1= in.read();
		int num2= in.read();
		int num3= in.read();
		int num4= in.read();
		
		
		System.out.println((char)num);
		System.out.println((char)num1);
		System.out.println(num2);// 13 /r
		System.out.println(num3);// 10 /n 
*/	
	}
}	

           最下面的部分是一般低效的方法

上面代码是默认的来源目的（键盘和显示屏）

下面示例 用system方法改变来源和目的

public class ReadIn02 {
	public static void main(String[] args) throws IOException {
//		method_01(); 
		
		//键盘录入的方式二： 
		BufferedReader bufr= new BufferedReader(new InputStreamReader(System.in));
		String str= bufr.readLine();
		
		
		// System.out.println(str.toUpperCase());
		
//		模拟了键盘输出。 
		OutputStream out = System.out; // PrintStream ----》OutputStream 
//		out.writer(); 写的字节  向控制台输出的内容都是字符。 
		
		//将字节流-0--->字符流输出。 
		/*OutputStreamWriter  osw= new OutputStreamWriter(out); //将一个字节输出流转换成一个字符输出流。  
		
		osw.write(str); 
		osw.flush(); 
		osw.close(); */
		
		
		PrintStream ps= System.out; //打印流。 
		ps.println(str); //换行。
		
	}

	public static void method_01() throws IOException {
		// 一次读取一行数据。   BufferedReader 类： （1）带有缓冲区。 （2）提供了一个新的方法： readLine(); 一次读取一行数据。  
		  
		InputStream in = System.in; // 一个字节流。 
		
		//能否将一个字节流 ---->字符流？  
		// 转换流： 桥接流： 
		InputStreamReader isr= new InputStreamReader(in); 
		
		
		BufferedReader  bufr= new  BufferedReader(isr); 
		
		//bufr对象存在。 readLine方法。 
		String line= null; 
		while((line=bufr.readLine())!=null){
			if("886".equals(line)){
				break; 
			}
			System.out.println(line.toUpperCase());
			
		}
		
		bufr.close();
	}
	
	
}

一：System类当中的方法： 
    System.in;  标准的输入流： 默认是键盘录入
    System.out; 标准的输出流： 默认是输出到控制台。 
  
    System.setIn(InputStream in); 改变来源。 
    System.setOut(PrintStream ps);  改变目的
    
    补充： 打印流：           
   PrintStream  构造器： 
   new PrintStream(String fileName);
   new PrintStream(OutputStream out); 
   
  PrintStream： 打印流（补充）

  特点： 
   （1）能够打印基本数据类型的值。 
   （2）PrintStream 永远不会抛出 IOException；
   （3）写入 byte 数组之后自动调用 flush 方法。自动刷新。
   （4）println(); 提供了换行的方法。 
  构造器： 
    PrintStream(File file) 
          创建具有指定文件且不带自动行刷新的新打印流。 
    PrintStream(File file, String csn)  
  
   PrintStream(OutputStream out) ; 
   PrintStream(OutputStream out, boolean autoFlush) ;自动刷新。 
   PrintStream(String fileName) 
   
 //使用PrintStream类，将异常信息打印在外部文件当中。 

2018年7月22日18:01:56 于易动

博客写太长的话一定要记得保存
不然今天下午写了一下午的博客  哎  又重写了一遍

远远没有第一遍写一边运行一遍写的流畅 +  注释详细

吸取教训~~！！！！！！！