core java--day20(PipedInputStream,PrintStream(out.println),字符流 :BufferedReader/PrintWrite,转换流)

java 专栏收录该内容
22 篇文章 0 订阅

复习:
    FileInputStream:
        没有该文件会报FileNo异常
    FileOutputStream:
        创建新文件,追加
    Properties:
        配置文件,把代码中一些可能发生改变的数据写到配置文件中,可以使代码变灵活,,,代码不用改,只需该配置文件的值
        hashtable的子类


    3.4: 字节流:PipedInputStream/PipedOutputStream 管道输入/输出流。一般结合线程来用。
        问题一:管道输入/输出流,这个输入/输出是相对于谁来说。
            答    :相对于当前代码来说
        问题二:管道输入流/输出流 怎么连接起来。
            答    :创建对象的时候用构造器传值就可以了。

package com.briup.ch20;

import java.io.IOException;
import java.io.InputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

//管道输入 输出流 多线程使用
public class Test2 {
	public static void main(String[] args) throws Exception {
		//管道输入
		PipedInputStream pis = 
				new PipedInputStream();
		// 管道输出
		PipedOutputStream pos = 
				new PipedOutputStream();
		//管道链接
		pis.connect(pos);
		
		//构建线程
		Read r = new Read(pis);
		Write w = new Write(pos);
		r.start();
		w.start();
	}
}
//从管道中拿数据
class Read extends Thread{
	//管道输入流
	PipedInputStream pis;
	@Override
	public void run() {
		while(true) {
			try {
				//从管道中死循环读数据
				System.out.println(pis.read());
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	public Read(PipedInputStream pis) {
		this.pis = pis;
	}
}
class Write extends Thread{
	//管道输出流
	PipedOutputStream pos;
	public Write(PipedOutputStream pos) {
		this.pos = pos;
	}
	@Override
	public void run() {
		System.out.println("管道输出流");
		try {
			//从控制台读取数据的类
			InputStream in = System.in;
			while(true) {
				//从控制台读取一个数据
				int read = in.read();
				//写到管道中
				pos.write(read);
				pos.flush();
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}


    3.5: 字节包装流 : BufferedInputStream/BufferedOutputStream 有缓冲区的包装流
        特点:有缓冲区的包装流 效率 会高一些,可以使用mark和reset功能(标记 回读 功能)
        提高效率的原因:BufferedInputStream对外提供滑动读取的功能实现,通过预先读入一整段原始输入流数据至缓冲区中,而外界对BufferedInputStream的读取操作实际上是在缓冲区上进行,如果读取的数据超过了缓冲区的范围,那么BufferedInputStream负责重新从原始输入流中载入下一截数据填充缓冲区,然后外界继续通过缓冲区进行数据读取。这样的设计的好处是:避免了大量的磁盘IO,因为原始的InputStream类实现的read是即时读取的,即每一次读取都会是一次磁盘IO操作(哪怕只读取了1个字节的数据),可想而知,如果数据量巨大,这样的磁盘消耗非常可怕。而通过缓冲区的实现,读取可以读取缓冲区中的内容,当读取超过缓冲区的内容后再进行一次磁盘IO,载入一段数据填充缓冲,那么下一次读取一般情况下就直接可以从缓冲区读取,减少了磁盘IO。
    
        3.5.1:构造器 new BufferedInputStream(字节流,缓冲区大小);//默认缓冲大小是8192字节
        
        3.5.2:构造器 new BufferedOutputStream(字节流,缓冲区大小)//默认缓冲大小是512字节
    

package com.briup.ch20;

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

//包装流:BufferedInputStream
//包装流:BufferedOutputStream45
public class Test3 {
	public static void main(String[] args) throws Exception {
		//文件输出流
		FileOutputStream fos = 
				new FileOutputStream("a.txt",true);
		//包装
		BufferedOutputStream bos = 
				new BufferedOutputStream(fos, 100);
		
		bos.write(97);
		bos.flush();
		
		bos.close();
		fos.close();
		
	}
	
	
	public static void mainIn(String[] args) throws Exception {
		//被包装的流
		FileInputStream fis =
				new FileInputStream("a.txt");
		//没有缓冲区的流 不支持 标记 回读
		System.out.println(fis.markSupported());
	
		//包装流,去包装 fis
		BufferedInputStream bis =
				new BufferedInputStream(fis);
		//有缓冲区的流 支持 标记 回读
		System.out.println(bis.markSupported());
		
		
		//返回-1 读取到流末尾
		bis.read();
		//关闭 : 先开的流 后关闭
		bis.close();
		fis.close();
	}
}







    3.6: 字节包装流 : DataInputStream/DataOutputStream 读取/写出 某个类型的数据
        
        特点:可以一次写一个int/long/double 基本数据类型+String的数据流中,可以从流中一次读取一个基本数据类型的数据。
        
        注意:是通过基本数据类型数据的 字节数 进行读取 ,如果a.txt中有一个字符6, 不能用readInt()去读取,因为这个6代表的字节数不是int所代表的字节数。
        
        推荐:使用DataInputStream读取数据 最好是读取 用DataOutputStream 写出去的数据。不然读取不到想要的效果。
    
        任务:利用DataOutputStream+ByteArrayOutputStream获得1000L所对应的字节数组。

     

package com.briup.ch20;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Test5 {
	
	public static void main(String[] args) throws Exception {
		// 基础输出流
		FileOutputStream fos = new FileOutputStream("b.txt");
		// 写一个boolean 写一个int
		// 使用字节包装流 进行包装
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeInt(1000);
		dos.flush();
		dos.close();
		fos.close();
		// 读
		// 基础输入流
		FileInputStream fis = new FileInputStream("b.txt");
		// 包装
		DataInputStream dis = new DataInputStream(fis);
		//读取到流末尾 EOFException
		System.out.println(dis.readLong());
		dis.close();
		fis.close();

	}

	public static void mainLong(String[] args) throws Exception {
		// 基础输出流
		FileOutputStream fos = new FileOutputStream("b.txt");
		// 写一个boolean 写一个int
		// 使用字节包装流 进行包装
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeLong(1000L);
		dos.flush();
		dos.close();
		fos.close();

		// 基础输入流
		FileInputStream fis = new FileInputStream("b.txt");
		// 包装
		DataInputStream dis = new DataInputStream(fis);
		// 安装写入的顺序读
		// 写了一个long 1000L 64位 8字节
		// readInt() int 32 4字节
// 0000 0000 0000 0000 0000 0000 0000 0000
// 0000 0000 0000 0000 0000 0011 1110 1000
//对应的字节数组
//     0         0         0         0
//     0         0         3        -24
	
		System.out.println(dis.readInt());
		System.out.println(dis.readInt());

		dis.close();
		fis.close();
	}
}
package com.briup.ch20;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.util.Arrays;

//把数字1000L转换为字节数组
public class Test6 {
	public static void main(String[] args) throws Exception {
		//字节数组输出流 ,把数据输出到字节数组中
		ByteArrayOutputStream baos = 
				new ByteArrayOutputStream();
		//想写一个Long 1000L
		DataOutputStream dos = 
				new DataOutputStream(baos);
		dos.writeLong(1000L);
		//把缓冲区的数据转换为字节数组
		byte[] bs = baos.toByteArray();
		dos.close();
		baos.close();
		//打印字节数组
		System.out.println(Arrays.toString(bs));
		
	}
}


     3.6: 字节包装流 PrintStream  为另一个输出流添加了功能
    PrintStream ps = new PrintStream(file);
    常见用法例子:
        // 定义一些变量,用来格式化输出。  
        double d = 345.678;  
        String s = "你好!";  
        int i = 1234;  
        // "%"表示进行格式化输出,"%"之后的内容为格式的定义。 
        // "f"表示格式化输出浮点数。 
        ps.printf("%f", d); //345.678000
        ps.println();  
        // "9.2"中的9表示输出的长度,2表示小数点后的位数。 注意输出数字前面的空格 
        ps.printf("%9.2f", d);//   345.68
        ps.println();  
        // "+"表示输出的数带正负号。  
        ps.printf("%+9.2f", d);//  +345.68
        ps.println();  
        // "-"表示输出的数左对齐(默认为右对齐)。  
        ps.printf("%-9.4f", d);//345.6780
        ps.println();  
        // "+-"表示输出的数带正负号且左对齐。  
        ps.printf("%+-9.3f", d);//+345.678
        ps.println();  
        // "d"表示输出十进制整数。
        ps.printf("%d", i);//1234
        ps.println();  
        // "o"表示输出八进制整数。 
        ps.printf("%o", i);//2322
        ps.println();  
        // "x"表示输出十六进制整数。  
        ps.printf("%x", i);//4d2
        ps.println();  
        // "#x"表示输出带有十六进制标志的整数。  
        ps.printf("%#x", i);//0x4d2
        ps.println();  
        // "s"表示输出字符串。
        ps.printf("%s", s);//你好! 
        ps.println();  
        ps.printf("输出一个浮点数:%f,一个整数:%d,一个字符串:%s", d, i, s);
    //输出一个浮点数:345.678000,一个整数:1234,一个字符串:你好!

package com.briup.ch20;

import java.io.PrintStream;

//打印 包装流
public class Test7 {
	public static void main(String[] args) throws Exception {
		PrintStream ps = 
				new PrintStream(System.out);
		ps.write(97);
		ps.print(true);
		ps.print("小明");
		ps.println("小红");//多一个灰回车换行
		//格式化输出
		//format 输出的格式,args 输出的数据
		//ps.printf(format, args);
		
		 double d = 345.678;  
		 ps.printf("%f", d); //345.678000
	     ps.println();  
		
	     
	}
}

  3.7:  字符流 : CharArrayReader/CharArrayWriter有缓冲区的字符输入/输出流.可使用 toCharArray() 和 toString() 获取数据。 
    

package com.briup.ch20;

import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.util.Arrays;

//字符流
public class Test8 {
	public static void main(String[] args) throws Exception {
		//获得字符数组
		String msg = "hello world";
		char[] buf = msg.toCharArray();
		
		//字符输入流
		CharArrayReader car = 
				new CharArrayReader(buf); 
		//读取字符数组中的数据
		int read = car.read();
		System.out.println(read);
		char[] cbuf = new char[20];
		//每次读取到的数据放到字符数组中
		car.read(cbuf);
		car.close();
		//------------字符输出流-------------
		CharArrayWriter caw =
				new CharArrayWriter();
		//数据都写到了 字符数组缓冲区
		caw.write(97);
		caw.write("tom");
		
		caw.append("lisi");
		caw.flush();
		//把字符数组中的数据导出为字符串
		String da = caw.toString();
		//把字符数组中的数据导出 字符数组
		char[] cs = da.toCharArray();
		System.out.println("字符串 :"+da);
		System.out.println(Arrays.toString(cs));
		
	}
}






    3.8:  字符流 :FileReader/FileWriter 每次读取的是字符,可以查看,可以操作。
    

package com.briup.ch20;

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

//FileReader
public class Test9 {
	public static void main(String[] args) throws Exception {
		
		//文件字符输入流
		FileReader fr = new FileReader("a.txt");
		
		char[] cbuf= new char[1000];
		
		int len = fr.read(cbuf);
		
		String msg = new String(cbuf,0,len);
		System.out.println(msg);
		//----------字符文件输出流----------------
		FileWriter fw = new FileWriter("a.txt");
		
		fw.append("字符串");
		
		fw.write('a');
		
		fw.write("hello");
		
		fw.flush();
		fw.close();
		
	
		
	}
}


    3.9:  字符流 :BufferedReader/PrintWriter :读取一行/写出一行
    

package com.briup.ch20;

import java.io.BufferedReader;
import java.io.FileReader;
//字符包装流
//有缓冲区的字符输入流 BufferedReader
public class Test10 {
	public static void main(String[] args) throws Exception {
		//字符输入流
		FileReader fr = new FileReader("a.txt");
		//字符输入 包装流  
		BufferedReader br = new BufferedReader(fr); 
		
		/*while(true) {
			// null
			String readLine = br.readLine();
			System.out.println(readLine);
			if(readLine==null) {
				break;
			}
		}
		br.close();
		fr.close();*/
		
		
		String da = "";
		while(  (da = br.readLine())!=null   ) {
			System.out.println(da);
		}

		
	}
}
package com.briup.ch20;

import java.io.BufferedReader;
import java.io.FileReader;

//BufferedReader 小问题 53
public class Test11 {
	public static void main(String[] args) throws Exception {
		FileReader fr = new FileReader("a.txt");
		//包装,要一次读取一行
		BufferedReader br = new BufferedReader(fr);
		//不会读取本行最后的\r\n
		String msg = br.readLine();
		
		System.out.println(msg);
		System.out.println(msg.length());
		
		br.close();
		fr.close();
	}
}
package com.briup.ch20;

import java.io.PrintWriter;

//PrintWriter
public class Test12 {
	public static void main(String[] args) throws Exception {
		//以GBK编码写数据到a.txt
		//参数 csn  为 编码
		PrintWriter pw = 
				new PrintWriter("a.txt", "UTF-8");
		pw.write("中文");
		pw.append("字符").append("\r\n").append("tom").append("为");
		pw.print("很好");
		pw.println("看着");
		pw.println("看着");
		pw.println("看着");
		pw.flush();
		pw.close();
		
	}
}


    3.10: 转换流 : 字节输入流转换为字符输入流:InputStreamReader
            字节输入流转换为字符输入流:OutputStreamWriter
          特  点 : 将字节流转换为字符流的时候可以 设置编码
    

package com.briup.ch20;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

//转换流 : 字节输出 --> 字符输出
public class Test13 {
	public static void main(String[] args) throws Exception {
		//数据写到文件中,true追加
		FileOutputStream fos = 
				new FileOutputStream("a.txt",true);
		//转换流,把字节流转换为字符流
		OutputStreamWriter osw = 
				new OutputStreamWriter(fos,"UTF-8");
		//得到字符输出流,一次写一行数据
		PrintWriter pw = new PrintWriter(osw);
		
		pw.append("李四").append("中午");
		pw.println("吃饭");
		
		pw.close();
		osw.close();
		fos.close();
		
		//-----------字节输入转换为字符输入流-----
		
		FileInputStream fis = 
			new FileInputStream("a.txt");
		InputStreamReader isr = 
			new InputStreamReader(fis,"UTF-8");
		BufferedReader br =
			new BufferedReader(isr);
		
		br.readLine();
		br.readLine();
		
		
		BufferedReader bra = new BufferedReader(new InputStreamReader(new FileInputStream("a.txt")));
		
	
		
	}
}

 

  • 0
    点赞
  • 0
    评论
  • 1
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值