IO流（一）

package io;

import java.io.*;

public class FileWriteDemo {
	public static void main(String[] args) throws IOException {
		
		//构造方法抛异常
		FileWriter write = new FileWriter("test.txt");

		//write方法，三种重载形式(string s) (int i ) (char [])
		write.write("this is a test");
		
		write.flush();
		
		write.close();
		
		
		//打开进行追加，文件存在时，不会覆盖原来的内容
		FileWriter fw = new FileWriter("test.txt",true);
		
		fw.write("ok, append something");
		fw.flush();
		fw.close();
	}
}

package io;
/*
 * 字符输入流
 *
 * 1. int reader() 读取单个字符,返回字符对应的int值,每次读取，指针就会向后移动，指向下一个字符,到文件末尾时，返回-1
 * 2. int reader(char []) 读取一个数组的长度，具体长度由数组的长度决定，返回读取的长度，到文件末尾时，返回-1
 *  
 */

import java.io.*;

public class FileReaderDemo {
	public static void main(String[] args) throws IOException {
		
		FileReader fr = new FileReader("test.txt");
		
		System.out.println((char)fr.read());
		System.out.println(fr.read());
		System.out.println(fr.read());
		System.out.println(fr.read());
		
		fr.close();

		method();
	}
	
	//读取数组
	public static void method ()throws IOException {
		FileReader fe = new FileReader("test.txt");
		
		char[] ch = new char[2];
		
		int i = 0;
		while((i = fe.read(ch)) != -1){
			String s = new String(ch,0,i);
			System.out.print(s);
		}
		
		fe.close();
	}
}

package io;
/*
 * 缓冲区demo
 */
import java.io.*;
public class BufferedWriterDemo {
	public static void main(String[] args) throws IOException{
		
		//创建字符输出流
		FileWriter fw = new FileWriter("E:\\test.txt");
		
		BufferedWriter bw = new BufferedWriter(fw);
		
		bw.write("test!\r132");
		
		bw.newLine();//跨平台性 win下是\r\n  linux下是\n
		
		bw.write("new test!");
		
		bw.flush();
		
		bw.close();

	}
}

package io;
import java.io.*;
/*
 *  BufferedReader
 *  String readerLine() 一次读取一行
 */
public class BufferedReaderDemo {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("E:\\test.txt"));
		String s = null;
		while( (s = br.readLine()) != null){
			System.out.println(s.length() +"..." + s);
		}
		br.close();
	}
}

package io;
import java.io.*;
/*
 * 一个练习，buffered读行，写行，换行
 * 处理异常
 * 目标文件：e:\temp.html
 */
public class CopyTextByBuffered {
	public static void main(String[] args) {
		
		BufferedReader bfr = null;
		BufferedWriter bfw = null;
		
		try{
			//初始化需要用的文件和缓冲区的读取和写入的对象
			bfr = new BufferedReader(new FileReader("E:\\temp.html"));
			bfw = new BufferedWriter(new FileWriter("E:\\newTemp.html"));
			
			String s = null;
			while((s = bfr.readLine()) != null){
				bfw.write(s);
				bfw.newLine();
				bfw.flush();
			}
			
		}catch(IOException e){			
			//
			throw new RuntimeException("文件copy失败");		
		}finally{ //关闭缓冲区
			try{
				bfw.close();
			}catch(IOException e){
				throw new RuntimeException("关闭文件写入缓冲区异常");
			}
			
			try{
				bfr.close();
			}catch(IOException e){
				throw new RuntimeException("关闭文件读取缓冲区异常");
			}
			
		}
	}
}

package io;
/*
 * 自己实现一个类似于BufferReader 里面的 readerline方法
 * 只是练习，直接把异常抛出去，没有做相应的处理
 */
import java.io.*;

public class ReaderLineTest {
	public static void main(String[] args) throws IOException{
		
      //初始化一个FileReader对象
		FileReader fr = new FileReader("E:\\test.txt");
		//讲文件内的内容全部打印出来，使用的文件是BufferedWriter中创建的文件
		String s = null;
		while((s = MeReaderLine(fr)) != null){
			System.out.println(s);
		}

		fr.close();
	}
	
	/*
	 * 传入一个流对象，返回一个String
	 */
	
	public static String MeReaderLine(FileReader fr) throws IOException{
		
		
		
		StringBuffer bf = new StringBuffer();
		
		if(fr == null)
			return  null;
		int temp = 0;
		
		try{
			while((temp = fr.read()) != -1){
				if(temp == 13)
					continue;
				if(temp == 10)
					return bf.toString();

				bf.append((char)temp);
			}
			
			if(bf.length() == 0)
				return null;
			else
				return bf.toString();
		}catch(IOException e){
			throw new RuntimeException("读取失败");
			
		}
	}
}

package io;
/*
 * 键盘输入练习
 * 使用StringBuffer实现内容的不定长读取
 * 1.while永真循环，遇到回车结束，判断\n实现
 * 2.while永真循环，用到规定的字符over结束，用endsWith判断实现
 * 3.使用转换流实现 InputStramReader
 */

import java.io.*;

public class TranseDemo {
	public static void main(String[] args) throws IOException{
		
		//getByKeyboard();
		getBygetByKeyboardAndInputStramReader();
	}
	
	/*
	 * 第3种、转换流思路实现
	 * 规定：over结尾，结束read
	 * 以over结尾的同时，在over之前如果有字符也予以read
	 */
	public static void getBygetByKeyboardAndInputStramReader() throws IOException{
		/*
		 * System.in返回一个BufferedInputStream对象，也就是字节流的子类
		 * 把System.in返回的字节流对象传给InputStreamReader的构造方法，得到转换流
		 * 把转换流传入BufferedReader的构造方法中就得到了BufferedReader的实例对象br
		 */
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		String line = null;
		while((line = br.readLine()) != null){
			if(line.endsWith("over")){
				if(line.length() != 4){
					System.out.println(line.substring(0, line.length()-4));
				}
				break;
			}
			System.out.println(line);
		}
	}
	
	/*
	 * 1.2思路实现
	 */
	public static void getByKeyboard() throws IOException{
		InputStream in = System.in;
		
		StringBuffer sb = new StringBuffer();
		
		int len = 0;
		while(true){
			len = in.read();
			if(len == 13)
				continue;
			if(len == 10){
				
				if(sb.toString().endsWith("over"))
					break;
				System.out.println(sb.toString());
				sb.delete(0, sb.length());
			}
			else{
				sb.append((char)len);
			}
		}
		
	}
}

package io;
/*
 * 转换流demo：
 * 字节流 -> 字符流 -> 程序处理字符流后 -> 字流节
 * 
 * 字符数据输出到字节流中，使用OutputStreamWriter
 * 
 * 程序直接全部使用匿名类对象，要改变输入源和输出源
 * 只需要更改InputStreamReader构造方法传入的参数就OK
 * 因为是示例程序，所以直接把IOException扔出去了
 * 
 * 注意：此demo外部的输入输出都是字节流，内部使用两次转换流
 */

import java.io.*;

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

		/*
		 * 字节流-》字符流
		 * System.in返回一个BufferedInputStream对象，也就是字节流的子类
		 * 把System.in返回的字节流对象传给InputStreamReader的构造方法，得到转换流
		 * 把转换流传入BufferedReader的构造方法中就得到了BufferedReader的实例对象br
		 */
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		/* 字符流-》字节流
		 * System.out返回PrintStream，是OutputStream的子类，也就是字节输出流
		 * PrintStream传入OutputStreamWriter的构造方法，得到一个转换流，此转换流将输出的字符流转为为字节流
		 * 最后使用BufferedWriter装饰类操作
		 */
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		
		String line = null;
		while((line = br.readLine()) != null){
			if(line.endsWith("#")){
				if(line.length() != 1){
					bw.write(line.substring(0, line.length()-1));
					bw.newLine();
					bw.flush();
				}
			
				break;
			}
			else{
				bw.write(line);
				bw.newLine();
				bw.flush();
			}
		}
		//关闭流对象
		br.close();
		bw.close();
	}
}

package io;

/*
 * 转换流的编码效果
 * 
 * 1.实现多种编码输出到文件
 * 2.实现多种编码下的转换流读取
 */
import java.io.*;

public class TranseEncodingDemo {
	public static void main(String[] args) throws IOException {
		
		writeWithGBK();
		writeWithUTF();
		readWithUTF();
		
	}
	
	/*
	 * 在win下GBK实际上是默认的读取方式
	 * 单还是显示实现进行对比
	 * 注意：传入的编码String不区分大小写
	 */
	public static void writeWithGBK() throws IOException{
		//初始化一个转换流对象
		OutputStreamWriter ow = new OutputStreamWriter(new FileOutputStream("E:\\textByGBK.txt"),"GBK");
		
		ow.write("这是一个测试！");
		
		ow.flush();
		ow.close();
	}
	
	/*
	 * 实现UTF-8的编码输出到文件
	 * 注意：传入的编码String不区分大小写
	 */
	public static void writeWithUTF() throws IOException{
		//初始化一个转换流对象
		OutputStreamWriter ow = new OutputStreamWriter(new FileOutputStream("E:\\textByUTF.txt"),"UTF-8");
		ow.write("这是一个测试！");
		ow.flush();
		ow.close();
	}
	
	/*
	 * 读取gbk就不写了，直接实现读取utf8
	 * 按照默认的gbk编码读取输出：杩欐槸涓?涓祴璇曪紒  （乱码了）
	 * 按照指定的编码utf-8输出：这是一个测试！  （正确）
	 */
	public static void readWithUTF() throws IOException{
		
		InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\textByUTF.txt"),"UTF-8");
		
		char[] ch = new char[20];
		int len = isr.read(ch);
		System.out.println(new String(ch).substring(0, len).toString());
		isr.close();
	}
}

package io;

/*
 * 汉字的编码和解码练习
 * 编码
 * utf-8 : -26 -99 -88 -26 -81 -108 -24 -67 -87 
 * gbk : -47 -18 -79 -56 -48 -7 
 * Unicode: -2 -1 103 104 107 -44 -113 105 
 * 
 * 解码和编码会有异常，懒得处理，直接抛了
 */
public class EncodingDemo {
	public static void main(String[] args) throws Exception {
		
		String s = "杨比轩";
		
		byte[] by = s.getBytes("gbk");
		
		for(byte b : by){
			System.out.print(b + " ");
		}
		
		System.out.println("\n" + decoding(by,"gbk"));
		
	}
	
	/*
	 * 解码方法
	 */
	public static String decoding(byte[] by, String coding) throws Exception{
		return new String(by,coding);
	}
}