IO流学习笔记

通过Buffered复制文件

package javaBase.io;
import java.io.*;
//通过字符流复制文件
public class FileCopyReadWrite {
	public static void main(String[] args) {
		copy();
	}
	public static void copy(){
		BufferedReader br = null;
		BufferedWriter bw = null;
		try {
			br = new BufferedReader(new FileReader("original.java"));
			bw = new BufferedWriter(new FileWriter("original_copy.java"));
			String str = null;
			while((str = br.readLine())!=null){
				bw.write(str);
				bw.newLine();//readLine（）不返回任何行终止符
				bw.flush();
			}
		} catch (IOException e) {
			throw new RuntimeException("read_write error !");
		}finally{
			try {
				if(br!=null)
				br.close();
			} catch (IOException e) {
				throw new RuntimeException("read error !");
			}
			try {
				if(bw!=null)//不判断的话可能会报空指针的错误
				bw.close();
			} catch (IOException e) {
				throw new RuntimeException("write error !");
			}
		}
	}
}

自定义一个BufferedReader  实现readLine（）方法

package javaBase.io;
import java.io.*;
//自定义一个BufferedReader来模拟实现readLine方法
class MyBufferedReader {
	private FileReader fr;
	public MyBufferedReader(FileReader fr){//构造方法
		this.fr = fr;
	}
	public String myReadLine() throws IOException{
		
		//定义一个临时容器来存放一行的数据，源码使用字符数组
		//这里用StringBuilder（可变字符序列，非线程安全），最终都是要转成String返回的
		StringBuilder sb = new StringBuilder();
		int ch = 0;
		while((ch = fr.read())!= -1){
			if(ch == '\r')
				continue;
			if(ch =='\n')
				return sb.toString();
			else
				sb.append((char)ch);
		}
		if(sb.length()!=0)//最后一行若是没有换行符的处理
			return sb.toString();
		return null;
	}
	public void myClose() throws IOException{
		fr.close();
	}
}

class MyReadLine{
		public static void main(String[] args) throws IOException {
			MyBufferedReader mybr = new MyBufferedReader(new FileReader("original.java"));
			String str = null;
			while((str = mybr.myReadLine())!=null){
				System.out.println(str);
			}
			mybr.myClose();
		}
	
	
}

字节流读取写入操作

package javaBase.io.stream;
import java.io.*;

//想要处理图片，视频等非文本数据，得用字节流
public class FileOutPutStreamDemo {
	public static void main(String[] args) throws IOException{
		writeFile();
		readFile();
	}
	public static void readFile() throws IOException {
		FileInputStream fi = new FileInputStream("original.java");
		byte[] buff = new byte[1024*2];//缓冲，用available（）数据太大可能出现内存溢出
		int len = 0;
		while((len = fi.read(buff))!=-1){//len是读入缓冲区字节总数
			System.out.println(new String(buff,0,len));//String类的构造方法之一
		}
		fi.close();
	}
	public static void writeFile() throws IOException{
		FileOutputStream fo = new FileOutputStream("original.java");
		fo.write("abcde".getBytes());//字符串转byte[],  toCharArray()是转char[]
		fo.close();
	}
}

字节流复制图片

package javaBase.io.stream;

import java.io.*;

public class CopyPic {
	public static void main(String[] args) {
		copyFile();
	}

	public static void copyFile() {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("E:\\Admin\\workspace\\itHeima\\man.jpg");
			fos = new FileOutputStream(	"E:\\Admin\\workspace\\itHeima\\man_copy.jpg");
			byte[] buff = new byte[1024 * 4];
			int len = 0;
			while ((len = fis.read(buff)) != -1) {
				fos.write(buff, 0, len);// 写入有效数据
			}
		} catch (IOException e) {
			throw new RuntimeException("读写失败");
		} finally {
			try {
				if (fis != null)
					fis.close();
			} catch (IOException e) {
				throw new RuntimeException("读失败");
			}
			try {
				if (fos != null)
					fos.close();
			} catch (IOException e) {
				throw new RuntimeException("写失败");
			}
		}
	}
}

通过键盘录入数据，每输入一行结束就转换为大写打印出来

遇到over结束

package javaBase.io.stream;

import java.io.*;
//通过键盘录入数据，每输入一行结束就转换为大写打印出来
//遇到over结束

public class SystemInDemo {
	public static void main(String[] args) throws IOException {
		//streamInLine();
		castInLine();//
	}
	/**
	 * 字节流字符流转换
	 */
	public static void castInLine() throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//键盘录入标准写法
		String str = null;
		while((str =br.readLine())!=null){
			if("over".equalsIgnoreCase(str))
				break;//定义键盘录入结束标记，否则按CTRL+C
			System.out.println(str.toUpperCase());
		}
		br.close();
	}
	/** 
	 * 字节流方法
	 */ 
	public static void streamInLine() throws IOException {
		InputStream in = System.in;
		
		StringBuilder sb = new StringBuilder();
		while (true) {
			int ch = in.read();
			if (ch == '\r')
				continue;
			if (ch == '\n') {
				String s = sb.toString();
				if ("over".equalsIgnoreCase(s)) {// 字符串的比较
					break;
				}
				System.out.println(s.toUpperCase());
				sb.delete(0, sb.length());// 每打印一次就清空缓冲
			} else // 必须有，不然在没有输入over的情况下每次清空sb后都会执行下面的语句，sb开头都带'\n'
				sb.append((char) ch);
		}

	}
}

printWriter

package javaBase.io.others;

import java.io.*;

/* 
 * PrintWriter 构造函数接收参数：
 * 1，字符串路径
 * 2，File对象
 * 3，字节输出流outputstream
 * 4，Writer（PrintStream没有）
 */
public class PrintWriterDemo {
	public static void main(String[] args) throws IOException{
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out,true);//TRUE会对println自动刷缓冲
//		PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);//File同样可以
		String line = null;
		while((line = in.readLine())!=null){
			if("over".equals(line))
				break;
			out.println(line);
		}
		in.close();
		out.close();
	}
}

Piped管道流

package javaBase.io;
import java.io.*;
/*
 * 读取管道流
 */
class ReadThread implements Runnable{
	private PipedInputStream in;
	ReadThread(PipedInputStream in){
		this.in = in;
	}
	@Override
	public void run() {
		byte[] buff = new byte[1024];
		try {
			System.out.println("读取之前");
			int len = in.read(buff);
			System.out.println("读好了");
			String str = new String(buff,0,len);
			System.out.println(str);
			in.close();
		} catch (IOException e) {
			throw new RuntimeException("管道读取异常");
		}
	}
	
}
/*
 * 写入管道流
 */
class WriteThread implements Runnable{
	private PipedOutputStream out ;
	public WriteThread(PipedOutputStream out) {
		this.out = out;
	}
	@Override
	public void run() {
		
		try {
			System.out.println("写线程休息4秒");
			Thread.sleep(4000);//interruption异常不是IO异常
			out.write("write some thing.....".getBytes());//字符串转字节数组
			out.close();
			
		} catch (Exception e) {
			throw new RuntimeException("管道写入异常");
		}
	}
	
}
public class PipedStreamDemo {
	public static void main(String[] args) throws IOException {
		PipedInputStream in = new PipedInputStream();
		PipedOutputStream out = new PipedOutputStream();
		in.connect(out);//out作为in 的输入
		WriteThread write = new WriteThread(out);
		ReadThread read = new ReadThread(in);
		new Thread(write).start();
		new Thread(read).start();
		
	}
}