数据输入输出流的概述和使用
A:数据输入输出流的概述
通过API查看
数据输入和输出流:
数据输入流: DataInpuStream
数据输出流: DataOutputStream
特点: 可以读写基本类型
B:案例演示: 数据输入输出流的基本使用
案例:
package javaSEreview20190724.杂七杂八流;
import java.io.*;
/**
* @Description:TODO
* @Author:@李小白
* @Date:2019/7/24 23:24
*/
public class Demo01数据输入输出流 {
public static void main(String[] args) throws IOException {
getOut();
//特点:可以读写基本类型
//怎么读的就怎么取,顺序不要乱
DataInputStream in = new DataInputStream(new FileInputStream("a.txt"));
System.out.println(in.readInt());
System.out.println(in.readBoolean());
System.out.println(in.readDouble());
System.out.println(in.readUTF());
in.close();
}
private static void getOut() throws IOException {
DataOutputStream out = new DataOutputStream(new FileOutputStream("a.txt"));
out.writeInt(100);
out.writeBoolean(false);
out.writeDouble(3.14);
out.writeUTF("可以是字符串");
out.close();
}
}
内存操作流的概述和使用
A:内存操作流的概述
a:操作字节数组
ByteArrayOutputStream
ByteArrayInputStream
此流关闭无效,所以无需关闭
b:操作字符数组
CharArrayWrite
CharArrayReader
c:操作字符串
StringWriter
StringReader
B:案例演示: 内存操作流的使用
// 构造方法: public ByteArrayOutputStream()
案例:
a:操作字节数组
ByteArrayOutputStream
ByteArrayInputStream
package javaSEreview20190724.杂七杂八流;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
/**
* @Description:TODO
* @Author:@李小白
* @Date:2019/7/24 23:35
*/
public class Demo02内存操作流 {
public static void main(String[] args) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
out.write("不关联文件在内存中操作".getBytes());
out.write("自带缓冲区,并可以自己扩大缓冲区".getBytes());
out.write("此流不需要关闭".getBytes());
//取出缓冲区的数据
byte[] bytes = out.toByteArray();
String s = new String(bytes);
System.out.println(s);
// String s1 = out.toString();
// System.out.println(s1);
// out.close();此流无需关闭
// out.write("abc".getBytes());
// String s2 = out.toString();
// System.out.println(s2);
ByteArrayInputStream in = new ByteArrayInputStream(bytes);
byte[] bytes1 = new byte[1024 * 8];
int len = in.read(bytes1);
String s1 = new String(bytes1,0,len);
System.out.println(s1);
}
}
b:操作字符数组
CharArrayWrite
CharArrayReader
package javaSEreview20190724.杂七杂八流;
import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.IOException;
/**
* @Description:TODO
* @Author:@李小白
* @Date:2019/7/24 23:49
*/
public class Demo03内存操作流字符数组 {
public static void main(String[] args) throws IOException {
CharArrayWriter cw = new CharArrayWriter();
cw.write("abc");
cw.write("abc");
cw.write("abc");
//取出缓冲区的数据
char[] chars = cw.toCharArray();
//输出缓冲区的数据
System.out.println(cw.toString());
System.out.println(String.valueOf(chars));
System.out.println(new String(chars));
// CharArrayReader cr = new CharArrayReader(chars);
}
}
c:操作字符串
StringWriter
StringReader
package javaSEreview20190724.杂七杂八流;
import java.io.StringWriter;
/**
* @Description:TODO
* @Author:@李小白
* @Date:2019/7/24 23:56
*/
public class Demo04内存操作流字符串 {
public static void main(String[] args) {
StringWriter sw = new StringWriter();
sw.write("abc");
sw.write("abc");
sw.append("ccc");
//直接输出
String s = sw.toString();
System.out.println(s);
}
}
把多个文件合成一个文件,两种方法
方法一:
package javaSEreview20190724.杂七杂八流;
import java.io.*;
import java.util.ArrayList;
/**
* @Description:TODO
* @Author:@李小白
* @Date:2019/7/25 0:01
*/
public class Demo05几个文件合成一个文件歌曲大合唱 {
public static void main(String[] args) throws IOException {
FileInputStream in1 = new FileInputStream(new File(""许巍-曾经的你.mp3""));
FileInputStream in2 = new FileInputStream(new File(""许巍-曾经的你.mp3""));
FileOutputStream out = new FileOutputStream(new File("大合唱"));
ArrayList<FileInputStream> list = new ArrayList<>();
list.add(in1);
list.add(in2);
int len=0;
byte[] bytes = new byte[1024 * 8];
for (FileInputStream in : list) {
while ((len=in.read(bytes))!=-1) {
out.write(len);
out.flush();
}
in.close();
}
out.close();
}
}
方法二:
package javaSEreview20190724.杂七杂八流;
import java.io.*;
import java.util.ArrayList;
/**
* @Description:TODO
* @Author:@李小白
* @Date:2019/7/25 0:17
*/
public class Demo06几个文件合成一各文件 {
public static void main(String[] args) throws java.io.IOException {
FileInputStream in1 = new FileInputStream("许巍 - 曾经的你.mp3");
FileInputStream in2 = new FileInputStream("许巍 - 蓝莲花.mp3");
FileOutputStream out = new FileOutputStream("歌曲大联唱.mp3");
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
//创建一个集合
ArrayList<FileInputStream> list = new ArrayList<>();
list.add(in1);
list.add(in2);
int len=0;
byte[] bytes = new byte[1024 * 8];
for (FileInputStream in : list) {
while ((len=in.read(bytes))!=-1){
byteOut.write(bytes,0,len);
byteOut.flush();
}
in.close();
}
//取出两首歌的字节数据
byte[] allBytes = byteOut.toByteArray();
System.out.println(allBytes.length);
//将两首歌的字节数据,写到硬盘上
ByteArrayInputStream byteIn = new ByteArrayInputStream(allBytes);
int len2 = 0;
byte[] bytes2 = new byte[1024 * 8];
while ((len2 = byteIn.read(bytes)) != -1) {
out.write(bytes, 0, len2);
out.flush();
}
out.close();
}
}
打印流的概述和特点以及作为Writer的子类使用
A:打印流的概述
通过API查看
字节流打印流
字符打印流
B:打印流的特点
a: 打印只能操作目的,不能操作数据源(不能进行读取)
- b: 可以操作任意数据类型的数据 调用print() 方法可以写任意数据类型
c: 如果我们启用自动刷新,那么在调用println、printf 或 format 方法中的一个方法的时候,会完成自动刷新
/**
通过以下构造创建对象 能够启动自动刷新 然后调用println、printf 或 format 方法中的一个方法的时候,会完成自动刷新
public PrintWriter(OutputStream out, boolean autoFlush) 启动 自动刷新
public PrintWriter(Writer out, boolean autoFlush) 启动自动刷新
*/
d: 这个流可以直接对文件进行操作(可以直接操作文件的流: 就是构造方法的参数可以传递文件或者文件路径)
C:案例演示: PrintWriter作为Writer的子类使用
案例:
package javaSEreview20190724.杂七杂八流;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintStream;
/**
* @Description:TODO
* @Author:@李小白
* @Date:2019/7/25 0:24
*/
public class Demo07打印流 {
public static void main(String[] args) throws IOException {
//字节打印流:
//字符打印流:
//打印流之关联目标文件,不关联源文件
//字节打印流
// PrintStream PrintStream 为其他输出流添加了功能,使它们能够方便地打印各种数据值表示形式。
// System.out; out:标准的输出流,所关联的设备是屏幕
// out.write("字节打印刘".getBytes());
// out.print(3.14);
// 构造方法摘要
// PrintStream(File file)
// 创建具有指定文件且不带自动行刷新的新打印流。
// PrintStream(File file, String csn)
// 创建具有指定文件名称和字符集且不带自动行刷新的新打印流。
// PrintStream(OutputStream out)
// 创建新的打印流。
// PrintStream(OutputStream out, boolean autoFlush)
// 创建新的打印流。
// PrintStream out = System.out;//通过System.out 返回的字节打印流,打印的数据会输出到屏幕
PrintStream ps = new PrintStream("a.txt");
ps.write(1);
ps.write("孤独的打印字符流".getBytes());
ps.println("abc");
ps.println("abc");
ps.println("abc");
ps.close();
}
}
案例一:
打印流复制文本文件 true自动刷新,两种打印方式
package javaSEreview20190724.杂七杂八流;
import java.io.*;
import java.util.Scanner;
/**
* @Description:TODO
* @Author:@李小白
* @Date:2019/7/25 0:28
*/
public class Demo08打印流复制文本文件 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new FileReader("b.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
String lin=null;
while ((lin=br.readLine())!=null) {
bw.write(lin);
bw.flush();
}
bw.close();
br.close();
System.out.println("--------------------");
//也可以用Scanner进行读
Scanner sc = new Scanner(new File("b.txt"));
BufferedWriter bw2 = new BufferedWriter(new FileWriter("a.txt",true));
while (sc.hasNextLine()){
String s = sc.nextLine();
System.out.println(s);
}
bw2.close();
sc.close();
}
}
案例二:
字节打印流
package org.westos.demo3;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
/**
* @Author: ShenMouMou
* @CreateTime: 2019-07-24 14:55
* @Description:西部开源教育科技有限公司
*/
public class 字节打印流 {
public static void main(String[] args) throws IOException {
//打印流:只操作目的地,不关联源文件
// PrintStream 字节打印流
PrintStream printStream = new PrintStream(new FileOutputStream("b.txt"));
printStream.write("字节打印流".getBytes());
printStream.print(true);
printStream.println(100);
printStream.close();
PrintStream out = System.out;
out.write("abc".getBytes());
out.println(3.14);
System.out.println("abc");
}
}
PrintWriter实现自动刷新和换行
A:案例演示:PrintWriter实现自动刷新和换行
PrintWriter pw = new PrintWriter(new FileWriter(“printWriter2.txt”) , true) ;
pw.println(true) ;
pw.println(100) ;
pw.println(“中国”) ;
案例:
//通过现有的 OutputStream 创建新的 PrintWriter。
//与 PrintStream 类不同,如果启用了自动刷新,
//则只有在调用 println、printf
//或 format 的其中一个方法时才可能完成此操作,
案例三:
字符打印流
package org.westos.demo3;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
/**
* @Author: ShenMouMou
* @CreateTime: 2019-07-24 15:01
* @Description:西部开源教育科技有限公司
*/
public class 字符打印流 {
public static void main(String[] args) throws IOException {
//参数2:true 自动刷新
//如果启用了自动刷新,则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作
PrintWriter writer = new PrintWriter(new FileOutputStream("c.txt"),true);
//writer.write("字符打印流");
writer.println("abc");
writer.println("abc");
writer.println("abc");
writer.println("abc");
writer.println("abc");
writer.println("abc");
writer.println("abc");
writer.flush();
writer.close();
}
}
标准输入输出流概述和输出语句的本质
A:标准输入输出流概述
在System这个类中存在两个静态的成员变量:
public static final InputStream in: 标准输入流, 对应的设备是键盘
public static final PrintStream out: 标准输出流 , 对应的设备就是显示器
System.in的类型是InputStream.
System.out的类型是PrintStream是OutputStream的孙子类FilterOutputStream 的子类.
二种方式实现键盘录入
A:Scanner
B:BufferedReader的readLine方法。
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
package day20190725.study01.杂七杂八流;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
/**
* @description: 2种键盘录入方式
* @author: @李小白
* @create: 2019-07-25 15:02
*/
public class Demo02标准的输入输出流2种键盘录入方式 {
public static void main(String[] args) throws IOException {
//方式一:
Scanner scanner = new Scanner(System.in);
//方式二:
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
while (true) {
System.out.println("请输入你想要输入的数据");
String s = br.readLine();
if (s.equals("886")) {
break;
}
System.out.println(s);
}
}
}
随机访问流概述和写出数据(断点下载,断点复制)
A:随机访问流概述 RandomAccessFile概述
-
用于断点下载,断点复制,按顺序读写
-
最大特点 能读能写 RandomAccessFile类不属于流,是Object类的子类。
-
但它融合了InputStream和OutputStream的功能。 支持对随机访问文件的读取和写入。
-
RandomAccessFile的父类是Object , 这个流对象可以用来读取数据也可以用来写数据.可以操作任意数据类型的数据.
-
getFilePointer方法获取文件指针
-
且可以通过seek(0)方法设置文件指针
B:案例演示: 随机访问流写出数据
案例:
//随机访问流:此流最大的特点是能读能写,而来可以设置文件指针的位置
//此类的实例支持对随机访问文件的读取和写入。
//随机访问文件的行为类似存储在文件系统中的一个大型 byte 数组。
//存在指向该隐含数组的光标或索引,称为文件指针;
//输入操作从文件指针开始读取字节,并随着对字节的读取而前移此文件指针。
package day20190725.study01.杂七杂八流;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* @description: 打印断点
* @author: @李小白
* @create: 2019-07-25 15:13
*/
public class Demo03随机访问流 {
public static void main(String[] args) throws IOException {
getWriter();
RandomAccessFile rafr = new RandomAccessFile("a.txt", "rw");
//读写顺序应该一致
int i = rafr.readInt();
System.out.println(rafr.getFilePointer());//指针的位置
boolean b = rafr.readBoolean();
System.out.println(rafr.getFilePointer());//指针的位置
double v = rafr.readDouble();
System.out.println(rafr.getFilePointer());//指针的位置
String s = rafr.readUTF();
System.out.println(rafr.getFilePointer());//指针的位置
System.out.println(i);
System.out.println(b);
System.out.println(v);
System.out.println(s);
rafr.close();
}
private static void getWriter() throws IOException {
RandomAccessFile raf = new RandomAccessFile("a.txt", "rw");
raf.write(100);
raf.writeBoolean(false);
raf.writeDouble(3.14);
raf.writeUTF("怎么读就怎么写");
raf.close();
}
}
随机访问流读取数据和操作文件指针(指针的放置位置)
import javax.sound.midi.Soundbank;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class MyTest {
public static void main(String[] args) throws IOException {
//随机访问流:此流最大的特点是能读能写,而来可以设置文件指针的位置
//此类的实例支持对随机访问文件的读取和写入。
//随机访问文件的行为类似存储在文件系统中的一个大型 byte 数组。
//存在指向该隐含数组的光标或索引,称为文件指针;
//输入操作从文件指针开始读取字节,并随着对字节的读取而前移此文件指针。
// writeData();
//你怎么写的就怎么读,顺不要乱
RandomAccessFile raf = new RandomAccessFile("e.txt", "rw");
boolean b = raf.readBoolean();
//获取当前文件的指针位置
System.out.println("指针位置:"+raf.getFilePointer());
double v = raf.readDouble();
System.out.println("指针位置:" + raf.getFilePointer());
int i = raf.readInt();
System.out.println("指针位置:" + raf.getFilePointer());
String s = raf.readUTF();
System.out.println("指针位置:" + raf.getFilePointer());
System.out.println(b);
System.out.println(v);
System.out.println(i);
System.out.println(s);
//设置指针的位置
raf.seek(13);
String s2 = raf.readUTF();//设置后把它再读一遍
System.out.println(s2);
}
private static void writeData() throws IOException {
RandomAccessFile raf = new RandomAccessFile("e.txt", "rw");
raf.writeBoolean(true);
raf.writeDouble(3.14);
raf.writeInt(1000);
//首先,把两个字节从文件的当前文件指针写入到此文件,
//类似于使用 writeShort 方法并给定要跟随的字节数
raf.writeUTF("你好");
raf.close();
}
}
断点下载,断点复制
案例:
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class MyTest2 {
public static void main(String[] args) {
RandomAccessFile in = null;
try {
//断点复制
in = new RandomAccessFile("E:\\疯狂动物城.mp4", "rw");
RandomAccessFile out = new RandomAccessFile("E:\\疯狂动物城2.mp4", "rw");
int len = 0;
byte[] bytes = new byte[1];
int num = 0;
while ((len = in.read(bytes)) != -1) {
num += len;
//故意模拟了一个异常
if (num > 20000) {
System.out.println(1 / 0);
}
out.write(bytes, 0, len);
}
} catch (Exception e) {
//记录指针位置 20000 位置要保存到一个文本文件中去
try {
long filePointer = in.getFilePointer();
System.out.println(filePointer);
} catch (IOException e1) {
e1.printStackTrace();
}
e.printStackTrace();
} finally {
}
}
}
序列化流和反序列化流的概述和使用
A:序列化流的概述
所谓的序列化:就是把对象通过流的方式存储到文件 对象---------硬盘 中 .注意:此对象 要重写Serializable 接口才能被序列化
反序列化:硬盘------内存 就是把文件中存储的对象以流的方式还原成对象
序列化流: ObjectOutputStream
反序列化流: ObjectInputStream
像这样一个接口中如果没有方法,那么这样的接口我们将其称之为标记接口(作用:给类打标记的,让JVM支持序列化)
一个对象可以被序列化的前提
- 是这个对象对应的类必须实现Serializable接口
- 给成员变量的前面加个ID public static final long serialVersionuID
如果不想被序列化
就在变量的前面加上transient
案例:
package day20190725.study01.杂七杂八流;
import java.io.Serializable;
/**
* @description: 序列化的学生类
* @author: @李小白
* @create: 2019-07-25 15:41
*/
public class Student implements Serializable {
public static final long serialVersionUID = 42L;
private String name;
//transient 某个成员变量不想序列化可以使用transient来修饰一下
public transient int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package day20190725.study01.杂七杂八流;
import java.io.*;
/**
* @description: 序列化
* @author: @李小白
* @create: 2019-07-25 15:36
*/
public class Demo04序列化 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
getOut();
ObjectInputStream in = new ObjectInputStream(new FileInputStream("a.txt"));
Object o1 = in.readObject();
Student student1= (Student) o1;
System.out.println(student1.getAge()+student1.getName());
Object o2 = in.readObject();
Student student2= (Student) o2;
System.out.println(student2.getAge()+student2.getName());
Object o3 = in.readObject();
Student student3= (Student) o3;
System.out.println(student3.getAge()+student3.getName());
}
private static void getOut() throws IOException {
Student student1 = new Student("zhang",18);
Student student2 = new Student("lisi",91);
Student student3 = new Student("wangwu",20);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("a.txt"));
out.writeObject(student1);
out.writeObject(student2);
out.writeObject(student3);
out.close();
}
}
对某个成员不想进行序列化
案例二:对案例一进行升级
package day20190725.study01.杂七杂八流;
import java.io.*;
import java.util.ArrayList;
/**
* @description: 序列化
* @author: @李小白
* @create: 2019-07-25 15:36
*/
public class Demo04序列化 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
getOut();
ObjectInputStream in = new ObjectInputStream(new FileInputStream("a.txt"));
Object o = in.readObject();
ArrayList<Student> obj= (ArrayList<Student>) o;//进行强制转换类型
System.out.println(obj);
Student student = obj.get(0);//可以进行指定索引
System.out.println(student.getName());
// Object o1 = in.readObject();
// Student student1= (Student) o1;//进行强制转换类型
// System.out.println(student1.getAge()+student1.getName());
// Object o2 = in.readObject();
// Student student2= (Student) o2;
// System.out.println(student2.getAge()+student2.getName());
// Object o3 = in.readObject();
// Student student3= (Student) o3;
// System.out.println(student3.getAge()+student3.getName());
}
private static void getOut() throws IOException {
Student student1 = new Student("zhang",18);
Student student2 = new Student("lisi",91);
Student student3 = new Student("wangwu",20);
ArrayList<Student> students = new ArrayList<>();
students.add(student1);
students.add(student2);
students.add(student3);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("a.txt"));
out.writeObject(students);
// out.writeObject(student1);
// out.writeObject(student2);
// out.writeObject(student3);
out.close();
}
}
Properties的概述和作为Map集合的使用
A:Properties的概述
查看API
Properties 类表示了一个持久的属性集,属于双列集合。
Properties 可保存在流中或从流中加载。
属性列表中每个键及其对应值都是一个字符串。
Properties父类是Hashtable
属于双列集合,这个集合中的键和值都是字符串 Properties不能指定泛型
- 方法:
- setProperly设值键和值
- getProperly由键索值
- load(new FileReader())读出文件
- stor(new FileWriter())写入文件
B:案例演示: Properties作为Map集合的使用
回顾:
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class MyTest {
public static void main(String[] args) {
//序列化流:
//ObjectOutputStream
//反序列化流:
//ObjectInputStream
//克隆:浅克隆
//深克隆:用序列化流和反序列化流可以实现对象的深克隆
//ObjectOutputStream
//ObjectInputStream
//作业:A:案例演示
// 需求:我有一个文本文件,我知道数据是键值对形式的,但是不知道内容是什么。
// 请写一个程序判断是否有“lisi”这样的键存在,如果有就改变其值为”100”
}
}
案例一:
package day20190725.study01.杂七杂八流;
import java.util.Properties;
/**
* @description: 属性集合也是双列集合
* @author: @李小白
* @create: 2019-07-25 16:10
*/
public class Demo05属性集合 {
public static void main(String[] args) {
//属性集合也就是双列集合,能共读写配置文件
Properties properties = new Properties();//默认定义了键值类型String
properties.setProperty("章晗","李强娜");//自定义键值
Object value1 = properties.get("章晗");//由键索值
System.out.println(value1);
//参数2,默认值,如果键没有找到对应的值,就返回默认值,键值输入错误
String value2 = properties.getProperty("章晗2", "默认值");
System.out.println(value2);
}
}
Properties的load()和store()功能
A:Properties的load()和store()功能
Properties和IO流进行配合使用:
- public void load(Reader reader): 读取键值对数据把数据存储到Properties中
public void store(Writer writer, String comments)把Properties集合中的键值对数据写入到文件中, comments注释
B:案例演示
Properties的load()和store()功能
案例二:
package day20190725.study01.杂七杂八流;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;
/**
* @description: 属性集合的两个特殊的方法
* @author: @李小白
* @create: 2019-07-25 16:23
*/
public class Demo05属性集合的两个特殊的方法 {
public static void main(String[] args) throws IOException {
Properties properties = new Properties();
//读出配置文件,从a.txt中读出来
//要求配置文件键值用等号 = 连接
properties.load(new FileReader("a.txt"));
System.out.println(properties);
properties.setProperty("李强娜","章晗");
properties.store(new FileWriter("a.txt"),null);//键无法对应,可以设值默认值
System.out.println(properties);
}
}
SequenceInputStream 合并流
把所有的流传入到 Vector中用vector.element迭代器,由迭代器再产给SequenceInputStream
A:案例需求:将a.txt和b.txt两个文本文件的内容合并到c.txt
B:案例需求:采用SequenceInputStream来改进
C:作业:将一个music.mp3文件,拆分成多个小文件,再将多个小文件,合并成一个mp3文件
D:SequenceInputStream
表示其他输入流的逻辑串联。
它从输入流的有序集合开始,
并从第一个输入流开始读取,直到到达文件末尾,接着从第二个输入流读取,
依次类推,直到到达包含的最后一个输入流的文件末尾为止
a:构造方法
SequenceInputStream(InputStream s1, InputStream s2)
通过记住这两个参数来初始化新创建的 SequenceInputStream(将按顺序读取这两个参数,先读取 s1,然后读取 s2),
以提供从此 SequenceInputStream 读取的字节。
b:构造方法
SequenceInputStream(Enumeration<? extends InputStream> e)
通过记住参数来初始化新创建的 SequenceInputStream,该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数
案例一:传统方法
//A:案例需求:将a.txt和b.txt两个文本文件的内容合并到c.txt
package day20190725.study01.杂七杂八流;
import java.io.*;
import java.util.ArrayList;
/**
* @description: 合并流 传统2合1
* @author: @李小白
* @create: 2019-07-25 16:37
*/
public class Demo06合并流传统2合1 {
public static void main(String[] args) throws IOException {
FileInputStream in1 = new FileInputStream("a.txt");
FileInputStream in2 = new FileInputStream("b.txt");
FileOutputStream out = new FileOutputStream("c.txt");
ArrayList<FileInputStream> in = new ArrayList<>();
in.add(in1);
in.add(in2);
int len=0;
byte[] bytes = new byte[1024 * 8];
for (FileInputStream inputStream : in) {
while ((len=inputStream.read(bytes))!=-1) {
out.write(len);
out.flush();
}
inputStream.close();
}
out.close();
}
}
案例二:改进2合1
package day20190725.study01.杂七杂八流;
import java.io.*;
import java.util.Enumeration;
import java.util.Vector;
/**
* @description: 合并流改进
* @author: @李小白
* @create: 2019-07-25 16:44
*/
public class Demo06合并流改进 {
public static void main(String[] args) throws IOException {
FileInputStream in1 = new FileInputStream("a.txt");
FileInputStream in2 = new FileInputStream("b.txt");
SequenceInputStream in = new SequenceInputStream(in1,in2);
FileOutputStream out = new FileOutputStream("c.txt");
int len = 0;
byte[] bytes = new byte[1024];
while ((len = in.read(bytes)) != -1) {
out.write(len);
}
in.close();
out.close();
}
}
案例三:同理3合1
package day20190725.study01.杂七杂八流;
import java.io.*;
/**
* @description: 合并三合一
* @author: @李小白
* @create: 2019-07-25 16:51
*/
public class Demo06合并流三合一 {
public static void main(String[] args) throws IOException {
FileInputStream in1 = new FileInputStream("a.txt");
FileInputStream in2 = new FileInputStream("b.txt");
FileInputStream in3 = new FileInputStream("d.txt");
FileOutputStream out = new FileOutputStream("c.txt");
//两个合并流进行其嵌套
SequenceInputStream onein = new SequenceInputStream(in1,in2);
SequenceInputStream allin = new SequenceInputStream(onein,in3);
}
}
案例三:
多个合并流
将in好的对象放到Vector()中,vector.elelment,传到 SequenceInputStream 即可
package day20190725.study01.杂七杂八流;
import java.io.*;
import java.util.Enumeration;
import java.util.Vector;
/**
* @description: 多个流
* @author: @李小白
* @create: 2019-07-25 16:54
*/
public class Demo06合并多个流 {
public static void main(String[] args) throws IOException {
//SequenceInputStream(Enumeration < ? extends InputStream > e)
//通过记住参数来初始化新创建的 SequenceInputStream,该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。
FileInputStream in1 = new FileInputStream("a.txt");
FileInputStream in2 = new FileInputStream("b.txt");
FileInputStream in3 = new FileInputStream("d.txt");
FileOutputStream out = new FileOutputStream("c.txt");
Vector<FileInputStream> vector = new Vector<>();
//返回此向量的组件的枚举。
vector.add(in1);
vector.add(in2);
vector.add(in3);
Enumeration<FileInputStream> elements = vector.elements();
SequenceInputStream in = new SequenceInputStream(elements);
int len=0;
byte[] bytes = new byte[1024 * 8];
while ((len=in.read(bytes))!=-1) {
out.write(len);
out.flush();
}
in.close();
out.close();
}
}