标签：arraylist 常用 读取文本 gem put span fileread 长度 file
缓冲输入字节流：
----------------------| InputStream 输入字节流的基类
----------------| FileInputStream 读取文件的输入字节流
----------------| BufferedInputStream 缓冲输入字节流 作用：提高读取文件的效率
缓冲输出字节流：
----------------------| OutputStream 输出字节流的基类
----------------| FileOutputStream 写入文件的输入字节流
----------------| BufferedOutputStream 缓冲输出字节流 作用：提高我们写入数据的效率
输入字符流：
--------------| Reader 输入字符流的基类。 抽象类
----------| FileReader 读取文件的输入字符流
----------| BufferedReader 缓存输入字符流（提高效率和扩展了FileReader的功能）。内部其实也维护了一个字符数组
扩展功能：
readLine() 一次读取文本的一行数据，如果读取到了文件末尾返回null
输出字符流：
--------------| Write 输出字符流的基类。 抽象类
----------| FileWrite 向文件输入数据
----------| BufferedWrite 缓存输出字符流。 内部维护了一个字符数组，当我们使用write的时候是把数据存储到了字符数组中，并不是写入了文件中
当我们使用flush，close方法或者数组满了的时候，才会写入文件中
扩展功能：
newLine() 添加一个回车符，实际上就是输出（/r/n）
//需求：把a.txt 和 b.txt的文本合并成一个文本
public class Demo1 { public static void main(String[] args) throws IOException { //找到目标文件 File inputfile1 = new File("D:\\新建文件夹\\a.txt"); File inputfile2 = new File("D:\\新建文件夹\\b.txt"); File outputfile = new File("D:\\新建文件夹\\c.txt"); //建立数据通道 FileInputStream fileInputStream1 = new FileInputStream(inputfile1); FileInputStream fileInputStream2 = new FileInputStream(inputfile2); FileOutputStream fileOutputStream = new FileOutputStream(outputfile); //我们建立一个集合来存储被合并文本的数据通道对象 ArrayList<FileInputStream> arrayList = new ArrayList<FileInputStream>(); arrayList.add(fileInputStream1); arrayList.add(fileInputStream2); //创建缓存字节数组 byte[] buf = new byte[1024]; //定义变量用来存储每次读取到数组中的字符长度 int length = 0; for (FileInputStream fileInputStream : arrayList) { while((length = fileInputStream.read(buf))!= -1) { //把读取的数据写入c.txt文本中, fileOutputStream.write(buf,0,length); } } //先开后关原则 fileOutputStream.close(); fileInputStream2.close(); fileInputStream1.close(); } }
我们可以发现，用上面的方式很不方便，书写很麻烦很繁琐
sun公司给我们提供了一个SequenceInputStream类：
表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，
接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止
其实我们可以发现，它的底层也是存在一个有序集合，原理一样都是遍历有序集合
SequenceInputStream的构造方法：
SequenceInputStream(InputStream s1, InputStream s2)
通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取 s2），以提供从此 SequenceInputStream 读取的字节
SequenceInputStream(Enumeration<? extends InputStream> e)
通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。
SequenceInputStream的常用方法：
close() 关闭此输入流并释放与此流关联的所有系统资源。
read() 从此输入流中读取下一个数据字节。
read(byte[] b, int off, int len) 将最多 len 个数据字节从此输入流读入 byte 数组。
//使用第一个构造方法实现2个文件合并SequenceInputStream(InputStream s1, InputStream s2)
public class Demo2 { public static void main(String[] args) throws IOException { //找到目标文件的父路径 File inputfile1 = new File("D:\\新建文件夹\\a.txt"); File inputfile2 = new File("D:\\新建文件夹\\b.txt"); File outputfile = new File("D:\\新建文件夹\\c.txt"); //建立数据通道 FileInputStream fileInputStream1 = new FileInputStream(inputfile1); FileInputStream fileInputStream2 = new FileInputStream(inputfile2); FileOutputStream fileOutputStream = new FileOutputStream(outputfile); SequenceInputStream sequenceInputStream = new SequenceInputStream(fileInputStream1, fileInputStream2); //创建一个缓存字节数组 byte[] buf = new byte[1024]; int length = 0; while((length = sequenceInputStream.read(buf))!= -1) { fileOutputStream.write(buf, 0, length); } //先开后关原则 fileOutputStream.close(); sequenceInputStream.close(); } }
那么如果我们有很多个文件要合并呢？
第二个构造方法：SequenceInputStream(Enumeration<? extends InputStream> e)
此构造方法要接受一个Vector集合的迭代器
有序集合的体系：
-----------------| List 如果实现了List接口的集合类，具备的特点是：有序，可重复
-------------| ArrayList ArrayList底层维护的是一个Object类型的数组，特点是：查询快，增删慢
-------------| LinkList LinkedList底层使用了链表数据结构实现的。特点是：查询慢，增删快
-------------| Vector 底层也是维护了一个Object类型的数组，实现与ArrayList一样，但是Vector线程安全，操作效率低
Vector中的方法：
elements() 返回一个Enumeration<E>类型的迭代器
Enumeration接口中的方法：
hasMoreElements() 判断是否还有下一个元素，有返回true，没有返回false
nextElement() 返回下一个元素
//使用第二个构造方法实现2个文件合并SequenceInputStream(Enumeration<? extends InputStream> e)
public class Demo3 { public static void main(String[] args) throws IOException { //找到目标文件的父路径 File inputfile1 = new File("D:\\新建文件夹\\a.txt"); File inputfile2 = new File("D:\\新建文件夹\\b.txt"); File inputfile3 = new File("D:\\新建文件夹\\c.txt"); File outputfile = new File("D:\\新建文件夹\\d.txt"); //建立数据通道 FileInputStream fileInputStream1 = new FileInputStream(inputfile1); FileInputStream fileInputStream2 = new FileInputStream(inputfile2); FileInputStream fileInputStream3 = new FileInputStream(inputfile3); FileOutputStream fileOutputStream = new FileOutputStream(outputfile); //把数据通道对象放入Vector有序集合中 Vector<FileInputStream> vector = new Vector<FileInputStream>(); vector.add(fileInputStream1); vector.add(fileInputStream2); vector.add(fileInputStream3); //获取迭代器 Enumeration<FileInputStream> e = vector.elements(); //创建SequenceInputStream(Enumeration<? extends InputStream> e)对象 SequenceInputStream sequenceInputStream = new SequenceInputStream(e); //创建缓存字节数组 byte[] buf = new byte[1024]; //定义变量，用来存储每次存入数组中字节数组的数据长度 int length = 0; //读取所有需要合并的文本并放入数组中 while((length = sequenceInputStream.read(buf))!= -1) { //把数组中的文件写入d.txt文本中 fileOutputStream.write(buf, 0, length); } fileOutputStream.close(); sequenceInputStream.close(); } }
练习：
需求1：把一个MP3格式音乐切割成n份
解决：我们可以控制缓存数组的大小，用来分割。如果一个文件的大小是10MB那么我们可以把字节数组大小定义为1MB，那么每次读取的数据是1MB，
然后我们把每次读取的数据都放在不同文件中，那么就实现了切割了
需求2：把切割成n份MP3格式的音乐还原
public class Demo4 { public static void main(String[] args) throws Exception { //splitMP3(); mergeMP3(); } //需求1：把一个MP3格式音乐切割成n份(注意：被分割的音乐可以播放哦) public static void splitMP3() throws IOException { //输入的目标 File inputfile = new File("D:\\新建文件夹\\阿杜 - 撕夜.mp3"); //输出的目标文件的父目录 File outputparentfile = new File("D:\\新建文件夹"); //建立数据通道 FileInputStream fileInputStream = new FileInputStream(inputfile); //建立缓存字节数组，并定义数组大小为1MB(1024字节 = 1kb 1014kb = 1MB) byte[] buf = new byte[1024*1024]; //定义存储每次读取数据的长度的变量 int length = 0; //读取文件并进行分割 for(int i = 1 ; (length = fileInputStream.read(buf))!=-1 ; i++) { FileOutputStream fileOutputStream = new FileOutputStream(new File(outputparentfile, "part"+i+".mp3")); fileOutputStream.write(buf, 0, length); fileOutputStream.close(); } fileInputStream.close(); } //需求2：把切割成n份MP3格式的音乐还原(不按照顺序合并也可以听哦) public static void mergeMP3() throws IOException { //创建输入文件的父路径 File inputparentfile = new File("D:\\新建文件夹"); //创建Vector有序集合 Vector<FileInputStream> vector = new Vector<FileInputStream>(); //定义File类的数组并存储在父路径找到的所有文件的绝对路径 File[] files = inputparentfile.listFiles(); //遍历数组 for (File temp : files) { //筛选出后缀名为MP3的文件temp：文件的绝对路径 getName()文件的名字 endsWith()文件的后缀名 if(temp.getName().endsWith(".mp3")) { vector.add(new FileInputStream(temp)); } } //获取vector的迭代器 Enumeration<FileInputStream> e = vector.elements(); //创建输出文件的绝对路径 File outputfile = new File("D:\\新建文件夹\\合并.mp3"); //创建输出数据通道 FileOutputStream fileOutputStream = new FileOutputStream(outputfile); //创建SequenceInputStream对象 SequenceInputStream sequenceInputStream = new SequenceInputStream(e); //创建缓存数组 byte[] buf = new byte[1024]; //定义存储每次读取到数据的长度的变量 int length = 0; //边读边写 while((length = sequenceInputStream.read(buf))!= -1) { fileOutputStream.write(buf, 0, length); } } }
标签：arraylist 常用 读取文本 gem put span fileread 长度 file
原文地址：https://www.cnblogs.com/zjdbk/p/9085514.html
