Java其他流

痛定思痛。 2022-06-06 10:46 147阅读 0赞

> 序列流SequenceInputStream：对多个流进行合并。序列流其实是多个输入流的串联，它从输入流的有序集合开始，从第一个输入流开始读取，直到文件末尾，接着从第二个输入流读取，以此类推，直到读完包含最后一个输入流的文件结束

构造函数：

*  SequenceInputStream(InputStream s1, InputStream s2)：通过记住这两个参数来初始化新创建的 SequenceInputStream（将按顺序读取这两个参数，先读取 s1，然后读取s2），以提供从此SequenceInputStream 读取的字节。
 *  SequenceInputStream(Enumeration`<? extends InputStream>` e)：通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的Enumeration 型参数。
    
    写个示例：

1.合并两个文件中的数据，使用序列流的第一种构造函数即可

public static void merge1()throws IOException{
            File file1 = new File("F:\\1.txt");
            File file2 = new File("F:\\2.txt");
            File outFile = new File("F:\\a.txt");
            FileInputStream inputStream1 = new FileInputStream(file1);
            FileInputStream inputStream2 = new FileInputStream(file2);
            FileOutputStream outputStream  = new FileOutputStream(outFile);
            SequenceInputStream sequence = new SequenceInputStream(inputStream1,inputStream2);
            byte[] buff = new byte[1024];
            int length = 0;
            while((length = sequence.read(buff))!=-1){
                outputStream.write(buff,0,length);
            }
            sequence.close();
            outputStream.close();
        }

2.若要合并的文件数量大于两个，则需要使用第二种构造函数。对于传递的参数，我们可以利用Vector

public static void merge2()throws IOException{
    
            File file1 = new File("F:\\1.txt");
            File file2 = new File("F:\\2.txt");
            File file3 = new File("F:\\3.txt");
            File file4 = new File("F:\\4.txt");
            File out = new File("F:\\a.txt");
            FileOutputStream outputStream = new FileOutputStream(out);
            Vector<FileInputStream> vector = new Vector<>();
            vector.add(new FileInputStream(file1));
            vector.add(new FileInputStream(file2));
            vector.add(new FileInputStream(file3));
            vector.add(new FileInputStream(file4));
            //将全部的文件输入流添加到向量中，然后获得向量的迭代器作为序列流构造函数的实参
            Enumeration<FileInputStream> e = vector.elements();
            SequenceInputStream sequence  = new SequenceInputStream(e);
            byte[] buff = new byte[1024];
            int length = 0;
            while((length = sequence.read(buff))!=-1){
                outputStream.write(buff,0,length);
            }
            sequence.close();
            outputStream.close();
        }

下面实现对一个mp3文件的切割及合成

public static void cutFile()throws IOException{
            File file = new File("F:\\1.mp3");
            FileInputStream inputStream = new FileInputStream(file);
            File dir = new File("F:\\music");
    
            byte[] buff = new byte[1024*1024];
            int length = 0;
            for(int i=1;(length = inputStream.read(buff))!=-1;i++){
                FileOutputStream output = new FileOutputStream(new File(dir,"part"+i+".mp3"));
                output.write(buff,0,length);
                output.close();
            }
            inputStream.close();
        }
        public static void mergeFile()throws IOException{
            File file = new File("F:\\music");
            File[] files = file.listFiles();
            Vector<FileInputStream> vector = new Vector<>();
            for(File f:files){
                if(f.getName().endsWith(".mp3")){
                    vector.add(new FileInputStream(f));
                }
            }
            Enumeration<FileInputStream> e = vector.elements();
            SequenceInputStream sequence = new SequenceInputStream(e);
            byte[] buff = new byte[1024];
            int length = 0;
            File out = new File("F:\\hear.mp3");
            FileOutputStream outputStream = new FileOutputStream(out);
            while((length = sequence.read(buff))!=-1){
                outputStream.write(buff,0,length);
            }
            outputStream.close();
            sequence.close();
        }

> 对象的序列化：可以实现对象的持久化存储

> Properties：和流相关的集合对象，继承自HashTable。是一个持久化的属性集，可保存在流中或从流中加载，属性列表中的每个键及其值都是一个String类对象，所以该类不需要泛型

虽然继承自HashTable，顶层接口是Map，如果存放对象可以使用put方法，但是这里不建议使用pu方法，因为它可以允许插入键或者值不是String的项，所以应该使用如下方法：

*  1，存入键值对：setProperty(key,value);
 *  2，获取指定键对应的值：value getProperty(key);
 *  3，获取集合中所有键元素： Enumeration propertyNames();

在jdk1.6版本给该类提供一个新的方法。`Set<String> stringPropertyNames();`

*  4，列出该集合中的所有键值对，可以通过参数打印流指定列出到的目的地。

list(PrintStream);  
list(PrintWriter);  
例：list(System.out):将集合中的键值对打印到控制台。  
list(new PrintStream(“prop.txt”)):将集合中的键值对存储到prop.txt文件中。

*  5，可以将流中的规则数据加载进行集合，并称为键值对：load(InputStream)

jdk1.6版本。提供了新的方法：load(Reader)—->如果数据包含中文，应该使用字符流对象  
注意：流中的数据要是”键=值” 的规则数据。  
\- 6，可以将集合中的数据进行指定目的的存储：store(OutputStram,String comment)

jdk1.6版本。提供了新的方法–>store(Writer ,String comment)：使用该方法存储时，会带着当时存储的时间。  
\*注意：  
Properties只加载key=value这样的键值对，与文件名无关，注释使用\#\*  
利用Properties类读写配置文件：

public static void writeProperties()throws IOException{
            Properties properties = new Properties();
            properties.setProperty("Dream","123");
            properties.setProperty("Mary","345");
            properties.setProperty("Thia","456");
            FileOutputStream output = new FileOutputStream(new File("F:\\new.properties"));
            properties.store(output,"newProperties");  //如果写入的配置文件包含中文，则需要传递字符流对象
            //写出的默认编码是ISO8859-1，字符流对象的编码是GBK
            output.close();
    }
    public static void readProperties()throws IOException{
            Properties properties = new Properties();
            properties.load(new FileInputStream(new File("F:\\new.properties")));  //如果读取的配置文件中包含中文，则需要传递字符流对象
            Set<Map.Entry<Object,Object>> entries = properties.entrySet();
            for(Map.Entry<Object,Object> entry : entries){
                System.out.println("键："+entry.getKey()+" 值："+entry.getValue());
            }
    }

示例：记录一个程序运行的次数，当满足指定次数时，该程序就不可以再继续运行了。  
通常可用于软件使用次数的限定。

public static void isAccess()throws IOException{
            //获得配置文件流对象
            Properties properties = new Properties();
            //获取文件对象
            File file = new File("F:\\exe.properties");
            //如果配置文件不存在，则创建文件
            if(!file.exists()){
                file.createNewFile();
            }
            //加载配置文件信息
            properties.load(new FileInputStream(file));
            int count = 0;
            //获取配置文件的count信息，如果是新创建的该文件，则读取的值是null
            String val = properties.getProperty("count");
            if(val!=null){
                count = Integer.parseInt(val);
            }
            //如果已经使用3次，则退出JVM
            if(count == 3){
                System.out.println("您的试用已经结束，请购买正版！");
                System.exit(0);
            }
            //每使用一次，count++
            count++;
            System.out.println("第"+count+"次使用本软件");
            //将最新的配置信息写出
            properties.setProperty("count",count+"");
            //每当新创建一个输出流对象时，会清空文件的内容，所以下面的语句必须等先读取完文件信息之后才能写出，否则将永远读不到上一次设置的count值
            FileOutputStream output = new FileOutputStream(file);
            properties.store(output,"UseAuthority");
            output.close();
        }

> 打印流：可以打印任何数据，而且打印数据之前将数据先转换为字符串再打印  
> PrintStream字节打印流对象：打印流本身并没有写数据的能力，其内部维护了一个BufferedWriter对象和OutputStreamWriter对象实现真正的写数据；通过构造函数传入的输出流OutputStream对象构造OutputStreamWriter对象；如果只传入文件名，则创建FileOutputStream类对象构造OutputStreamWriter对象，再将OutputStreamWriter对象传递给BufferedWriter对象

package BasicObject.day21;
    
    import java.io.IOException;
    import java.io.PrintStream;
    
    /** * Created by Dream on 2017/11/7. */
    class Animal{
        String name;
        String color;
        public Animal(String name,String color){
            this.name = name;
            this.color = color;
        }
        public String toString(){
            return ("名字："+name+" 颜色："+color);
        }
    }
    public class PrintStreamPractice { 
        public static void main(String[] args)throws IOException{
            //创建具有指定文件且不带自动行刷新的新打印流
            PrintStream printStream = new PrintStream("F:\\1.txt");
            printStream.println(97);
            printStream.println("a");
            printStream.println("Hello World!");
            printStream.println(true);
            printStream.println(new Animal("Mouse","Black"));
        }
    }

文件中数据：  
97  
a  
Hello World!  
true  
名字：Mouse 颜色：Black

平时输出数据到控制台上，我们使用的是System.out.println()方式，其中out就是一个PrintStream类型的标准输出流，如果我们想将数据输出到文件中，那么可以通过System的static void setOut(PrintStream out)方法，重新分配“标准”输出流，那么就可以直接输出数据到文件了。

PrintStream printStream = new PrintStream("F:\\1.txt");
    //setOut(PrintStream out) 重新分配“标准”输出流。
    System.setOut(printStream);
    System.out.println("Hello World!");

PrintStream还有一个很重要的作用就是用于输出日志文件。对于出现错误的日志，我们之前习惯于输出到控制台上，但是控制台可容纳的数据是有限的，如果日志非常多，那么就会有信息的丢失，所以写出到文件上更合理。

public static void ErrorLog()throws IOException{
            /*这种情况下仅能输出一条错误日志信息，但是现在想每次将错误信息追加到错误日志文件中 PrintStream printStream = new PrintStream("F:\\error.log"); */
            File file = new File("F:\\error.log");
            FileOutputStream outputStream = new FileOutputStream(file,true);
            //打印流本身没有可以在文件后面追加的方法，但是传递的输出流可以通过构造参数的设置实现追加数据
            PrintStream printStream = new PrintStream(outputStream);
            try{
                int result = 3/0;
            }catch (Exception e){
                e.printStackTrace(printStream);
            }
        }

> 转换流：字节流通向字符流的桥梁  
> 为什么需要这种转换呢？  
> 我们需要写字符数据，但是仅仅能获得字节流，那么如果此时有这样一个类，可以将字节流转换为字符流，那么就非常方便了，否则还得借助String类来实现编码和解码从而读写字符。

输入字节流转换为输入字符流：InputStreamReader  
示例：

public static void InputStream2Reader()throws IOException{
            InputStream in = System.in; //获得标准输入字节流
            InputStreamReader inputStreamReader = new InputStreamReader(in);  //输入字节流流转输入字符流
            BufferedReader reader  = new BufferedReader(inputStreamReader);
            String line = null;
            while((line = reader.readLine())!= null){  //利用缓冲输入流实现按行读取
                System.out.println(line);
            }
        }

输出字节流转换为输出字符流：OutputStreamWriter  
示例：

public static void OutputStream2Writer()throws IOException{
            FileOutputStream fileOutputStream = new FileOutputStream("F:\\aa.txt");
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream);
            BufferedWriter writer = new BufferedWriter(outputStreamWriter);
            String str = "Hello,我是耿耿Dream";
            writer.write(str);
            writer.close();
        }

可能会纳闷，在上述示例中，直接使用FileWriter不就可以了，为什么非的使用字节流对象然后转换，确实在上述示例中可以直接使用，但是在实际应用中，有时候获取到的流对象是字节流，但是使用字符流读写更加方便，此时需要将字节流转换为字符流，那么该类的价值就体现出来了！  
Plus：使用转换流还可以指定码表，FileReader和FileWriter是不能指定码表的，而转换流可以！

public static void readCoding()throws IOException{
            File file = new File("F:\\code.txt");
            FileInputStream inputStream = new FileInputStream(file);
            //设定利用gbk码表进行解码
            InputStreamReader reader = new InputStreamReader(inputStream,"gbk");
            char[] buff = new char[1024];
            int length = 0;
            //read(char[] cbuf, int offset, int length)将字符读入数组中的某一部分
            while((length = reader.read(buff))!=-1){
                System.out.println(new String(buff,0,length));
            }
        }
        public static void writeCoding()throws IOException{
            File file = new File("F:\\code.txt");
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            //设定利用gbk码表进行编码
            OutputStreamWriter writer = new OutputStreamWriter(fileOutputStream,"gbk");
            String str = "我是耿耿Dream";  //写出到文件，大小为13个字节
            writer.write(str);
            writer.close();
        }

如果设定的编码解码使用的码表不一样，则会出现乱码，即不能得到原来的数据！