天天看点
返回

字符流

* OutputStreamWriter的方法：

*

* 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);//写一个字符串的一部分

* 面试题：

* close()和flush()的区别？

* close()关闭流对象，但是先刷新一次缓冲区，关闭以后，该对象不可以继续再使用了。

* flush()仅仅刷新缓冲区，刷新之后，流对象还可以继续使用。

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

/*
 * OutputStreamWriter的方法：
 * 
 * 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);//写一个字符串的一部分
 * 
 * 面试题：
 * close()和flush()的区别？
 * close()关闭流对象，但是先刷新一次缓冲区，关闭以后，该对象不可以继续再使用了。
 * flush()仅仅刷新缓冲区，刷新之后，流对象还可以继续使用。
 * */

public class IntegerDemo {
	public static void main(String[] args) throws IOException {

		FileOutputStream fos = new FileOutputStream("E:\\zikao\\file\\cs.txt");

		OutputStreamWriter osw = new OutputStreamWriter(fos);

		osw.write("我爱你");

		osw.close();
	}
}

* InputStreamReader的方法：

* int read();//一次读取一个字符

* int read(char chs[]);//一次读取一个字符数组

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

/*
 * InputStreamReader的方法：
 * 
 * int read();//一次读取一个字符
 * int read(char chs[]);//一次读取一个字符数组
 * */

public class IntegerDemo {
	public static void main(String[] args) throws IOException {

		FileInputStream fis = new FileInputStream("E:\\zikao\\file\\cs.txt");

		InputStreamReader isr = new InputStreamReader(fis);

		int ch = 0;
		while ((ch = isr.read()) != -1) {
			System.out.print((char) ch);
		}

		isr.close();
	}
}

* 字符缓冲流的特殊方法：

* BufferedReader:

* public String readLine();//一次读取一行数据

* 包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回null

* BufferedWriter:

* public void newLine();//根据系统来决定换行符

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

/*
 * 字符缓冲流的特殊方法：
 * 
 * BufferedReader:
 * public String readLine();//一次读取一行数据
 * 包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回null
 * 
 * BufferedWriter:
 * public void newLine();//根据系统来决定换行符
 * */

public class IntegerDemo {
	public static void main(String[] args) throws IOException {
		myWrite();
		myRead();
	}

	public static void myRead() throws IOException {
		FileReader fr = new FileReader("E:\\zikao\\file\\cs.txt");
		BufferedReader br = new BufferedReader(fr);

		String line = null;

		while ((line = br.readLine()) != null) {
			System.out.println(line);
		}
	}

	public static void myWrite() throws IOException {
		FileWriter fw = new FileWriter("E:\\zikao\\file\\cs.txt");
		BufferedWriter bw = new BufferedWriter(fw);

		for (int i = 0; i < 10; i++) {
			bw.write("hello" + i);
			bw.newLine();
			bw.flush();
		}

		bw.close();
	}
}

* 字符流5种方式复制文件：

* 复制数据，如果使用记事本打开后能够读懂，就用字符流，否则用字节流

* 通过该原理，用字符流更方便

* 字符流有5种方式复制数据，推荐掌握第5种

*

* 基本字符流一次读写一个字符

* 基本字符流一次读写一个字符数组

* 字符缓冲流一次读写一个字符

* 字符缓冲流一次读写一个字符数组

* 字符缓冲流一次读写一个字符串

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

/*
 * 字符流5种方式复制文件：
 * 
 * 复制数据，如果使用记事本打开后能够读懂，就用字符流，否则用字节流
 * 通过该原理，用字符流更方便
 * 字符流有5种方式复制数据，推荐掌握第5种
 *
 * 基本字符流一次读写一个字符
 * 基本字符流一次读写一个字符数组
 * 字符缓冲流一次读写一个字符
 * 字符缓冲流一次读写一个字符数组
 * 字符缓冲流一次读写一个字符串
 * */

public class IntegerDemo {
	public static void main(String[] args) throws IOException {
		method1("E:\\zikao\\cs.txt", "E:\\zikao\\file\\1.txt");
		method2("E:\\zikao\\cs.txt", "E:\\zikao\\file\\2.txt");
		method3("E:\\zikao\\cs.txt", "E:\\zikao\\file\\3.txt");
		method4("E:\\zikao\\cs.txt", "E:\\zikao\\file\\4.txt");
		method5("E:\\zikao\\cs.txt", "E:\\zikao\\file\\5.txt");
	}

	// 基本字符流一次读写一个字符
	public static void method1(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();

		FileReader fr = new FileReader(srcString);
		FileWriter fw = new FileWriter(destString);

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

		fw.close();
		fr.close();

		long end = System.currentTimeMillis();

		System.out.println("共耗时：" + (end - start) + "毫秒");
	}

	// 基本字符流一次读写一个字符数组
	public static void method2(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();

		FileReader fr = new FileReader(srcString);
		FileWriter fw = new FileWriter(destString);

		char chs[] = new char[1024];
		int len = 0;
		while ((len = fr.read(chs)) != -1) {
			fw.write(chs, 0, len);
		}

		fw.close();
		fr.close();

		long end = System.currentTimeMillis();

		System.out.println("共耗时：" + (end - start) + "毫秒");
	}

	// 字符缓冲流一次读写一个字符
	public static void method3(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();

		FileReader fr = new FileReader(srcString);
		FileWriter fw = new FileWriter(destString);

		BufferedReader br = new BufferedReader(fr);
		BufferedWriter bw = new BufferedWriter(fw);

		int ch;
		while ((ch = br.read()) != -1) {
			bw.write(ch);
		}

		bw.close();
		br.close();

		long end = System.currentTimeMillis();

		System.out.println("共耗时：" + (end - start) + "毫秒");
	}

	// 字符缓冲流一次读写一个字符数组
	public static void method4(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();

		FileReader fr = new FileReader(srcString);
		FileWriter fw = new FileWriter(destString);

		BufferedReader br = new BufferedReader(fr);
		BufferedWriter bw = new BufferedWriter(fw);

		char chs[] = new char[1024];
		int len = 0;
		while ((len = br.read(chs)) != -1) {
			bw.write(chs, 0, len);
		}

		bw.close();
		br.close();

		long end = System.currentTimeMillis();

		System.out.println("共耗时：" + (end - start) + "毫秒");
	}

	// 字符缓冲流一次读写一个字符串
	public static void method5(String srcString, String destString) throws IOException {
		long start = System.currentTimeMillis();

		FileReader fr = new FileReader(srcString);
		FileWriter fw = new FileWriter(destString);

		BufferedReader br = new BufferedReader(fr);
		BufferedWriter bw = new BufferedWriter(fw);

		String line = null;
		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		bw.close();
		br.close();

		long end = System.currentTimeMillis();

		System.out.println("共耗时：" + (end - start) + "毫秒");
	}
}

要求：把ArrayList集合中的字符串数据存储到文本文件

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

/*
 * 要求：把ArrayList集合中的字符串数据存储到文本文件
 * */

public class IntegerDemo {
	public static void main(String[] args) throws IOException {
		// 封装数据源（创建集合对象）
		ArrayList<String> array = new ArrayList<String>();
		array.add("hello");
		array.add("world");
		array.add("java");

		// 封装目的地
		FileWriter fw = new FileWriter("E:\\zikao\\file\\cs.txt");
		BufferedWriter bw = new BufferedWriter(fw);

		// 遍历集合
		for (String s : array) {
			// 写数据
			bw.write(s);
			bw.newLine();
			bw.flush();
		}

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

要求：从文本文件中读取数据到集合中，并遍历集合

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

/*
 * 要求：从文本文件中读取数据到集合中，并遍历集合
 * */

public class IntegerDemo {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		FileReader fr = new FileReader("E:\\zikao\\file\\cs.txt");
		BufferedReader br = new BufferedReader(fr);

		// 封装目的地
		ArrayList<String> array = new ArrayList<String>();

		// 读取数据存储得到集合中
		String line = null;
		while ((line = br.readLine()) != null) {
			array.add(line);
		}

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

		// 遍历集合
		for (String s : array) {
			System.out.println(s);
		}
	}
}

要求：一个文本文件中存储了多行，写一个程序实现随机访问一行

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;

/*
 * 要求：一个文本文件中存储了多行，写一个程序实现随机访问一行
 * */

public class IntegerDemo {
	public static void main(String[] args) throws IOException {
		// 封装数据源
		FileReader fr = new FileReader("E:\\zikao\\file\\cs.txt");
		BufferedReader br = new BufferedReader(fr);

		// 封装目的地
		ArrayList<String> array = new ArrayList<String>();

		// 读取数据存储得到集合中
		String line = null;
		while ((line = br.readLine()) != null) {
			array.add(line);
		}

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

		// 随机产生一个索引
		Random r = new Random();
		int index = r.nextInt(array.size());

		// 根据索引值获取一个值
		String str = array.get(index);
		System.out.println(str);
	}
}
      
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

public class IntegerDemo {
	public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader("E:\\zikao\\file\\cs.txt");

		LineNumberReader lnr = new LineNumberReader(fr);

		String line = null;
		while ((line = lnr.readLine()) != null) {
			System.out.println(lnr.getLineNumber() + ":" + line);
		}

		lnr.close();
	}
}
java 字符流 字符数组 缓冲流 字符串
上一篇: 接口和抽象类有什么区别
下一篇: IO流-字节流与字符流

继续阅读