IO流学习

已于 2022-03-06 20:43:24 修改
阅读量430 收藏
点赞数
分类专栏： 笔记 切入点 文章标签： 学习
于 2022-03-05 22:17:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45972425/article/details/123298355
版权

 

个人理解：文件的输入输出流式基于java内存而言，比如说文件读入java内存就是输入流，从java内存写进磁盘就是输出流

File

package com.Zh;

import org.junit.Test;

import java.io.File;
import java.io.IOException;

/**
 * @author OZH
 * @Description:创建文件的三种方式
 * @date 2022/3/5 18:58
 */
public class fileDemo {
    @Test
    public void create01() {
        String filePath = "F:\\OpenCode\\IO\\FileUpload\\create01.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("F:\\OpenCode\\IO\\FileUpload");
        String fileName = "create02.txt";
        File file = new File(parentFile, fileName);
        try {
            file.createNewFile();
            System.out.println("创建成功!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test//第三种方式创建文件
    public void create03() {
        //这个方法和上面那个方法参数不同(重载)
        File file = new File("F:\\OpenCode\\IO\\FileUpload", "create03.txt");
        try {
            file.createNewFile();
        } catch (IOException e) {
            System.out.println("文件创建成功!");
            e.printStackTrace();
        }
    }
}


package com.Zh;

import org.junit.Test;

import java.io.File;

/**
 * @author OZH
 * @Description:
 * @date 2022/3/5 19:25
 */
public class FileInformation {
    public static void main(String[] args) {

    }

    //获取文件的信息
    @Test
    public void info() {
        //先创建文件对象
        File file = new File("F:\\OpenCode\\IO\\FileUpload\\create01.txt");
        //调用相应的方法,得到对应信息
        long length = file.length();
        System.out.println("文件绝对路径=" + file.getAbsolutePath());
        System.out.println("文件名字=" + file.getName());
        System.out.println("文件父级目录=" + file.getParent());
        System.out.println("文件大小(字节)=" + file.length());
        System.out.println("文件是否是一个文件=" + file.isFile());
        System.out.println("文件是否是一个文件夹=" + file.isDirectory());
        String name = file.getName();
        String[] split = name.split("\\.");
        System.out.println("split[0].toString() = " + split[0]);
    }
}


package com.Zh;

import org.junit.Test;

import java.io.File;

/**
 * @author OZH
 * @Description:
 * @date 2022/3/5 19:46
 */
public class Directory_ {
    public static void main(String[] args) {

    }

    //判断 文件是否存在,如果存在则删除
    @Test
    public void m1() {
        File file = new File("F:\\OpenCode\\IO\\FileUpload\\create01.txt");
        if (file.exists()) {
            System.out.println("文件存在,删除");
            boolean delete = file.delete();
            if (delete) {
                System.out.println("文件删除成功");
            } else {
                System.out.println("文件删除失败");
            }
        } else {
            System.out.println("该文件不存在............");

        }
    }

//    /判断 目录是否存在,如果存在则删除
    @Test
    public void m2() {
        File file = new File("F:\\OpenCode\\IO\\FileUpload\\heh");
        if (file.exists()) {
            System.out.println("目录存在,删除");
            boolean delete = file.delete();
            if (delete) {
                System.out.println("目录删除成功");
            } else {
                System.out.println("目录删除失败");
            }
        } else {
            System.out.println("该目录不存在............");

        }
    }
    //    /判断 目录是否存在,如果不存在则创建
    @Test
    public void m3() {
        File file = new File("F:\\OpenCode\\IO\\FileUpload\\a");
        if (file.exists()) {

            System.out.println("存在"+file.getName());
        } else {
                //创建成功返回true,创建一级目录mkdir(),创建多级目录mkdirs()
//            file.mkdir();/一级目录
            file.mkdirs();//创建多级目录
        }
    }
}

 

 

 

 文件输入流(字节流)

package com.Zh.InputStream;

import org.junit.Test;

import java.io.FileInputStream;

/**
 * @author OZH
 * @Description:FileInputStream的使用(字节输入流   文件  --- > 程序 )
 * @date 2022/3/5 20:28
 */
public class FileInputStream_ {
    public static void main(String[] args) {


    }

    /**
     * 演示读取文件效果
     * @throws Exception
     */
    @Test
    public void readFile01() throws Exception{
        FileInputStream fileInputStream = new FileInputStream("F:\\OpenCode\\IO\\FileUpload\\txt.txt");
        int readData = 0;
        while ((readData = fileInputStream.read()) != -1) {
            System.out.print((char) readData);
        }
        fileInputStream.close();
    }
    @Test
    public void readFile02() throws Exception{
        FileInputStream fileInputStream = new FileInputStream("F:\\OpenCode\\IO\\FileUpload\\txt.txt");
        byte[] bytes = new byte[1024];
        int len = 0;
        //该输入流最多读取1024字节的数据到字节数组,此方法将阻塞,直到某些输入可用
        //如果返回-1,表示读取完毕
        //如果读取正常,返回实际读取的字节数
        while ((len = fileInputStream.read(bytes)) != -1) {
//            System.out.println(len);
            System.out.println(new String(bytes, 0, len));
        }
        fileInputStream.close();
    }
}

 文件输出流(字节流)

package com.Zh.OutputStream;

import org.junit.Test;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author OZH
 * @Description:
 * @date 2022/3/5 21:02
 */
public class FileOutputStream_ {
    @Test
    public void FileOutputStreamDemo() throws Exception {
        File file = new File("F:\\OpenCode\\IO\\FileUpload\\txt.txt");
        if (!file.exists()) {
            file.mkdirs();
        }
//        FileOutputStream fileOutputStream = new FileOutputStream(file);//覆盖的写法
        FileOutputStream fileOutputStream = new FileOutputStream(file,true);//追加的写法

        fileOutputStream.write("heheh".getBytes());
        System.out.println("写入成功");
        fileOutputStream.close();

    }
}

 文件复制

package com.Zh.OutputStream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.UUID;

/**
 * @author OZH
 * @Description:
 * @date 2022/3/5 21:20
 */
//文件拷贝
public class FileCopy {
    public static void main(String[] args) throws Exception {
        //思路,边使用输入流读取文件边使用输出流写进磁盘
        File file = new File("F:\\OpenCode\\image\\zh.jpeg");
        FileInputStream fileInputStream = new FileInputStream(file);
        File file1 = new File("F:\\OpenCode\\IO\\FileUpload\\" + UUID.randomUUID().toString() + ".jpeg");
        if (!file1.exists()) {
            file1.createNewFile();
        }
        FileOutputStream fileOutputStream = new FileOutputStream(file1);
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = fileInputStream.read(bytes)) != -1) {
//            fileOutputStream.write(bytes);//这个方法有可能会出错
            //使用这个方法,因为byte数组默认值为0,如果有14字节数据,数组长度8,那么第二次循环的时候就会有两个0在里面
            fileOutputStream.write(bytes, 0, len);

        }

        fileInputStream.close();
        fileOutputStream.close();

    }
}

  个人理解:读取单个字符或者比特的时候返回值是int,能转化为对应的类型的值,而读取到字符数组或者比特数组的时候,返回值是读取到的个数/字节数

 FileWriter

package com.Zh.writer;

import java.io.FileWriter;

/**
 * @author OZH
 * @Description:
 * @date 2022/3/6 12:25
 */
public class FileWriter_ {
    public static void main(String[] args) throws Exception {
        //创建FileWriter对象
        String filePath = "F:\\OpenCode\\IO\\FileUpload\\writer.txt";
        FileWriter fileWriter = new FileWriter(filePath);//默认覆盖
        fileWriter.write("ZH");
        //一定要close或者是flush
        fileWriter.flush();
        fileWriter.close();

    }
}

执行close或者是flush才是真正的写入,基于FileOutputStream

节点流

直接操作数据源

 

 包装流(处理流)(修饰器设计模式)

 

 

 

 字节流(二进制文件(音频,视频)),字符流(字符(文本))

BufferedReader 

package com.Zh.Reader;

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

/**
 * @author OZH
 * @Description:使用BufferedReader
 * @date 2022/3/6 14:03
 */
public class BufferedReader_ {
    public static void main(String[] args) throws Exception {
        String filePath = "F:\\OpenCode\\IO\\FileUpload\\txt.txt";
        //创建BufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取
        String line;//按行读取,效率高
        //1.line=bufferedReader.readLine();  是按行读取文件
        //2.当返回null时,表示文件读取完毕
        line = bufferedReader.readLine();
        while ((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
        }
        //关闭流,这里只需要关闭bufferedReader,因为底层会自动的去关闭 节点流
        //FileReader
        bufferedReader.close();

    }
}

BufferedWriter

package com.Zh.writer;

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

/**
 * @author OZH
 * @Description:
 * @date 2022/3/6 14:16
 */
public class BufferedWriter_ {
    public static void main(String[] args) throws Exception {
        //追加或者是覆盖
        FileWriter fileWriter = new FileWriter("F:\\OpenCode\\IO\\FileUpload\\bre.txt",true);
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

        for (int i = 0; i < 10; i++) {
            bufferedWriter.write('a');
            bufferedWriter.newLine();
            bufferedWriter.flush();
        }
        bufferedWriter.close();
    }
}

BufferedWriter和BufferedReader完成文本类型的拷贝

 

package com.Zh.writer;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

/**
 * @author OZH
 * @Description:
 * @date 2022/3/6 14:28
 */
public class BufferedCopy_ {
    public static void main(String[] args) throws Exception{
        //字符流不要操作二进制文件,可能会导致文件损坏
        String path = "F:\\OpenCode\\IO\\FileUpload\\txt.txt";
        String destFilepath = "F:\\OpenCode\\IO\\FileUpload\\copyCat.txt";//目的地
        BufferedReader bufferedReader = new BufferedReader(new FileReader(path));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(destFilepath));
        String read = null;
//        readLine()读取一行,没有带换行符
        while ((read=bufferedReader.readLine()) != null) {
            //读取到内容,写入磁盘
            bufferedWriter.write(read);
            bufferedWriter.newLine();//不同系统换行符号是不一样,这个会自动处理
            bufferedWriter.flush();
        }
        bufferedWriter.close();
        bufferedReader.close();
        System.out.println("copy success!");

    }
}

BufferedOutputStream和BufferedInputStream拷贝二进制文件夹

package com.Zh.OutputStream;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * @author OZH
 * @Description:演示BufferedOutputStream和BufferedInputStream使用
 * @date 2022/3/6 15:02
 */
public class BufferedCopy02_ {
    public static void main(String[] args) throws Exception{
        //源文件
        String srcFilePath = "F:\\OpenCode\\IO\\FileUpload\\315c60da-8b43-45fb-90cb-aed070c1a59e.jpeg";

        String destFilePath = "F:\\OpenCode\\IO\\FileUpload\\hehe.jpeg";//
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(srcFilePath));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(destFilePath));
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = bufferedInputStream.read(bytes)) != -1) {
            bufferedOutputStream.write(bytes, 0, len);
            bufferedOutputStream.flush();
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
        System.out.println("拷贝成功");
    }
}

 对象流

 

 

package com.Zh.OutputStream;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * @author OZH
 * @Description:ObjectOutputStream的使用,完成数据的序列化
 * @date 2022/3/6 15:33
 */
public class ObjectOutStream_ {
    public static void main(String[] args) throws Exception{
        //序列化后,保存的文件格式,不是纯文本,而是按照它的格式来保存
        String filePath = "F:\\OpenCode\\IO\\FileUpload\\data.dat";
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化数据到F:\OpenCode\IO\FileUpload\data.dat
        objectOutputStream.writeInt(100);//int -> Integer(实现了 Serializable)
        objectOutputStream.writeBoolean(true);//boolean -> Boolean(实现了 Serializable)
        objectOutputStream.writeChar('a');//char - >Character (实现了 Serializable)
        objectOutputStream.writeDouble(9.1);
        objectOutputStream.writeFloat(2.1f);
        objectOutputStream.writeUTF("ozh");//字符串
        //保存对象
        objectOutputStream.writeObject(new Dog("狗子", 10));
        objectOutputStream.close();
    }
}

class Dog implements Serializable {
    private String name;
    private int 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;
    }

    public Dog() {
    }

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

ObjectInputStream

package com.Zh.InputStream;

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

/**
 * @author OZH
 * @Description:
 * @date 2022/3/6 15:51
 */
public class ObjectInputStream_ {
    public static void main(String[] args) throws Exception{
        //指定反序列化的文件F:\OpenCode\IO\FileUpload\data.dat
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("F:\\OpenCode\\IO\\FileUpload\\data.dat"));
        //读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致
        //2.否则会报异常
        System.out.println(objectInputStream.readInt());
        System.out.println(objectInputStream.readBoolean());
        System.out.println(objectInputStream.readChar());
        System.out.println(objectInputStream.readDouble());
        System.out.println(objectInputStream.readUTF());
        Object dog = objectInputStream.readObject();
        System.out.println("运行类型=" + dog.getClass());
        System.out.println("dog信息=" + dog);
        objectInputStream.close();
    }
}
class Dog implements Serializable {
    private String name;
    private int 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;
    }

    public Dog() {
    }

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

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

 标准输入输出流

package com.Zh.standard;

import java.util.Scanner;

/**
 * @author OZH
 * @Description:标准输入输出流
 * 输入:键盘
 * 输出:显示器
 * @date 2022/3/6 16:32
 */
public class InputAndOutput {
    public static void main(String[] args) {
        //编译类型 InputStream
        //运行类型 BufferedInputStream
        //表示的是标准输入 键盘
        System.out.println(System.in.getClass());
        //编译类型 PrintStream
        //运行类型 PrintStream
        //表示标准输出  显示器
        System.out.println(System.out.getClass());
        System.out.println("看见没?有out,这就是标准输出流");
        Scanner sc = new Scanner(System.in);
        System.out.println("输入点东西试试:");
        String next = sc.next();
        System.out.println(next);
    }
}

转换流

 

 

 

package com.Zh.transformation;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

/**
 * @author OZH
 * @Description:演示使用InputStreamReader转换流解决中文乱码问题
 * 将字节流转成字符流
 * 将字节流 FileInputStream 转成字符流  InputStreamReader,指定编码 gbk/utf-8
 * @date 2022/3/6 17:06
 */
public class InputStreamReader_  {
    public static void main(String[] args) throws Exception {
        String filePath = "F:\\OpenCode\\IO\\FileUpload\\txt.txt";
        //1.把FileInputStream 转成 InputStreamReader
        //2.指定编码GBK
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(filePath), "UTF-8");
        //3.把InputStreamReader 传入 BufferedReader
        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        //4.读取
        String read = null;
        while ((read = bufferedReader.readLine()) != null) {
            System.out.println(read);
        }
        bufferedReader.close();

    }
}


package com.Zh.transformation;

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/**
 * @author OZH
 * @Description:OutputStreamWriter的使用
 *把FileOutputStream字节流  转换成字符流
 * 指定处理的编码
 * @date 2022/3/6 17:42
 */
public class OutputStreamWriter_ {
    public static void main(String[] args) throws Exception{
        String filePath = "F:\\OpenCode\\IO\\FileUpload\\aaa.txt";
        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(filePath), "GBK");
        BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
        bufferedWriter.write("abc");

//        outputStreamWriter.write("呵呵呵呵呵aaaaa");
//        outputStreamWriter.close();
        bufferedWriter.close();
    }
}

打印流

PrintStream(字节流),PrintWriter(字符流)只有输出流没有输入流

package com.Zh.transformation;

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

/**
 * @author OZH
 * @Description:PrintWriter使用方式
 * @date 2022/3/6 19:43
 */
public class PrintWriter_ {
    public static void main(String[] args) throws Exception{
        PrintWriter printWriter = new PrintWriter(System.out);
//        PrintWriter printWriter = new PrintWriter(new FileWriter("F:\\OpenCode\\IO\\FileUpload\\hehehaaa.txt"));
        printWriter.print("hello");
        printWriter.close();

    }
}

Properties

package com.Zh.Properties;

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

/**
 * @author OZH
 * @Description:
 * @date 2022/3/6 20:00
 */
public class Properties01 {
    public static void main(String[] args) throws Exception{
        //读取mysql.properties文件,并得到Ip,user和pwd
        BufferedReader bufferedReader = new BufferedReader(new FileReader("F:\\OpenCode\\IO\\IOIO\\src\\main\\resources\\mysql.properties"));
        String read = null;
        while ((read = bufferedReader.readLine()) != null) {
            String[] split = read.split("=");
            System.out.println(split[0] + "=" + split[1]);
        }
        bufferedReader.close();

    }
}

package com.Zh.Properties;

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

/**
 * @author OZH
 * @Description:
 * @date 2022/3/6 20:30
 */
public class Properties02 {
    public static void main(String[] args) throws Exception{
        //使用Properties 类来读取mysql.properties 文件
        //1.创建Properties 对象
        Properties properties = new Properties();
        //2.加载指定1配置文件
        properties.load(new FileReader("F:\\OpenCode\\IO\\IOIO\\src\\main\\resources\\mysql.properties"));
        //3.把k-v显示控制台
        properties.list(System.out);
        //4.根据key 获取对应的值
        String user = properties.getProperty("user");
        System.out.println(user);

    }
}

package com.Zh.Properties;

import java.io.FileWriter;
import java.util.Properties;

/**
 * @author OZH
 * @Description:
 * @date 2022/3/6 20:36
 */
public class Properties03 {
    public static void main(String[] args)  throws Exception{
        //使用Properties 类来创建配置文件,修改配置文件内容
        Properties properties = new Properties();
        //创建
        //1.如果该文件没有key 就是创建
        //2.如果该文件有key,就是修改
        properties.setProperty("zh", "123");
        //将k-v存储文件中即可
        properties.store(new FileWriter("F:\\OpenCode\\IO\\IOIO\\src\\main\\resources\\mysql.properties"), null);
        System.out.println("保存配置文件成功");

    }
}

CV工程湿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java关于IO流的学习
qq_46011398的博客
08-23 145
IO流 一、Java 的IO 流主要包括输入流和输出流两种 输入：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。将持久化的文件数据加载到内存中。 输出：将程序（内存）数据输出到磁盘、U盘等存储设备中。 二、每种输入、输出流又可分为字节流和字符流两大类： 字节流以字节为单位来处理输入、输出操作(音频、图像、视频) 字符流以字符为单位来处理输入、输出操作（文本文件） File类 File 类代表与平台无关的文件和目录。 File 能新建、删除、重命名文件和目录，但File 不能访问文件内容本
IO流的练习
weixin_45687080的博客
11-26 198
1.项目根目录下建立文件： user.txt，文件中存放用户名和登录密码，格式：用户名，密码,如：aaa,123； 2. user.txt文件中初始存放的用户信息有如下： jack,123 rose,123 tom,123 3.要求完成如下功能： 程序运行时：控制台提示用户输入注册的用户名和密码； 验证键盘录入的用户名跟user.txt中已注册的用户名是否重复： 是：控制台提示：用户名已存在 否：...
IO流的学习
WKF903582415的博客
11-22 380
File类的使用 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对 象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。 常用构造器 路径中的每级目录之间用一个路径分隔符隔开。 路径分隔符和系统有关： windows和DOS系统默认使用“\”来表示 UNIX和URL使用“/”来表示 Java程序支持跨平台运行，因此路径分隔符要慎用。 为了解决这个隐患，File类提供了一个常量： public static final String separator。 根
io流学习
m0_61749866的博客
01-21 348
目录 1.File 1.1File类概述和构造方法 1.2File类的创建功能： 1.3File类判断和获取功能 1.4File类删除方法 1.File 1.1File类概述和构造方法 File（String pathname）： 这里在路径上并没有kunkun.txt这个文本，但是输出也没有报错 说明这个f1只是一个抽象的路径名。 并且file类重写了tostring方法。 File（String parent，String child）： 他...
Java通俗易懂30天 第26天:IO流
程序员小刘
09-21 1400
文章目录 文章目录文章目录第13章 IO流File类的使用File类的实例化File类的常用方法1File类的常用方法2课后练习IO流原理及流的分类IO流原理; 流的分类IO 流体系节点流(或文件流)FileReader读入数据的基本操作FileReader中使用read(char[] cbuf)读入数据FileWriter写出数据的操作使用FileReader和FileWriter实现文本文件的复制使用FileInputStream不能读取文本文件的测试使用FileInputStream和FileOutp
最全最详细的IO流教程
奔跑的熊猫
05-27 8288
最全最详细的IO流教程
Java中io流的学习（总结）
热门推荐
有问题请发邮箱dengyifanlittle@163.com进行讨论
08-18 1万+
Java中按照流的不同方向分为输入流和输出流，凡是含有in的，都可理解为输入流，输入流即从文件读取到程序，凡是含有out的，都可以理解为输出流，输出流即从程序输出到文件。按照单位分的话，可以分为字节流和字符流，字节流（读取-二进制文件。写入、拷贝-文本、二进制文件）中包括： InputStream--字节输入流的基类（抽象类） OutputStream--字节输出流的基类（抽象类） File...
java-io流学习总结.doc
11-24
Java IO 流学习总结 Java IO 流是 Java 语言中最重要的 Input/Output 机制之一，通过流我们可以自由地控制文件、内存、IO 设备等数据的流向。流机制是 Java 及 C++中的一个重要机制。 一、什么是流？ 流是字节...
IO流学习总结
01-26
本文档为本人学习 java IO流期间的学习总结笔记，希望对新学习的朋友有所帮助和参考价值。本人java 开发时间不是太长，可能存在不完善或不对之处，欢迎指正！
javaio流学习总结.pdf
08-09
JavaIO流学习总结 JavaIO流是Java语言中最基本的输入/输出机制，它提供了多种方式来读取和写入数据。下面是JavaIO流的学习总结。 一、 IO流的分类 IO流可以从不同的角度进行分类，包括： * 按流的方向分为：输入...
《JAVA_IO流学习总结》
04-23
Java IO流是Java平台核心特性之一，它负责在程序与外部资源之间传输数据。这个概念在Java编程中至关重要，因为它提供了处理输入（读取）和输出（写入）的机制，无论是从键盘、文件、网络还是其他数据源。在本文中，...
JAVA-IO流学习总结.docx
最新发布
06-27
### JAVA IO流学习总结 #### 一、流的概念与分类 **流(Stream)**是一种抽象的概念，用来表示数据的有序集合，这些数据可以被连续读取或写入。在Java中，流是处理输入/输出（I/O）的核心机制，允许程序员以一种统一...
java IO流学习总结
weixin_34290096的博客
10-02 2274
java IO流学习总结 近期学习了Java的IO流，尝试着总结一下。 java.io 包下的IO流很多： 其中，以Stream结尾的为字节流，以Writer或者Reader结尾的为字符流。所有的输入流都是抽象类IuputStream（字节输入流）或者抽象类Reader（字符输入流）的子类，所有的输出流都是抽象类OutputStream(字节输出流)或者抽象类Writer(字符输出流)的...
Java IO流学习总结一：输入输出流
weixin_34198881的博客
01-09 3983
Java IO流学习总结一：输入输出流 转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/54292148 本文出自【赵彦军的博客】 Java流类图结构： 流的概念和作用 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。...
Java学习总结-IO流的概念理解
嘉会的博客
06-20 3120
一、Java io流 的概念 流存在的意义： 1. 数据的传输量很大 2. 内存有限 3. 带宽有限 而Stream可以1点1点地逐步传输所有数据, 这就是Stream存在的根本意义。想想我们是怎样下载1个大文件的, 下载软件(例如x雷)并不会占用你内存很大的空间, 而只是在内存划分1个缓冲区, 一点一点地下载到自己的内存(缓冲区满了再写到硬盘), 这也是流的1个例子。 1、java...
利用PostMan和Kibanan操作ElasticSearch和个人理解
weixin_45972425的博客
01-21 8258
PostMan操作 Kibanan操作
VS2019常用快捷键
weixin_45972425的博客
11-15 3034
Ctrl + Shift +} = 在匹配的括号、括号内选择文本。Ctrl+Shift+空格键 / Ctrl+K,P: 参数信息。Ctrl+E,U / Ctrl+K,U: 取消选定注释内容。Ctrl + K，Ctrl + U = 取消选定行的注释。Ctrl + K，Ctrl + D = 正确对齐所有代码。Ctrl + K Ctrl + K = 将当前行添加书签。Ctrl + K Ctrl + N = 导航至下一个书签。CTRL + K, CTRL + U取消对选择代码的注释。
linux修改IP地址的命令
weixin_45972425的博客
01-10 2741
vim /etc/sysconfig/network-scripts/ifcfg-ens33
.net的io流学习
05-24
在 .NET 中，IO 流是用于读取和写入文件的重要组件。以下是一些常用的 .NET IO 流类： 1. StreamReader 和 StreamWriter 类：这两个类用于读取和写入文本文件。...希望这可以帮助你开始学习 .NET IO 流。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CV工程湿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值