DAY20：尚学堂高琪JAVA（156~164）其他流及 IO的设计模式

最新推荐文章于 2020-04-13 21:47:49 发布

tayer13

最新推荐文章于 2020-04-13 21:47:49 发布

阅读量308

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/qq_40802113/article/details/88622498

版权

JAVA 专栏收录该内容

30 篇文章 1 订阅

订阅专栏

其他流

一、节点流
1.字节数组节点流
输入流 ByteArrayInputStream-----read(byte[] b,int off,int len)+close()
输入流 ByteArrayOutputStream----write(byte[] b,int off,int len)+toByteArray() 不能使用多态

package otherio;
/*
 * 156 字节数组流的读写
 * */
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
public class ByteArrayDemo1 {
	public static void main(String[] args) throws IOException {
		read(write());
	}
	//输入流操作与文件输入流操作一致
	public static void read(byte[] src) throws IOException {
		//数据源
		
		//选择流
		InputStream is1=new BufferedInputStream(
				new ByteArrayInputStream(src));
		//操作
		byte[] car=new byte[1024];
		int len=0;
		while (-1!=(len=is1.read(car))) {
			System.out.println(new String(car,0,len));
		}
		//
		is1.close();
	}
	//输出流操作与文件输出流操作有些不同，有新增方法，不能使用多态
	public static byte[] write() throws IOException{
		//目的地
		byte[] dest;
		//选择流 不同
		ByteArrayOutputStream b1=new ByteArrayOutputStream();
		//操作 写出
		String s1="输出流操作与文件输出流操作有些不同，有新增方法，不能使用多态";
		byte[] info =s1.getBytes();
		b1.write(info);
		//获取数据
		dest=b1.toByteArray();
		//
		b1.close();
		return dest;
	}
	
}

在这里插入图片描述

package otherio;
/*
 * 156 字节数组流与文件流的对接
 * 文件--程序--字节数组
 *   a.文件输入流
 *   b.字节数组输出流
 *  字节数组 --程序--文件
 *   a.字节数组输入流
 *   b.文件输出流
 * */
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class ByteArrayDemo2 {
	public static void main(String[] args) throws IOException {
		byte[] test=getBytesFromFile("H:/1/1.jpg");
		System.out.println(new String(test));
		toFileFromByteArray(test, "H:/1/2.jpg");//也可以是其他格式
	}
	public static byte[] getBytesFromFile(String srcPath) throws IOException {
		//创建源文件和目的地
		File f1=new File(srcPath);
		byte[] dest=null;
		//选择流
		InputStream is1=new BufferedInputStream(new FileInputStream(f1)) ;
		ByteArrayOutputStream bos1=new ByteArrayOutputStream();
		//操作  不断读取文件，写出到字节数组流中
		byte[] car=new byte[1024];
		int len=0;
		while (-1!=(len=is1.read(car))) {
		//写出到数组流中
			bos1.write(car,0,len);
		}
		bos1.flush();
		//获取数据
		dest=bos1.toByteArray();
		
		bos1.close();
		is1.close();
		return dest;
	}
	public static byte[] toFileFromByteArray(byte[] src,String destPath) throws IOException {
		//创建源
		//目的地
		File dest=new File(destPath);
		//选择流
		InputStream is1=new BufferedInputStream(new ByteArrayInputStream(src));
		OutputStream os1=new BufferedOutputStream(new FileOutputStream(dest));
		操作  不断读取数组，写出到文件输出流中
		byte[] car=new byte[1024];
		@SuppressWarnings("unused")
		int len=0;
		while(-1!=(len=is1.read(car))){
			os1.write(car,0, car.length);
		}
		os1.flush();
		
		os1.close();
		is1.close();
		return null;
	}
}

二、数据流
1.基本类型+String 保留数据+类型
输入流：DataInputStream readxxx
输出流：DataOutputStream writexxx

package otherio;
//158 基本类型（基本+String）处理流
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataDemo1 {

	public static void main(String[] args) throws IOException {
		write("H:/1/1.txt");
		read("H:/1/1.txt");
	}
	//数据+类型输出到文件
	public static void write(String destPath) throws IOException {
		double point=2.5;
		long num=100L;
		String s1="数据类型";
		//创建源
		File dest=new File(destPath);
		//选择流 DataOutputStream
		DataOutputStream dos1=new DataOutputStream(
				new BufferedOutputStream(
						new FileOutputStream(dest)));
		//操作 写出的顺序为读取准备
		dos1.writeDouble(point);
		dos1.writeLong(num);
		dos1.writeUTF(s1);
		
		dos1.flush();
		dos1.close();
	}
	//从文件中读取数据+类型
	@SuppressWarnings("resource")
	public static void read(String destPath) throws IOException {
		
		File src=new File(destPath);
		//选择流 DataInputStream
		DataInputStream dis1=new DataInputStream(
				new BufferedInputStream(
						new FileInputStream(src)));
		//操作 读取顺序必须与写出一致
		double num1=dis1.readDouble();
		Long num2=dis1.readLong();
		String s2=dis1.readUTF();
		
		System.out.println(num1);
		System.out.println(num2);
		System.out.println(s2);
	}
}

在这里插入图片描述
三、引用类型（对象）保留数据+类型
反序列化输入流：ObjectInputStream readObjec()
序列化输出流：ObjecOutputStream writeObjec()
注意：1.先序列化，再反序列化。反序列化顺序必须与序列化一致。
2.不是所有的对象都可以序列化，java.io.Serializable
不是所有的属性都需要序列化 transient

package otherio;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Array;
import java.util.Arrays;
//159
public class EmployeeDemo1 {

	public static void main(String[] args) throws IOException, ClassNotFoundException {
		// TODO Auto-generated method stub
		seri("H:/1/1.txt");
		read("H:/1/1.txt");
	}
	//序列化
	public static void seri(String destPath) throws IOException{
		Employee e1=new Employee("lzk", 600);
		File dest=new File(destPath);
		int[] arr1={1,2,3,4,5};//数组也可以序列化
		//选择流 ObjectOutputStream
		ObjectOutputStream dos1=new ObjectOutputStream(
				new BufferedOutputStream(
						new FileOutputStream(dest)));
		//写入流
		dos1.writeObject(e1);
		dos1.writeObject(arr1);
		
		dos1.flush();
		dos1.close();
	}
	//反序列化
	public static void read(String destPath) throws IOException, ClassNotFoundException{
		File src=new File(destPath);
		//选择流 
		ObjectInputStream dis1=new ObjectInputStream(
				new BufferedInputStream(
						new FileInputStream(src)));
		//操作  
		Object o1=dis1.readObject();
		if (o1 instanceof Employee) {
			Employee e1=(Employee)o1;
			System.out.println(e1.getName());
			System.out.println(e1.getSalary());
		}
		Object o2=dis1.readObject();
		int[] arr1=(int[])o2;
		System.out.println(Arrays.toString(arr1));
		
		dis1.close();
	}
}

package otherio;
//159
public class Employee implements java.io.Serializable {
 
	private static final long serialVersionUID = 1L;
	private transient String name;
	private double salary;
	public Employee(String name, double salary) {
		super();
		this.name = name;
		this.salary = salary;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
}

在这里插入图片描述
四：打印流
PrintStream（属于处理流）

package otherio;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
//161
public class PrintStreamDemo01 {

	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub
		PrintStream ps1=System.out;
		ps1.println(false);
	//输出到文件
		File src=new File("H:/1/1.txt");
		
		ps1=new PrintStream(new BufferedOutputStream(
				new FileOutputStream(src)));
		
		ps1.print("IO12346");
		
		ps1.close();
	}

}

System的三个常量及重定向

package otherio;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.Scanner;
/*
 * 161 三个常量
 * 1.System.in 输入流   键盘，文件输入
 * 2.System.out 输出流  控制台输出
 * 3.System.err 输出流  控制台输出
 * 
 * 重定向：
 * setIn()
 * setOut()
 * setErr()
 * 
 * FileDescriptor.in
 * FileDescriptor.out
 * FileDescriptor.err
 * */
public class SystemDemo1 {

	public static void main(String[] args) throws FileNotFoundException {
		// TODO Auto-generated method stub
		test2();
		//重定向  控制台---》文件
		System.setOut(new PrintStream(new BufferedOutputStream(
				new FileOutputStream("H:1/1.txt")),true));
		System.out.println("重定向到文件");
		//重定向  文件---》控制台
		System.setOut(new PrintStream(new BufferedOutputStream(
				new FileOutputStream(FileDescriptor.out)),true));
		System.out.println("重定向到控制台");
	}
	public static void test2() throws FileNotFoundException{
		InputStream is1=System.in;
		//从文件中输入，而不是键盘 (is1已经不再是System.in，而是FileInputStream)
		is1=new BufferedInputStream(new FileInputStream("H:/1/1.txt"));
				
		Scanner sc1=new Scanner(is1);
		System.out.println(sc1.nextLine());
	}

}

在这里插入图片描述

IO设计模式

package patterio;
/*
 * 162 IO里的设计模式：装饰设计模式
 * 类与类之间的关系：
 * 1.依赖：形参或者局部变量
 * 2.关联：属性（本例中Amplifier类中的voice对象就被看为属性）
 *     聚合：属性 整体与部分 不一致的生命周期
 *     组合：属性 整体与部分 一致的生命周期
 * 3.继承：父子类关系
 * 4.实现：接口与实现类的关系
 * */
public class App {
	public static void main(String[] args) {
		Voice v1=new Voice();
		v1.say();
		Amplifier a1=new Amplifier(v1);
		a1.say();
	}
}

package patterio;
//162
public class Voice {
	private int voice=10;

	public Voice() {
	}
	public Voice(int voice) {
		super();
		this.voice = voice;
	}

	public int getVoice() {
		return voice;
	}

	public void setVoice(int voice) {
		this.voice = voice;
	}
	public void say() {
		System.out.println("音量："+voice);
	}
}

package patterio;
//162
public class Amplifier {
	private Voice voice;

	public Amplifier() {
		// TODO Auto-generated constructor stub
	}
	public Amplifier(Voice voice) {
		super();
		this.voice = voice;
	}
	public void say() {
		System.out.println("音量："+voice.getVoice()*100);;
	}
	
}

在这里插入图片描述

tayer13

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
DAY20：尚学堂高琪JAVA（156~164）其他流及 IO的设计模式

处理流作用：增强功能，提高性能，节点流之上一：缓冲流1.字节缓冲流BufferedInputStreamBufferedIOutputStream2.字符缓冲流BufferedReader ----readLine()BufferedReader ----newLine()package buffered;/*152 字节流文件拷贝+缓冲 * * */import j...
复制链接

扫一扫

专栏目录