Java-IO流(节点流和处理流)

【Java】IO流--节点流、处理流 包装流、BufferedReader 包装流 字符输入流、BufferedWriter 包装流 字符输出流、包装流 字符流 使用、包装流 字节流 使用 阅读详情

基本介绍

1)节点流可以从一个特定的数据源读写数据,如:FileReader、FileWriter;

2)处理流(包装流)是“连接”在已存在的流(节点流或处理流)之上,为程序提供更为强大的读写能力,如:BufferedReader、BufferedWriter;

类属分类字节输入流字节输出流字符输入流字符输出流
抽象基类InputStreamOutputStreamReaderWriter
节点流访问文件FileInuputStreamFileOutputStreamFileReaderFileWriter
访问数组ByteArrayInuputStreamByteArrayOutputStreamCharArrayReaderCharArrayWriter
访问管道PipedInputStreamPipedOutputStreamPipedReaderPipedWriter
访问字符串StringReaderStringWriter
处理流缓冲流BufferedInputStreamBufferedOutputStreamBufferedReaderBufferedWriter
转换流InputStreamReaderOutputStreamWriter
对象流ObjectInputStreamObjectOutputStream
抽象基类FilterInputStreamFilterOutputStreamFilterReaderFilterWriter
打印流PrintStreamPrintWriter
推回输入流PushbackInputStreamPushbackReader
特殊流DataInputStreamDataOutputStream

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

1)节点流是底层流/低级流,直接跟数据源相接;

2)处理流包装节点流,即可以消除不同节点流的实现差异,也可以提供更方便的方法来完成输入输出;

3)处理流(包装流)对节点流进行包装,使用了修饰器设计模式,不会直接与数据源相连;

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

1)性能的提高:主要以增加缓冲的方式来提高输入输出的效率;

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

字符处理流BufferedReader和BufferedWriter

★BufferedReader和BufferedWriter属于字符流,按照字符来读取数据;

★关闭时,只需要关闭外层流即可,包装流会自动关闭被包装的节点流。

BufferedReader测试代码

package com.pero.demo;

import org.junit.jupiter.api.Test;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * @author Pero
 * @version 1.0
 */
public class BufferedReader_ {
    public static void main(String[] args) {

    }

    @Test
    public void test() throws IOException {
        String path = "d:\\:demo\\test\\Story.txt";
        String line;
        BufferedReader bufferedReader = new BufferedReader(new FileReader(path));

        while ((line = bufferedReader.readLine()) != null){ //表示按行读取,如果达到流的末尾则返回null
            System.out.println(line);
        }
        bufferedReader.close();
    }
}

bufferedReader.close()源码

public void close() throws IOException {
        synchronized (lock) {
            if (in == null)
                return;
            try {
                in.close();    //FileReader关闭
            } finally {
                in = null;
                cb = null;
            }
        }
    }

BufferedWriter测试代码

package com.pero.demo;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @author Pero
 * @version 1.0
 */
public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {

        //创建路径
        String path = "d:\\demo\\test\\Story.txt";
        //创建BufferedWriter(字符输出缓冲流)
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(path,true));
        String str = "床前明月光,疑是地上霜";

        bufferedWriter.write('a');
        bufferedWriter.write(str+'\n');
        bufferedWriter.write(str.toCharArray(),0,5);

        //关闭外层流,传入的节点流new FileWriter(),会在底层关闭
        bufferedWriter.close();
    }
}

使用BufferedReader和BufferedWriter进行文本拷贝

package com.pero.demo;

import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * @author Pero
 * @version 1.0
 */
public class BufferedCopy_ {
    public static void main(String[] args) throws IOException {

        //读取目标文件地址
        String readerPath = "d:\\demo\\test\\Story.txt";
        //拷贝数据存放地址
        String writerPath = "d:\\demo\\test\\Book.txt";
        char[] chars = new char[1024];
        int length = 0;

        //创建BufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(readerPath));

        //创建BufferedWriter
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(writerPath));

        while((length = bufferedReader.read(chars)) != -1) {
            bufferedWriter.write(chars,0,length);
        }

        bufferedReader.close();
        bufferedWriter.close();
    }
    
    
    @Test
    public void test(){
        //读取目标文件地址
        String readerPath = "d:\\demo\\test\\Story.txt";
        //拷贝数据存放地址
        String writerPath = "d:\\demo\\test\\Book.txt";
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        String line = null;

        try {
            bufferedReader = new BufferedReader(new FileReader(readerPath));
            bufferedWriter = new BufferedWriter(new FileWriter(writerPath));

            while ((line = bufferedReader.readLine()) != null){
                bufferedWriter.write(line);
                bufferedWriter.newLine();   //换行,不进行换行操作的话,打印内容会在一行
            }
            
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            if (bufferedReader != null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bufferedWriter != null){
                try {
                    bufferedWriter.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

BufferedInputStream和BufferedOutputStream字节处理流

BufferedInputStream是字节输入缓冲流,在创建BufferedInputStream时,会创建一个内部缓冲区数组;BufferedOutputStream是字节输出缓冲流,实现缓冲的输出流,可以将多个字节写入底层输出流中,而不必对每次字节写入调用底层系统。

字节处理流拷贝文件

package com.pero.demo;

import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * 字节流可以操作二进制文件,也可以操作文本文件
 * 
 * @author Pero
 * @version 1.0
 */
public class BufferedCopy02_ {
    public static void main(String[] args) throws IOException {

        String inputPath = "C:\\Users\\Pero\\Desktop\\4.jpeg";
        String outputPath = "d:\\demo\\test\\boom.jpeg";
        int length = 0;
        byte[] bytes = new byte[1024];

        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(inputPath));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(outputPath));

        while((length = bufferedInputStream.read(bytes)) != -1){
            bufferedOutputStream.write(bytes,0,length);
        }
        System.out.println("文件拷贝完毕");

        if (bufferedInputStream != null){
            bufferedInputStream.close();
        }
        if (bufferedOutputStream != null){
            bufferedOutputStream.close();
        }
    }

    @Test
    public void test(){
        String inputPath = "C:\\Users\\Pero\\Desktop\\4.jpeg";
        String outputPath = "d:\\demo\\test\\boom.jpeg";
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        int length = 0;
        byte[] bytes = new byte[1024];

        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream(inputPath));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(outputPath));

            while((length = bufferedInputStream.read(bytes)) != -1){
                bufferedOutputStream.write(bytes,0,length);
            }
            System.out.println("文件拷贝完毕");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            if (bufferedInputStream != null){
                try {
                    bufferedInputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bufferedOutputStream != null){
                try {
                    bufferedOutputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

对象流ObjectInputStream和ObjectOutputStream

将基本数据类型或者对象进行序列化和反序列化操作。

★序列化和反序列化

1)序列化是指保存数据时,保存数据的值和数据类型;

2)反序列化是指在恢复数据时,恢复数据的值和数据类型;

3)需要让某个对象支持序列化机制,则必须让其类是可序列化的,也就是让该类必须实现如下两个接口之一:

☆Serializable接口(标记接口)

☆Externalizable接口

 ObjectOutputStream测试代码

package com.pero.demo;

import java.io.*;

/**
 * @author Pero
 * @version 1.0
 */
public class ObjectOutputStream_ {
    public static void main(String[] args) throws IOException {

        //保存文件路径
        String path = "d:\\demo\\test.dat"; //序列化后,保存文件格式是按照特定格式来保存的
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(path));
        //序列化数据到文件中
        objectOutputStream.write(100);  //int ->Integer(实现了Serializable接口)
        objectOutputStream.writeBoolean(true);
        objectOutputStream.writeChar('a');
        objectOutputStream.writeByte(11010);
        objectOutputStream.writeObject(new Dog("tom",16));

        objectOutputStream.close();
    }
}

//如果序列化类的对象,该类必须实现Serializable或者Externalizable接口
class Dog implements Serializable {
    private String name;
    private int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

ObjectInputStream测试代码

package com.pero.demo;

import java.io.*;

/**
 * @author Pero
 * @version 1.0
 */
public class ObjectInputStream_ {
    public static void main(String[] args) throws IOException {
        //反序列化文件路径
        String path = "d:\\demo\\test.dat";
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(path));

        //反序列化顺序必须和序列化顺序一致
        System.out.println(objectInputStream.readInt());
        System.out.println(objectInputStream.readBoolean());
        System.out.println(objectInputStream.readChar());
        System.out.println(objectInputStream.readByte());
        System.out.println(objectInputStream.readUTF());
        System.out.println(objectInputStream.readDouble());
        try {
            //dog的编译类型是Object,dog的运行类型是Dog
            Object dog = objectInputStream.readObject();
            System.out.println(dog.getClass());
            System.out.println(dog);
            //如果需要调用Dog的方法,需要向下转型,必须能够访问Dog类
            //Dog类可以声明为public的
        } catch (ClassNotFoundException e) {    //类型转换,底层把对象从Object转成Dog
            throw new RuntimeException(e);
        }
        //关闭外层流,底层会关闭节点流
        objectInputStream.close();
    }

}

注意事项和细节

1)读写顺序一致;

2)实现序列化或反序列化对象,必须实现serializable或者Externalizable接口;

3)序列化的类中建议添加SeriaVersionUID,为了提高版本的兼容性;

4)序列化对象时,默认将所有属性都进行序列化,但除了static或transient修饰的成员;

5)序列化对象时,要求属性类型也要实现序列化接口;

6)序列化具备可继承性,某类实现了序列化,那么它的子类也默认实现了序列化。

标准输入输出流

编译类型运行类型默认设备
System.in标准输入InputStreamBufferedInputStream键盘
System.out标准输出PrintStreamPrintStream显示器
package com.pero.demo;

/**
 * @author Pero
 * @version 1.0
 */
public class InputAndOutput {
    public static void main(String[] args) {

        //标准输入流
        //public final static InputStream in = null;
        //编译类型InputStream,运行类型是BufferedInputStream
        System.out.println(System.in.getClass());

        //标准输出流
        //public final static PrintStream out = null;
        //编译类型PrintStream,运行类型是PrintStream
        System.out.println(System.out.getClass());
    }
}

 转换流InputStreamReader和OutputStreamWriter

1)InputStreamReader:Reader的子类,可以将InputStream(字节流)包装成(转换)Reader(字符流);

2)OutputStreamWriter:Writer的子类,可以将OutputStream(字节流)包装成Writer(字符流);

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

4)可以在使用时指定编码格式(UTF-8,gnk等等)。

InputStreamReader测试代码

package com.pero.demo;

import java.io.*;

/**
 * 默认读取文件时是默认UTF-8的编码
 * 如果不指定读取文件的编码模式,当编码模式不相同时则会出现乱码
 *
 * @author Pero
 * @version 1.0
 */
public class Transformation_ {
    public static void main(String[] args) throws IOException {
        String path = "d:\\demo\\test\\next.txt";
        InputStreamReader inputStreamReader = null;
        char[] chars = new char[1024];
        int length = 0;

//        bufferedReader = new BufferedReader(new FileReader(path));
//        while ((readLine_ = bufferedReader.readLine()) != null){
//            System.out.println(readLine_);
//        }
//        if (bufferedReader != null){
//            bufferedReader.close();
//        }
        //第一次转换,将FileInputStream包装成InputStreamReader;
        //指定编码类型为gbk/utf-8/utf8
        inputStreamReader = new InputStreamReader(new FileInputStream(path),"utf8");   
        //第二次转换,将InputStreamReader包装成BufferedReader;
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        
//        BufferedReader bufferedReader1 = new BufferedReader(
//                new InputStreamReader(
//                        new FileInputStream(path),"gbk"));
        String s = bufferedReader.readLine();
        System.out.println(s);
        //关闭外层流
        bufferedReader.close();

    }
}

OutputStreamWriter测试代码

package com.pero.demo;

import java.io.*;

/**
 * @author Pero
 * @version 1.0
 */
public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {

        String filePath = "d:\\demo\\test\\writer.txt";
        String charSet = "utf-8" ;
        //转为字符流
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(
                //字节流
                new FileOutputStream(filePath,true),charSet);    //要添加转换格式
        outputStreamWriter.write("hello,world");
        outputStreamWriter.close();
        System.out.println("文件按照"+charSet+"保存文件成功");
    }
}

打印流PrintStream(字节打印流)和PrintWriter(字符打印流)

PrintStream测试代码

package com.pero.demo;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintStream;

/**
 * PrintStream字节打印流,输出流
 *
 * @author Pero
 * @version 1.0
 */
public class PrintStream_ {
    public static void main(String[] args) throws FileNotFoundException {
        PrintStream out = System.out;
        //在默认情况下,PrintStream输出数据的位置是标准输出,即显示器
        /*
        * public void print(String s) {
                if (s == null) {
                    s = "null";
                }
                write(s);
            }
        * */
        out.print("hello,world");
        //打印也可以用write来运行
        try {
            out.write("完成打印".getBytes());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        out.close();

        //修改打印流输出的位置
        //setOut方法可以修改printStream的输出路径
        //PrintStream的构造器支持传入一个输出地址
        //public static void setOut(PrintStream out) {
        //        checkIO();
        //        setOut0(out);     //native方法,修改了out
        //    }
        System.setOut(new PrintStream("d:\\demo\\test.txt"));
        System.out.println("打印完成"); //输出到"d:\\demo\\test.txt"

    }
}

PrintWriter测试代码

package com.pero.demo;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * @author Pero
 * @version 1.0
 */
public class PrintWriter_ {
    public static void main(String[] args) throws IOException {
        //PrintWriter printWriter = new PrintWriter(System.out/*标准输出流*/);
        PrintWriter printWriter = new PrintWriter(
                new FileWriter("d:\\demo\\test\\look.txt"));
        printWriter.print("打印成功");//输出到"d:\\demo\\test\\look.txt"文件
        printWriter.close();    //如果没有关闭则不会进行内容输出
    }
}

Properties类

properties是Hashtable的子类,读取和写入properties配置文件。

(BufferedReader+FileReader读取properties配置文件)

package com.pero.properties_;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**
 * @author Pero
 * @version 1.0
 */
public class Properties01 {
    public static void main(String[] args) throws IOException {
        //读取mysql.properties文件,并得到ip,user,pwd
        //用缓冲流BufferedReader+FileReader
        //拿到后要进行拆解(繁琐步骤)
        String read = null;
        BufferedReader bufferedReader = new BufferedReader(
                new FileReader("src\\mysql.properties"));
        while ((read = bufferedReader.readLine()) != null) {
            String[] split = read.split("=");   //把字符串等号两边拆成字符串数组
            if ("ip".equals(split[0])) {
                System.out.println(split[1]);
            }
        }
        bufferedReader.close(); //关闭流
    }
}

1)properties类是专门用于读写配置文件的集合类:

配置文件的格式:

键=值

键=值

2)键值对不需要有空格,值不需要引号引起来。默认类型是String。

3)Properties的常见方法:

①load()方法:加载配置文件的键值对到Properties对象;

②list()方法:将数据显示到指定设备;

③getProperty(key)方法:根据键获取值;

④setProperty(key,value)方法:设置键值对到Properties对象;

⑤store()方法:将Properties中的键值对存储到配置文件,在idea中,保存信息到配置文件,如果含有中文会存储为unicode码。

package com.pero.properties_;

import org.junit.jupiter.api.Test;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

/**
 * @author Pero
 * @version 1.0
 */
public class Properties02 {
    public static void main(String[] args) throws IOException {
        //创建Properties对象
        Properties properties = new Properties();
        //加载指定路径文件键值对到Properties对象
        properties.load(new FileReader("src\\mysql.properties")/*Reader or InputStream*/);
        //获取值对象
        String ip = properties.getProperty("ip");
        System.out.println(ip);
        //打印所有信息
        properties.list(System.out/*PrintStream or PrintWriter*/);
    }

    @Test
    public void test() throws IOException {

        //用Properties类创建配置文件,修改配置文件内容
        Properties properties = new Properties();
        //properties对象中有三个键值对存储在其中(目前键值对在内存中)
        properties.setProperty("ip","192.168.1.1");
        properties.setProperty("user","杰克");    //保存时是中文unicode码
        properties.setProperty("pwd","987654");
        
        properties.setProperty("pwd","654456"); //  如果key值存在,再次创建则是修改
        //将键值对数据存储在文件中
        properties.store(
                new FileWriter("src\\mysql2.properties")/*Writer or OutputStream*/,
                null/*comments*/);
        System.out.println("成功保存配置文件");
    }
}

课后习题

package com.pero;

import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * 判断d盘下是否有文件夹mytemp,如果没有就创建mytemp文件夹
 * 在mytemp文件夹下创建文件hello.txt
 * 如果hello.txt已经存在,则提示文件已经存在不再重复创建
 * 在hello.txt文件中写入hello,world
 *
 * @author Pero
 * @version 1.0
 */

public class Homework01 {
    public static void main(String[] args) {

    }

    @Test
    public void test() throws IOException {
        //创建文件路径
        String filePath = "d:\\mytemp";
        //创建当前地址的文件对象
        File file = new File(filePath);
        if(!file.exists()){ //如果文件不存在
            if (file.mkdirs()){ //创建多级目录,如果创建成功返回true
                System.out.println("文件夹创建成功");
            }else {
                System.out.println("文件夹创建失败");
            }
        }else {
            System.out.println("文件夹存在");
        }
        File fileHello = new File("d:\\mytemp\\hello.txt");
        if (!fileHello.exists()){
            if (fileHello.createNewFile()){     //创建文件
                FileWriter fileWriter = new FileWriter(fileHello);
                fileWriter.write("hello,world");
                fileWriter.close();
                System.out.println("文件创建成功");
            }else {
                System.out.println("文件创建失败");
            }
        }else {
            System.out.println("文件已经存在,不再重复创建");
            FileWriter fileWriter = new FileWriter(fileHello,true);
            fileWriter.write("hello,world");
            fileWriter.close();
        }
    }
}

package com.pero;

import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * 使用BufferedReader读取一个文本文件,
 * 为每一行加上行号,连同内容一并输出到屏幕上
 *
 * @author Pero
 * @version 1.0
 */

public class Homework02 {
    public static void main(String[] args) throws IOException {
        String versePath = "d:\\books\\book\\verse.txt";
        String line = null;
        int temp = 1;

        BufferedReader bufferedReader = new BufferedReader(new FileReader(versePath));
        //遇到乱码时(默认处理为utf-8,如果文本文件是gbk将出现乱码),
        // 使用转换流将FileInputStream->InputStreamReader[这里可以指定编码]->BufferedReader
        PrintStream out = System.out;
        while ((line = bufferedReader.readLine()) != null) {
            if (temp % 2 != 0) {
                out.print(temp + line + "," + '\n');
            } else {
                out.print(temp + line + "。" + '\n');
            }
            temp++;
        }
        temp = 1;
        bufferedReader.close();
        out.close();
    }

    @Test
    public void test() throws IOException {
        //把诗句写入文本文件中
        //创建二级文件夹books\\book,将诗词verse.txt放进文件在中
        String bookPath = "d:\\books\\book";
        File file = new File(bookPath);
        //判断这两个文件夹有没有,如果有就不用创建了,如果没有则创建
        if (!file.exists()) {
            if (file.mkdirs()) {    //创建二级目录
                System.out.println("文件夹创建成功");
            } else {
                System.out.println("文件夹创建失败");
            }
        } else {
            System.out.println("文件夹存在");
        }
        //将诗词文本文件创建在book文件夹中
        File fileVerse = new File(bookPath + "\\verse.txt");
        if (!fileVerse.exists()) {
            if (fileVerse.createNewFile()) {
                System.out.println("诗词文本文件创建成功");
                BufferedWriter bufferedWriter =
                        new BufferedWriter(
                                new FileWriter(bookPath + "\\verse.txt"));
                bufferedWriter.write("锄禾日当午" + '\n' +
                        "汗滴禾下土" + '\n' +
                        "谁知盘中餐" + '\n' +
                        "粒粒皆辛苦");
                System.out.println("诗词写入成功");
                if (bufferedWriter != null) {
                    bufferedWriter.close();
                }
            } else {
                System.out.println("诗词文本文件创建失败");
            }
        } else {
            System.out.println("诗词文本文件已存在");
        }
    }
}
package com.pero;

import org.junit.jupiter.api.Test;

import java.io.*;
import java.util.Properties;

/**
 * 编写dog.properties
 * name=tom
 * age=5
 * color=red
 * 编写Dog类(name,age,color)创建一个dog对象,读取dog.properties
 * 用相应的内容完成初始化,并输出
 *
 * @author Pero
 * @version 1.0
 */


public class Homework03 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Properties properties = new Properties();
        FileReader fileReader = new FileReader("src\\dog.properties");
        properties.load(fileReader);
        //properties存储的数据默认为Object类
        String name = properties.getProperty("name");
        int age = Integer.parseInt(properties.getProperty("age"));
        String color = properties.getProperty("color");
        Dog dog = new Dog(name, age, color);
        System.out.println(dog);

        //序列化对象存放地址
        String dogPath = "d:\\demo\\dog.dat";
        ObjectOutputStream objectOutputStream =
                new ObjectOutputStream(new FileOutputStream(dogPath));
        objectOutputStream.writeObject(dog);    //Dog类必须实现序列化接口
        objectOutputStream.close();
        System.out.println("dog对象序列化成功");
        //反序列化对象打印出对象信息
        ObjectInputStream objectInputStream =
                new ObjectInputStream(new FileInputStream(dogPath));
        Dog dogSee = (Dog)objectInputStream.readObject();  //向下转型
        System.out.println(dogSee);
        objectInputStream.close();
    }


    //创建dog.properties
    @Test
    public void test() throws IOException {
        String dogSqlPath = "src\\dog.properties";
        Properties properties = new Properties();
        properties.setProperty("name","tom");
        properties.setProperty("age","5");
        properties.setProperty("color","red");
        properties.store(new FileWriter(dogSqlPath),null);
        System.out.println("dogSql文件保存成功");
    }
}
class Dog implements Serializable{
    private String name;
    private int age;
    private String color;

    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
}

数据库1:数据库创建与管理(头歌云课) 在 Windows 系统中,可以直接通过 SQLServer 的应用程序连接数据库,不过很多时候在生产环境下,我们需要通过命令行来连接数据库。两个数据库,数据库名分别为 TestDb 和 MyDb 的数据库,注意先后顺序。为了完成本关任务,你需要掌握:1.如何在 Linux 系统中连接 SQLServer 数据库,2.如何创建数据库。连接的数据库是本地数据库,用户名是 sa ,密码是 ' 阅读详情

相关推荐

Unity 2022.3.3 LTS + Visual Studio 2022:手把手教你复刻《吸血鬼幸存者》核心战斗(附完整项目源码)

本文详细介绍了如何使用Unity 2022.3.3 LTS和Visual Studio 2022从零构建《吸血鬼幸存者》式战斗系统。通过图文开发教程,涵盖对象池优化、ECS架构雏形、2D物理碰撞控制等关键技术,帮助开发者高效复刻这款热门游戏的自动攻击与海量刷怪机制。

weixin_30721077的博客 460

Java之节点流和处理流(Buffered字节字符处理流)

Java中的流按照功能可以分为节点流和处理流。其中节点流是直接用来访问数据源,而数据源又分为文件、内存、管道(线程间通信使用),所以就需要不同的类来进行处理。每次从数据源中读取的数据单位又可以分为字节和字符。节点流:可以从一个特定的数据源读写数据,如FileReader、FileWriter等(程序用于直接操作目标设备所对应的类)处理流:是“连接”已存在的流(节点流和处理流)之上,为程序提供强大的读写功能,更加灵活。

墨辰JC的博客 2318

等离子体密度诊断集

在实验上不仅要对带电粒子的分布和运动状态进行诊断,如电子温度、电子密度、电离温度等参数,还需要对等离子体中的中性粒子进行必要的实验测量,来获得有关物种的产生、能量分布以及各个激发态布居数分布等信息,如气体温度、转动温度、振动温度、激发温度等参数。

in546的博客 1356

节点流和处理流 字符处理流BufferedReader、BufferedWriter,字节处理流-BufferedInputStream和BufferedOutputStream (代码均正确且可运行

节点流和处理流 对象处理流-ObjectInputStream和ObjectOutputStream字符处理流BufferedReader、BufferedWriter,字节处理流-BufferedInputStream和BufferedOutputStream (代码均正确且可运行)

weixin_73936404的博客 1487

SillyTavern 向量存储配置踩坑记:从卡死到本地部署 Ollama 跑通

用此命令看到镜像就算成功。

qq_62483451的博客 1268

Cursor AI编程工具保姆级安装指南:从下载到中文界面设置(含免费额度说明)

本文提供Cursor AI编程工具的保姆级安装与设置教程。详细指导从官网下载、安装到中文界面切换的每一步,并重点说明其每月500次高级模型调用的免费额度策略。通过个性化设置与核心插件推荐,帮助开发者快速上手,提升AI辅助编程效率。

weixin_29191761的博客 676

节点流和处理流 详解

(2)PrintStream是字节打印流,在默认情况下,输出数据的位置是标准输出,即输出到显示器。(2)ObjectInputStream和ObjectOutputStream是对象处理流,提供了对基本类型或对象类型的序列化和反序列化的方法。(2)BufferedOutputStream是字节流,实现缓冲的输出流,可以将多个字节写入底层输出流中,而不必对每次字节写入调用底层系统。①InputStreamReader:Reader的子类,可以将InputStream(字节流)包装成Reader(字符流)。

m0_75013084的博客 599

GEE开发之ERA5(气温、降水、压力、风速等)数据获取和分析

前言:ERA5主要提供DAILY和MONTHLY两大类别数据,其中主要包括气温、降水、压力、风速等。

等待着冬天的风的博客 3万+

Java之IO流:节点流和处理流(模拟修饰器设计模式)

代码块1:创建BufferReader_类,继承抽象类Reader_,里面的构造方法可以传入不同的类型比如FileReader_和StringReader_这两个类,通过可以调用BufferReader_中的不同的来达到对应数据源的操作。简单点来说就是在创建BufferReader_这个类的时候,传入对应的数据源对象,然后根据传入的对象,调用相应的方法。处理可以根据传入对象的不同,进而可以访问更详细的数据源,比如数组,文件等。处理流:在已经存在的流的基础之上,为程序提供更强大的读写功能。

2301_79677484的博客 203

把 LLM 编排能力塞进 ABAP 系统里,ZLLM 仓库的工程价值与 SAP 落地场景

ZLLM项目将LLM应用开发中的常见工程问题引入ABAP原生环境,为SAP系统提供AI工作流构建能力。它类似ABAP版的LangChain,支持Chain组合、Prompt模板、状态传递等核心功能,强调纯ABAP实现、延迟执行以及与ABAP数据结构的深度集成。项目包含工厂类、LLM客户端、负载均衡器等模块,特别设计了能处理ABAP内表和结构的模板引擎,使业务数据可直接用于Prompt生成。通过Step和Flow机制支持复杂业务过程编排,并采用延迟执行和并行处理优化批量任务性能。该项目为ABAP开发者提供了在

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 61

华为OD新系统机试真题 - API请求日志去重分析

华为OD新系统机试真题【API请求日志去重分析】,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。华为OD4月15号机试真题【API请求日志去重分析】

qq_45776114的博客 921

JAVA:IO流 之 节点流与处理流(2)

1. 流的分类 按数据流的方向不同:输入流,输出流。 按处理数据单位不同:字节流,字符流。 (1) 字节流:数据流中最小的数据单元是字节。 (2)字符流:数据流中最小的数据单元是字符, Java中的字符是Unicode编码,一个字符占用两个字节。 按功能不同:节点流,处理流。 (1)程序用于直接操作目标设备所对应的类叫节点流。 (2)程序通过一个间接流类去调用节点流类,以达到更加灵活方...

区块链之美 2万+

芒果YOLO11改进21:检测头Head篇:即插即用|新颖轻量化非对称多级压缩LADH检测头,原创改进适配YOLOv8高效检测头,检测头新颖性改进,全网首发独一份

检测头Head篇:即插即用|新颖轻量化非对称多级压缩LADH检测头,原创改进适配YOLOv8高效检测头,检测头新颖性改进,全网首发独一份

包括YOLOv5、YOLOv7、YOLOv8等模型改进 798

Java IO节点流和处理流

Java IO节点流和处理流

WYSCODER的博客 2520

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

节点流与处理流:深入解析Java中的IO流

在Java的IO(输入/输出)库中,节点流(Node Stream)和处理流(Processing Stream)是两个重要的概念。虽然它们都是用于数据的输入和输出,但它们在功能和使用上有所不同。

✨ 欢迎来到【Seal ^_^ 的CSDN博客】!✨ 5895

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

【Java】IO流 - 节点流和处理流【Buffered】

节点流和处理流的区别,BufferedReader/BufferedWriter和BufferedInputStream/BufferedOutputStream的使用

Lov1_BYS的博客 1501

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

java 节点流_java io 节点流和处理流

节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装,称为流的链接。常用的节点流父 类 InputStream OutputStream Reader Writer文 件 *FileInput...

weixin_35823099的博客 216

JAVA IO操作总结——节点流和处理流

JAVA IO操作总结——节点流和处理流 按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流和处理流两类。 节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader 处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装,称为流

cool_ping的专栏 1763

java中的节点流_Java-IO中的节点流和处理流

理解好Java-IO中的节点流和处理流是理解Java输入、输出的关键基础,因此,了解节点流和处理流相关的知识点尤为重要。1.定义(1)节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader。(2)处理流(用来包装节点流):是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象...

weixin_36378683的博客 797

【JAVA基础】 IO操作小结——节点流和处理流

JAVA IO操作小结——节点流和处理流 JAVA IO操作总结——节点流和处理流  按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流和处理流两类。   节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader   处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是

youxia0075454的专栏 446

Java学习之路(五十七)| IO流(四)节点流和处理流

这章听得懵圈了,回头再专题整理。

weixin_45904051的博客 204

java io 节点流和处理流

JAVA IO操作总结:节点流和处理流 JAVA IO操作总结——节点流和处理流   按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流和处理流两类。   节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader   处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总

bslzl的专栏 690

Java IO流-- JAVA流式输入/输出原理 & 输入输出流分类 & 节点流和处理流 & IO流总结

1. JAVA流式输入/输出原理 在Java程序中,对于数据的输入/输出操作以“流”(Stream)方式进行;Java提供了各种各样的“流”类,用以获取不同种类的数据:程序中通过标准的方法输入或输出数据。 读入写出 流是用来读写数据的,java有一个类叫File,它封装的是文件的文件名,只是内存里面的一个对象,真正的文件是在硬盘上的一块空间,在这个文件里面存放着各种各样的数据,我们想读文件里面的数据怎么办呢?是通过一个流的方式来读,咱们要想从程序读数据,对于计算机来说,无论读什么类型的数据都是以

天行健 君子以自强不息,地势坤 君子以厚德载物。 1977

JAVA IO操作总结:节点流和处理流

JAVA IO操作总结——节点流和处理流   按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流和处理流两类。   节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader   处理流:是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写。如BufferedReader。处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包

dragon_fire的专栏 800
上一篇: Java-IO流(IO流原理和流的分类)
下一篇: Java-网络编程
Neo丶
博客等级 码龄9年 4粉丝 63原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值