Java基础之IO

Java基础之IO流

IO的作用：

将数据存储到文件中或从文件中读取数据

IO分类：

根据处理的数据单位不同分为字符流和字节流，根据流传输的方向分为输入流和输出流

字符流

​ 读取数据时先将数据通过编码字符集转换成相应字符，之后传入到文件中。所以读写容易出现乱码现象，在读写时最好指定编码集。只适用于纯文本文件的传输。

InputStreamReader

​ --FileReader（InputStreamReader的子类，一般用它来进行读数据）

OutputStreamWriter

​ --FileWriter（OutputStreamReader的子类，一般用它来进行写数据）

高效读写

BufferedReader

​ --特殊方法：.readLine() :读取一行数据

BufferedWriter

​ --特殊方法： .newLine() :换行

字节流

可以传输任何形式的文件，多用于传输多媒体文件。

InputStream

​ --FileInputStream

​ --BufferedInputStream

OutputStream

​ --FileOutputStream

​ --BufferedOutputStream

FileWriter代码示例：

/**
 *  输出流 FileWriter
 *  1.创建对象
 *  2.调用方法输出数据并刷新缓冲区
 *  3.释放资源
 */
public class FileWriterDemo {
	public static void main(String[] args) throws IOException {
		/**
		 * 1.创建a.txt文件
		 * 2.创建FileWriter对象
		 * 3.将对象指向这个文件
		 */
		FileWriter fw=new FileWriter("c.txt");
        //FileWriter fw=new FileWriter("c.txt",true);//不会覆盖原来的数据   默认为false
        fw.write("helloworld");
		fw.write("\n");//换行符  \n
		fw.flush();//刷新缓冲区
		fw.close();//释放资源     释放资源的同时也会刷新缓冲区，所以在数据较少的情况下可以直接释放资源
	}
}

/**
 * .write(char[] cbuf)
 * .write(int c)
 * .write(String str)
 * .write(char[] cbuf, int off,int len)
 * .write(String str,int off,int len)
 */
public class FileWriterDemo2 {
	public static void main(String[] args) throws IOException {
		FileWriter fw=new FileWriter("c.txt");
		char[] ch= {'a','b','c','d','e'};
		fw.write(ch);//abcde
		fw.write("\n");
		fw.write(97);//a
		fw.write("\n");
		fw.write('a');//a
		fw.write("\n");
		fw.write("abcde");//abcde
		fw.write("\n");
		fw.write(ch,1,3);//bcd   从下标为1开始,写3个
		fw.write("\n");
		fw.write("abcde",1,3);//bcd  从下标为1开始,写3个	
		fw.close();
	}	
}

FileRead代码示例：

/**
 *  输入流（读取文件中的数据）
 *  1.创建对象
 *  2.调用方法读取数据
 *  3.释放资源
 */
public class FileReaderDemo {
	public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader("c.txt");
		int read = fr.read();//一次读一个字符
		System.out.println((char)read);//类型为int型，也可以转换为对应的char类型
		//读取全部数据  如果数据全部读取完 返回-1
		int ch;
		while((ch=fr.read())!=-1) {
			System.out.print((char)ch);
		}
		fr.close();
	}
}

public class FileReaderDemo2 {
	public static void main(String[] args) throws IOException {
		FileReader fr=new FileReader("c.txt");
		char[] chs=new char[7];//一般为1024或1024的倍数
		int len = fr.read(chs); //将读取每个字符放入数组中包括换行符  \n
		System.out.println(chs);
		System.out.println(len);//读取的字符个数
		fr.close();
	}
}

BufferedWriter代码示例:

public class BufferWriterDemo {
	public static void main(String[] args) throws IOException {
		BufferedWriter bw = new BufferedWriter(new FileWriter("d.txt"));
		bw.write("HelloWorld");
		bw.newLine();//特有方法  换行
		bw.write("HelloJava");
		bw.close();
	}
}

BufferedReader代码示例:

public class BufferReaderDemo {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("d.txt"));
		//BufferedReader特有方法    其他方法与FileReader用法一样
		String readLine1 = br.readLine();//读取一行数据
		String readLine2 = br.readLine();//没有数据可读时返回null
		System.out.println(readLine1);
		System.out.println(readLine2);
		br.close();
	}
}

练习

读取a.txt的数据,写入到b.txt

/**
 * 读取文件  并  写入到另一个文件
 * 读取a.txt文件中的数据写入到b.txt文件
 */
public class IODemo {
	public static void main(String[] args) throws IOException {
		//单个字符读写
		method1();
		//字符数组读写
		method2();
		//高效读写 使用特有方法
		method3();
	}

	private static void method3() throws IOException {
		BufferedReader reader = new BufferedReader(new FileReader("a.txt"));
		BufferedWriter writer = new BufferedWriter(new FileWriter("b.txt"));
		String str;
		while((str=reader.readLine())!=null) {
			writer.write(str);
			writer.newLine();
			writer.flush();
		}
		reader.close();
		writer.close();
		
	}
	private static void method2() throws IOException {
		FileWriter fw=new FileWriter("b.txt");
		FileReader fr=new FileReader("a.txt");
		char[] chs=new char[1024];
		int len;
		while((len=fr.read(chs))!=-1) {
			fw.write(chs,0, len);
			fw.flush();
		}
		fw.close();
		fr.close();
	}
	private static void method1() throws IOException {
		FileWriter fw=new FileWriter("b.txt");
		FileReader fr=new FileReader("a.txt");
		int ch;
		while((ch=fr.read())!=-1) {
			fw.write(ch);
			fw.flush();
		}
		fw.close();
		fr.close();
	}
}

FileInputStream代码示例：

/**
 * 字节输入流(读)
 */
public class FileInputStreamDemo {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("a.txt");
//		int i = fis.read();//读取一个字节
//		System.out.println((char)i);
//		//读取全部字节
//		while((i=fis.read())!=-1) {
//			System.out.print((char)i);//不能正常读取中文文本
//		}
		byte[] bys=new byte[1024];
		int len = fis.read(bys);
		int i;
		while((i=fis.read(bys))!=-1) {
			System.out.println(new String(bys));
		}
		System.out.println();
		System.out.println(len);//读取的字节个数
		fis.close();
	}
}

FileOutputStream代码示例：

/**
 * 字节输出流(写)
 */
public class FileOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		FileOutputStream fop = new FileOutputStream("e.txt");
		fop.write("String".getBytes());//不能直接写字符串类型，需要把字符串转换成byte数组
		fop.write("\n".getBytes());//换行
		fop.write(97);//a(int类型对应的字符)
		fop.write("HelloWorld".getBytes(),0,5);//从0坐标开始，写入5个
		fop.close();
	}
}

BufferedInputStream代码示例：

和FileInputStream的方法一致，只是创建对象时不同：
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("f.txt"));

BufferedOutputStream代码示例：

和FileOutputStream的方法一致，只是创建对象时不同：
BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("f.txt"));

练习

/**
 * 读取文件  并  写入到另一个文件
 * 读取a.txt文件中的数据写入到b.txt文件
 */
public class IODemo {
	public static void main(String[] args) throws IOException {
		//单个字符读写
		//method1();
		//字符数组读写
		//method2();
		//高效读写 使用特有方法
		//method3();
        //字节流读写
		//method4();
        //高效字节流读写
		method5();
	}

	private static void method5() throws IOException {
		BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("b.txt"));
		BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("a.txt"));	
		byte[] bys=new byte[1024];
		int len;
		while((len=bufferedInputStream.read(bys))!=-1) {
			bufferedOutputStream.write(bys,0,len);
			bufferedOutputStream.flush();
		}
		bufferedInputStream.close();
		bufferedOutputStream.close();
	}

	private static void method4() throws IOException {
		FileOutputStream fileOutputStream = new FileOutputStream("b.txt");
		FileInputStream fileInputStream = new FileInputStream("a.txt");	
		byte[] bys=new byte[1024];
		int len;
		while((len=fileInputStream.read(bys))!=-1) {
			fileOutputStream.write(bys,0,len);
			fileOutputStream.flush();
		}
		fileInputStream.close();
		fileOutputStream.close();
	}

总结：

1.最主要的就两个方法，reader和writer方法

2.读写完成后，记得释放资源.close()

3.BufferedRead特有方法 .readLine()，读取一行数据

4.BufferedWriter特有方法 .newLine(), 换行

5.换行符
“\n”:Linux
“\r\n”:windows
“\r”:mac