java学习（五）之输入输出流

今日学习

字节输入流

InputStream所有字节输入流的抽象父类

1. 方法
   1. int read();从输入流中读取数据的下一个字节，返回的是读取的字节
   2. int read(byte[] b);从输入流中读取一定数量的字节，并将其存储到字节数组b中，返回的是读取到的有效字节的长度，没有读到字节则返回-1b存储读取的多个字节；
      注意：b大小一般定义为1024，起缓冲作用，存储每次读取的多个字节
      read()每次读取字节之后，会将指针移到下一位上
   3. void close();关闭输入流，释放相关资源

文件字节输入流

FileInputStream extends InputStream将硬盘中文件中的数据读取到内存中

1. 构造方法
   1. FileInputStream(String name);
   2. FileInputStream(File file);
      注意：name/file是读取文件的数据源
      作用：
      • 创建一个FileInputStream的对象
      • 将对象指向读取的文件
2. 读取数据原理

3. 使用步骤
   1. 创建一个FileInputStream对象
   2. 调用read()方法读取文件数据

      //两种调用read()方法的固定格式
      //方法一：每次读取一个字节
      int len = 0;
      while((len=fis.read())!=-1){
      	System.out.println(len);
      }
      //方法二：每次读取多个字节
      byte[] b = new byte(1024);
      int len2 = 0;
      while((len2 = fis.read(b))!=-1){
      System.out.println(new String(b, 0, len));//输出一次读取的多个字节组成的字符串
      //String构造方法
      //  1.String(byte[] b );
      //  2.String(byte[] b, int offset, int length)
      }
      

   3. 调用close()关闭输入流，释放资源

字节流读取文件存在中文乱码的问题：
读中文时，在GBK编码表中，1个中文=2个字节；在UTF-8编码表中，1个中文=3个字节
因此，引出字符输入流

----------------------------------------------------------我是一条华丽的分割线---------------------------------------------------------
昨天晚上看的学习视频，只整理了笔记，今早补上！

字符输入流

java.io.Reader是所有字符输入流的抽象父类

1. 方法
   1. int read();读取单个字符并返回
   2. int read(char[] cbuf);读取多个字符放入字符数组中
   3. void close();关闭输入流并释放相关资源
2. 子类
   BufferReader、CharArrayReader、FilterReader、InputStreamReader、PipedReader…

文件字符输入流

java.io.FileReader extends java.io.inputStreamReader extends java.io.Reader
将硬盘文件中的数据读取到内存中

1. 构造方法
   1. FileReader(String fileName);，fileName表示文件路径
   2. FileReader(File file);，file表示文件对象
      file/fileName是读取文件的数据源。
      作用：1.创建一个FileReader对象；2.将此对象指向待读取文件
2. 使用步骤
   1. 创建一个FileReader对象：FileReader fr = new FileReader(String fileName/File file);
   2. 调用read()方法读取文件数据

      //调用int read()读取单个字符
      while((len=fr.read())!=-1){
      	System.out.println((char)len);//输出读取的字符
      }
      //调用int read(char[] cbuf)读取多个字符
      while((len=fr.read(b))!=-1){
      //将字符数组转换为字符串的方式：
      //1.new Sring(char[] cbuf)
      //2.new String(char cbuf, int offset, int length)
      	System.out.println(new String(b,0,len));//调用String类的构造方法，将读取到的字符数组转换为字符串
      }
      

   3. 调用close()关闭输入流，释放相关资源

字符输出流

java.io.Writer是所有字符输出流的抽象父类

1. 方法
   1. void write(int c);写入单个字符
   2. void write(char[] cbuf);写入字符数组
   3. abstract void write(char[] cbuf, int off, int len);写入字符数组的一部分，从索引off开始，长度为len
   4. void write(String str);写入字符串
   5. void write(String str, int off, int len);写入字符串的一部分
   6. void flush();刷新该流的缓冲区
   7. void close();关闭输出流，并释放资源
2. 子类
   FileWriter、BufferedWriter、CharArrayWriter、FilterWriter、OutputStreamWriter、PipedWriter、PrintWriter、StringWriter

文件字符输出流

java.io.FileWriter extends java.io.OutputStreamWriter extends java.io.Writer
将内存中的字符数据写入到硬盘文件中

1. 构造方法
   1. FileWriter fw = new FileWriter(String fileName);，fileName表示文件路径
   2. FileWriter fw = new FileWriter(File file);，file表示文件对象
      fileName/file表示写入字符数据的目的地
      作用：创建一个FileWriter对象，根据构造方法中传递的参数创建空文件，将FileReader对象指向文件
2. 使用步骤
   1. 创建一个FileWriter对象：FileWriter fw = new FileWrter(String fileName/File file);
   2. 调用write()方法将数据写入内存缓冲区
   3. 调用flush()将内存缓冲区的数据刷新到文件中（可省略）
   4. 调用close()先内存缓冲区中的数据刷新到文件中，再关闭输出流，释放资源
3. close()VS flush()
close()先刷新缓冲区，在通知系统释放资源，流对象不可再使用
   flush()刷新缓冲区，流对象可继续使用
4. 续写
   构造方法：
   1. FileWriter(String fileName, boolean append);
   2. FileWriter(File file, boolean append);
append为true，续写；false，创建新文件，覆盖原文件
5. 换行：同字节输出流相同

IO异常处理（JDK7/JDK9）

一般格式

//格式：
try{
	//可能抛出异常的代码
}catch(异常类变量){
	//异常处理逻辑
}finally{
	释放资源
}
//示例
FileInputStream fis = null;//提高fw的作用域
try{
	fis = new FileInputStream("c:\\a.txt");
	int len = 0;
	while((len=fis.read())!=-1){
		System,out.println(len);
	}
}catch(IOException e){
	e.printStackTrace();
}finally{
	//若FileInputStream构造方法中传递的参数不存在，则会抛出空指针（NullPointerExxception）异常
	if(fw!=null){//优化
		try{
			fw.close();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

JDK7

//格式
try(定义流对象;定义流对象...){
		//可能抛出异常的代码
}catch(异常类变量){
		//异常处理逻辑
}
//示例
try(FileInputStream fis = new FileInputStream("c:\\a.txt");FileOutputStream fos = new FileOUtputStream("d:\\a.txt");){
	int len = 0;
	byte[] b = new byte(1024);
	while((len=fis.read(b))!=-1){
		fos.write(b, 0, len);
	}
}catch(IOException e){
	e.printStackTrace();
}

JDK9

//格式
A a new A();//定义流对象;
B b = new B();//定义流对象;
try(a;b){
		//可能抛出异常的代码
}catch(异常类变量){
		//异常处理逻辑
}
//示例
public static void main(String[] args)throws FileNotFoundException{
//定义流对象时若抛出异常，需要再方法外抛出，如：throws FileNotFoundException
FileInputStream fis = new FileInputStream("c:\\a.txt");
FileOutputStream fos = new FileOUtputStream("d:\\a.txt");
try(fis;fos){
	int len = 0;
	byte[] b = new byte(1024);
	while((len=fis.read(b))!=-1){
		fos.write(b, 0, len);
	}
}catch(IOException e){
	e.printStackTrace();
}