黑马程序员——Java中IO流笔记（上）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

IO流部分


一,IO流概述


1)IO流用来处理设备之间的数据传输
上传文件和下载文件
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中


2)IO流作用:
实现设备之间的数据传输
设备：计算机中的存储设备，硬盘，外接存储设备，另一台计算机
   可以在两个计算机之间进行数据的传输
   IO流技术可以实现文件的上传和下载
 
 
3) IO分类
  按照流向分
 输入流 Input   JAVA程序读取一个数据源
 输出流 Output  JAVA程序写一个数据到目的中
  
  按照操作的数据分
 字节流  操作的是字节数据  字节是计算机中最小的存储单位  8个二进制位  任意文件
                  字符流  专门用于操作文本文件，人类可以直接识别 ， 操作的数据以字符为单位的， 1个字符 16个         二进制位
  JDK1.1开始出现了，字符类，方便操作文本文件，读取还是写入都会查询系统默认编码表 GBK
  
 
4)IO流中的四大抽象基类


 字节输出流抽象基类，用于写文件
 java.io.OutputStream
 实现子类:FileOutputStream
 字节输入流抽象基类，用于读取文件
 java.io.InputStream
 实现子类:FileInputStream
 
 字符输出流抽象基类，用于写文本文件
 java.io.Writer
 字符输入流抽象基类，用于读取文本文件
 java.io.Reader


二, FileOutputStream的构造方法


FileOutputStream(File file)
FileOutputStream(String name)


字节流写数据的方式
//写入单个字节
public void write(int b)
//写入字节数组
public void write(byte[] b)
//写入字节数组,并指定了长度
public void write(byte[] b,int off,int len)


示例:

/**
 * 写入文件
 * write(byet[]bytes); 写入字节数组
 * write(byet[]bytes,int offset,int length); 写入字节数组,并指定了长度
 *  
 * write(int a ); 写入单个字节
 * 
 * */
	public static void method() throws IOException{
		FileOutputStream fos = new FileOutputStream("D:\\abc\\456.txt");
		//字节数组
		fos.write("你好".getBytes(),0,4);
		fos.write("你好".getBytes());
		//单个字节
		fos.write(97);
		//关闭输出流
		fos.close();
	}

}


示例:
/**
 * 写入文件时 的异常处理方式
 * */
	public static void method_1(){
		//提升变量fos作用域
		//try外面定义变量,里面创建对象
		FileOutputStream fos = null;
		try{
			fos = new FileOutputStream("d:\\abc\\456.txt");
			fos.write("bbb".getBytes());
		}catch(IOException e){
			//让程序停止,抛出运行时期异常
			throw new RuntimeException("文件写入失败");
		}finally{
			System.out.println("s");
			try{
				if(fos!=null)
					fos.close();
			}catch(IOException e){
				throw new RuntimeException("释放资源失败");
			}
		}
	}

三, FileInputStream的构造方法


InputStream
实现子类:FileInputStream


1) FileInputStream的构造方法
FileInputStream(File file)
FileInputStream(String name)
2) FileInputStream的成员方法
public int read()
public int read(byte[] b)
示例:读取文件中的数据
 通常用到循环
 int read()方法
 返回值为int类型  表示读取到的字符数据

public static void method_3() throws IOException{
		FileInputStream fis = 
				new FileInputStream("d:\\abc\\456.txt");
		int x=0;
		//循环条件是,read()的返回值是不是-1;
		while((x=fis.read())!=-1){
			
			//打印语句中不可再有fis.read();所以要先在循环外定义x
			System.out.print((char)x);
		}
		fis.close();
		
	}

示例:用缓冲数组来 读取文件
 用缓冲数组来 读取文件
  FileInputStream 读取文本文件,使用数组缓冲(同大口喝水是一个道理)
  提高读取效率,用循环读取
  read方法,到结尾时  返回-1 停止循环
  除此之外返回值为  读到的有效字节数.

public static void method_4() throws IOException {
		FileInputStream fis = 
				new FileInputStream("d:\\abc\\456.txt");
		//定义字节数组
		byte[] bytes = new byte[5];
		//int x变量,保存read方法读取有效字节个数,不等以-1时可以循环
		int x = 0;
		//read()方法返回值为,读取字节的有效个数
		while((x=fis.read(bytes))!=-1){
			//输出有效个数
//			System.out.print(x);
							//将字节数组变为字符串
			System.out.print(new String(bytes,0,x));
			
		}
	}

四,应用:


IO流实现文件数据的复制


  字节流 复制数据(一个字节一个字节复制)

  原理:字节输入流,读取数据源文件的字节
         字节输出流,将读取到的字节,写入数据目的

  FileInputStream 类中的

read()方法
  FileOutputStream 类中的

 write()方法
  
 

public static void method_5() {
		//声明类的变量为空,提升作用域
		//创建FileInputStream对象  读取数据源
		FileInputStream fis = null;
		//创建FileOutputStream对象,写数据目的
		FileOutputStream fos = null;
		try{
			//复制源文件
		fis = new FileInputStream("d:\\abc\\456.txt");
		//指定复制位置
		fos = new FileOutputStream("e:\\123.txt");
		//读一个字节,写一个字节
		int x = 0;
		//采用循环
		while((x = fis.read())!=-1){
			fos.write(x);
		}
		}catch(IOException e){
			throw new RuntimeException("文件复制失败");
		}finally{
			try{
				if(fos!=null)
					fos.close();
			}catch(IOException e){
				throw new RuntimeException("资源关闭失败");
			}finally{
				try{
					if(fis!=null)
						fis.close();
				}catch(IOException e){
					throw new RuntimeException("资源关闭失败");
				}
			}
		}
		
	}

示例:


   字节流 复制数据(以字节数组的方式)
   效率会提高

public static void method_6(){
	  //定义子类对象,输入源文件
		FileInputStream fis = null;
		//写入目的文件
		FileOutputStream fos = null;
		//处理异常
		try{
			fis = new FileInputStream("d:\\11.jpg");
			fos = new FileOutputStream("e:\\12.txt");
			//定义三个位置的字节数组
			byte [] b = new byte[3];
			//定义获取长度的初始值
			int len = 2;
			while((len=fis.read(b))!=-1){
				//一次写入字节数为len个
				fos.write(b,0,len);
			}
		  }catch(IOException e){
				throw new RuntimeException("复制文件失败");
			}finally{
				try{
				if(fos!=null)
					fos.close();
				}catch(IOException e){
					throw new RuntimeException("资源关闭失败");
				}try{
					if(fis!=null)
						fis.close();
					}catch(IOException e){
						throw new RuntimeException("资源关闭失败");
					}
			}
			
		}

五,四大抽象基类的实现类方法汇总


OutputStream类的方法，写文件的类，里面的方法主要都是写入的方法
write(byte[] bytes)写字节数组
write(byte[] bytes ,int offset,int length)将字节数组一部分写入，开始索引，写几个
write(int a) 写入单个字节
close() 关闭资源，释放资源
 
 
 InputStream类的方法，读取文件的类，里面的方法主要读取的方法
read(byte[] bytes)读取数据装进字节数组
read(byte[] bytes,int offset,int length)读取数据装进字节数组一部分，开始索引，装几个
read() 读取单个字节
close() 关闭资源
available() 获取读取文件的字节数
 
 
 Writer类的方法，写文件的，写文本文件，里面的方法主要都是写入的方法
write(char[] ch)写入字符数组
write(char[] ch,int offset,int length)将字符数组一部分写入，开始索引，写几个
write(int a) 写单个字符
write(String s)写入字符串
close() 关闭资源
flush() 刷新流的缓冲
 
 
 Reader类的方法，读取文件，读取文本文件，里面的方法主要都是读取的方法
read(char[] ch)读取数据装进字符数组
read(char[] ch,int offset,int length)读取数据装进字符数组一部分，开始索引，装几个
read() 读取单个字符
close() 关闭资源




六,字节缓冲流


字节缓冲输出流
BufferedOutputStream
构造方法:
BufferedOutputStream(OutputStream out);
多态 参数 传递子类对象FileOutputStream fos


字节缓冲输入流
BufferedInputStream
 构造方法：参数 子类对象 FileInputStream fis
示例：

/*
 * 利用字节缓冲区对象，实现文件的复制
 * 
 * */
	public static void method_7() {
		FileOutputStream fos = null;
		FileInputStream fis = null;
		try {
			// 创建字节输出流对象
			fos = new FileOutputStream("e:\\11.jpg");
			// 创建字节输入流对象
			fis = new FileInputStream("d:\\11.jpg");
			// 创建字节流缓冲区对象
			BufferedOutputStream bos = new BufferedOutputStream(fos);
			BufferedInputStream bis = new BufferedInputStream(fis);
			// 定义字节数组
			byte[] bytes = new byte[1024];
			// 初始长度
			int len = 0;
			// 先读再写
			while ((len = bis.read(bytes)) != -1) {
				bos.write(bytes);
			}
		} catch (IOException e) {
			throw new RuntimeException("复制文件失败");
		} finally {
			try {
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e) {
				throw new RuntimeException();
			}
			try {
				if (fos != null) {
					fos.close();
				}
			} catch (IOException e) {
				throw new RuntimeException();
			}
		}

	}

七,转换流出现的原因及思想


由于字节流操作中文不是特别方便，所以，java就提供了转换流。
字符流=字节流+编码表。


编码表


由字符及其对应的数值组成的一张表


常见编码表


ASCII/Unicode 字符集
ISO-8859-1
GB2312/GBK/GB18030
BIG5
UTF-8


编码
把看得懂的变成看不懂的


解码
把看不懂的变成看得懂的
示例；

/**
 * 字符的解码
 * */
	public static void method_10() throws Exception {
		byte[] b = { -28, -67, -96, -27, -91, -67 };
		String s = new String(b, "utf-8");
		System.out.println(s);
	}
示例：
/**
 * 演示 字符的编码
 * */
	public static void method_9() throws IOException {
		// 将字符串转换为字节数组
		byte[] b = "你好吗".getBytes("UTF-8");
		for (byte b1 : b) {
			System.out.println(b1);
		}
	}

八、 转换流概述


OutputStreamWriter 字符输出流


public OutputStreamWriter(OutputStream out)
public OutputStreamWriter(OutputStream out,String charsetName)


写数据方法：
public void write(int c)
public void write(char[] cbuf)
public void write(char[] cbuf,int off,int len)
public void write(String str)
public void write(String str,int off,int len)






InputStreamReader 字符输入流

public InputStreamReader(InputStream in)
public InputStreamReader(InputStream in,String charsetName)


读数据方法：
public int read()
public int read(char[] cbuf)
示例：

/*
 * 转换流对象InputStreamReader，读取文件 
 * 构造方法的参数为 字节输入流 对象,可以有第二个参数字符串形式的编码表名称
 */
	public static void method_11() throws IOException {
		FileInputStream fis = new FileInputStream("d:\\123.txt");
		// 创建转换流对象，传递字节流对象
		InputStreamReader isr = new InputStreamReader(fis);
		int len = 0;
		while ((len = isr.read()) != -1) {
			System.out.print((char) len);
		}
		isr.close();
	}

九、转换流的简化写法


FileWriter


FileReader


示例：
/* 
 *转换流对象为： OutputStreamWriter  InputStreamReader
 *转换流对象的简写格式 FileWriter  FileReader 
 *构造方法的参数为  File类对象  或者  String类型的文件名
 *如果需要追加写入，构造方法参数中可以写true
 *使用转换流简化对象 复制文本文件
 * */

public static void method_21() throws IOException{
		//创建目的文件
//		FileWriter fw = new FileWriter(new File("D:\\123.txt"));
		FileWriter fw = new FileWriter("e:\\123.txt");
		//创建源文件
		FileReader fr = new FileReader("d:\\123.txt");
		int len = 0;
		
		while ((len = fr.read())!=-1){
			fw.write((char)len);
			fw.flush();
		}
		fw.close();
		
	}
示例：
/*
 * 把ArrayList集合中的字符串数据，存到指定文本里； 
 *思路：遍历集合，获取元素。 用 BufferedWriter 字符缓冲区对象 写入数据
 */
	public static void method_15() throws IOException {
		// 定义集合
		ArrayList<String> al = new ArrayList<String>();
		// 添加元素
		al.add("abc");
		al.add("pok");
		al.add("uiy");
		// 创建BufferedWriter 字符缓冲区对象
		BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\456.txt"));
		// 遍历集合 增强for
		for (String s : al) {
			// 用字符缓冲区对象， 接收字符串；
			bw.write(s);
			bw.newLine();
			bw.flush();
		}
		bw.close();
	}

十、字符缓冲流


BufferedWriter


特有方法：void newLine()


BufferedReade


特有方法：String readLine()




示例：

/*
 * 使用 字符缓冲区对象BufferedWriter 写入字符串， 要求有换行 
 *	思路： newLine()方法 进行换行
 */
	public static void method_19() throws Exception {
		// 指定写入目的文件
		FileWriter fw = new FileWriter(new File("d:\\demo\\345.txt"));
		// 与上一行等价
		// FileWriter fw = new FileWriter("d:\\demo\\345.txt");
		// 创建BufferedWriter对象。参数为 FileWriter对象
		BufferedWriter bw = new BufferedWriter(fw);
		bw.write("abc");
		bw.write("def");
		bw.newLine();
		bw.write("123");
		bw.close();
	}

示例：字符缓冲流读取数据
/*
 * 从文本中读取一行存进集合中； 并遍历集合 
 * BufferedReader的构造方法参数为 FileReader
 */

public static void method_16() throws IOException {
		// 定义字符缓冲区对象
		BufferedReader br = new BufferedReader(new FileReader("d:\\456.txt"));
		// 创建集合
		ArrayList<String> arr = new ArrayList<>();
		String s = null;
		// 每次读取一行 ， 集合接收一行
		while ((s = br.readLine()) != null) {
			arr.add(s);
		}
		for (String st : arr) {
			System.out.println(st);
		}
	}

应用：

 复制单级文件夹
 
 思路：    1、复制文件夹到指定位置 

2、遍历源文件，获取各文件对象 f，对象调用getName()获取文件名 

3、以目的路径+ 文件名为参数  创建文件对象File fi。
                4、分别以这两个对象为参数，创建文件输出流对象，和文件输入流对象。 
       5、循环读、写每一个文件。
 

public static void method_17() throws Exception {
		// 创建源文件对象，并封装路径
		File src = new File("d:\\demo");
		// 创建目的文件对象； 参数为父路径+ 子路径
		File targ = new File("e:", src.getName());
		// 完成复制文件夹
		targ.mkdirs();

		// ======================完成复制文件夹到e盘中
		// 初始获取字节有效长度
		int len = 0;
		// 定义字节缓冲数组
		byte[] bytes = new byte[1];

		// 遍历文件夹里面的文件，并写进复制后的文件夹里；
		// listFiles() 方法返回值为 文件对象数组。
		File[] file = src.listFiles();

		// f 为存放在数组中的 文件对象 。
		for (File f : file) {

			// 获取文件名
			String fName = f.getName();

			// 把路径封装为文件对象， 参数为 父路径 子路径
			File fi = new File(targ.getPath(), fName);

			// 以文件对象为参数
			FileInputStream fis = new FileInputStream(f);

			// 以文件对象为参数
			FileOutputStream fos = new FileOutputStream(fi);

			// 循环获取文件数据
			while ((len = fis.read(bytes)) != -1) {

				fos.write(bytes, 0, len);

			}
			// 关闭流
			fos.close();
			fis.close();
		}

	}