16 SequenceInputStream、PrintStream、Properties、递归、编码

最新推荐文章于 2023-01-26 21:50:28 发布

guanhang89

最新推荐文章于 2023-01-26 21:50:28 发布

阅读量1k

点赞数 1

分类专栏： java学习

本文链接：https://blog.csdn.net/guanhang89/article/details/50641300

版权

java学习专栏收录该内容

37 篇文章 0 订阅

订阅专栏

SequenceInputStream

SequenceInputStream(序列流)
案例：合并文件内容

合并两个文件

采用传统方法

public static void merge1() throws IOException{
        //找到目标文件
        File inFile1 = new File("F:\\a.txt");
        File inFile2 = new File("F:\\b.txt");
        File outFile = new File("F:\\c.txt");
        //建立数据的输入输出通道
        FileOutputStream fileOutputStream = new FileOutputStream(outFile);
        FileInputStream fileInputStream1 = new FileInputStream(inFile1);
        FileInputStream fileInputStream2 = new FileInputStream(inFile2);

        //把输入流存储到集合中，然后再从集合中读取
        ArrayList<FileInputStream> list = new ArrayList<FileInputStream>();
        list.add(fileInputStream1);
        list.add(fileInputStream2);

        //准备一个缓冲数组
        byte[] buf = new byte[1024];
        int length = 0 ; 

        for(int i = 0 ; i< list.size() ; i++){
            FileInputStream fileInputStream = list.get(i);
            while((length = fileInputStream.read(buf))!=-1){
                fileOutputStream.write(buf,0,length);
            }
            //关闭资源
            fileInputStream.close();
        }
        fileOutputStream.close();

    }

使用SequenceInputStream合并文件。自身不具备读写能力，所以关闭方法close关闭的是传递的参数

//  使用SequenceInputStream合并文件。
    public static void merge2() throws IOException{
        //找到目标文件
        File inFile1 = new File("F:\\a.txt");
        File inFile2 = new File("F:\\b.txt");
        File outFile = new File("F:\\c.txt");
        //建立数据的输入输出通道
        FileOutputStream fileOutputStream = new FileOutputStream(outFile);

        FileInputStream fileInputStream1 = new FileInputStream(inFile1);
        FileInputStream fileInputStream2 = new FileInputStream(inFile2);
        //建立序列流对象
        SequenceInputStream inputStream = new SequenceInputStream(fileInputStream1,fileInputStream2);
        byte[] buf = new byte[1024];
        int length = 0 ; 

        while((length = inputStream.read(buf))!=-1){
            fileOutputStream.write(buf,0,length);
        }
        //关闭资源
        inputStream.close();
        fileOutputStream.close();

    }

合并多个文件

使用Enumeration集合

//把三个文件合并成一个文件
public static void merge3() throws IOException{
    //找到目标文件
    File file1 = new File("F:\\a.txt");
    File file2 = new File("F:\\b.txt");
    File file3 = new File("F:\\c.txt");
    File file4 = new File("F:\\d.txt");
    //建立对应 的输入输出流对象
    FileOutputStream fileOutputStream = new FileOutputStream(file4);
    FileInputStream fileInputStream1 = new FileInputStream(file1);
    FileInputStream fileInputStream2 = new FileInputStream(file2);
    FileInputStream fileInputStream3 = new FileInputStream(file3);
    //创建序列流对象
    Vector<FileInputStream> vector = new Vector<FileInputStream>();
    vector.add(fileInputStream1);
    vector.add(fileInputStream2);
    vector.add(fileInputStream3);
    Enumeration<FileInputStream> e = vector.elements();
    SequenceInputStream sequenceInputStream = new SequenceInputStream(e);
    //读取文件数据
    byte[] buf = new byte[1024];
    int length = 0; 

    while((length = sequenceInputStream.read(buf))!=-1){
        fileOutputStream.write(buf,0,length);
    }
    //关闭资源
    sequenceInputStream.close();
    fileOutputStream.close();   
}

ObjectOutputStream &&ObjectInputStream

对象的输入输出流 : 对象的输入输出流主要的作用是用于写对象的信息与读取对象的信息。对象信息一旦写到文件上那么对象的信息就可以做到持久化了

对象的输出流： ObjectOutputStream
对象的输入流: ObjectInputStream

对象输入输出流要注意的细节：

如果对象需要被写出到文件上，那么对象所属的类必须要实现Serializable接口。 Serializable接口没有任何的方法，是一个标识接口而已。
对象的反序列化创建对象的时候并不会调用到构造方法的
serialVersionUID 是用于记录class文件的版本信息的，serialVersionUID这个数字是通过一个类的类名、成员、包名、工程名算出的一个数字。
使用ObjectInputStream反序列化的时候，ObjeectInputStream会先读取文件中的serialVersionUID，然后与本地的class文件的serialVersionUID进行对比，如果这两个id不一致，那么反序列化就失败了。
如果序列化与反序列化的时候可能会修改类的成员，那么最好一开始就给这个类指定一个serialVersionUID，如果一类已经指定的serialVersionUID（private static final long serialVersionUID = 1L;），然后在序列化与反序列化的时候，jvm都不会再自己算这个 class的serialVersionUID了。
如果一个对象某个数据不想被序列化到硬盘上，可以使用关键字transient修饰。
如果一个类维护了另外一个类的引用，那么另外一个类也需要实现Serializable接口。

//定义方法把对象的信息写到硬盘上------>对象的序列化。
public static void writeObj() throws IOException{
    //把user对象的信息持久化存储。
    Address address = new Address("中国","广州");
    User user = new User("admin","123",15,address);
    //找到目标文件
    File file = new File("F:\\obj.txt");
    //建立数据输出流对象
    FileOutputStream fileOutputStream = new FileOutputStream(file);
    //建立对象的输出流对象
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
    //把对象写出
    objectOutputStream.writeObject(user);
    //关闭资源
    objectOutputStream.close(); 

}

反序列化

//把文件中的对象信息读取出来-------->对象的反序列化
    public static void readObj() throws  IOException, ClassNotFoundException{
        //找到目标文件
        File file = new File("F:\\obj.txt");
        //建立数据的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //建立对象的输入流对象
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        //读取对象信息
        User user = (User) objectInputStream.readObject(); //创建对象肯定要依赖对象所属的class文件。
        System.out.println("对象的信息："+ user);
    }

Properties文件

Properties（配置文件类）: 主要用于生产配置文件与读取配置文件的信息。
Properties要注意的细节：
1. 如果配置文件的信息一旦使用了中文，那么在使用store方法生成配置文件的时候只能使用字符流解决，如果使用字节流生成配置文件的话，默认使用的是iso8859-1码表进行编码存储，这时候会出现乱码。所以输出流使用FileWriter（字符流）。
2. 如果Properties中的内容发生了变化，一定要重新使用Properties生成配置文件，否则配置文件信息不会发生变化。

properties使用以及产生配置文件
注意：properties只能存储字符串

//保存配置文件文件的信息。
public static void creatProperties() throws IOException{
    //创建Properties
    Properties properties = new Properties();
    properties.setProperty("狗娃", "123");
    properties.setProperty("狗剩","234");
    properties.setProperty("铁蛋","345");
    // 遍历Properties
    /*Set<Entry<Object, Object>> entrys = properties.entrySet();
    for(Entry<Object, Object> entry  :entrys){
        System.out.println("键："+ entry.getKey() +" 值："+ entry.getValue());
    }*/

    //使用Properties生产配置文件。
    //properties.store(new FileOutputStream("F:\\persons.properties"), "haha"); //第一个参数是一个输出流对象，第二参数是使用一个字符串描述这个配置文件的信息。
    properties.store(new FileWriter("F:\\persons.properties"), "hehe");

读取配置文件以及修改：

//读取配置文件爱你的信息 
public static void readProperties() throws IOException{
    //创建Properties对象
    Properties properties = new Properties();
    //加载配置文件信息到Properties中
    properties.load(new FileReader("F:\\persons.properties"));
    //遍历
    Set<Entry<Object, Object>> entrys = properties.entrySet();
    for(Entry<Object, Object> entry  :entrys){
        System.out.println("键："+ entry.getKey() +" 值："+ entry.getValue());
    }
    //修改狗娃的密码
    //把修改后的Properties再生成一个配置文件
    properties.setProperty("狗娃", "007");
    properties.store(new FileWriter("F:\\persons.properties"), "hehe"); 
}

Properties案例

注意此案例中的FileOutputStream如果要单独形成一个变量一定要在load之后，因为创建一个新的流对象，会清空里面的内容（不能加true，因为true是续写）。

public static void main(String[] args) throws IOException {
        File file = new File("F:\\count.properties");
        if(!file.exists()){
            //如果配置文件不存在，则创建该配置文件
            file.createNewFile();
        }
        //创建Properties对象。
        Properties properties = new Properties();
        //把配置文件的信息加载到properties中
        properties.load(new FileInputStream(file));
        //FileOutputStream fileOutputStream = new FileOutputStream(file);
        int count = 0; //定义该变量是用于保存软件的运行次数的。
        //读取配置文件的运行次数
        String value = properties.getProperty("count");
        if(value!=null){
            count = Integer.parseInt(value);
        }
        //判断使用的次数是否已经达到了三次，
        if(count==3){
            System.out.println("你已经超出了试用次数，请购买正版软件！！");
            System.exit(0);
        }
        count++;
        System.out.println("你已经使用了本软件第"+count+"次");
        properties.setProperty("count",count+"");
        //使用Properties生成一个配置文件
        properties.store(new FileOutputStream(file),"runtime"); 
    }

PrintStream

打印流（printStream）打印流可以打印任意类型的数据，而且打印数据之前都会先把数据转换成字符串再进行打印。(如果采用FileOutpurtStream要采用getBytes)

其实System.out里面也保存了一个PrintSteam的对象，可以通过setOut方法重置标准的输出流，如果这个输出流绑定了文件，那么输出会保存在文件中，而不是显示在控制台。

//打印流可以打印任何类型的数据，而且打印数据之前都会先把数据转换成字符串再进行打印。
File file = new  File("F:\\a.txt");
//创建一个打印流
PrintStream printStream = new PrintStream(file);
printStream.println(97);
printStream.println(3.14);
printStream.println('a');
printStream.println(true);
Animal a = new Animal("老鼠", "黑色");
printStream.println(a);//调用toString的方法
//默认标准的输出流就是向控制台输出的，
//System.setOut(printStream); //重新设置了标准的输出流对象
//System.out.println("哈哈，猜猜我在哪里！！");

PrintStream使用：收集异常信息
这里用FileOutputStream包装是为了获得追加功能

File logFile = new File("F:\\2015年1月8日.log");
PrintStream logPrintStream = new PrintStream( new FileOutputStream(logFile,true) );
try{
    int c = 4/0;
    System.out.println("c="+c);
    int[] arr = null;
    System.out.println(arr.length);

}catch(Exception e){
    e.printStackTrace(logPrintStream);

编码与解码

编码与解码
编码：把看得懂的字符变成看不懂码值这个过程我们称作为编码。
解码：把码值查找对应的字符，我们把这个过程称作为解码
注意：以后编码与解码一般我们都使用统一的码表。否则非常容易出乱码。
getBytes采用平台默认的gbk编码表，String类也是

String str = "中国";
byte[] buf = str.getBytes("utf-8");// 平台默认的编码表是gbk编码表。  编码
System.out.println("数组的元素："+Arrays.toString(buf)); //
str = new String(buf,"utf-8");  //默认使用了gbk码表去解码。可以指定码表 
System.out.println("解码后的字符串："+ str);//

//Unicode知识一个规范
String str = "a中国"; // -2，-1，0, 97, 78, 45, 86, -3，前面-2 -1代表Unicode编码
byte[] buf = str.getBytes("unicode");  //编码与解码的时候指定的码表是unicode实际上就是用了utf-16.
System.out.println("数组的内容："+ Arrays.toString(buf));

解码错误后的还原，能还原的前提是，对于每个编码都有相应的字符对应

String str = "大家好";
byte[] buf = str.getBytes(); //使用gbk进行编码
System.out.println("字节数组："+ Arrays.toString(buf));  // -76, -13, -68, -46, -70, -61
str = new String(buf,"iso8859-1");
// 解码不一致后的还原
byte[] buf2 = str.getBytes("iso8859-1");
str = new String(buf2,"gbk"); 
System.out.println(str);

InputStreamReader&&OutputStreamWriter

转换流:

输入字节流的转换流：InputStreamReader 是字节流通向字符流的桥
InputStreamReader

输出字节流的转换流：
OutputStreamWriter 可以把输出字节流转换成输出字符流。
转换流的作用：
1. 如果目前所获取到的是一个字节流需要转换字符流使用，这时候就可以使用转换流。字节流—-> 字符流
2. 使用转换流可以指定编码表进行读写文件。

示例

    InputStream in = System.in; //获取了标准的输入流。
    //System.out.println("读到 的字符："+ (char)in.read());  //read()一次只能读取一个字节。
    //需要把字节流转换成字符流。
    InputStreamReader inputStreamReader = new InputStreamReader(in);
    //使用字符流的缓冲类
    BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
    String line = null;
    while((line = bufferedReader.readLine())!=null){
        System.out.println("内容："+ line);
    }

//使用输出字节流的转换流指定码表写出数据
public static void writeTest2() throws IOException{
    File file = new File("F:\\a.txt");
    //建立数据的输出通道
    FileOutputStream fileOutputStream = new FileOutputStream(file);
    //把输出字节流转换成字符流并且指定编码表。
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "utf-8");
    outputStreamWriter.write("新中国好啊");
    //关闭资源
    outputStreamWriter.close(); 
}
//使用输入字节流的转换流指定码表进行读取文件数据
public static void readTest2() throws IOException{
    File file = new File("F:\\a.txt");
    FileInputStream fileInputStream = new FileInputStream(file);
    //创建字节流的转换流并且指定码表进行读取
    InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"utf-8");
    char[] buf = new char[1024];
    int length = 0;
    while((length = inputStreamReader.read(buf))!=-1){
        System.out.println(new String(buf,0,length));
    }
}

递归案例

    //删除了一个非空的目录
    public static void deleteDir(File dir){ 
        File[] files = dir.listFiles(); //列出了所有的子文件
        for(File file : files){
            if(file.isFile()){
                file.delete();
            }else if(file.isDirectory()){
                deleteDir(file);
            }
        }
        dir.delete();
    }
    public static void listFiles3(File dir,String space){ //space 存储的是空格
        File[] files = dir.listFiles(); //列出所有 的子文件
        for(File file : files){
            if(file.isFile()){
                System.out.println(space+file.getName());
            }else if(file.isDirectory()){
                System.out.println(space+file.getName());
                listFiles3(file,"|   "+space);
            }   
        }   
    }
    //列出一个文件夹的子孙文件与目录。并显示目录结构
    public static void listFiles2(File dir,String space){ //space 存储的是空格
        File[] files = dir.listFiles(); //列出所有 的子文件
        for(File file : files){
            if(file.isFile()){
                System.out.println(space+file.getName());
            }else if(file.isDirectory()){
                System.out.println(space+file.getName());
                listFiles2(file,"  "+space);
            }

        }


    }
    //列出一个文件夹的子孙文件与目录。
    public static void listFiles1(File dir){
        File[] files = dir.listFiles(); //列出所有 的子文件
        for(File file : files){
            if(file.isFile()){
                System.out.println("文件名："+file.getName());
            }else if(file.isDirectory()){
                System.out.println("文件夹："+file.getName());
                listFiles1(file);
            }   
        }   
    }

guanhang89

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
16 SequenceInputStream、PrintStream、Properties、递归、编码

SequenceInputStream合并两个文件合并多个文件ObjectOutputStream ObjectInputStreamSequenceInputStreamSequenceInputStream(序列流) 案例：合并文件内容合并两个文件采用传统方法public static void merge1() throws IOException{ //找到目标文件
复制链接

扫一扫

专栏目录