java之19天 IO 转换流(三)

读取键盘录入
转换流的使用

/**
 * 读取键盘录入
 * System.out : 对应的是标准的输出设备,默认:控制台
 * System.in  : 对应的是标准的输入设备,默认:键盘
 * 
 * 需求:
 * 通过键盘录入数据
 * 当录入一行数据后,就将该行数据进行打印.
 * 如果录入的数据是over,那么 停止录入.
 * 
 * InputStreamReader: 字节转 字符 读取流
 * 通过需求变形2,发现 其实就是读取一行readLine的原理
 * 思考:
 *   能不能直接使用readLine方法完成键盘录入一行数据的读取呢?
 *   readLine()是字符流BufferedReader类的方法
 *   而键盘录入的read方法是字节流InputStream的方法
 *   那么能不能将字节流转换成字符流在使用字符流缓冲区的readLine()方法呢? 
 *   (请看变形3)
 *
 * OutputStreamWriter: 字节转 字符  写入流
 */
public class ReadIn {
	public static void main(String[] args) throws IOException {
		 //method_1();
		 //method_2();
		method_4();
	}
	
	//既然有 字节 --转--字符 读取流 肯定有字节 --转--字符写入流
	public static void method_4() throws IOException{
		
		/*//接受键盘输入
		InputStream in=System.in;
		//转换流读取流:  字节 -->字符
		InputStreamReader isr=new InputStreamReader(in);
		//读取
		BufferedReader bufr=new BufferedReader(isr);*/
		
		//简写 上面三句
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		
		//设置输出的目的地
		/*OutputStream out=System.out;
		//转换流写入流:   字节 -->字符
		OutputStreamWriter osw=new OutputStreamWriter(out);
		BufferedWriter bufw=new BufferedWriter(osw);*/
		
		//简写 上面三句
		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
		
		String line=null;
		while((line=bufr.readLine())!=null){
			if("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();
	}
	
	
	//发现 变形2  其实就是读取一行的原理
	public static void method_3() throws IOException{
		//获取键盘录入对象.
		InputStream in=System.in;
		
		//将字节流转换成字符流对象,使用转换流,InputStreamReader
		InputStreamReader isr=new InputStreamReader(in);
		
		//为了提高效率,将字符串进行缓冲区技术搞笑操作,使用BufferedReader
		BufferedReader bufr=new BufferedReader(isr);
		
		String line=null;
		while((line=bufr.readLine())!=null){
			if("over".equals(line))
				break;
			System.out.println(line.toUpperCase());
		}
		bufr.close();
	}
	
	//需求 变形2
	public static void method_2() throws IOException{
		InputStream in=System.in;
		StringBuilder sb=new StringBuilder();
		
		while(true){
			int ch=in.read();
			if(ch==13) //13='\r'
				continue;
			if(ch==10){
				String s=sb.toString();
				if("over".equals(s))
					break;
				System.out.println(s.toUpperCase());
				sb.delete(0, sb.length());
			}else{
				sb.append((char)ch);
			}
		}
		
	}

	
	//需求 变形1
	public static void method_1() throws IOException{
		InputStream in=System.in;
		int ch=0;
		while((ch=in.read())!=-1){
			System.out.println(ch);
		}
	}
	
	
	//键盘输入
	public static void method() throws IOException{
		InputStream in=System.in;
		int by=in.read();// 阻塞式方法
		System.out.println(by);
		int by1=in.read();// 阻塞式方法
		System.out.println(by1);
		
		//window中的换行
		System.out.println('\r'+0);  //13
		System.out.println('\n'+0);//10
	}

}

流的一般操作规律

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/**
 * 1.
 * 源:键盘录入
 * 目的:控制台
 *
 * 2.需求:想把键盘录入的数据存储到一个文件中.
 * 源:键盘
 * 目的:文件
 * 
 * 
 * 3.需求:想要将一个文件的数据打印在控制台上.
 * 源:文件
 * 目的:控制台
 * 
 * 
 * 流操作的基本规律
 * 最痛苦的就是流对象有很多,不知道用那个 
 * 
 * 通过三个明确来完成
 * 1.明确源和目的
 * 		源    : 输入流    InputStream     Reader
 *      目的: 输出流    OutputStream    Writer
 * 2.明确操作的数据是否是纯文本
 *      是    : 字符流   
 *      不是: 字节流 
 * 3.当体系明确后,在明确要使用哪个具体的对象
 *    通过设备来进行区分
 *    源设备    :内存,硬盘 ,键盘
 *    目的设备:内存 ,硬盘,控制台 
 *    
 * 1.需求:将一个文本文件数存储到另一个文件.--复制文件
 *    源     :因为是源,所以使用 读取流   InputStream Reader
 *        是不是操作文本文件?
 *        是: 这是就可以选择Reader. 这样体系就明确了
 *        接下来明确要使用该系统中的哪个对象 
 *        明确设备?--> 硬盘上的一个文件
 *        Rreader 体系中 可以操作文具的对象 是 FileReader.
 *        
 *        FileReader fr=new FileReader("a.txt");
 *        
 *        是否需要提高效率呢?
 *        是! 加入Reader体系缓存去中 的 BufferedReader
 *        
 *        BufferedReader bufr=new BufferedReader(fr);
 *        
 *        
 *    目的 :OutputStream Writer
 *      目的是否是纯文本呢?
 *      是:Writer
 *      设备:硬盘,一个文件
 *      Writer体系中可以操作文件的对象是:FileWriter
 *      
 *      FileWriter fw=new FileWriter("b.txt");
 *       
 *      是否需要提高效率呢?
 *      是! 加入Writer体系缓存去中 的 BufferedWriter
 *      
 *      BufferedWriter bufw=new BufferedWriter(fw);
 *      
 * 练习:将一个图片文件中数据存储到另一个文件中,复制文件,要按照以上格式自己完成三个明确
 *   源:因为是源:所以可以选择读取流是 InputStream Reader
 *     是不是操作文本文件?
 *     不是! 所以选择 InputStream
 *     明确体系中使用的那个对象 ?
 *     明确设备--->硬盘上一个图片
 *     InputStream 体系中可以操作 字节流的对象是 :FileInputStream
 *     FileInputStream fis=new FileInputStream("a.jpg");
 *     
 *     是否要提高效率呢?
 *     是! 加入InputStream体系中缓冲区 BufferedInputStream
 *     BufferedInputStream bufis=new BufferdInputStream(fis)
 *     
 *    目的:OutputStream Writer
 *      图片: OutputStream
 *      硬盘上的一个文件
 *      FileOutputStream fos=new FileOutputStream("b.jpg");
 *      是否提高效率?
 *      是:
 *      BufferedOutputStream bufos=new BufferedOutputStream(fos);
 *      
 *    
 * -----------------------------    
 * 2.需求:将键盘录入的数据保存到一个文件中
 *    源:InputStream Reader
 *       是不是纯文本? 是: Reader
 *       设备:键盘  对应的对象是Sytem.in
 *       不是选择Reader吗? System.in对应的不是字节流吗?
 *       为了操作键盘的文件数据方便,转成字符流按照字符串操作的最方便.
 *       所以既要明确Reader 那么就需要将System.in转成 Reader
 *       用了Reader 体系中的InutStreamReader.
 *       
 *       InputStreamReader isr=new InputSreamReader(System.in);
 *       
 *       需要提高 效率吗? 需要 BufferedReader
 *       BufferedReader bufr=new BufferedReader(isr);
 *           
 *    目的:OutputStream Writer
 *    是否是纯文本?是 Writer
 *    设备:硬盘,一个文件,使用 FileWriter
 *    FileWriter fw=new FileWriter("c.txt");
 *    需要提高效率吗?
 *    BufferedWriter bufw=new BufferedWriter(fw)
 *    
 *      
 *      
 * 扩展下:想要把录入的数据按照指定的编码表(utf-8)将数据保存到文件中
 *   目的: OutputStream Writer
 *    是否是纯文本?是 Writer
 *    设备:硬盘,一个文件,使用 FileWriter
 *    但是FileWriter使用的默认编码表  GBK
 *   
 *    但是要存储的是,需要加入指定的编码表UTF-8 而指定的编码表只有转换流可以指定.
 *    所以要使用的对象是OutputStreamWriter
 *    而该转换流对象要接受一个字节输出流,而且还可以操作文件的字节输出流, FileOutputStream
 *    
 *    OutputStraemWriter osw=new OutputStreamWriter(new FileOutputStream("a.txt"),"UTF-8");
 *    
 *    需要提高效率吗?
 *    是
 *    BufferedWriter bufw=new Buffered(osw);
 *    所以,记住,转换流什么时候用? 字节和字符之间的桥梁,通常,涉及到的字符编码转换时候,需要使用大转换流.
 *    
 */
public class TransStreamDemo2 {

	public static void main(String[] args) throws IOException {
		//method();
		//method_1();
		
		//method_2();
		method_3();
	}
	//读取上面 d.txt 由于是UTF-8所以不能使用 FileReader,因为FileReader 使用 的GBK
	public static void method_3() throws IOException{
		BufferedReader bufr=new BufferedReader(new InputStreamReader(new FileInputStream("E:\\workspace4\\exam\\d.txt"),"UTF-8"));
		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
		
		String line=null;
		while((line=bufr.readLine())!=null){
			bufw.write(line);
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();
	}
	
	//输出到指定编码格式的文件中  UTF-8
	public static void method_2() throws IOException, FileNotFoundException{
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		
		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8"));
		
		String line=null;
		while((line=bufr.readLine())!=null){
			if("over".equals(line))
				break;
			bufw.write(line);
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();
	}
	
	
	
	//需求2
	public static void method_1() throws IOException{
		BufferedReader bufr=new BufferedReader(new InputStreamReader(new FileInputStream("E:\\workspace4\\exam\\src\\com\\itheima\\day19\\p1\\CopyPic.java")));
		
		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
		
		String line=null;
		while((line=bufr.readLine())!=null){
			if("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();
		
	}
	//需求2:
	public static void method() throws IOException{
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		
		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("outputSteam.txt")));
	
		String line=null;
		while((line=bufr.readLine())!=null){
			if("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();
	}

}

改变标准的输入输出设备

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;


/**
 * 改变默认的输出 :控制台
 * 和输入设备:键盘 
 * System.setIn()
 * System.setOut()
 */
public class TransSystemInOutDemo {

	
	public static void main(String[] args) throws IOException {
		method_2();
	}
	//输出到指定编码格式的文件中  UTF-8
	public static void method_2() throws IOException{
		
		//修改源
		System.setIn(new FileInputStream("E:\\workspace4\\exam\\FileReaderDemo_copy.txt"));
		//修改目的
		System.setOut(new PrintStream("zz.txt"));
		
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		
		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));
		
		String line=null;
		while((line=bufr.readLine())!=null){
			if("over".equals(line))
				break;
			bufw.write(line);
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();
	}
}

异常的日志信息

import java.io.IOException;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 异常信息的保存
 * 网络上有个 log4j工具 专门用于处理 日志信息的打印 
 */
public class ExceptionInfo {
	public static void main(String[] args) {
		method_4();
	}
	
	//变形4 加入异常发生的时间
	public static void method_4() {
		try {
			int[] arr=new int[2];
			System.out.println(arr[3]);
		} catch (Exception e) {
			try {
				Date d=new Date();
				SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				String s=sdf.format(d);
				PrintStream ps=new PrintStream("exception.log");
				//	ps.print(d.toString());
				ps.println(s);
				System.setOut(ps);
				ps.close();
			} catch (Exception e2) {
				throw new RuntimeException("日志文件创建失败!");
			}
			e.printStackTrace(System.out);
		}
	}
	
	
	//变形 三  发现 还不够完善  没有时间啊 
	public static void method_3() {
		try {
			int[] arr=new int[2];
			System.out.println(arr[3]);
		} catch (Exception e) {
			try {
				System.setOut(new PrintStream("exception.log"));
			} catch (Exception e2) {
				throw new RuntimeException("日志文件创建失败!");
			}
			e.printStackTrace(System.out);
		}
	}
	
	//变形二 打印大文件中去
	public static void method_2() throws IOException{
		try {
			int[] arr=new int[2];
			System.out.println(arr[3]);
		} catch (Exception e) {
			e.printStackTrace(new PrintStream("a.txt"));  //发现原来还打印在控制台了
		}
		
	}
	
	
	//变形一
	//e.printStackTrace() -->里面写的就是 e.printStackTrace(System.out)
	public static void method_1(){
		try {
			int[] arr=new int[2];
			System.out.println(arr[3]);
		} catch (Exception e) {
			e.printStackTrace(System.out);  //发现原来还打印在控制台了
		}
		
	}
	public static void method(){
		try {
			int[] arr=new int[2];
			System.out.println(arr[3]);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
}

格式化系统信息输出

import java.io.IOException;
import java.io.PrintStream;
import java.util.Properties;

public class SystemInfo {

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

		Properties prop=System.getProperties();
		//以前 
		System.out.println(prop);
		
		//Properties 能够和流相连
		prop.list(System.out); //发现还是打印在控制台
		
		//想保存在文件中 
		prop.list(new PrintStream("systemInfo.txt"));  //这个流没有关闭哦 
		
	}

}