java~IO流

已于 2024-07-31 22:42:24 修改
阅读量1.2k 收藏 16
点赞数 32
分类专栏： Java 文章标签： java 开发语言
于 2024-07-31 14:44:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65186476/article/details/140812403
版权

目录

文件

常用的文件操作

（1）创建文件的相关方法

（2）获取文件的相关信息 

（3）目录的操作和文件删除 

IO流 

流的分类

体系图

​编辑

节点流

InputStream（字节输入流）

FileInputStream

OutputStream（字节输出流）

FileOutputStream

​编辑

处理流

BufferedInputStream

BufferedOutputStream 

字符流

FileReader

 FileWriter

处理流  

BufferedReader

BufferedWriter 

对象处理流 

ObjectInputStream

ObjectOutputStream

标准输入输出流

转换流

InputStreamReader

OutputStreamWriter

 打印流

PrintStream（字节打印流）

PrintWriter

 Properties

文件

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

 

常用的文件操作

（1）创建文件的相关方法

  1. new File(String pathname) //根据路径构建一个File对象；
  2. new File(File parent,String child) //根据父目录文件+子路径构建一个File对象；
  3. new File(String parent,String child) //根据父目录+子路径构建一个File对象；
  4. 使用createNewFile()创建新文件。
public class FileCreate {
    public static void main(String[] args) {
 
    }
 
    //方式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) //根据父目录文件+子路径构建
    //e:\\news2.txt
    @Test
    public  void create02() {
        File parentFile = new File("e:\\");
        String fileName = "news2.txt";
        //这里的file对象，在java程序中，只是一个对象
        //只有执行了createNewFile 方法，才会真正的，在磁盘创建该文件
        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 parentPath = "e:\\";
        String fileName = "news4.txt";
        File file = new File(parentPath, fileName);
 
        try {
            file.createNewFile();
            System.out.println("创建成功~");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 

}

（2）获取文件的相关信息 

public class FileInformation {
    public static void main(String[] args) {
 
    }
 
    //获取文件的信息
    @Test
    public void info() {
        //先创建文件对象
        File file = new File("e:\\news1.txt");
 
        //调用相应的方法，得到对应信息
        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());
        //按字节计算，utf-8编码下，一个英文字母一个字节，一个汉字三个字节
        System.out.println("文件是否存在=" + file.exists());//T
        System.out.println("是不是一个文件=" + file.isFile());//T
        System.out.println("是不是一个目录=" + file.isDirectory());//F
 
 
    }
}

（3）目录的操作和文件删除 

  1. mkdir() //创建一级目录(文件夹)，返回boolean
  2. mkdirs() //创建多级目录(文件夹)，返回boolean
  3. delete() //删除空目录或文件，返回boolean，可同时做判断条件看删除成功与否
public class Directory_ {
    public static void main(String[] args) {
 
        
    }
 
    //判断 d:\\news1.txt 是否存在，如果存在就删除
    @Test
    public void m1() {
 
        String filePath = "e:\\news1.txt";
        File file = new File(filePath);
        if (file.exists()) {
            if (file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该文件不存在...");
        }
 
    }
 
    //判断 D:\\demo02 是否存在，存在就删除，否则提示不存在
    //这里我们需要体会到，在java编程中，目录也被当做文件
    @Test
    public void m2() {
 
        String filePath = "D:\\demo02";
        File file = new File(filePath);
        if (file.exists()) {
            if (file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该目录不存在...");
        }
 
    }
 
    //判断 D:\\demo\\a\\b\\c 目录是否存在，如果存在就提示已经存在，否则就创建
    @Test
    public void m3() {
 
        String directoryPath = "D:\\demo\\a\\b\\c";
        File file = new File(directoryPath);
        if (file.exists()) {
            System.out.println(directoryPath + "存在..");
        } else {
            if (file.mkdirs()) { //创建一级目录使用mkdir() ，创建多级目录使用mkdirs()
                System.out.println(directoryPath + "创建成功..");
            } else {
                System.out.println(directoryPath + "创建失败...");
            }
        }
    }
    //判断 D:\\demo 目录是否存在，如果存在就提示已经存在，否则就创建
    @Test
    public void m4() {
 
        String directoryPath = "D:\\demo";
        File file = new File(directoryPath);
        if (file.exists()) {
            System.out.println(directoryPath + "存在..");
        } else {
            if (file.mkdir()) { //创建一级目录使用mkdir() ，创建多级目录使用mkdirs()
                System.out.println(directoryPath + "创建成功..");
            } else {
                System.out.println(directoryPath + "创建失败...");
            }
        }
    }
}

IO流 

流的分类

InputStream 按字节读取效率较慢，                        
OutputStram 如图片/音乐/视频/doc/pdf

体系图

节点流

从一个特定的数据源读写数据，是底层流/低级流，直接跟数据源相接

InputStream（字节输入流）

常用子类 

  • FileInputStram：文件输入流

  • BufferedInputStream：缓冲字节输入流

  • ObjectInputStream：对象字节输入流

FileInputStream

String filePath = "xxx";
//（1）一次读取一个字节
int readData = 0;
//创建 FileInputStream，用于读取文件
FileInputStream fileInputStream = new FileInputStream(filePath);
//从该输入流中读取一个字节的数据。如果返回-1，表示读取完毕。如果没有输入可用，该方法将阻止。
while((readData = fileInputStream.read()) != -1 ) {
	System.out.print((char)readData);//转成char显示
}



//（2）一次读取多个字节
byte[] buf = new byte[8]; //初始化字节数组，如音乐/图片一次读取1024个字节(1kb)
int readLen = 0;
FileInputStream fileInputStream = new FileInputStream(filePath);
//从该输入流读取最多buf.length字节的数据到字节数组。如果返回-1，表示读取完毕。如果没有输入可用，该方法将阻止。
while((readLen = fileInputStream.read(buf)) != -1) {
	System.out.print(new String(buf, 0, readLen)); //显示：如果读取正常，返回实际读取的字节数
}
//关闭流资源
fileInputStream.close();

OutputStream（字节输出流）

FileOutputStream
//创建FileOutputStream对象，获得输出流
String filePath = "xxx"; //如果文件不存在，会创建文件，前提时目录已存在
FileOutputStream fileOutputStream = new (filePath); //(1)写入内容会覆盖原内容
FileOutputStream fileOutputStream = new (filePath, true);//(2)写入内容会追加原内容
//写入内容
fileOutputStream.write('H'); //(1)写入一个字符,会自动转换成int
String str = "hello, world!"; //(2)写入字符串
fileOutputStream.write(str.getBytes()); //getBytes()把字符串转换为字节数组
fileOutputStream.write(str.getBytes(), 0, 3); //write(byte[] b, int off, int len)将len字节从位于偏移量off的指定字节数组写入此文件输出流
//关闭输出流资源
fileOutputStream.close();

处理流

BufferedInputStream

BufferedOutputStream 

/ * 思考：字节流可以操作二进制文件，可以操作文本文件吗？当然可以
 */
public class BufferedCopy02 {
    public static void main(String[] args) {
 
//        String srcFilePath = "e:\\Koala.jpg";
//        String destFilePath = "e:\\hsp.jpg";
//        String srcFilePath = "e:\\0245_韩顺平零基础学Java_引出this.avi";
//        String destFilePath = "e:\\hsp.avi";
        String srcFilePath = "e:\\a.java";
        String destFilePath = "e:\\a3.java";
 
        //创建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();
            }
 
        }
 
 
    }
}

字符流

FileReader

 字符读取

int data = 0;
fileReader = new FileReader(filePath);
//循环读取 使用read, 单个字符读取
while ((data = fileReader.read()) != -1) {
    System.out.print((char) data);

字符数组读取 

int readLen = 0;
char[] buf = new char[8];
//创建FileReader对象
fileReader = new FileReader(filePath);
//循环读取 使用read(buf), 返回的是实际读取到的字符数
while ((readLen = fileReader.read(buf)) != -1) {
    System.out.print(new String(buf, 0, readLen));

 FileWriter

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("程序结束...");
    }
}

处理流  

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

        这个Reader/Writer可以是FileReader/FileWriter，进行一个包装，只要是其子类就可以包装，可以对文件、数组、管道等进行操作。
        处理流包装节点流，使用了修饰器模式，不会直接与数据源相连，消除了不同节点流的实现差异，也提供更方便的方法完成输入输出
        优点1：增加缓冲提高输入输出效率
        优点2：提供方法一次输入输出大批量数据，操作更便捷

模拟修饰器设计模式

//Reader_类
abstract class Reader_ { //抽象类
    public abstract void read();
}

//FileReader_类
class FileReader_ extends Reader_ {

    public void read() {
        System.out.println("对文件进行读取...");
    }
}

// StringReader_类
class StringReader_ extends Reader_ {
    public void read() {
        System.out.println("读取字符串..");
    }

}

// BufferedReader_类
class BufferedReader_{

    private Reader_ reader_; //属性是 Reader_类型

    //接收Reader_ 子类对象
    public BufferedReader_(Reader_ reader_) {
        this.reader_ = reader_;
    }


    //让方法更加灵活， 多次读取文件, 或者加缓冲byte[] ....
    public void readFiles(int num) {
        for(int i = 0; i < num; i++) {
            reader_.read();
        }
    }

    //扩展 readString, 批量处理字符串数据
    public void readStrings(int num) {
        for(int i = 0; i <num; i++) {
            reader_.read();
        }
    }
    
}


public class Test_ {
    public static void main(String[] args) {
        BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
        bufferedReader_.readFiles(10);
        
        BufferedReader_ bufferedReader_2 = new BufferedReader_(new StringReader_());
        bufferedReader_2.readStrings(5);
    }
}

BufferedReader和BufferedWriter属于字符流，是按照字符来读取数据的,不要操作二进制文件
处理流只是包装，操作数据还是节点流，关闭处理流会自动关闭节点流，只需要关闭外层流。

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.close();
 
    }
}
BufferedWriter 

写入文本文件

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();
 
    }
}

对象处理流 

需求

  • 将int num = 100 的int数据保存到文件中，注意不是100数字，而是int 100，能够从文件中直接恢复int 100
  • 将Dog dog = new Dog{“小黄”, 3}这个dog对象保存到文件中，并且能从文件恢复

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

序列化和反序列化

  • 序列化就是在保存数据时，保存数据的值和数据类型
  • 反序列化就是在恢复数据时，恢复数据的值和数据类型
  • 需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：
                 Serializable //这是一个标记接口，没有方法
                 Externalizable//该接口有方法需要实现，因此我们一般实现上面的Serializable接口

ObjectInputStream

数据反序列化


import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;

/**
 * 演示ObjectInputStream的使用，完成数据的反序列化
 */
public class ObjectInputStream_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //使用ObjectInputStream读取data.dat并反序列化恢复数据
        //1.创建流对象
        String filePath = "D:\\AAA\\t\\1.dat";//指定反序列化的文件
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
        //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());
        //dog的编译类型是Object, 运行类型是Dog
        Object dog = ois.readObject();
        System.out.println("dog的运行类型:" + dog.getClass());
        System.out.println("dog的信息:" + dog);
        //重要细节
        //希望调用Dog的方法，需要向下转型 Object -> Dog
        //ObjectInputStream 和 ObjectOutputStream 需要引用同一个Dog包
        Dog dog1 = (Dog) dog;
        System.out.println(dog1.getName());
        //3.关闭
        ois.close();
    }
}

ObjectOutputStream

数据序列化

import java.io.*;
/**
 * 演示ObjectOutputStream的使用，完成数据的序列化
 */
public class ObjectOutputStream_ {
    public static void main(String[] args) throws IOException {
        //使用ObjectOutputStream序列化基本数据类型和一个Dog对象(name, age), 并保存到data.dat文件中
        //序列化后, 保存的数据格式不是纯文本格式，而是按照它自己的格式来保存
        String filePath = "D:\\AAA\\t\\1.txt";
        //1.创建流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        //2.写入对象(序列化)
        oos.writeInt(100);//int 自动装箱->Integer(Integer实现了Serializable接口)
        oos.writeBoolean(true);
        oos.writeChar(97);
        oos.writeChar('a');
        oos.writeDouble(3.14);
        oos.writeUTF("韩顺平教育");
        //保存一个dog对象
        oos.writeObject(new Dog("小黄", 3));
        //3.关闭
        oos.close();
        System.out.println("数据保存完毕(序列化形式)");
    }
}
//如果要序列化某个对象，必须实现Serializable接口
class Dog implements Serializable {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 注意事项和细节说明

（1）读写顺序要一致

（2）要求实现序列化或反序列化的对象，需要实现Serializable

（3）序列化的类中建议添加serialVersionUID，目的是提高版本的兼容性

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

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

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

标准输入输出流

Scanner in = new Scanner(System.in);

转换流

在默认情况下，读取文件是按照utf-8编码，若修改文件的编码，原先文件的中文字符就会变为乱码，为了解决这个问题，就需要转换流。

转换流可以把字节流转换成字符流，而字节流可以指定编码方式

InputStreamReader

可以将InputStream（字节流）包装成Reader（字符流）

/**
 * 演示使用 InputStreamReader 解决中文乱码问题
 * 将字节流 FileInputStream 转成字符流 InputStreamReader, 并指定编码
 */
public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        //编程将字节流 FileInputStream 包装成（转换成）字符流 InputStreamReader
        //对文件进行读取(按照utf-8/gbk格式)，进而再包装成BufferedReader
        //上个视频，a.txt的格式已改为ANSI国标码，根据当前系统，为gbk格式编码
        String filePath = "F:\\a.txt";
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");
        BufferedReader br = new BufferedReader(isr);
        //BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(filePath), "gbk"));
        String s = br.readLine();
        System.out.println("读取到的内容:" + s);
        br.close();
    }
}

OutputStreamWriter

可以将OutputStream（字节流）包装成Writer（字符流） 

/**
 * 演示使用 OutputStreamWriter 指定文件编码方式保存文件
 */
public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {
        //编程将字节流 FileOutputStream 包装成（转换成）字符流 OutputStreamWriter
        //对文件进行写入（指定保存的编码方式，按照gbk格式）
        String filePath = "F:\\hsp.txt";
        String charSet = "gbk";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath), charSet);
        osw.write("hello 韩顺平教育");
        osw.close();
        System.out.println("按照" + charSet + "保存文件成功!");
    }
}

 打印流

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

PrintStream（字节打印流）

package chapter19.printstream;

import java.io.IOException;
import java.io.PrintStream;
/**
 * 演示 PrintStream 使用方式
 */
public class PrintStream_ {
    public static void main(String[] args) throws IOException {
        PrintStream out = System.out;
        //默认情况下，PrintStream输出数据的位置是标准输出，即显示器
        out.print("hello world!");
        /*
            public void print(String s) {
                if (s == null) {
                    s = "null";
                }
                write(s);
            }
        */
        //print底层使用write，所以我们可以直接调用write进行打印/输出
        out.write("hello".getBytes());
        out.close();
        //我们可以修改打印流输出的位置
        System.setOut(new PrintStream("F:\\test.txt"));
        System.out.println("hello 韩顺平教育！");
    }
}

PrintWriter

package chapter19.transformation;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
 * 演示 PrintWriter 使用方式
 */
public class PrintWriter_ {
    public static void main(String[] args) throws IOException {
//        PrintWriter pw = new PrintWriter(System.out);
        PrintWriter pw = new PrintWriter(new FileWriter("F:\\a.txt"));
        pw.print("hello world!");
        pw.close();//flush + 关闭流，才能将数据写入
    }
}

 Properties

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

​              配置文件的格式：

                ​ 键=值

​                 键=值

（2）注意：键值对不需要有空格，值不需要用引号，默认类型是String

（3）常用方法

  • load 加载配置文件的键值对到Properties对象
  • list 将数据显示到指定设备
  • getProperty(key) 根据键获取值
  • setProperty(key，value) 设置键值对到Properties对象
  • store 将Properties中的键值对存储到配置文件，在idea中，保存信息到配置文件，如果含有中文，会存储为unicode码
package chapter19.properties_;

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

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);
        System.out.println();
        //根据键获取值
        String user = properties.getProperty("user");
        String pwd = properties.getProperty("pwd");
        System.out.println("用户名:" + user);
        System.out.println("密码:" + pwd);
    }
}

package chapter19.properties_;

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class Properties03 {
    public static void main(String[] args) throws IOException {
        //使用Properties创建配置文件，修改配置文件内容
        Properties properties = new Properties();
        //创建
        properties.setProperty("charset", "uts-8");
        properties.setProperty("user", "汤姆");//中文保存时，是保存对应的unicode编码
        properties.setProperty("pwd", "123456");
        //修改
        //如果该文件没有key，就是创建
        //如果该文件有key，就是修改
        properties.setProperty("pwd", "666666");
        //将键值对k-v存储到文件中
        //null表示没有注释，有注释的话会写在文件的最上面，#...
        properties.store(new FileOutputStream("src\\mysql2.properties"), null);
    }
}

CYX_cheng
关注
专栏目录
Java读写IO流详解
AriesLY0411的博客
11-21 3412
一、IO流要明确的几点 （1）明确要操作的数据是数据源还是数据目的（是读还是写） 源/读 InputStream Reader 目的/写 OutputStream Writer （2）明确操作设备上的数据是字节还是文本 源/读 字节：InputStream 文本：Reader 目的/写 字节：OutputStream ...
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
javaIO流详解
weixin_46676497的博客
01-27 1923
java常用io流介绍
JAVA—IO流详解
weixin_48006490的博客
09-01 7958
IO:Input/Output即输入&输出，也称之为流（河流，水流），指的是数据从一个地点到另一个地点过程；对于计算机来说文件的拷贝过程，文件的编写保存，显示功能都是使用到IO；将数据的传输过程看做一个输入输出。现实角度考虑可以将耳朵作为输入流，将嘴巴当做输出流输入输出介质：文件网络键盘（输入）显示器（输出）
Java io流 详解
m0_68987535的博客
06-11 4636
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
java中的io流
m0_66689823的博客
07-19 9874
流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出 。
Java IO流的种类
程序员
02-20 3252
Java IO流的种类
java IO流之BufferedReader和BufferedWriter
学习笔记，相关教程 分享
04-03 6240
笑霸能看懂的学习笔记
java中的IO流
m0_64372028的博客
04-20 2045
1.什么是IO流 1. IO 表示有两个单词的缩写，对文件内容进行读写操作 I：inputStream输入流（读） O：outputStream输出流（写） 2. IO的作用：就是对文件中的内容进行操作 输入: 读操作（读取文件的内容） 输出: 写操作(往文件中写内容) 3. IO流的分类： (1)根据流的方向: ---输入流: 程序可以从中读取数据的流 ---输出流: 程序能向其中写入数据的流 (2)根据流的单位: ---字节流: 以字节为...
Java IO流（超详细！）
一只小菜鸡
05-07 5万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
java IO流详细笔记
07-12
Java IO流详解
java基础之IO流
06-18
### Java IO流基础知识点 #### 一、IO流概述 - **定义**：在Java中，IO流（Input/Output Streams）是用来处理输入输出的基本工具。流是一种有序的数据集合，通常涉及从源到目的地的数据传输过程。源可以是文件、...
Java 的 IO流笔记.md
03-08
### Java IO流学习笔记 #### 一、IO流的四大抽象类 - **InputStream/OutputStream**：字节的输入输出流的抽象类。 - 数据单位：字节（8比特，范围0-255） - **Reader/Writer**：字符的输入输出流的抽象类。 - ...
枚举工具类
qq_43049583的博客
08-04 296
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 336
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 665
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 672
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值