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")); //这个流没有关闭哦
}
}