java19

java19

关于IO流------InPut OutPut Stream 输入输出流

IO流的本质，就是数据传输的一套机制

根据数据传输的方向：往内存传输数据—输入流

内存向外传输数据-----输出流

根据数据传输的方式：字符流、字节流

javaIO流的四大基本流

字符流 字节流
输出流 字符输出流（Writer） 字节输出流（OutputStream）
输入流 字符输入流（Reader） 字节输入流（InputStream）

四大基本类都是抽象类

数据存储/获取的位置（数据传输的场景）：硬盘、内存、网络、外设设备

硬盘：
向硬盘上的一个txt文件写入数据；–FileWriter

从一个硬盘的txt文件读取数据； —FileReader

Buffereader缓冲区

字符输出流 文件—FileWriter

输入流没有缓冲区

import java.io.FileWriter;
import java.io.IOException;

public class LiuIO {
public static void main(String[] args) throws IOException {
//	创建FileWriter对象
//	检测路径正确与否
//	如果路径正确，没有具体的文件，就会创建一个空文件
//	如果文件已经存在，就会创建一个空文件覆盖之前的文件
//	保证写入数据之前，这个文件一定是一个空文件。
	FileWriter writer = new FileWriter("E:\\1.txt");
	
//	写数据
//	底层基于缓冲区进行数据传输的
//	默认要求缓冲区数据装满才能进行传输
//	下面的数据没有装满，缓冲区就没有进行传输
	writer.write("你好");
//	冲刷缓冲区--不管缓冲区有没有存满，都要进行传输
//	防止数据直流在缓冲区产生数据流失
	writer.flush();
	
//	写完数据之后，需要关闭连接通道
//  在关闭通道之前会自动进行冲刷缓冲区	
	writer.close();
	
//	强制对象指为null
//	将对象置为无用对象，在某个时间进行垃圾回收
	writer =null;
	
	
}
}



	public class FileWriterDemo2 {
		
		public static void main(String[] args) {
			//创建FileWriter对象
			//1.声明FileWriter对象
			FileWriter writer=null;//保证有值  不能保证try块里一定能赋值
			try {
				//对象真实赋值
				writer=new FileWriter("D:\\2.txt");
				//写出数据
				writer.write("123");
				//4.手动冲刷缓冲区
				writer.flush();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}finally{//不管try块里代码正确与否都要关流
				//2.保证对象初始化成功有值才能正确调用关流方法
				//为null的情况不用处理
				if(writer!=null)
					try {
						writer.close();//关流有可能失败
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}finally {
						//3.对象置为无用对象---垃圾回收
						writer=null;
					}
			}
		}
		
	
	}
	
	
	
	
	
	
	
	public class FileWriterDemo3 {
		
		public static void main(String[] args) {
			//jdk1.7提供  try-with-resources
			//自动冲刷缓冲区、关流
			try(FileWriter writer=new FileWriter("D:\\3.txt")){
				writer.write("456");
			} catch (Exception e) {
				// TODO: handle exception
			}
		}
	
	}
	
从一个硬盘的txt文件读取数据      字符输入流  文件---FileReader
public class FileReaderDemo1 {
	
	public static void main(String[] args) throws IOException {
		//创建FileReader对象
		FileReader reader=new FileReader("D:\\2.txt");
		//读取数据
		//返回的是读取到字符的编码值
		//读取结束的标志就是返回-1
		/*System.out.println((char)reader.read());
		System.out.println((char)reader.read());
		System.out.println((char)reader.read());
		System.out.println(reader.read());*/
		int len=-1;//提供变量供给读取数据覆盖
		while((len=reader.read())!=-1){//避免读取两次情况
			System.out.println(len);
		}
		//关流---输入流没有缓冲区
		reader.close();
		
	}

}



public class FileReaderDemo2 {
	
	public static void main(String[] args) throws IOException {
		//创建FileReader对象
		FileReader reader=new FileReader("D:\\a.txt");
		
		//读取数据
		//自建缓冲区---数组---字符流---字符数组
		char[] cs=new char[3];
		int len=-1;
		//reader.read(字符数组)--返回值就是每次读取到的字符个数
		while((len=reader.read(cs))!=-1){//读取到的内容存放到数组
			System.out.println(new String(cs,0,len));
		}
		
		//关流
		reader.close();
	
	}

}

4.字节
往硬盘上一个txt文件写入数据 字节输出流 文件—FileOutputStream
public class FileOutPutStreamDemo {

	public static void main(String[] args) throws IOException {
		//创建字节输出流对象---没有缓冲区  true表明文件可追加
		FileOutputStream os=new FileOutputStream("D:\\c.txt",true);
		//写出数据
		os.write("中".getBytes());//获取字节数组
		//关流
		os.close();
	}

}

从一个硬盘的txt文件读取数据    

 字节输入流  文件---FileInputStream

public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		//字节输入流对象
		FileInputStream is=new FileInputStream("D:\\1.txt");
		//读取数据  结束标志是-1
		//System.out.println(is.read());
		//自建缓冲区
		byte[] bs=new byte[10];
		int len=-1;
		while((len=is.read(bs))!=-1){
			System.out.println(new String(bs,0,len));
		}
		//关流
		is.close();
	}
}

5.缓冲流（用于提供缓冲区）

		BufferedReader：给字符输入流提供缓冲区  readLine读取一行
		public class BufferedReaderDemo {
			
			public static void main(String[] args) throws IOException {
				//创建缓冲流对象
				//真正读取内容的流对象是FileReader，字符输入流
				//缓冲流对象只是给字符输入流提供一个缓冲区
				BufferedReader br=new BufferedReader
						(new FileReader("D:\\3.txt"));
				
				//读取一行---结束标志null
				/*System.out.println(br.readLine());
				System.out.println(br.readLine());
				System.out.println(br.readLine());
				System.out.println(br.readLine());*/
				String str="";
				while((str=br.readLine())!=null){
					//
					System.out.println(str);
				}
				
			}
		
		}
		
		BufferedWriter：给字符输出流提供一个更大的缓冲区  newLine换行
		public class BufferedWriterDemo {
			public static void main(String[] args) throws IOException {
				//
				BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\b.txt"));
				//写出数据
				bw.write("abc");
				//换行---不管具体什么的操作系统
				//不同操作系统的换行符不一样
				//Windows---\r\n  linux---\n
				bw.newLine();
				bw.write("123");
				
				//关流--冲刷缓冲区
				bw.close();
			}
		}

6.转换流

OutputStreamWriter---字符流转成字节流
public class OutputStreamWriterDemo {
	public static void main(String[] args) throws IOException {
		//底层真正做数据传输的是字节输出流
		//要写出的数是字符
		//字符输出流---字节输出流
		OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("D:\\12.txt"));
		//写出数据---字符串---字符
		osw.write("abc");
		//关流
		osw.close();
	}
}

InputStreamReader---字节流转成字符流
public class InputStreamReaderDemo {
	public static void main(String[] args) throws IOException {
		//底层从文件读取的是字节输入流
		//展示的时候使用字符输入流
		//字节流---字符流
		InputStreamReader isr=new InputStreamReader(new FileInputStream("D:\\12.txt"));
		//读取数据---字符数组--字符---字符流
		char[] cs=new char[5];
		int len=-1;
		while((len=isr.read(cs))!=-1){
			System.out.println(new String(cs,0,len));
		}
	}

}

7.系统流(都是字节流)

System.out 、System.err、System.in

系统流都是静态的不能关流

ublic static void main(String[] args) {
		//
		Scanner sc1=new Scanner(System.in);
		String s1=sc1.nextLine();
		//关流
		sc1.close();
		//系统流都是静态的不能关流
		/*Scanner sc2=new Scanner(System.in);
		String s2=sc2.nextLine();
		System.out.println(s1);
		System.out.println(s2);*/
	}

8.异常处理
1、在try块外进行声明对象，在try块里进行对象初始化
2、保证对象已经进行正常的初始化才能进行关流操作
3、不管关流成功还是失败都要对对象进行置为无用对象的操作，等待回收
4、流关闭失败有可能是在自动冲刷缓冲区之前，保证数据不能滞留在缓冲区中，自己进行手动冲刷缓冲区