IO流-字节输入输出流

IO流的分类与 FileOutputStream的构造方法

package outputstream;

import java.io.FileOutputStream;
import java.io.IOException;

/*
 * IO流的分类与 FileOutputStream的构造方法
 *
 * IO流的分类:
 * 		流向:
 * 			输入流 读取数据
 * 			输出流 写出数据
 * 		数据类型:
 * 			字节流:
 * 				字节输入流 读取数据	InputStream
 * 				字节输出流 写出数据	OutputStream
 * 			字符流:
 * 				字符输入流 读取数据	Reader
 * 				字符输出流 写出数据	Writer
 * 		注意:	
 * 			一般在讨论IO流的时候,如果没有明确说出按哪种分类来说,默认情况下按数据分类来使用
 * 
 * 需求:我要往一个文本文件中输入一句话:hello,io.
 * 
 * 分析:
 * 		A:本操作最好使用字符流使用,但现在使用字节流演示
 * 		B:由于是写入一句话,所以使用字节输出流
 * 
 * 所以要使用:OutputStream.
 * 但通过查看API,发现该流对象是一个抽象类,不能实例化.
 * 所以使用一个具体的子类:FileOutputStream
 * 
 * FileOutputStream的构造方法:
 * 		FileOutputStream(File file);
 * 		FileOutputStream(String name);两种方法其实相同
 * 
 * 字节输出流操作步骤:
 * 		创建字节输出流对象
 * 		写数据
 * 		释放资源
 */
public class FileOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		// 创建字节流输出对象
		// FileOutputStream(String name)
		FileOutputStream fos = new FileOutputStream("fos.txt");
		// 创建字节流输出对象做了几件事情
		// 1.调用系统功能去创建文件
		// 2.创建fos对象
		// 3.把fos对象指向这个文件

		// 写数据
		fos.write("hello,io".getBytes());

		// 释放资源
		// 关闭此文件输出流并释放与此流有关的所有系统资源
		fos.close();
		/*
		 * 为什么一定要close()呢?
		 * 1.让流对象变成垃圾,以被垃圾回收器回收
		 * 2.通知系统去释放跟该文件有关的系统资源
		 */
	}
}

FileOutputStream的三个Write()方法

package outputstream;

import java.io.FileOutputStream;
import java.io.IOException;

/*
 * FileOutputStream的三个Write()方法
 * 字节输出流操作步骤:
 * 		创建字节输出流对象
 * 		写数据
 * 		释放资源
 * 
 * public void write(Int b);写一个字节
 * public void write(byte[] b);写一个字节数组
 * public void write(byte[] b,int off,int len);写一个字节数组的一部分
 */
public class FileOutputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		// 创建字节流输出对象
		FileOutputStream fos = new FileOutputStream("fos2.txt");

		// 调用write();
		fos.write(97);

		// public void write(byte[] b);写一个字节数组
		byte[] b = { 97, 98, 99, 100, 101 };
		fos.write(b);

		// public void write(byte[] b,int off,int len);写一个字节数组的一部分
		fos.write(b, 1, 3);

		// 释放资源
		fos.close();
	}
}

数据的换行和数据的追加写入

package outputstream;

import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 数据的换行和数据的追加写入
 * 
 * 如何实现数据的换行?
 * 		写入换行符号即可
 * 
 * 注意:
 * 		不同的系统对于不同的换行符识别不一样
 * 		windows:\r\n
 * 		linux:\n
 * 		Mac:\r
 * 		常见的高级笔记本可以任意识别换行符
 * 
 * 如何实现数据的追加写入?
 * 		public FileOutputStream(String name,boolean append)
 * 		如果第二个参数为true,则将字节写入文件末尾处,而不是写入文件开始处
 */
public class FileOutputStreamDemo3 {
	public static void main(String[] args) throws IOException {
		// 创建字节流输出对象
		FileOutputStream fos = new FileOutputStream("fos3.txt");
		// 如果第二个参数为true,则将字节写入文件末尾处,而不是写入文件开始处
		FileOutputStream fos2 = new FileOutputStream("fos3.txt", true);

		// 写数据
		for (int i = 0; i < 10; i++) {
			fos.write(("hello" + i).getBytes());
			fos.write("\r\n".getBytes());
		}

		for (int i = 0; i < 10; i++) {
			fos2.write(("hello" + i).getBytes());
			fos2.write("\r\n".getBytes());
		}
		// 释放资源
		fos.close();
	}
}

加入异常处理的字节输出流

package outputstream;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 加入异常处理的字节输出流
 */
public class FileOutputStreamDemo4 {
	public static void main(String[] args) {
		// 分开做异常处理,可读性很差
		// FileOutputStream fos=null;
		// try {
		// fos = new FileOutputStream("fos4.txt");
		// } catch (FileNotFoundException e) {
		// e.printStackTrace();
		// }
		//
		// try {
		// fos.write("保护刘波".getBytes());
		// } catch (IOException e) {
		// e.printStackTrace();
		// }
		//
		// try {
		// fos.close();
		// } catch (IOException e) {
		// e.printStackTrace();
		// }

		// 一起做异常处理
		// try {
		// FileOutputStream fos = new FileOutputStream("fos4.txt");
		// fos.write("保护刘波".getBytes());
		// fos.close();
		// } catch (FileNotFoundException e) {
		// e.printStackTrace();
		// } catch (IOException e) {
		// e.printStackTrace();
		// }

		// 改进版
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream("fos4.txt");
			fos.write("保护刘波".getBytes());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 如果fos不是null,才需要close
			if (fos != null) {
				// 为了保证close一定会执行,所以放到这里
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

FileInputStream的read()方法

package inputstream;

import java.io.FileInputStream;
import java.io.IOException;

/*
 * FileInputStream的read()方法
 * 
 * 字节输入流操作步骤:
 * 		创建字节输入流对象
 * 		调用read()读取数据,并输出在控制台
 * 		释放资源
 * 
 * 读取数据的方式:
 * 		int read();一次读取一个字节
 * 		int read(byte[] b);一次读取一个字节数组
 */
public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("fis.txt");

		// //调用read()读取数据,并输出在控制台
		// int by=fis.read();
		// System.out.println(by);
		// System.out.println((char)by);
		//

		// 改进版代码
		int by = 0;
		// 读取,赋值,判断
		while ((by=fis.read()) != -1) {
			System.out.print((char) by);
		}
		fis.close();
	}
}

计算机是如何识别什么时候该把两个字节转化成一个中文呢

package example;

import java.util.Arrays;

/*
 * 计算机是如何识别什么时候该把两个字节转化成一个中文呢
 * 
 * 在计算机中中文的存储分两个字节:
 * 		第一个字节肯定是负数。
 * 		第二个字节常见的是负数,可能有正数。但是没影响
 * 
 */
public class StringDemo {
	public static void main(String[] args) {
		// String s = "abcd";

		String s = "我爱你中国";
		// [-50, -46, -80, -82, -60, -29, -42, -48, -71, -6]

		byte[] bys = s.getBytes();
		System.out.println(Arrays.toString(bys));
	}
}

一次读取一个字节数组:int read(byte[] b)

package inputstream;

import java.io.FileInputStream;
import java.io.IOException;

/*
 * 一次读取一个字节数组:int read(byte[] b)
 * 返回其实是实际读取取的字节个数。 
 *
 */
public class FileInputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		// 创建字节输入流对象
		// FileInputStream fis = new FileInputStream("fis2.txt");
		FileInputStream fis = new FileInputStream("FileOutputStreamDemo.java");

		// 读取数据
		// 定义一个字节数组
		// 第一次读取
		// byte[] bys = new byte[5];
		// int len = fis.read(bys);
		// System.out.println(len);
		// System.out.println(new String(bys, 0, len));
		//
		// // 第二次读取
		// len = fis.read(bys);
		// System.out.println(len);
		// System.out.println(new String(bys, 0, len));
		//
		// // 第三次读取
		// len = fis.read(bys);
		// System.out.println(len);
		// System.out.println(new String(bys, 0, len));
		//
		// // 第四次读取
		// len = fis.read(bys);
		// System.out.println(len);
		// System.out.println(new String(bys, 0, len));
		// // 代码重复了,用循环改进
		// // 但是我不知道循环条件
		// len = fis.read(bys);
		// System.err.println(len);
		// len = fis.read(bys);
		// System.err.println(len);
		// 如果读取到的实际数据是-1,就说明没有数据了

		// byte[] bys = new byte[115];
		// int len = 0;
		// while ((len = fis.read(bys)) != -1) {
		// System.out.print(new String(bys, 0, len));
		// // System.out.println(new String(bys));//千万要带上len的使用
		// }

		// 最终代码版
		// 数组的长度一般是1024或者1024的整倍数
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = fis.read(bys)) != -1) {
			System.out.print(new String(bys, 0, len));
		}

		// 释放资源
		fis.close();
	}
}