Java基础篇－IO流

已于 2022-05-24 09:49:41 修改
阅读量232 收藏 1
点赞数 1
分类专栏： Java基础篇 文章标签： java
于 2022-05-11 10:48:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XXXanghongin/article/details/124682037
版权

目录

1.文件

1.1 什么是文件？

1.2 文件流

2.常用的文件操作.

2.1 创建文件对象相关的构造器和方法

2.2 获取文件的相关信息

2.3 目录的操作和文件删除

3. IO流原理及流的分类

3.1 JavaIO流原理

3.2 流的分类

4.IO流体系图－常用的类

​编辑

4.1 FileInputStream 介绍

4.2 FileOutputStream 介绍

4.3 FileReader 和 FileWrite 介绍

4.4 FileReader 和 FileWriter 应用案例

5. 节点流和处理流

5.1基本介绍

5.2 节点流和处理流一览图

5.3  节点流和处理流的区别与联系

5.4 处理流的功能主要体现在以下两个方面

5.5 处理流－BufferedReader和BufferWriter

​编辑

5.6 BufferedReader和BufferWriter应用案例

5.7 介绍BufferedOutputStream

5.8 对象流－ObjectInputStream和ObjectOutputStream

5.9 对象流介绍

5.10 标准输入输出流 

5.11 转换流 － InputStreamReader 和 OutputWriter

6.打印流－PrintStream 和 PrintWriter

7.Properties类

7.1 基本介绍

7.2 应用案例

1.文件

1.1 什么是文件？

文件是可以保存数据的地方，比如大家经常使用的word文档，txt文档....

都是文件，它既可以保存一张图片，也可以保存视频，声音....

1.2 文件流

文件在程序中是以流的形式来操作的。

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZWxreg==,size_20,color_FFFFFF,t_70,g_se,x_16

 流：数据在数据源(文件)和程序之间经历的路径。

输入流：数据从数据源(文件)到程序(内存) 的路径。

输出流：数据从程序（内存）到数据源（文件）的路径。

2.常用的文件操作.

2.1 创建文件对象相关的构造器和方法

－>相关方法

new File(String pathname) //根据路径构建一个File对象。

new File(File parent,String child) //根据父目录文件 + 子路径构建。

new File(String parent,String child) //根据父目录 + 子路径构建。

creatNewFile 创建新文件（当new一个File对象时，在Java程序中，只是一个对象，只有执行了creatcreatNewFile方法，才会真正的在磁盘中创建该文件。）

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZWxreg==,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZWxreg==,size_16,color_FFFFFF,t_70,g_se,x_16

//方式1 new File(String pathname)
@Test 
public void create01() { 
    String filePath = "e:\\news1.txt"; 
    File file = new File(filePath); 
    try { 
        file.createNewFile(); 
        System.out.println("文件创建成功"); 
    } catch (IOException e) { 
        e.printStackTrace(); 
    } 
} 
//方式 2 new File(File parent,String child) //根据父目录文件+子路径构建 
@Test 
public void create02() { 
    File parentFile = new File("e:\\"); 
    String fileName = "news2.txt";
    File file = new File(parentFile, fileName);
    try { 
        file.createNewFile(); 
        System.out.println("创建成功~"); 
    } catch (IOException e) { 
        e.printStackTrace(); 
    } 
}
//方式 3 new File(String parent,String child) //根据父目录+子路径构建 
@Test 
public void create03() { 
    String parentPath = "e:\\"; 
    String fileName = "news4.txt"; 
    File file = new File(parentPath, fileName); 
    try { 
        file.createNewFile(); 
        System.out.println("创建成功~"); 
    } catch (IOException e) { 
        e.printStackTrace(); 
    } 
}

2.2 获取文件的相关信息

19507dbc74ac407790ab2fed86b0eab1.png

System.out.println("文件名字=" + file.getName()); 
//getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory 
System.out.println("文件绝对路径=" + file.getAbsolutePath()); 
System.out.println("文件父级目录=" + file.getParent()); 
System.out.println("文件大小(字节)=" + file.length()); 
System.out.println("文件是否存在=" + file.exists());//T 
System.out.println("是不是一个文件=" + file.isFile());//T 
System.out.println("是不是一个目录=" + file.isDirectory());//F

2.3 目录的操作和文件删除

mkdir 创建一级目录，mkdirs创建多级目录，delete删除空目录或文件。

返回值为boolean。

注意是目录，相当于文件夹，不是新建文件，新建文件是前面的creatNewFile。

3. IO流原理及流的分类

3.1 JavaIO流原理

1. I/O 是Input/output的缩写，I/O技术是非常实用的技术，用于处理数据传输，如读写文件，网络通讯等。

2. java程序中，对于数据的输入/输出操作以“流（stream)"的方式进行。

3. java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据。

4. 输入input：读取外部数据（磁盘，光盘等存储设备的数据）到程序（内存）中。

5. 输出output：将程序（内存）数据输出到磁盘，光盘等存储设备中。

3.2 流的分类

－>按操作数据单位不同分为：字节流（8bit）二进制文件，字符流（按字符）文本文件。

－>按数据流的流向不同分为：输入流，输出流。

－>按流的角色不同分为：节点流，处理流/包装流。

ed3ef8444b3e4af2a812973eaa3aca35.png

 ->Java的IO流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的。

 ->由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。

4.IO流体系图－常用的类

f62b8cc55d354a0f8ac3522bc83ec724.jpeg

4.1 FileInputStream 介绍

6b64f41b18664c1c92dd44d6066515fa.png

演示FileInputStream的使用（字节输入流 文件->程序）

/** 
*演示读取文件...  
 单个字节的读取，效率比较低 
*->使用 read(byte[] b) 
*/ 
@Test 
public void readFile01() { 
    String filePath = "e:\\hello.txt"; 
    int readData = 0; 
    FileInputStream fileInputStream = null; 
    try { 
        //创建 FileInputStream 对象，用于读取 文件 
        fileInputStream = new FileInputStream(filePath); 
        //从该输入流读取一个字节的数据。 如果没有输入可用，此方法将阻止。 
        //如果返回-1 , 表示读取完毕 
        while ((readData = fileInputStream.read()) != -1) { 
        System.out.print((char)readData);//转成 char 显示 
        } 
    } catch (IOException e) { 
        e.printStackTrace(); 
    } finally { 
        //关闭文件流，释放资源
        try { 
            fileInputStream.close(); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
}
/** 
*使用 read(byte[] b) 读取文件，提高效率 
*/ 
@Test 
public void readFile02() { 
    String filePath = "e:\\hello.txt"; 
    //字节数组 
    byte[] buf = new byte[8]; //一次读取 8 个字节.  
    nt readLen = 0; 
    FileInputStream fileInputStream = null; 
    try { 
        //创建 FileInputStream 对象，用于读取 文件 
        fileInputStream = new FileInputStream(filePath); 
        //从该输入流读取最多 b.length 字节的数据到字节数组。 此方法将阻塞，直到某些输入可用。 
        //如果返回-1 , 表示读取完毕 
        //如果读取正常, 返回实际读取的字节数 
        while ((readLen = fileInputStream.read(buf)) != -1) {
        System.out.print(new String(buf, 0, readLen));//显示 
        }
    catch (IOException e) { 
        e.printStackTrace(); 
    } 
    finally { 
        //关闭文件流，释放资源.  
        try { 
            fileInputStream.close(); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
}

4.2 FileOutputStream 介绍

150f85634d9e4e56bd2203d0298978cd.png

 FileOutputStream 应用实例

要求: 请使用 FileOutputStream 在 a.txt 文件，中写入 “hello，world。如果文件不存在，会创建 
文件(注意：前提是目录已经存在.)

public void writeFile() { 
    //创建 FileOutputStream 对象 
    String filePath = "e:\\a.txt"; 
    FileOutputStream fileOutputStream = null; 
    try { 
        //得到 FileOutputStream 对象 对象 
        //1. new FileOutputStream(filePath) 创建方式，当写入内容时，会覆盖原来的内容 
        //2. new FileOutputStream(filePath, true) 创建方式，当写入内容时，是追加到文件后面 
        fileOutputStream = new FileOutputStream(filePath, true); 
        //写入一个字节 
        //fileOutputStream.write('H');// 
        //写入字符串 
        String str = "hsp,world!"; 
        //str.getBytes() 可以把 字符串-> 字节数组 
        //fileOutputStream.write(str.getBytes()); 
        /* 
        write(byte[] b, int off, int len) 将 len 字节从位于偏移量 off 的指定字节数组写入                                此文件输出流 
        */ 
        fileOutputStream.write(str.getBytes(), 0, 3); 
    } catch (IOException e) { 
        e.printStackTrace(); 
    } finally { 
        try{
            fileOutputStream.close(); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
}

4.3 FileReader 和 FileWrite 介绍

相应构造方法：

7ddb05b74d874a48a9e0711ed43abe13.jpeg

－>FileReader 相关方法：

1）new FileReader(File/String)

2）read：每次读取单个字符，返回该字符，如果到文件末尾返回－1

3）read(char[])：批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回－1

相关API：

1）new String(char[]):将char[]转换成String

2）new String(char[],off,len)：将char[]的指定部分转换成String

－>FileWrite 常用方法

1）new FIleWriter(File/String)：覆盖模式，相当于流的指针在首端

2）new FIleWriter(File/String,true)：追加模式，相当于流的指针在尾端

3）write(int):写入单个字符

4）write(char[]):写入指定数组

5）write(char[],off,len):写入指定数组的指定部分

6）write(String):写入整个字符串

7）write(String,off,len):写入字符串的指定部分

相关API：

String类：toCharArray:将String转换成char[]

－>注意：

FileWriter使用后，必须要关闭（close）或刷新（flush），否则写入不到指定的文件。

4.4 FileReader 和 FileWriter 应用案例

要求：

1）使用FileReader从story.txt读取内容，并显示。

/** 
*单个字符读取文件 
*/ 
@Test 
public void readFile01() { 
    String filePath = "e:\\story.txt"; 
    FileReader fileReader = null; 
    int data = 0; 
    //1. 创建 FileReader 对象 
    try { 
        fileReader = new FileReader(filePath); 
        //循环读取 使用 read, 单个字符读取 
        while ((data = fileReader.read()) != -1) { 
        System.out.print((char) data); 
        }
    } catch (IOException e) { 
        e.printStackTrace(); 
    } finally { 
        try { 
            if (fileReader != null) { 
                fileReader.close(); 
            } 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
} 
/** 
*字符数组读取文件 
*/ 
@Test 
public void readFile02() { 
    System.out.println("~~~readFile02 ~~~"); 
    String filePath = "e:\\story.txt"; 
    FileReader fileReader = null; 
    int readLen = 0; 
    char[] buf = new char[8]; 
    //1. 创建 FileReader 对象
    try { 
        fileReader = new FileReader(filePath); 
        //循环读取 使用 read(buf), 返回的是实际读取到的字符数 
        //如果返回-1, 说明到文件结束 
        while ((readLen = fileReader.read(buf)) != -1) { 
        System.out.print(new String(buf, 0, readLen)); 
        } 
    } catch (IOException e) { 
        e.printStackTrace(); 
    } finally { 
        try { 
            if (fileReader != null) { 
                fileReader.close(); 
            } 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
}

2)使用FileWriter将“风雨之后，定见彩虹” 写入到 note.txt 文件中，注意细节.

public class FileWriter_ { 
    public static void main(String[] args) { 
        String filePath = "e:\\note.txt"; 
        //创建 FileWriter 对象 
        FileWriter fileWriter = null; 
        char[] chars = {'a', 'b', 'c'}; 
        try { 
            fileWriter = new FileWriter(filePath);//默认是覆盖写入 
            // 3) write(int):写入单个字符 
            fileWriter.write('H'); 
            // 4) write(char[]):写入指定数组 
            fileWriter.write(chars); 
            // 5) write(char[],off,len):写入指定数组的指定部分 
            fileWriter.write("韩顺平教育".toCharArray(), 0, 3); 
            // 6) write（string）：写入整个字符串 
            fileWriter.write(" 你好北京~"); 
            fileWriter.write("风雨之后，定见彩虹");
            // 7) write(string,off,len):写入字符串的指定部分 
            fileWriter.write("上海天津", 0, 2); 
            //在数据量大的情况下，可以使用循环操作.  
        catch (IOException e) { 
            e.printStackTrace(); 
        } finally {
            //对应FileWriter,一定要关闭流，或者 flush 才能真正的把数据写入到文件
            try { 
                //fileWriter.flush(); 
                //关闭文件流，等价 flush() + 关闭 
                fileWriter.close(); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        } 
        System.out.println("程序结束..."); 
    }
}

5. 节点流和处理流

5.1基本介绍

1）节点流可以从一个特定的数据源读写数据，如FileReader,FileWrite

6fdaba9f31374eeb81bc152c3179c9b2.png

2）处理流（也叫包装流）是“连接”在已存在的流（节点流或处理流）之上，为程序提供更为强大的读写功能，也更加灵活如BufferedReader,BufferedWriter

756b9096fce041d9b1a31bd85bad7d7d.png

5.2 节点流和处理流一览图

06e0f2b27d814aee932e6f107ad308cc.png

5.3  节点流和处理流的区别与联系

1）节点流是底层流/低级流，直接跟数据源相接。

2）处理流（包装流）包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出。

3）处理流（包装流）对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连。

5.4 处理流的功能主要体现在以下两个方面

1）性能的提高：主要以增加缓冲的方式来提高输入输出的效率。

2）操作的便捷：处理流可能提供了一系列便携的方法来一次输出大批量的数据，使用更加灵活方便。

5.5 处理流－BufferedReader和BufferWriter

－>BufferedReader和BufferedWriter属于字符流，是按照字符来读取数据的

－>关闭处理流时，只需要关闭外层流即可

－>BufferedReader:

ec82564d867146a7ad3378245f5dbe2e.png

4340e86dbae04b5fa79c4d08f1829d40.png

－>BufferedReader类中，有属性Reader，即可以封装一个节点流，该节点流可以是任意的，只要是Reader子类。 

－>BufferedWriter类似于BufferedReader.

5.6 BufferedReader和BufferWriter应用案例

1）使用BufferedReader读取文本文件，并显示在控制台。

public class BufferedReader_ { 
    public static void main(String[] args) throws Exception { 
        String filePath = "e:\\a.java"; 
        //创建 bufferedReader 
        BufferedReader bufferedReader = new BufferedReader(new         FileReader(filePath));
        //读取 
        String line; //按行读取, 效率高 
        //说明 
        //1. bufferedReader.readLine() 是按行读取文件 
        //2. 当返回 null 时，表示文件读取完毕 
        while ((line = bufferedReader.readLine()) != null) { 
            System.out.println(line); 
        } 
        //关闭流, 这里注意，只需要关闭 BufferedReader ，因为底层会自动的去关闭节点流        FileReader。
        bufferedReader.close(); 
    } 
}

2）使用BufferedWriter将“hello，world”写入到文件中。

public class BufferedWriter_ { 
    public static void main(String[] args) throws IOException { 
        String filePath = "e:\\ok.txt"; 
        //创建 BufferedWriter 
        //说明: 
        //1. new FileWriter(filePath, true) 表示以追加的方式写入 
        //2. new FileWriter(filePath) , 表示以覆盖的方式写入
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath)); 
        bufferedWriter.write("hello, world!"); 
        bufferedWriter.newLine();//插入一个和系统相关的换行 
        bufferedWriter.write("hello2, world!"); 
        bufferedWriter.newLine(); 
        bufferedWriter.write("hello3, world!"); 
        bufferedWriter.newLine(); 
        //说明：关闭外层流即可 ， 传入的 new FileWriter(filePath) ,会在底层关闭 
        bufferedWriter.close(); 
    } 
}

5.7 介绍BufferedOutputStream

－>BufferedOutputStream 是字节流，实现缓冲的输出流，可以将多个字节写入底层输出流中，而不必对每次字节写入调用底层系统。

－>BufferedInputStream类似于BufferedOutputStream

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZWxreg==,size_20,color_FFFFFF,t_70,g_se,x_16

－>应用案例（演示使用BufferedInputStreamBufferedOutputStream，使用它们，可以完成对二进制文件的操作）：

    要求：编程完成图片/音乐的拷贝（要求使用Buffered...流）

public class BufferedCopy02 { 
    public static void main(String[] args) { 
        String srcFilePath = "e:\\Koala.jpg"; //图片
        String destFilePath = "e:\\Kolar2.jpg"; 
        String srcFilePath = "e:\\超能陆战队.avi"; //视频
        String destFilePath = "e:\\超能陆战队2.avi";
        //创建 BufferedOutputStream 对象 BufferedInputStream 对象 
        BufferedInputStream bis = null; 
        BufferedOutputStream bos = null; 
        try { 
            //因为 FileInputStream 是 InputStream 子类 
            bis = new BufferedInputStream(new FileInputStream(srcFilePath));
            bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
            //循环的读取文件，并写入到 destFilePath 
            byte[] buff = new byte[1024]; 
            int readLen = 0; 
            //当返回 -1 时，就表示文件读取完毕 
            while ((readLen = bis.read(buff)) != -1) { 
                bos.write(buff, 0, readLen); 
            } 
            System.out.println("文件拷贝完毕~~~"); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } finally { 
            //关闭流 , 关闭外层的处理流即可，底层会去关闭节点流 
            try { 
                if(bis != null) { 
                    bis.close(); 
                } 
                if(bos != null) { 
                    bos.close(); 
                } 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        }
    }
}

5.8 对象流－ObjectInputStream和ObjectOutputStream

->看一个需求：

1）. 将int num = 100 这个int数据保存到文件中，注意不是100数字，而是Int 100，并且，能够从文件中直接恢复int 100。

2）.将Dog dog ＝ new Dog("大黄“，3)这个dog对象保存文件中，并且能够从文件中恢复。

3）.上面的要求，就是能够将基本数据类型或者对象进行序列化和反序列化操作。

－>序列化和反序列化

1）序列化就是在保存数据时，保存数据的值和数据类型

2）反序列化就是在恢复数据时，恢复数据的值和数据类型

3）需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须要实现如下两个接口之一：

        －>Serializable （这是一个标记接口，没有方法）

        －>Extermalizable （该接口有方法需要实现，因此我们一般实现上面的Serializable接口

236260478b194b7898b771d2db746249.png

5.9 对象流介绍

－>功能：提供了对基本数据类型或对象类型的序列化和反序列化的方法

        ObjectOutputStream 提供 序列化功能

        ObjectInputStream 提供反序列化功能

aa8c3f17a496445fa6f70f6dd23b891e.png

e5ebff52279a430f8acb5270d1e8d51b.png

 －>应用案例

1） 使用ObjectOutputStream序列化基本数据类型和一个dog对象（name，age），并保存到date.dat文件中     

public class ObjectOutStream_ { 
    public static void main(String[] args) throws Exception { 
        //序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存 
        String filePath = "e:\\data.dat"; 
        ObjectOutputStream oos = new ObjectOutputStream(new     FileOutputStream(filePath)); 
        //序列化数据到 e:\data.dat 
        oos.writeInt(100);// int -> Integer (实现了 Serializable) 
        oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable) 
        oos.writeChar('a');// char -> Character (实现了 Serializable) 
        oos.writeDouble(9.5);// double -> Double (实现了 Serializable) 
        oos.writeUTF("你好");//String 
        //保存一个 dog 对象 
        //此Dog对象实现了Serializable接口
        oos.writeObject(new Dog("旺财", 10, "日本", "白色")); 
        oos.close();
        System.out.println("数据保存完毕(序列化形式)");
    }
}

2）使用ObjectInputStream读取date.dat并反序列化恢复数据

// 1.创建流对象 
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src\\data.dat")); 
// 2.读取， 注意顺序 
System.out.println(ois.readInt()); 
System.out.println(ois.readBoolean()); 
System.out.println(ois.readChar()); 
System.out.println(ois.readDouble()); 
System.out.println(ois.readUTF()); 
System.out.println(ois.readObject()); 
System.out.println(ois.readObject()); 
System.out.println(ois.readObject()); 
// 3.关闭 
ois.close(); 
System.out.println("以反序列化的方式读取(恢复)ok~");

－>注意事项

1）读写顺序要一致

2）序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient（短暂的）修饰的成员

3）序列化对象时要求里面属性的类型也需要实现序列化接口

4）序列化具备可继承性，也就是如果某类已经实现了序列化，则他的子类也已经默认实现了序列化

5.10 标准输入输出流 

类型默认设备
System.in 标准输入InputStream键盘
System.out 标准输出PrintStream显示器

5.11 转换流 － InputStreamReader 和 OutputWriter

－>介绍：

1）InputStreamReader:Reader的子类，可以将InputStream（字节流）包装成（转换）Reader（字符流）

2）OutPutStreamWriter：Writer的子类，实现将OutputStream（字节流）包装成Writer（字符流）

3）当处理纯文本数据时，如果使用字符流效率更高，并且可以有效解决中文问题，所以建议将字节流转换成字符流

4）可以在使用时指定编码格式（如utf-8,gbk,gb2312,ISO8859-1等）

3fa4f67cd8554baf8c935c18a92acb6a.png

 －>应用案例：

1）编程将字节流FileInputStream包装成（转换成）字符流InputStreamReader，对文件进行读取，（按照utf-8/gbk）格式，进而在包装成BufferedReader

public class InputStreamReader_ { 
    public static void main(String[] args) throws IOException { 
        String filePath = "e:\\a.txt"; 
        //解读 
        //1. 把 FileInputStream 转成 InputStreamReader
        //2. 指定编码 gbk 
        //InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk"); 
        //3. 把 InputStreamReader 传入 BufferedReader 
        //BufferedReader br = new BufferedReader(isr); 
        //将 2 和 3 合在一起 
        BufferedReader br = new BufferedReader(new InputStreamReader( 
        new FileInputStream(filePath), "gbk")); 
        //4. 读取 
        String s = br.readLine(); 
        System.out.println("读取内容=" + s); 
        //5. 关闭外层流 
        br.close(); 
    } 
}

2）编程将字节流FileOutputStream包装成（转换成）字符流OutputStreamWriter，对文件进行写入（按照gbk格式，可以指定其他，比如utf-8)

// 1.创建流对象 
OutputStreamWriter osw = 
new OutputStreamWriter(new FileOutputStream("d:\\a.txt"), "gbk");
// 2.写入 
osw.write("hello,world"); 
// 3.关闭 
osw.close(); 
System.out.println("保存成功~");

6.打印流－PrintStream 和 PrintWriter

－>打印流只有输出流，没有输入流

049a47b9792a4c3cb33c0285c096d4e6.png

ad24aebcf47247de9b2ef611bc541667.png

 －>应用实例

//演示PrintWriter使用方式
public class PrintWriter_ { 
    public static void main(String[] args) throws IOException { 
        //PrintWriter printWriter = new PrintWriter(System.out); 
        PrintWriter printWriter = new PrintWriter(new FileWriter("e:\\f2.txt"));
        printWriter.close;
    }
}

//演示PrintStream（字节打印流/输出流）
public class PrintStream_ { 
    public static void main(String[] args) throws IOException { 
        PrintStream out = System.out; 
        //在默认情况下，PrintStream 输出数据的位置是 标准输出，即显示器
        out.print("john, hello"); 
        //因为 print 底层使用的是 write , 所以我们可以直接调用 write 进行打印/输出 
        out.write("你好".getBytes()); 
        out.close(); 
        //我们可以去修改打印流输出的位置/设备 
        //1. 输出修改成到 "e:\\f1.txt" 
        //2. "hello,world" 就会输出到 e:\f1.txt 
        //3. public static void setOut(PrintStream out) { 
            // checkIO(); 
            // setOut0(out); // native 方法，修改了 out 
        // } 
        //System.setOut(new PrintStream("e:\\f1.txt")); 
        //System.out.println("hello, world"); 
    } 
}

7.Properties类

7.1 基本介绍

1）专门用于读写文件的集合类

        配置文件的格式：

        键＝值

        键＝值

8da58d3c6a8f4811aebe5b026dcedfd9.png

2）注意：健值对不需要有空格，值不需要用引号一起来，默认类型是String

3）Properties的常见方法 

load：加载配置文件的健值对到Properties对象

list：将数据显示到指定设备

getProperty（key）：根据键获取值

setProperty（key，value）：设置键值对到properties对象

store：将Properties中的健值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码

7.2 应用案例

1）使用Properties类完成对mysql.properties的读取

2）使用Properties类添加key-val到新文件mysql2.properties中

3）使用Properties类完成对mysql2.properties的读取，并修改某个key－val

public class Properties02 { 
    public static void main(String[] args) throws IOException { 
        //使用 Properties 类来读取 mysql.properties 文件 
        //1. 创建 Properties 对象 
        Properties properties = new Properties(); 
        //2. 加载指定配置文件 
        properties.load(new FileReader("src\\mysql.properties")); 
        //3. 把 k-v 显示控制台 
        properties.list(System.out); 
        //4. 根据 key 获取对应的值 
        String user = properties.getProperty("user"); 
        String pwd = properties.getProperty("pwd"); 
        System.out.println("用户名=" + user); 
        System.out.println("密码是=" + pwd); 
    } 
}
public class Properties03 { 
    public static void main(String[] args) throws IOException { 
        //使用 Properties 类来创建 配置文件, 修改配置文件内容 
        Properties properties = new Properties(); 
        //创建 
        //1.如果该文件没有 key 就是创建 
        //2.如果该文件有 key ,就是修改
        properties.setProperty("charset", "utf8"); 
        properties.setProperty("user", "汤姆");//注意保存时，是中文的 unicode 码值 
        properties.setProperty("pwd", "888888"); 
        //将 k-v 存储文件中即可 
        properties.store(new FileOutputStream("src\\mysql2.properties"), null); 
        System.out.println("保存配置文件成功~"); 
    }
}

elkz
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java基础篇之IO流，动力节点老杜详细笔记
qq_45769329的博客
01-21 1203
详细讲解IO流，主要聚焦如何使用、掌握常用方法等
Java基础篇：IO流.pdf
05-19
该文档主要整理了Java IO流的相关信息，主要包括IO流的按照不同维度的分类、节点流、处理流、输入输出流的处理过程、抽象基类的使用等细节内容
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java 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流【理论篇】
weixin_44050211的博客
09-12 734
IO流是java知识体系中很重要的一部分
Java基础 -- 呕心沥血的JavaIO流篇笔记
wanghuichen的博客
06-13 2056
呕心沥血的javaio流篇笔记（内含代码练习）
Java中的IO流 - 入门篇
Li_Jian_Hui_的博客
05-12 4510
简介 文件IO流，主要有两种方式 字节流：基于各种文件，包括普通文本txt，音频文件mp3，视频文件mp4等 字符流：基于普通的文本字符串，比如普通文本txt等 本例中用到的相关类如下： 所有的读写操作都是针对内存而言的，因为程序就是运行在内存中 读操作就是从磁盘文件或网络流读到内存，对于内存而言就是Input 写操作就是从内存写到磁盘文件或网络流，对于内存而言就是Output 下面分别介绍这两种方式 字节流 本例子，字节流中主要讲的是ObjectInputStream和ObjectOut
【愚公系列】2023年10月 Java教学课程 061-IO流之字符缓冲流
时光隧道
10-11 4万+
Java中IO流（Input/Output stream）用于处理输入和输出数据的机制，它包括输入流和输出流两个部分。输入流用于从外部读取数据，输出流用于向外部写入数据。Java中的IO流可以让我们从文件、网络、控制台等地方读取数据和输出数据。IO流主要分为字节流和字符流两类，字节流适用于处理二进制数据，而字符流适用于处理文本数据。Java中的IO流分层结构非常清晰，所有的输入流和输出流都是从抽象基类InputStream和OutputStream派生出来的。
【Java 基础篇】Java IO流详解
繁依Fanyi的博客
06-26 2998
本文详细介绍了Java IO流的原理、分类、使用场景和常用类。IO流提供了一种统一的方式来处理输入和输出操作，无论是从文件、网络连接还是内存中。通过使用不同的IO流类，我们可以实现数据的读取和写入，满足不同的需求。希望本文对你理解和应用Java IO流有所帮助！
JAVA—IO流详解
weixin_48006490的博客
09-01 7919
IO:Input/Output即输入&输出，也称之为流（河流，水流），指的是数据从一个地点到另一个地点过程；对于计算机来说文件的拷贝过程，文件的编写保存，显示功能都是使用到IO；将数据的传输过程看做一个输入输出。现实角度考虑可以将耳朵作为输入流，将嘴巴当做输出流输入输出介质：文件网络键盘（输入）显示器（输出）
【愚公系列】2023年10月 Java教学课程 058-IO流之字节流
时光隧道
01-07 3万+
Java中IO流（Input/Output stream）用于处理输入和输出数据的机制，它包括输入流和输出流两个部分。输入流用于从外部读取数据，输出流用于向外部写入数据。Java中的IO流可以让我们从文件、网络、控制台等地方读取数据和输出数据。IO流主要分为字节流和字符流两类，字节流适用于处理二进制数据，而字符流适用于处理文本数据。Java中的IO流分层结构非常清晰，所有的输入流和输出流都是从抽象基类InputStream和OutputStream派生出来的。
JavaSE基础篇 -- IO流的详细操作
07-28
本资源内详尽描述了Java基础的IO操作，包括基本的文件读取、写入、复制、分割、合并等动作，详情另可参见我的博客http://blog.csdn.net/zhongkelee/article/details/47061013
commons-io-2.6--java框架技术
04-20
Apache Commons IO 是一个Java库，专门用于处理输入/输出流操作。版本2.6是该库的一个稳定版本，提供了大量的类和方法来简化常见的IO任务。这个库是Java开发人员在处理文件、流、过滤器、读写操作时的重要工具。在本...
Java学习笔记-IO篇
03-25
这是我自己整理的Java学习笔记，希望对大家有帮助
Java语言基础教程-Java NIO流篇2
03-25
在Java的IO体系中，流是数据传输的抽象，它代表了数据的流向，可以是输入流（InputStream）或输出流（OutputStream）。然而，NIO中的流与传统的IO流有所不同，它们不仅支持字节流，还支持字符流，并且引入了缓冲区...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 559
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 809
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
springboot中抽离日志
最新发布
qq_24223159的博客
07-08 218
【代码】springboot中抽离日志。
ShardingSphere
Casual_Lei的博客
07-04 677
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
JAVA-SE入门学习——第九讲IO流
06-08
JAVA-SE入门学习——第九讲IO流

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值