Java基础--IO流

IO流的分类

根据处理数据类型的不同分为：字符流和字节流
根据数据流向不同分为：输入流和输出流

字符流和字节流

字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。 字节流和字符流的区别：
读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。
处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。

输入流和输出流

对输入流只能进行读操作，对输出流只能进行写操作，程序中需要根据待传输数据的不同特性而使用不同的流。

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

JAVA字节流

FileInputStream和FileOutputStream
这两个类属于结点流，第一个类的源端和第二个类的目的端都是磁盘文件，它们的构造方法允许通过文件的路径名来构造相应的流。如： 
FileInputStream infile = new FileInputStream("myfile.dat");
FileOutputStream outfile = new FileOutputStream("results.dat");
要注意的是，构造FileInputStream, 对应的文件必须存在并且是可读的，而构造FileOutputStream时，如输出文件已存在，则必须是可覆盖的。

BufferedInputStream和BufferedOutputStream
它们是过滤器流，其作用是提高输入输出的效率。
DataInputStream和DataOutputStream
这两个类创建的对象分别被称为数据输入流和数据输出流。这是很有用的两个流，它们允许程序按与机器无关的风格读写Java数据。所以比较适合于网络上的数据传输。这两个流也是过滤器流，常以其它流如InputStream或OutputStream作为它们的输入或输出。

Java的字符流

字符流主要是用来处理字符的。Java采用16位的Unicode来表示字符串和字符，对应的字符流按输入和输出分别称为readers和writers。
InputStreamReader和OutputStreamWriter
在构造这两个类对应的流时，它们会自动进行转换，将平台缺省的编码集编码的字节转换为Unicode字符。对英语环境，其缺省的编码集一般为ISO8859-1。
BufferedReader和BufferedWriter
这两个类对应的流使用了缓冲，能大大提高输入输出的效率。这两个也是过滤器流，常用来对InputStreamReader和OutputStreamWriter进行处理。
对BufferedReader类，该类的readLine()方法能一次从流中读入一行，但对于BufferedWriter类，就没有一次写一行的方法，所以若要向流中一次写一行，可用PrintWriter类将原来的流改造成新的打印流，PrintWriter类有一个方法println()，能一次输出一行。

代码1--ReaderFileUtil

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class ReaderFileUtil {

	
	//以字节的方式读取文件中
	public static String readFileBytes(String fileName){
		//获取当前的文件
		File file  = new File(fileName);
		//获取当前文件的所在的目录，如果目录不存在，就采用自动创建目录的方式 
		File rootPath = file.getParentFile();
		if(!rootPath.exists())rootPath.mkdirs();
		try (
			//建立输出流
			FileInputStream in = new FileInputStream(fileName);
		){
			byte[] b = new byte[1024];
			int len = 0;
			StringBuilder builder  = new StringBuilder();
			while((len=in.read(b))!=-1){
				builder.append(new String(b, 0, len));
			}
			return builder.toString();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	
	//以字符的方式进行 读取
	public static String readFileChars(String fileName){
		//获取当前的文件
		File file  = new File(fileName);
		//获取当前文件的所在的目录，如果目录不存在，就采用自动创建目录的方式 
		File rootPath = file.getParentFile();
		if(!rootPath.exists())rootPath.mkdirs();
		try (
			FileReader reader = new FileReader(fileName);	
		){
			char[] b = new char[64];
			int len = 0;
			StringBuilder builder  = new StringBuilder();
			while((len=reader.read(b))!=-1){
				builder.append(new String(b, 0, len));
			}
			return builder.toString();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	
	//以行读取
	public static String readFileLine(String fileName){
		//获取当前的文件
		File file  = new File(fileName);
		//获取当前文件的所在的目录，如果目录不存在，就采用自动创建目录的方式 
		File rootPath = file.getParentFile();
		if(!rootPath.exists())rootPath.mkdirs();
		try (
			//建立输出流
			FileReader fileReader = new FileReader(fileName);	
			BufferedReader reader = new BufferedReader(fileReader);
		){
			String line = null;
			StringBuilder builder  = new StringBuilder();
			while((line = reader.readLine())!=null){
				builder.append(line+"\r\n");
			}
			return builder.toString();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	
	
	
	
	public static void main(String[] args) {
		String file = "c://test/a.txt";
//		String result1 = readFileBytes(file);
//		System.out.println("*********************************");
//		System.out.println(result1);
//		String result2 = readFileChars(file);
//		System.out.println("*********************************");
//		System.out.println(result2);
		String result3 = readFileLine(file);
		System.out.println("*********************************");
		System.out.println(result3);
	}
}

代码2--WriterFileUtil

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class WriterFileUtil {

	
	//以字节的方式写入文件中
	public static void wirterFileBytes(String content,String fileName,boolean append){
		//获取当前的文件
		File file  = new File(fileName);
		//获取当前文件的所在的目录，如果目录不存在，就采用自动创建目录的方式 
		File rootPath = file.getParentFile();
		if(!rootPath.exists())rootPath.mkdirs();
		try (
			//建立输出流
			FileOutputStream out = new FileOutputStream(fileName,append);
		){
			byte[] b = content.getBytes();
			out.write(b);
		} catch (Exception e) {
		}
	}
	
	//以字符的方式进行 写入
	public static void wirterFileChars(String content,String fileName,boolean append){
		//获取当前的文件
		File file  = new File(fileName);
		//获取当前文件的所在的目录，如果目录不存在，就采用自动创建目录的方式 
		File rootPath = file.getParentFile();
		if(!rootPath.exists())rootPath.mkdirs();
		try (
			//建立输出流
//			FileOutputStream out = new FileOutputStream(fileName,append);
//			OutputStreamWriter writer = new OutputStreamWriter(out);
			FileWriter writer = new FileWriter(fileName,append);	
		){
			writer.write(content);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	//以行写入
	public static void wirterFileLine(String content,String fileName,boolean append){
		//获取当前的文件
		File file  = new File(fileName);
		//获取当前文件的所在的目录，如果目录不存在，就采用自动创建目录的方式 
		File rootPath = file.getParentFile();
		if(!rootPath.exists())rootPath.mkdirs();
		try (
			//建立输出流
			FileOutputStream out = new FileOutputStream(fileName,append);
			OutputStreamWriter outwriter = new OutputStreamWriter(out);
			BufferedWriter writer = new BufferedWriter(outwriter);
		){
			writer.write(content);
			writer.newLine();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	
	public static void wirterFileLines(String content,String fileName,boolean append){
		//获取当前的文件
		File file  = new File(fileName);
		//获取当前文件的所在的目录，如果目录不存在，就采用自动创建目录的方式 
		File rootPath = file.getParentFile();
		if(!rootPath.exists())rootPath.mkdirs();
		try (
			//建立输出流
				PrintWriter writer = new PrintWriter(new FileOutputStream(file, append));
		){
			writer.println(content);
			writer.flush();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	
	public static void main(String[] args) {
		String file = "c://test/a.txt";
//		wirterFileBytes("I",file,true);
//		wirterFileChars("\tLove ",file,true);
//		wirterFileLine("<span style="font-family: Arial, Helvetica, sans-serif;">白日依山尽，\r\n黄河入海流。\r\n欲穷千里目，\r\n更上一层楼。</span>",file,true);
		
		wirterFileLines("白日依山尽，\r\n黄河入海流。\r\n欲穷千里目，\r\n更上一层楼。",file,false);
	}
}

代码3--测试

package com.fileiodemo;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class IODemo {

	public static void main(String[] args) throws IOException {
		File file = new File("E:/app/test/a.txt");
		FileInputStream fileInputStream = new FileInputStream(file);
		
		InputStreamReader inReader = new InputStreamReader(fileInputStream, "UTF-8");
		
		int len = 0;
		//a.txt为UTF-8格式，读出来为乱码
//		byte[] b = new byte[1024];
//		while ((len = fileInputStream.read(b)) != -1) {
//			System.out.println(new String(b));
//		}
		
		//正确字符
		char[] c = new char[128];
		while ((len = inReader.read(c)) != -1) {
			System.out.println(new String(c,0,len));
		}

		System.out.println("----------------InputStreamReader--------------------");
		
		File file2 = new File("E:/app/test/ab.txt");
		if (!file2.exists()) {
			System.out.println("文件不存在！");
		}
		try {
			//字节流--文本文件
			FileInputStream in = new FileInputStream(file2);
			//建立输入流--转换流 -字节流---转换成--字符流
			InputStreamReader isr = new InputStreamReader(in, "UTF-8");
			char[] c2 = new char[128];
			int len2 = 0;
			while ((len2=isr.read(c2)) != -1) {
				System.out.println(new String(c2,0,len2));
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		} 
		
		System.out.println("----------------BufferedReader--------------------");
		File file3 = new File("E:/app/test/abc.txt");
		//字节流--文本文件
		FileInputStream in3 = new FileInputStream(file3);
		//建立输入流--转换流 -字节流---转换成--字符流
		InputStreamReader isr3 = new InputStreamReader(in3, "UTF-8");
		//缓存流--数据数据缓冲的作用，高效运行--可以一行读取
		BufferedReader reader = new BufferedReader(isr3);
		
		String line = null;
		while ((line = reader.readLine()) != null) {
			if (!line.equalsIgnoreCase("")) {
				System.out.println(line);
			}
		}
		System.out.println("----------------输出流--另存为--------------------");
		File file4 = new File("E:/app/test/abcd.txt");
		File fileout = new File("E:/app/test/abcd1.txt");
		//字节流--文本文件
		FileInputStream in4 = new FileInputStream(file4);
		//建立输入流--转换流 -字节流---转换成--字符流
		InputStreamReader isr4 = new InputStreamReader(in4, "UTF-8");
		//缓存流--数据数据缓冲的作用，高效运行--可以一行读取
		BufferedReader reader4 = new BufferedReader(isr4);
		
		FileOutputStream out4 = new FileOutputStream(fileout);
		OutputStreamWriter osw = new OutputStreamWriter(out4, "GBK");
		BufferedWriter writer = new BufferedWriter(osw);
		
		String line4 = null;
		while ((line4=reader4.readLine()) != null) {
			if (!line4.trim().equals("")) {
				writer.write(line4+"\n");
			}
		}
		writer.flush();
		
	}
}