Java基础-IO流

最新推荐文章于 2024-06-12 23:40:32 发布
最新推荐文章于 2024-06-12 23:40:32 发布
阅读量847 收藏 16
点赞数 16
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sha_bo/article/details/135983602
版权

文章目录

IO流
1.1概述
  • I 表示 Input , 是数据从硬盘文件读到内存的过程 ， 即输入，负责读
  • O表示 Output，是内存程序的数据从内存写到硬盘文件的过程，即输出 ， 负责写

IO流的分类

  • 按方向：

    • 输入流
    • 输出流

  • 按流中的数据最小单元

    image-20240131162643376

  • 缓冲流

    • 缓冲流也称为 高效流或者高级流。

    • 作用： 缓冲流自带缓冲区、可以提高 原始字节流和字符流 读写数据的性能；

    • 分类：

      字节缓冲流（BufferedInputStream、BufferedOutputStream）和字符缓冲流（BufferedReader、BufferedWriter）

      字节缓冲流自带 8K 缓冲区

image-20240201154323711

本文所涉及:

image-20240201221707586
1.2字节流
1.2.1 FileInputStream

  • 文件字节输入流 FileInputStream

  • 以内存为基准，把磁盘文件中的数据以字节的形式读到内存中

构造器

  • 方法说明
    public FileInputStream(File file)创建字节输入流管道与源文件对象接通
    public FileInputStream(String pathName)创建字节输入流管道与源文件路径接通

输入

方法说明
public int read()每次读取一个字节返回，如果字节已经没有可读的则返回-1
public int read(byte[] bytes)每次读取一个字节数组返回，如果字节已经没有可读的返回-1
public byte[] readAllBytes() throws IOException直接将当前字节输入流对应的 文件对象的字节数据封装到一个字节数组返回

每次读取一个字节

public class FileInputStreamDemo {
    public static void main(String[] args) throws Exception{
        //1.先创建FileInputStream对象    字节输入流管道 与 源文件对象连接
        //D:\code\javaSEImprove\file-io-app\src\abc.txt
        FileInputStream is = new FileInputStream(new File("src\\abc.txt"));
        //2.读取水滴 read
        int rs = is.read();             //每次读取一个字节,完毕返回-1
        System.out.println(rs);
        System.out.println((char)rs);   //转为字符型
        System.out.println((char)is.read());
        //3.优化，  循环     ，  性能太差，而且 两者 都不能处理中文字符(2或3个字节)乱码
        while((rs = is.read()) != -1){
            System.out.print((char) rs);
        }
        is.close;		
    }
}

上述问题：

  • 循环，性能较慢

  • 读取中文字符输出 ， 一定会发生乱码问题

解决中文乱码：

1.读取一个字节数组 read(byte[] bytes)

配合String解码

public class Test {
    public static void main(String[] args) throws Exception{
        InputStream is = new FileInputStream("src\\kk.txt");
        //UTF-8  一个中文需要3个字节存储
        byte[] bytes = new byte[3];
        //一次访问 长度为3的字节数组
        is.read(bytes);
        System.out.print(new String(bytes));
        //循环 访问
        while(is.read(bytes) !=-1){
            System.out.print(new String(bytes));
        }
        is.close();
    }
}

还会出现 中文乱码的情况; 因为非中文字符大小还是1，字节数组内可能包含不止一个元素；

2.还是使用 read(byte[] bytes) 字节数组大小 设置 与文件大小一样

public class Test01 {
    public static void main(String[] args) throws Exception{
        InputStream is = new FileInputStream("src\\kk.txt");
        File file = new File("src\\kk.txt");
        //定义与  文件字节大小  一致的字节数组
        byte[] bytes = new byte[(int)file.length()]; 
        //
        is.read(bytes);
        System.out.println(new String(bytes));       //解码
		//资源回收
        is.close();
    }
}

3.使用 readAllBytes() 获取字节数组， 再进行String解码

1.2.2 FileOutputStream

文件字节输出流 FileOutputStream 写数据

构造器

方法说明
public FileOutputStream(File file , boolean append)创建字节输出流管道与源文件对象接通，并设置是否追加数组管道 true追加，false覆盖（默认）
public FileOutputStream(String pathName , boolean append)创建字节输出流管道与源文件路径接通，并设置是否追加数组管道 true追加，false覆盖（默认）

输出

方法说明
public void write(int a)写一个字节出去
public void write(byte[] bytes)写一个字节数组出去
public void write(byte[] bytes , int pos , int len)写一个字节数组的一部分出去

  • byte[] 配合使用String编码

  • 流的关闭与刷新

    • 方法说明
      flush()刷新流，还可以继续写数据
      close()关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据
public class FileOutputStreamDemo1 {
    public static void main(String[] args) throws Exception{
        //1.创建 文字字节输出流管道与目标文件接通
        //可以自动创建新文件
//        OutputStream os = new FileOutputStream("src/love.txt"); //每次写入，覆盖！！！
        OutputStream os = new FileOutputStream("src/love.txt",true); //追加数据管道，append
        os.flush();
        //2.写数据出去  .write(byte)
        //中文名称
        os.write("马老师".getBytes());		  //String编码
        //换行
        os.write("\r\n".getBytes());        //!!!   注意：字符串编码形式 ， \r\n适应环境
        //一个字节
        os.write('I');
        os.write(' ');
//        os.write(98);
        //一个字节数组
        byte[] b = {'l','o','v',101};
        os.write(b);
        os.write(' ');
        //字符串编码
        os.write("you".getBytes());
        os.write("\r\n".getBytes());
        //截取字节数组输出
        byte[] bytes = {89,'a','b',99};
        os.write(bytes,0,3);
        os.write("\r\n".getBytes());
        //3.数据刷新，写出数据生效
        os.flush();         //刷新后，可以继续输出
        //4.关闭流，结束输出流管道
        os.close();         //不可继续输出
    }
}
1.2.3 文件拷贝

image-20240131220344253

public class CopyDirTest {
    public static void main(String[] args) throws Exception{
        //1.创建文件字节输入流 与 源文件接通
        InputStream is = new FileInputStream("src\\love.txt");  //txt
        //2.创建文件字节输出流 与 目标文件接通
        OutputStream os = new FileOutputStream("src\\love1.txt");
        //3.转移数据
        //一般，每次读入一个 字节 的桶
        byte[] buffer = new byte[1024];
        int len ;   //读入的字节数组长度
        while ((len = is.read(buffer)) != -1){
            os.write(buffer,0,len);
            //刷新数据
            os.flush();
        }
        //4.关闭流
        os.close();
        is.close();
    }
}
1.2.4 BufferedInputStream

字节缓冲输入流 BufferedInputStream

构造器

  • public BufferedInputStream（InputStream is）
1.2.5 BufferedOutputStream

字节缓冲输出流 BufferedOutputStream

构造器

  • public BufferedOutputStream（OutputStream os）
//文件拷贝
public class BufferedInputStreamDemo {
    public static void main(String[] args) {
        try (
                //1.创建字节输入流管道与源文件连通
                InputStream is  = new FileInputStream("src/abc.txt");
                //2.把原始输入流管道包装成 高级的缓冲字节输入流
                InputStream bis = new BufferedInputStream(is);

                //3.创建字节输出流管道与目标文件连通
                OutputStream os = new FileOutputStream("src/out.txt");
                //4.把原始输出流管道包装成 高级的缓冲字节输出流
                OutputStream bos = new BufferedOutputStream(os);
        ){
            int len;            //记录每次读入的字节数
            byte[] buffer = new byte[1024];
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
            }
            System.out.println("复制完成了!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
1.2.6 对象序列化流

  • ObjectInputStream 和 ObjectOutputStream（对象序列化流）是Java中用于将对象持久化存储或在网络间传输的 。 提供了对对象的序列化和反序列化功能。

  • 允许将对象转换为字节流（对象序列化），然后再将字节流转化为 原始对象（反序列化）；

  • ObjectOutputStream ：是一个输出流，用于将对象序列化为字节流；使用 writeObject（）方法可以将对象写入到输出流中。当需要将一个对象进行持久化存储或在网络上进行传输时，可以使用 ObjectOutputStream将其序列化为字节流；

  • ObjectInputStream：是一个输入流，用于从字节流中反序列化对象；使用readOject（）方法可以从输入流中读取字节流 并将其转换为原始对象。当需要从持久化存储或网络中接受的字节流中恢复对象时，可以使用ObjectInputStream 进行反序列化；

对象序列化流的工作原理：是将对象以二进制形式序列化，并将序列化数据写入流中，以便在需要时重新构建该对象。这使得对象能够跨越应用程序、操作系统和网络传输，而无需重新编写复杂的数据映射逻辑。

使用对象序列化流的注意：

  • 类的序列化：要将对象进行序列化，相应的类必须实现 Serializable接口，这是一个标记接口，没有定义任何方法，仅用于表示该类可以被序列化。

  • 字段的序列化：要将字段序列化为字节流，它们必须是可序列化的。 可序列化的字段是指原始类型、String、数组和实现了Serializable接口的对象。

  • transient修饰符：使用transient修饰字段时，这些字段将不会被序列化，自然它们在反序列化过程中保持 默认值

  • 版本控制：当序列化类发生更改时，可能需要进行版本控制以确保兼容性。可以通过在类中定义一个名为 serialVersionUID的静态常量来实现版本控制。

什么是Java序列化？何时需要序列化

Java序列化是将Java对象转换为字节序列的过程，反序列化是将字节序列转换成Java对象的过程。
Java序列化以便可以将其存储在文件中、在网络上传输或者在进程之间传递，可以将对象的状态保存到硬盘或者内存中，同时又能够方便地将对象恢复到其原始状态。

1.需要序列化的情况通常包括：

    将对象存储到文件中，以便在以后的某个时间点检索它；
    将对象通过网络传输，例如在客户端和服务器之间传输数据；
    在进程之间传递对象。

2.需要注意的是，不是所有的对象都需要或能够序列化。例如下面这些情况：

    包含非序列化字段的类对象，比如 Thread 类、InputStream 类等；
    包含对不可序列化实例化对象的引用的类对象，因为这个引用指向的对象不可序列化，那么这个类对象也不可序列化；
    包含循环引用的类对象，即一个对象引用了另一个对象，而后者又引用了前者，这种情况会导致无限递归，无法序列化；
    包含被 static修饰的静态变量的类对象，因为静态变量不属于任何一个实例化对象，无法通过实例化对象进行序列化；
    包含匿名内部类、局部内部类和 lambda 表达式的类对象，因为这些类没有名字，无法被序列化；
    包含被 transient 修饰的变量的类对象，因为 transient 可以用来修饰不需要序列化的变量，这些变量的值在序列化和反序列化时会被忽略。

//Student类序列化
public class Student implements Serializable {
    //申明序列化的版本号
    //序列化的版本号与反序列化的版本号必须一致，否则报错！  需要重新输出 序列化，才能反序列化
    public static final long serialVersionUID = 2;
    private String name;
    private char sex;
    private int age;
    private String loginName;
    //transient修饰的成员变量不参与序列化
    private transient String passWord;
    
    public Student(){
    }

    public Student(String name, char sex, int age, String loginName, String passWord) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.loginName = loginName;
        this.passWord = passWord;
    }
    
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                ", loginName='" + loginName + '\'' +
                ", passWord='" + passWord + '\'' +
                '}';
    }
}

public class ObjectOutputStreamDemo {
    public static void main(String[] args) {
        //对象序列化存储
        try(//1.创建字节输入流管道与源文件接通
            OutputStream os = new FileOutputStream("src/out03.txt");
            //2.对象序列化：使用对象字节输出流包装输出流管道
            ObjectOutputStream oos = new ObjectOutputStream(os);
            ){
            Student student = new Student("马老师", '男', 22,"Mr.Ma","123456");
            //3.直接调用序列化方法
            oos.writeObject(student);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

public class ObjectInputStreamDemo1 {
    public static void main(String[] args) throws Exception{
        //1.创建对象字节输入流管道包装 低级字节输入流管道
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/out03.txt"));
        //2.调用对象反序列化方法
        Student s = (Student) ois.readObject();		//反序列化输出
        //transient 密码不被反序列化
        System.out.println(s);
    }
}

结果

Student{name='马老师', sex=男, age=22, loginName='Mr.Ma', passWord='null'}
1.2.7 打印流

输入

  • 打印流可以实现方便、高效的打印数据到 文件 中去。
  • 打印流一般是指：PrintStream 、PrintWriter两个类
  • 可以实现打印什么数据就是什么数据，例如打印整数97就是97，打印boolean的true，写出去就是true

构造器

构造器说明
public PrintStream（OutputStream os）打印流直接通向字节输出流管道
public PrintStream（File f）打印流直接通向文件对象
public PrintStream（String filePath）打印流直接通向文件路径

方法

  • public void print（Xxx xx） 打印任意类型的数据出去
public class PrintStreamDemo {
    public static void main(String[] args) throws Exception{
        //1.创建打印流对象
        PrintStream ps = new PrintStream(new FileOutputStream("src/out04.txt"));
//        PrintWriter pw = new PrintWriter("src/out04.txt");  //两者使用一样
        ps.println(98);
        ps.println('a');
        ps.println("我爱你中国");
        ps.print(true);
        ps.println();
        ps.close();
    }
}
  • 输出语句 重定向
    • 属于打印流的一种应用，可以把输出语句的打印位置 改为 文件
    • image-20240201220748817 
public class PrintStreamDemo2 {
    public static void main(String[] args) throws Exception{
        // public final static PrintStream out = null;
       System.out.println("锦瑟无端五十弦");
       System.out.println("一弦一柱思华年");
	   //定义打印流
       PrintStream ps = new PrintStream(new FileOutputStream("src/out04.txt",true));
       //重定向打印 格式固定！！！
       System.setOut(ps);
	   //此时转为 打印到ps , 而不是控制台
       System.out.println("庄生晓梦迷蝴蝶");
       System.out.println("望帝春心归杜鹃");
    }
}
1.3字符流
1.3.1 FileReader

  • 文件字符输入流：Reader

  • 作用：以内存为基准，把磁盘文件中的数据以 字符 的形式读到内存中去

构造器

构造器描述
public FileReader(File file)创建字符 输入流管道 与 源文件对象接通
public FileReader(String pathname)创建字符 输入流管道 与 源文件路径接通

输入

方法说明
public int read()每次读取一个字符返回，如果字符已经没有可读的返回 -1
public int read(char[] buffer)每次读取一个字符数组，返回读取的字符个数，如果字符已经没有可读的返回-1
public class FileReaderDemo {
    public static void main(String[] args) throws Exception{
        //1.创建构造器
        //创建输入流管道与源文件对象连通
        Reader r = new FileReader("src/love.txt");
        int rs;
        //2.read() 输入
        while ((rs=r.read())!=-1){
            System.out.print((char)rs);
        }
        
        //3.read(byte[] buffer)
        char[] buffer = new char[1024];
        while ((rs=r.read(buffer))!=-1){
            System.out.print(rs);
        }
    }
}
  • 读取中文字符不会出现乱码 （如果代码和文件的编码一致）
  • 性能较慢
1.3.2 FileWriter

  • 文件字符输出流：FileWriter

  • 作用：以内存为基准，把内存中的数据以字符的形式写出到磁盘文件去的流；

构造器

构造器说明
public FileWriter(File file , boolean append)创建字符输出流管道与源文件对象接通 , 是否追加数据
public FileWriter(String filePath , boolean append)创建字符输出流管道与源文件对象接通，是否追加数据

输出

方法描述
void write(char n)写一个字符
void write(char[] cbuf)写入一个字符数组
void write(char[] cbuf, int off , int len)写入字符数组的一部分
void write(String str)写一个字符串
void write(String str, int off , int len)写一个字符串的一部分
void write(int n)写一个字符

流的关闭与刷新

方法描述
flush()刷新流，还可以继续写数据
close()关闭流，释放资源，但是在关闭之前会先刷新流。一旦关闭，就不能再写数据
public class FileWriterDemo {
    public static void main(String[] args) throws Exception{
        //1.创建 字节输出管道与文件连通
//        Writer wr = new FileWriter("src/out01.txt");     覆盖
        Writer wr = new FileWriter("src/out01.txt",true); // 追加
        //2.write() 输出
        //单个字符
        wr.write(97);
        wr.write('b');
        wr.write('马');
        wr.write("\r\n");
        //一个字符串
        wr.write("马甜甜");
        wr.write("马老师喜欢马老师",0,5);
        wr.write("\r\n");
        //一个字符数组
        char[] chars = "马老师是中国人".toCharArray();    //字符串转换为 一个字符数组
        wr.write(chars);
        wr.write("\r\n");
        wr.write(chars,0,6);
        //wr.write("\r\n");    有点意外
        wr.flush();
        wr.close();
    }
}
1.3.3 BufferedReader

字符缓冲输入流 BufferedReader

  • 除了提高字符输入流 读取速度外，还多了 按行读取数据的功能

构造器

  • public BufferedReader（Read r） 可以把低级的字符输入流包装成一个高级的缓冲字符流管道，从而提高字符输入流读取数据性能

新增功能

  • public String readLine() 读取一行数据返回，无行可读返回NULL
public class BufferedReaderDemo {
    public static void main(String[] args) {
        try (
                Reader fr  = new FileReader("src/abc.txt");
                BufferedReader br = new BufferedReader(fr);
                )
        {
            String line ;
            //BufferedReader 独有方法readLine() 读取一整行字符
            while ((line = br.readLine()) != null){
                //需要添加换行符 ！！！
                System.out.println(line);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
1.3.4 BufferedWriter

字符缓冲输出流 BufferedWriter

  • 除了提高字符输出流 写取 数据的性能外， 多了换行的功能 ; 之前是 “\r\n”

构造器

  • public BufferedWriter（Writer w）

新增功能

  • public void newLine() 换行操作
public class BufferedWriterDemo {
    public static void main(String[] args) throws Exception{
        //1.创建 字节输出管道与文件连通
//        Writer wr = new FileWriter("src/out01.txt");     覆盖
        Writer fw = new FileWriter("src/out01.txt",true); // 追加
        //shift + F6 全改变量名
        BufferedWriter bw = new BufferedWriter(fw);
        //2.write() 输出
        //单个字符
        bw.write(97);
        bw.write('b');
        bw.write('马');
        bw.write("\r\n");
        //独有换行方法
        bw.newLine();
        //一个字符串
        bw.write("马甜甜");
        bw.write("马老师喜欢马老师",0,5);
        bw.write("\r\n");
        //一个字符数组
        char[] chars = "马老师是中国人".toCharArray();
        bw.write(chars);
        bw.write("\r\n");
        bw.write(chars,0,6);
        //wr.write("\r\n");    有点意外
        bw.flush();
        bw.close();
    }
}

综合案例

出师表有序拷贝

image-20240201165439501 
public class BufferedTest {
    public static void main(String[] args) {
        //出师表有序拷贝
        try(
                //1.创建输入缓冲流
                BufferedReader br = new BufferedReader(new FileReader("src/csb.txt"));
                //2.创建输出缓冲流
                BufferedWriter bw = new BufferedWriter(new FileWriter("src/csbSort.txt"));
        ){
            //3.创建复制 文件内容的容器
            List<String> out = new ArrayList<>();
            //4.换行 复制
            String line;
            while ((line = br.readLine()) != null){
                out.add(line);
            }
            //5.定义序列集合
            List<String> index = new ArrayList<>();
            Collections.addAll(index,"一","二","三","四","五","六","七","八","九","十");
            //6.排序
            //自定义排序规则
//            Collections.sort(out, (o1,  o2) -> {
//                    //按照字符串首字母，所在 index集合中的 序列进行比较
//                    //indexOf() 获取元素的序列， substring截取字符串
//                    return index.indexOf(o1.substring(0,o1.indexOf("、"))) - index.indexOf(o2.substring(0,o2.indexOf("、")));
//            });
            Collections.sort(out, Comparator.comparingInt(o -> index.indexOf(o.substring(0, o.indexOf("、")))));

            //7.遍历排序后的集合
            for (String s : out) {
                bw.write(s);
                bw.newLine();
                bw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

结果

image-20240201165533494
1.3.5 转换流
  • 字符输入转换流，InputStreamReader，可以把字节输入流 按照 指定编码转换成字符输入流；
    • 构造器
      • public InputStream(InputStream is) 把字节输入流转换成字符输入流。与默认的FileReader一样，几乎不用;
      • public InputStream(InputStream is , String charset) 把字节输入流按照指定编码转换成字符输入流，这样字符流中字符就不乱码了 （重点）
public class InputStreamReaderDemo {
    public static void main(String[] args) {
        try (
                //处理中文乱码问题
                //创建原始字节流
                InputStream is = new FileInputStream("src\\out01.txt");
                //多态，字符转换流 -> 父类 Reader
                Reader isr  = new InputStreamReader(is,"UTF-8");     //要与文件编码格式一致
                //创建 字符缓冲流
                BufferedReader br = new BufferedReader(isr);
        ){
            String line ;
            //BufferedReader 独有方法readLine() 读取一整行字符
            while ((line = br.readLine()) != null){
                //需要添加换行符
                System.out.println(line);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
  • 字符输出转换流，OutputStreamWriter，可以把字节输出流 按照指定编码转换成字符输出流；
    • 构造器
      • public OutputStreamWriter（OutputStream os） 可以把字节输出流 按照代码默认编码转换成 字符输出流。几乎不用
      • public OutputStreamWriter（OutputStream os ，String charset）可以把字节输出流 按照指定编码转换成 字符输出流（重点）
public class OutputStreamWriterDemo {
    public static void main(String[] args) {
        try(
            OutputStream os = new FileOutputStream("src/out02.txt");
            Writer osw = new OutputStreamWriter(os,"UTF-8");
            BufferedWriter bw = new BufferedWriter(osw);
        ){
            bw.write("我爱你中国~~~");
            bw.newLine();
            bw.write("我爱你中国~~~");
            bw.write("我爱你中国~~~");
            bw.write("我爱你中国~~~");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
1.4资源释放的方式

1.try-catch-finally

  • finally ：在异常处理时提供 finally 块来执行所有的清除操作，比如：IO流中的释放资源
  • 特点：被finally控制的语句 最终一定会执行，除非JVM退出 System.exit(0);
  • 异常处理标准格式： try…catch…finally
  • 手动释放资源
public class TryCatchFinallyTest {
    public static void main(String[] args) throws Exception{
        File sourceFile = new File("src\\love.txt");
        File targetFile    = new File("src\\love1.txt");
        //检查文件是否存在 , 创建源文件并利用  Files类写入内容(File类不能写入内容)
        if (!sourceFile.exists()){
           try{
               sourceFile.createNewFile();
               Files.write(sourceFile.toPath(),"你好，中国".getBytes(StandardCharsets.UTF_8));
           }catch (IOException e){
               e.printStackTrace();
           }
        }
		//文件输入输出流
        InputStream is  = new FileInputStream(sourceFile);
        OutputStream os = new FileOutputStream(targetFile,true);
        byte[] bytes = new byte[1024];
        //try-catch-finally
        try {
            int len;
            while ((len = is.read(bytes))!=-1){
                os.write(bytes,0,len);
                //刷新
                os.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally{
            is.close();
            os.close();
        }
    }
}

2.try(定义流对象)-catch

  • JDK7 没有finally
  • 资源用完最终自动释放
try(定义流对象){
	可能出现异常的代码;
}catch(异常类名 变量名){
	异常的处理代码;
}

3.catch(输入输出流对象)-catch

  • JDK9

  • 资源用完最终自动释放

定义输入流对象;
定义输出流对象;
try(输入流对象;
	输出流对象;){
	可能出现异常的代码;	
}catch(异常类名 变量名){
	异常的处理代码;
}
1.5 Properties
image-20240201221829708
  • Properties属性集对象
  • Properties代表的是一个属性文件，可以把自己对象中的键值对信息存到一个属性文件中去
    • 属性文件：后缀是 . properties结尾的文件，里面的内容都是 key = value ，用作系统配置信息

集合方法

  • 添加 put （独有）：public Object setProperty（String key ，String value）
  • 此属性列表中指定索引 属性值 get （独有） ：public String getProperty（String key）
  • 获取集合 所有键的名称集合 keySet （独有）： public Set< String > stringPropertyNames()

Properties与IO流 结合 的方法

  • 读取
    • void load(InputStream is) 从输入字节流读取属性列表(properties)
    • void load(Reader r) 从输入字符流读取属性列表
  • 存储
    • void store(OutputStream out , String comments) 将此属性列表 写入到 属性文件中
    • void store(Writer writer , String comments) 将此属性列表 写入到 属性文件中
public class PropertiesDemo {
    public static void main(String[] args) throws Exception{
        //1.创建 空的构造器
        //使用Properties 把键值对信息存入到属性文件中
        Properties properties = new Properties();
//        properties.put("msl","456");      父类方法
        //独有方法  setProperty 添加
        properties.setProperty("Mr.Ma","123456");
        properties.setProperty("Mr.Li","1234");
        properties.setProperty("Ms.Wan","13456");
        properties.setProperty("MsMa","1256");
        System.out.println(properties);
        //2.保存管道，存储properties
        /**
            参数一：保存管道 字符（字节）输出流管道 , 最好保存至 properties文件
            参数二：保存心得（注释）
         */
        properties.store(new FileWriter("src/out04.properties",true),
                "This is a good day~~~");
    }
}

public class PropertiesDemo2 {
    public static void main(String[] args) throws Exception{
        //1.Properties 读取属性文件中的键值对信息
        Properties properties = new Properties();
        System.out.println(properties);       // {}
        //2.加载  属性文件中 键值对数据到属性对象Properties中去
        properties.load(new FileReader("src/out04.properties"));
        System.out.println(properties);      //{MsMa=1256, Ms.Wan=13456, Mr.Ma=123456, Mr.Li=1234}
        //3.读取 键对应值
        //独有方法 getProperty
        String s = properties.getProperty("MsMa");
        System.out.println(s);
        //4.获取所有键的名称，返回Set集合
        Set<String> names = properties.stringPropertyNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}
总结
  • 字节流适合做一切文件数据的拷贝（音视频、文本）
  • 字节流 不适合 读取中文内容输出
  • 字符流适合做文本文件的输出（读、写）
参考

Java基础教程-IO篇

Java基础3

黎榕
关注
  • 16
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java对象转化为流_Java基础-IO流对象之转换流（InputStreamReader与OutoutStreamWriter）...
weixin_42113794的博客
02-23 1454
Java基础-IO流对象之转换流(InputStreamReader与OutoutStreamWriter)作者：尹正杰版权声明：原创作品，谢绝转载！否则将追究法律责任。一.转换流概述我们之前介绍过FileWrite和FileReader两个字符类，FileReader是用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileIn...
Java基础---IO流
我是太阳
01-30 2万+
1、File类的使用 常用构造器 路径分隔符 常用方法 2、IO流原理及流的分类 3、节点流(或文件流) 4、缓冲流 5、转换流 6、标准输入、输出流 7、 打印流 8、数据流 9、对象流 10、随机存取文件流 11、Path、Paths、Files类的使用 ...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 14万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
java基础-IO流【理论篇】
weixin_44050211的博客
09-12 726
IO流是java知识体系中很重要的一部分
java基础-IO流回顾
技术何
10-23 751
IO流回顾 java.io.File类的使用 IO原理及流的分类 文件流 FileOutputstream/FileInputStream/FileReader/FileWriter 缓冲流 BufferedInputStream/BufferedOutputStream /BufferedReader/BufferedWriter 转换流 InputStreamReader/O
Java--IO流文件读写
yang_54120的博客
04-03 2124
在Java中，IO流是用于处理输入和输出的一种机制。Java提供了许多类和接口，用于读取和写入不同类型的数据。Java的IO流可以分为两种类型：字节流和字符流。字节流：字节流以字节为单位进行数据传输。它们通常用于处理二进制数据或未经过处理的原始数据。Java提供了两个基本的字节流类：InputStream和OutputStream。字符流：字符流以字符为单位进行数据传输。它们通常用于处理文本数据。Java提供了两个基本的字符流类：Reader和Writer。
Java基础-IO流-将学生信息添加入集合并从高到底排序写入文件中
NONAME999的博客
12-16 1290
录入五个学生信息，按总分高低，存储至文本文件中 1、创建学生对象 2、创建集合对象 TreeSet(自然排序，或比较器排序) 3、键盘录入学生信息，存储到集合 4、从集合中获取元素，写入文件 创建学生类 这里偷懒了 没有私有化属性
Java基础 -- IO流、深 / 浅拷贝
天行健 君子以自强不息，地势坤 君子以厚德载物。
05-12 839
IO流、深 / 浅拷贝
Java基础系列35-IO流
只是甲的博客
09-16 2万+
文章目录一.IO流概述二. 字节流2.1 FOS与FIS2.2 FOS写数据的三种方式2.3 FOS如何实现换行和追加写数据2.4 FOS写数据加入异常处理2.5 FIS读数据方式1一次读取一个字节2.6 FIS读数据方式2一次读取一个字节数组2.7 字节流练习之复制文本文件2.8 字节流练习之复制图片三. 字节缓冲区流3.1 概述3.2 四种方式复制图片效率测试四. 转换流4.1 什么是编码表4.2 String类的编解码4.3 字符流Stream的编解码(写入文件)五. 字符流5.1 复制Java文件5
Java-Io流，练习
07-06
关于java的IO流基础的练习，适合刚接触IO流，没有基础的同学
Java基础-IO流(作业,适合Java初学者查看).zip
01-30
Scanner input = new Scanner(System.in); /** * 创建管理员对象 */ Manager gly = new Manager(); ObjectInputStream save = new ObjectInputStream(new FileInputStream( "savegly.txt"));...
Java-IO流/Stream流总结
07-12
Java-IO流/Stream流总结，内容...适合人群：有编程基础及Java基础伙伴 适用场景：Java中的流是随处可见的，涉及文件的操作必须使用IO流，Stream流可以对一些集合进行简便的操作，代码十分优雅，开发中非常常见。
java基础之IO流
06-18
java基础之IO流，基础简介知识，帮助你了解java的io技术
java-网络编程-io流-学习案例
02-25
基于 Java socket + 基础 io 流 + swing 窗口的聊天程序，供学习参考
简单的项目部署脚本（转载）
u010230019的博客
06-09 603
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1234
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
java.lang.reflect.Type是什么
最新发布
yuchangyuan5237的博客
06-12 397
通过 java.lang.reflect.Type 接口及其实现，Java 提供了一个强大的机制，用于在运行时检查和操作类型信息。这在编写通用库、框架和工具时特别有用，因为它允许你处理泛型类型和其他复杂类型结构。
修改菜品——后端Java
weixin_53717695的博客
06-09 409
修改菜品——后端Java
java思维导io流
09-30
Java的IO流是用来进行输入和输出操作的工具。在Java中，IO流分为字节流和字符流两种类型。字节流用于处理二进制数据，而字符流则用于处理文本数据。 字节流的处理流的基类是FilterInputStream和FilterOutputStream，其中缓冲流是重点。缓冲流可以提高IO性能，通过在内存中建立缓冲区，减少实际的IO操作次数。 对于字节流，可以使用DataInputStream和DataOutputStream来方便地读写Java基本类型以及String数据。DataOutputStream可以将数据写入到指定的文件中，而DataInputStream则可以从指定的文件中读取数据。 在IO流的使用中，可以使用节点流作为构造方法的参数，然后使用装饰流对节点流进行装饰。装饰流可以在节点流的基础上添加额外的功能，比如缓冲区的大小。 Java的IO流非常灵活和强大，可以满足各种不同的需求，比如文件操作、网络通信等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值