IO流概述及FileWriter类使用

  • IO流用来处理设备之间的数据传输
  • Java对数据的操作是通过流的方式
  • Java用于操作流的类都在IO包中
  • 流按流向分为两种:输入流,输出流

FileWriter类使用

案例代码-FileWriter类

package com.io;
import java.io.FileWriter;
import java.io.IOException;
/*
 * 需求:往文件中写数据
 * 		写数据--输出流--FileWriter
 * 
 * FileWriter:
 * 		FileWriter(String fileName):传递一个文件名称
 * 
 * 输出流写数据的步骤:
 * 		A:创建输出流对象
 * 		B:调用输出流对象的写数据的方法
 * 		C:释放资源
 */
public class IoDemo {
	public static void main(String[] args) throws IOException {
		//创建输出流对象
		FileWriter fw = new FileWriter("d:\\a.txt");
		/*
		 * 		A:调用系统资源创建了一个文件
		 * 		B:创建输出流对象
		 * 		C:把输出流对象指向文件
		 */
		//调用输出流对象的写数据的方法
		//写一个字符串数据
		fw.write("IO流你好");
		//数据没有直接写到文件,其实是写到了内存缓冲区
		fw.flush();
		
		//释放资源
		//通知系统释放和该文件相关的资源
		fw.close();
		//while(true) {}
	}

}

案例代码-flush和close

package com.io;

import java.io.IOException;
import java.io.FileWriter;
/*
 * 输出流写数据的步骤:
 * 		A:创建输出流对象
 * 		B:调用输出流对象的写数据方法,并刷新缓冲区
 * 		C:释放资源
 * 
 * 相对路径:相对当前项目而言的,在项目的根目录下(a.txt)
 * 绝对路径:以盘符开始的路径(d:\\a.txt)
 * 
 * close()和flush()方法的区别:
 * 		flush():刷新缓冲区。流对象还可以继续使用。
 * 		close():先刷新缓冲区,然后通知系统释放资源。流对象不可以再被使用了。
 */

public class IoDemo2 {
	public static void main(String[] args) throws IOException {
		// 创建输出流对象
		// FileWriter fw = new FileWriter("d:\\a.txt");
		FileWriter fw = new FileWriter("a.txt");
		// 调用输出流对象的写数据方法,并刷新缓冲区
		fw.write("helloworld");
		fw.flush();
		fw.write("java");
		fw.flush();
		// 释放资源
		fw.close();
		// Stream closed
		// fw.write("javaee");
		// fw.flush();
	}

}

案例代码-FileWriter其它写方法

package com.io;

import java.io.IOException;
import java.io.FileWriter;
/*
 * void write(String str):写一个字符串数据
 * void write(String str,int index,int len):写一个字符串中的一部分数据
 * void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据,也可以写char对应的int类型的值。'a',97
 * void write(char[] chs):写一个字符数组数据
 * void write(char[] chs,int index,int len):写一个字符数组的一部分数据
 */

public class IoDemo3 {
	public static void main(String[] args) throws IOException {
		// 创建输出流对象
		FileWriter fw = new FileWriter("b.txt");

		// void write(String str):写一个字符串数据
		// fw.write("abcde");

		// void write(String str,int index,int len):写一个字符串中的一部分数据
		// fw.write("abcde",0,5);
		fw.write("abcde", 1, 3);

		// void write(int
		// ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据,也可以写char对应的int类型的值。'a',97
		// fw.write('a');
		// fw.write(97);

		// void write(char[] chs):写一个字符数组数据
		char[] chs = { 'a', 'b', 'c', 'd', 'e' };
		// fw.write(chs);

		// void write(char[] chs,int index,int len):写一个字符数组的一部分数据
		// fw.write(chs,0,5);
		fw.write(chs, 2, 3);

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

}

案例代码-写入换行以及向文本末尾追加

package com.io;

import java.io.FileWriter;
import java.io.IOException;

/*
 * 如何实现数据的换行?
 * 		\n可以实现换行,但是windows系统自带的记事本打开并没有换行,这是为什么呢?因为windows识别的换行不是\n,而是\r\n
 * 		windows:\r\n
 * 		linux:\n
 * 		mac:\r
 * 如何实现数据的追加写入?
 * 		FileWriter(String fileName, boolean append)
 */

public class IoDemo4 {
	public static void main(String[] args) throws IOException {
		// 创建输出流对象
		// FileWriter fw = new FileWriter("c.txt");
		FileWriter fw = new FileWriter("c.txt", true); // 表示追加写入,默认是false

		for (int x = 0; x < 10; x++) {
			fw.write("hello" + x);
			fw.write("\r\n");
		}

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

}

FileReader类使用

案例代码-读数据

package com.io2;

import java.io.FileReader;
import java.io.IOException;

/*
 * 需求:从文件中读数据并显示到控制台
 * 		读数据--输入流--FileReader
 * 
 * FileReader:
 * 		FileReader(String fileName):传递文件名称
 * 
 * 输入流读文件的步骤:
 * 		A:创建输入流对象
 * 		B:调用输入流对象的读数据方法
 * 		C:释放资源
 * 
 * java.io.FileNotFoundException: fr.txt (系统找不到指定的文件。)
 */

public class IoDemo {
	public static void main(String[] args) throws IOException {
		// 创建输入流对象
		//FileReader fr = new FileReader("fr.txt");
		FileReader fr = new FileReader("a.txt");

		// 调用输入流对象的读数据方法
		// int read():一次读取一个字符
		int ch;
		// 1:fr.read()
		// 2:ch=fr.read()
		// 3:ch != -1
		while ((ch = fr.read()) != -1) {
			System.out.print((char) ch);
		}

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

}

案例代码-文件复制

package com.io2;

import java.io.IOException;
import java.io.FileWriter;
import java.io.FileReader;;
/* 数据源:
* 		a.txt-- 读数据 -- FileReader
* 目的地:
* 		b.txt -- 写数据 -- FileWriter
*/

public class IoDemo2 {
	public static void main(String[] args) throws IOException {
		FileWriter fw = new FileWriter("b.txt", true);
		FileReader fr = new FileReader("a.txt");

		int ch;
		while ((ch = fr.read()) != -1) {
			fw.write(ch);
		}
		fw.close();
		fr.close();

	}
}

案例代码-利用字符数组拷贝

package com.io2;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/* 数据源:
* 		a.txt-- 读数据 -- FileReader
* 目的地:
* 		b.txt -- 写数据 -- FileWriter
*/

public class IoDemo3 {
	public static void main(String[] args) throws IOException {
		//创建输入流对象
		FileReader fr  = new FileReader("a.txt");
		//创建输出流对象
		FileWriter fw = new FileWriter("b.txt");
		
		//读写数据
		char[] chs = new char[1024];
		int len;
		while((len=fr.read(chs))!=-1) {
			fw.write(chs, 0, len);
		}
		
		//释放资源
		fw.close();
		fr.close();
	}
}

缓冲流使用

案例代码-缓冲流的基本使用

package com.io3;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 * BufferedWriter:将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。 
 * BufferedReader:从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取。
 */

public class IoDemo {
	public static void main(String[] args) throws IOException {
		// 创建输出缓冲流对象
		/*
		 * BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
		 * bw.write("hello"); //bw.flush(); bw.close();
		 */
		// 创建输入缓冲流对象
		BufferedReader br = new BufferedReader(new FileReader("a.txt"));
		/*
		 * //一次读写一个字符 int ch; while((ch=br.read())!=-1){ System.out.print((char)ch); }
		 */
		// 一次读写一个字符数组
		char[] chs = new char[1024];
		int len;
		while ((len = br.read(chs)) != -1) {
			System.out.print(new String(chs, 0, len));
		}
		// 释放资源
		br.close();
	}
}

案例代码-缓冲流复制文本

package com.io3;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import com.sun.swing.internal.plaf.basic.resources.basic;

/*
 * 数据源:
 * 		a.txt -- 读数据 -- FileReader -- 高效的读数据 -- BufferedReader
 * 目的地:
 * 		b.txt-- 写数据 -- FileWriter -- 高效的写数据 -- BufferedWriter
 */

public class IoDemo2 {
	public static void main(String[] args) throws IOException {
		// 创建输入缓冲流对象
		BufferedReader br = new BufferedReader(new FileReader("a.txt"));
		// 创建输出缓冲流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
		// 一次读写一个字符数组
		char[] chs = new char[1024];
		int len;
		while ((len = br.read(chs)) != -1) {
			bw.write(chs, 0, len);
		}

		// 释放资源
		bw.close();
		br.close();
	}

}

案例代码-缓冲流的特有方法

package com.io3;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*
 * 缓冲流的特殊功能:
 * BufferedWriter
 * 		void newLine():写一个换行符,这个换行符由系统决定
 * BufferedReader
 * 		String readLine():一次读取一行数据,但是不读取换行符
 */

public class IoDemo3 {
	public static void main(String[] args) throws IOException {
		/*
		 * BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt")); for(int
		 * x=0; x<10; x++) { bw.write("hello"+x); //bw.write("\r\n"); bw.newLine();
		 * bw.flush(); } bw.close();
		 */

		BufferedReader br = new BufferedReader(new FileReader("br.txt"));
		String line;
		// 1:br.readLine()
		// 2:line=br.readLine()
		// 3:line != null
		while ((line = br.readLine()) != null) {
			System.out.println(line);
		}

		br.close();
	}

}

案例代码-缓冲流的特有方法复制文件

package com.io3;

import java.io.IOException;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.BufferedWriter;

public class IoDemo4 {
	public static void main(String[] args) throws IOException {
		// 创建输入缓冲流对象
		BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));
		// 创建输出缓冲流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));

		// 读写数据
		String line;
		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		// 释放资源
		bw.close();
		br.close();
	}

}

IO流相关案例

复制文本文件的5种方式

package com.io4;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 复制文本文件(5种方式)
 * 
 * 数据源:
 * 		a.txt
 * 目的地:
 * 		b.txt
 */
public class IoDemo {
	public static void main(String[] args) throws IOException {
		String srcFileName = "a.txt";
		String destFileName = "b.txt";

//		method1(srcFileName,destFileName);
//		method2(srcFileName,destFileName);
		method3(srcFileName, destFileName);
//		method4(srcFileName,destFileName);
//		method5(srcFileName,destFileName);
	}

	// 缓冲流一次读写一个字符串
	public static void method5(String srcFileName, String destFileName) throws IOException {
		// 创建输入缓冲流对象
		BufferedReader br = new BufferedReader(new FileReader(srcFileName));
		// 创建输出缓冲流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));

		// 一次读写一个字符串
		String line;
		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		// 释放资源
		bw.close();
		br.close();
	}

	// 缓冲流一次读写一个字符数组
	public static void method4(String srcFileName, String destFileName) throws IOException {
		// 创建输入缓冲流对象
		BufferedReader br = new BufferedReader(new FileReader(srcFileName));
		// 创建输出缓冲流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));

		// 一次读写一个字符数组
		char[] chs = new char[1024];
		int len;
		while ((len = br.read(chs)) != -1) {
			bw.write(chs, 0, len);
		}

		// 释放资源
		bw.close();
		br.close();
	}

	// 缓冲流一次读写一个字符
	public static void method3(String srcFileName, String destFileName) throws IOException {
		// 创建输入缓冲流对象
		BufferedReader br = new BufferedReader(new FileReader(srcFileName));
		// 创建输出缓冲流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));

		// 一次读写一个字符
		int ch;
		while ((ch = br.read()) != -1) {
			bw.write(ch);
		}

		// 释放资源
		bw.close();
		br.close();
	}

	// 基本流一次读写一个字符数组
	public static void method2(String srcFileName, String destFileName) throws IOException {
		// 创建输入流对象
		FileReader fr = new FileReader(srcFileName);
		// 创建输出流对象
		FileWriter fw = new FileWriter(destFileName);

		// 一次读写一个字符数组
		char[] chs = new char[1024];
		int len;
		while ((len = fr.read(chs)) != -1) {
			fw.write(chs, 0, len);
		}

		// 释放资源
		fw.close();
		fr.close();
	}

	// 基本流一次读写一个字符
	public static void method1(String srcFileName, String destFileName) throws IOException {
		// 创建输入流对象
		FileReader fr = new FileReader(srcFileName);
		// 创建输出流对象
		FileWriter fw = new FileWriter(destFileName);

		// 一次读写一个字符
		int ch;
		while ((ch = fr.read()) != -1) {
			fw.write(ch);
		}

		// 释放资源
		fw.close();
		fr.close();

	}
}

案例代码- 把集合中的数据写到文本文件

package com.io4;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

/*
 * 把ArrayList集合中的字符串数据存储到文本文件
 * 每一个字符串元素作为文件中的一行数据
 * 
 * 分析:
 * 		A:创建集合对象
 * 		B:往集合中添加字符串元素
 * 		C:创建输出缓冲流对象
 * 		D:遍历集合,得到每一个字符串元素,然后把该字符串元素作为数据写到文本文件
 * 		E:释放资源
 */
public class IoDemo2 {
	public static void main(String[] args) throws IOException {
		// 创建集合对象
		ArrayList<String> array = new ArrayList<String>();

		// 往集合中添加字符串元素
		array.add("hello");
		array.add("world");
		array.add("java");

		// 创建输出缓冲流对象
		BufferedWriter bw = new BufferedWriter(new FileWriter("array.txt"));

		// 遍历集合,得到每一个字符串元素,然后把该字符串元素作为数据写到文本文件
		for (int x = 0; x < array.size(); x++) {
			String s = array.get(x);
			bw.write(s);
			bw.newLine();
			bw.flush();
		}

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

}

案例代码-把文本文件中的数据读取到集合

package com.io4;

import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;
/*
 * 从文本文件中读取数据到ArrayList集合中,并遍历集合
 * 每一行数据作为一个字符串元素
 * 
 * 分析:
 * 		A:创建输入缓冲流对象
 * 		B:创建集合对象
 * 		C:读取数据,每次读取一行数据,把该行数据作为一个元素存储到集合中
 * 		D:释放资源
 * 		E:遍历集合
 */
import java.util.ArrayList;

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader.Array;

public class IoDemo3 {
	public static void main(String[] args) throws IOException {
		// 创建输入缓冲流对象
		BufferedReader br = new BufferedReader(new FileReader("array.txt"));

		// 创建集合对象
		ArrayList<String> array = new ArrayList<String>();

		// 读取数据,每次读取一行数据,把该行数据作为一个元素存储到集合中
		String line;
		while ((line = br.readLine()) != null) {
			array.add(line);
		}

		// 释放资源
		br.close();

		// 遍历集合
		for (int x = 0; x < array.size(); x++) {
			String s = array.get(x);
			System.out.println(s);
		}
	}

}