5.19I/O流续

ws1995_java

于 2018-05-24 18:24:55 发布

阅读量136

点赞数

文章标签： Java I/O流

本文链接：https://blog.csdn.net/ws1995_java/article/details/80439714

版权

package org.westos.IO流博客练习;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 能看的懂得文件优先采用字符流读取;看不懂的文件优先采用字节流读取
 * 读取效率:
 * 	一次读取一个字节的效率最低.接下来是一次读取一个字节数组,读取效率最高的是BufferedInputStream
 * 写入效率:与读取效率类似
 * */
/**
 * BufferedInputStream类:
 * 字节缓冲流读取;
 * 构造方法:
 *  public BufferedInputStream(InputStream in):默认缓冲区大小构造缓冲输入流对象
 * 	public BufferedInputStream(InputStream in,int size):指定缓冲区大小构造缓冲输入流对象
 * 方法:
 * 	public int read()
 * 	public int read(byte[] b,int off,int len)
 * BufferedOutputStream类
 * 字节缓冲流写入;
 * 构造方法:
 * 	public BufferedOutputStream(OutputStream out):采用的默认的缓冲区大小(足够大了) ,来构造一个字节缓冲输出流对象
 * 	public BufferedOutputStream(OutputStream out,int size):指定size缓冲区大小构造缓冲输出流对象
 * 方法:
 * 		public void write(int by)一次写一个字节
 * 		public void write(byte[] b,int off,int len)一次写入一个字节组的一部分
 * 		public void flush() 刷新此缓冲的输出流。这迫使所有缓冲的输出字节被写出到底层输出流中
 * */
public class Text1 {
	public static void main(String[] args) throws IOException {
		BufferedInputStream bip = new BufferedInputStream(
				new FileInputStream("e:\\apple.txt"));//需要传递FileInputStream类的参数b
		BufferedOutputStream bop = new BufferedOutputStream(
				new FileOutputStream("e:\\applecopy.txt"));
		//一个字节一个字节的读取与写入
		int by = 0;
		while((by = bip.read())!=-1) {
			bop.write(by);
		}
		//刷新流
		bop.flush();
		//释放资源.优先释放写入对象
		bop.close();
		bip.close();
	}
}

package org.westos.IO流博客练习;

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

/**
 * 解码与编码:
 * 	解码:将看不懂的东西转换为可以看懂的东西;
 * 	编码:将看得懂的东西转换为看不懂的东西;
 *	解码与编码的前后格式要相同;
 *
 *属于String类:
 * 编码:	将字符串变成一个字节数组	
 * 		public byte[] getBytes() :平台默认编码集(默认的是Gbk)
 * 	   	public byte[] getBytes(Charset charset) ;"指定编码格式
 * 
 * 解码:将字节数组--->字符串
 * 		public String(byte[] bytes) :使用平台默认编码集(gbk)
 * 		public String(byte[] bytes,Charset charset):用指定的编码格式来解码
 **/
/**
 * 字符流:
 * 当使用字节流来读取或写入带有中文的文件是会出现乱码;
 * Java就提供了字符流来解决中文乱码问题
 * 读取:Reader类    写入:Writer类   两者都属于抽象类;
 * 所以需要使用它们的子类:
 * Reader子类:BufferedReader		InputStreamReader	FileReader(这是一个便捷类,继承于InputStreamReader类)
 * Writer子类:BufferedWriter		OutputStreamWriter	FileWriter(这是一个便捷类,继承于OutputStreamWriter类)
 **/
/**
 *InputStreamReader:
 *	构造方法:
 *		public InputStreamReader(InputStream in)创建一个使用默认字符集的 InputStreamReader。
 *		public InputStreamReader(InputStream in,Charset cs)创建使用给定字符集的 InputStreamReader。
 *												例如UTF-8或者GBK
 *	方法:
 *		public int read()读取单个字符。 
 *		public int read(char[] cbuf,int offset,int length)将字符读入数组中的某一部分。 
 *		
 *OutputStreamReader: 
 *	构造方法:
 *		public OutputStreamWriter(OutputStream out)创建使用默认字符编码的 OutputStreamWriter。 
 *		public OutputStreamWriter(OutputStream out,Charset cs)创建使用给定字符集的 OutputStreamWriter。 
 *	方法:
 *		public void write(int c)写入单个字符。 
 *		public void write(char[] cbuf,int off,int len)写入字符数组的某一部分。
 *		public void flush()刷新该流的缓冲
 **/
public class Text2 {
	public static void main(String[] args) throws IOException {
		InputStreamReader isr = new InputStreamReader(
				new FileInputStream("e:\\Java.txt"));
		OutputStreamWriter osw  = new OutputStreamWriter(
				new FileOutputStream("e:\\Java2.txt"),"gbk");
		//一次读取一个字符数组
		int len = 0;
		char[] ch = new char[1024];
		while((len = isr.read(ch))!=-1) {
			System.out.println(new String(ch,0,len));//可以在控制台打印出文件内容
			osw.write(ch);
		}
		//刷新流
		osw.flush();
		//释放流资源
		osw.close();
		isr.close();
	}
}

package org.westos.IO流博客练习;

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

/**
 * 由于使用InputStreamReader/OutputStreamWriter创建一个对象太过于繁琐
 * Java提供了一个便捷类:FileReader/FileWriter;
 * 它们都继承与InputStreamReader/OutputStreamWriter
 * */
public class Text3 {
	public static void main(String[] args) throws IOException {
		FileReader fr = new FileReader("e:\\Java.txt");
		FileWriter fw = new FileWriter("e:\\Java3.txt");
		//一次读取一个字符数组
		int len = 0;
		char[] ch = new char[1024];
		while((len = fr.read(ch))!=-1) {
			System.out.println(new String(ch,0,len));
			fw.write(ch);
		}
		//刷新流
		fw.flush();
		//关闭资源
		fw.close();
		fr.close();
	}
}

package org.westos.IO流博客练习;

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

/**
 * BufferedReader:字符缓冲输入流
 * 构造方法
 * 		public BufferedReader(Reader in)创建一个使用默认大小输入缓冲区的缓冲字符输入流。 
 * 		public BufferedReader(Reader in, int sz)创建一个使用指定大小输入缓冲区的缓冲字符输入流。
 * 新增方法:
 * 		public String readLine()读取一个文本行。通过下列字符之一即可认为某行已终止
 * 						换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。 
 * BufferedWriter:字符缓冲输出流
 * 构造方法:
 * 		public BufferedWriter(Writer out)创建一个使用默认大小输出缓冲区的缓冲字符输出流。
 * 		public BufferedWriter(Writer out,int sz)创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
 * 新增方法:
 * 		public void newLine()写入一个行分隔符。
 * 						行分隔符字符串由系统属性 line.separator 定义，并且不一定是单个新行 ('\n') 符。 
 * 		public void write(String s,int off,int len)写入字符串的某一部分。
 * */
public class Text4 {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("e:\\Java.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("e:\\Java4.txt"));
		String str = null;
		while((str = br.readLine())!=null) {
			bw.write(str);
			bw.newLine();//如果不写这条语句,所有写入内容就将显示在同一行上
		}
		//刷新流
		bw.flush();
		//释放资源
		bw.close();
		br.close();
	}
}

package org.westos.IO流博客练习;

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

/**
 *将集合中的数据添加到文本文件中
 * */
public class Text5 {
	public static void main(String[] args) throws IOException{
		ArrayList<Student> list = new ArrayList<Student>();
		Student s1 = new Student("张三",12);
		Student s2 = new Student("李四",13);
		Student s3 = new Student("赵五",14);
		list.add(s1);
		list.add(s2);
		list.add(s3);
		BufferedWriter bw = new BufferedWriter(new FileWriter("e:\\集合.txt"));
		String str = null;
		for(Student s :list) {
			str = s.toString();//转换为String类型
			bw.write(str);
			bw.newLine();
			//刷新资源
			bw.flush();
		}
		//释放资源
		bw.close();
	}
}

package org.westos.IO流博客练习;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/**
 * DataOutputStream/DateInputStream:
 * 数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入
 * 构造方法:
 * 		public DataOutputStream(OutputStream out)
 * 			创建一个新的数据输出流，将数据写入指定基础输出流。计数器 written 被设置为零。
 * 		public DataInputStream(InputStream in)使用指定的底层 InputStream 创建一个 DataInputStream。 
 * 方法:
 * 		对象名.read基础类型();读取
 * 		对象名.write基础类型();写入(它所写入的内容在文件中是我们所看不懂的,只有通过读取可以将其显示在控制台上)
 * */
/**
 * 内存操作流:在一些程序结束之后,内存中中的程序变量就会消失,内存操作流就可以对这些数据进行读取与写入
 * 		ByteArrayInputStream:内存操作输入流
 * 		构造方法:
 * 			public ByteArrayInputStream(byte[] buf)创建一个 ByteArrayInputStream，
 * 				使用 buf 作为其缓冲区数组。该缓冲区数组不是复制得到的。pos 的初始值是 0，count 的初始值是 buf 的长度
 * 		方法:
 * 			public int read()从此输入流中读取下一个数据字节。返回一个 0 到 255 范围内的 int 字节值。
 * 				如果因为到达流末尾而没有可用的字节，则返回值 -1。 此 read 方法不会阻塞。
 * 		ByteArrayOutputStream:内存操作输出流
 * 		构造方法:
 * 			public ByteArrayOutputStream()创建一个新的 byte 数组输出流。
 * 				缓冲区的容量最初是 32 字节，如有必要可增加其大小。
 * 		方法:
 * 			public void write(int b)将指定的字节写入此 byte 数组输出流。 	
 * 注意:
 * 		关闭内存操作流是无效的,仍然可以对其进行操作
 * */
public class Text6 {
	public static void main(String[] args) throws IOException {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		for(int i = 0;i<10;i++) {
			baos.write(("hello"+i).getBytes());//转化为Byte类型
		}
		//从内存中将内从中的数据显到控制台上
		//public byte[] toByteArray():构造一个字符串
		byte[] by = baos.toByteArray();
		//创建输入流对象,并传入Byte[]参数
		ByteArrayInputStream bais = new ByteArrayInputStream(by);
		int bys = 0;
		//一次读取一个字节
		while((bys = bais.read())!=-1) {
			System.out.print((char)bys);
		}
	}
}

package org.westos.IO流博客练习;

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

/**
 *打印流
 *		字符打印流(针对文本进行操作:PrintWriter)
 *		字节打印流(printStream 和标准输出流有关系 System.out;)  
 *
 *PrintWriter:属于输出流
 *			1)只能写数据(只能针对目的地文件进行操作),不能读数据(不能针对源文件进行操作)
 *			2)可以针对文件直接进行操作
 *				如果一个类中的构造方法里面有File对象或者String类型数据,这个类可以对文本文件直接操作
 *				FileInputStream
 *				FileOutputStream
 *				FileWriter
 *				FileReader..
 *				PrintWriter
 *			3)自动刷新功能::PrintWriter(OutputStream out/Writer out,boolean autoflush);第二个参数如果是true 表示启动自动刷新功能
 *			4)打印的方法:print(XXX x)/println(XXX  xx)
 * 
 * */
public class Text7 {
	//复制文件
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("e:\\Java.txt"));
		//true提供了自动刷新功能
		PrintWriter pw = new PrintWriter(new FileWriter("e:\\Java5.txt"),true);
		String line = null;
		while((line = br.readLine())!=null) {
			pw.println(line);
		}
		//关闭
		pw.close();
		br.close();
	}
}

package org.westos.IO流博客练习;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
 *标准的输入输出流
 *		InputStream in = System.in 
 *		PrintStream out = System.out ;
 *
 *jdk5以后,Java--->Scanner(InputStream in)
 *
 *	键盘录入
 *		1)Scanner
 *		2)BufferedReader里面包装字符转换输入流,包装System.in
 * */
public class Text8 {
	public static void main(String[] args) throws IOException {
		
		InputStream in = System.in;
		BufferedReader br = new BufferedReader(new InputStreamReader(in));
		System.out.println("请输入一个字符串");
		String line = br.readLine();
		System.out.println(line);
		System.out.println("请输入一个整数");
		line = br.readLine();
		//使用包装类型转化
		int num = Integer.parseInt(line);
		System.out.println(num);
	}

}

package org.westos.IO流博客练习;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;

/**
 * 标准输出流:返回PrintStream
 * 		PrintStream out = System.out ;
 * */
public class Text9 {
	public static void main(String[] args) throws IOException {
		
		PrintStream ps = System.out;
		ps.println("张三");
		
		
		//装饰者模式
		OutputStream out = System.out;
		BufferedWriter br = new BufferedWriter(new OutputStreamWriter(out));
		br.write("Java");
		br.flush();
		br.close();
	}
}

package org.westos.IO流博客练习;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;

/**
 *SequenceInputStream 表示其他输入流的逻辑串联(合并流)
 * 
 * 
 *构造方法
 * public SequenceInputStream(InputStream s1, InputStream s2)
 * 复制文件
 * 	a.txt----->b.txt
 * 	c.txt----->d.txt
 * 
 * 现在的需求:
 * 		a.txt+b.txt--->c.txt
 * StringDemo.java+SystemInDemo.java---->Copy.java 
 **/
/**
 * 先创建两个FileInoutStream类对象
 * 再将两个对象传入SequenceInputStream
 * 创建接收对象FileOutputStream
 * */
public class Text10 {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("e:\\apple.txt");
		SequenceInputStream sis = new SequenceInputStream(new FileInputStream("e:\\Java.txt"),
				fis);
		FileOutputStream fos = new FileOutputStream("e:合并复制.txt");
		byte[] by = new byte[1024];
		int len = 0;
		while((len = sis.read(by))!=-1){
			fos.write(by,0,len);
		}
		fos.flush();
		fos.close();
		sis.close();
		fis.close();
	}
}