javaIO流深入研究

已于 2022-09-28 16:19:19 修改
阅读量259 收藏
点赞数
分类专栏： javaSE 文章标签： java ide
于 2022-09-28 16:12:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54353206/article/details/127091536
版权

文章目录

java IO流

1、文件

文件流

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

image-20220926141452345

流:数据在数据源(文件)和程序(内存)之间经历的路径

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

输出流:数据从程序(内存)到数据源(文件)的路径

常用文件操作

创建文件

类名：File

类图：

image-20220926144847845

构造方法：

image-20220926142041046

代码：

package IO;
import java.io.File;
import java.io.IOException;

public class Filenew {
    public static void main(String[] args) {
        newf();
        newf1();
        newf2();
    }
//    方式一
    public static void newf(){
        String url="C:\\Users\\lenovo\\Desktop\\ok.txt";
        File file = new File(url);
        try {
            file.createNewFile();
            System.out.println("创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //    方式二
    public static void newf1(){
        File pfile=new File("C:\\Users\\lenovo\\Desktop\\");
        String filename="ok1.txt";
        File file = new File(pfile,filename);
        try {
            file.createNewFile();
            System.out.println("创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //    方式三
    public static void newf2(){
        String pname="C:\\Users\\lenovo\\Desktop\\";
        String filename="ok2.txt";
        File file = new File(pname,filename);
        try {
            file.createNewFile();
            System.out.println("创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
获取文件相关信息

代码：

package IO;

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

public class FileInfo {
    public static void main(String[] args) throws IOException {
        info();
    }
    public static void info() throws IOException {
        File file=new File("C:\\Users\\lenovo\\Desktop\\hello.txt");
        file.createNewFile();
//        1、获取类名
        System.out.println(file.getName());
//        2、获取绝对路径
        System.out.println(file.getAbsolutePath());
//        3、获取文件父级目录
        System.out.println(file.getParent());
//        4、获取文件大小（字节）
        System.out.println(file.length());
//        5、文件是否存在
        System.out.println(file.exists());
//        6、文件是否属于一个父级目录
        System.out.println(file.isDirectory());
    }
}
目录的操作和文件的删除

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

image-20220926150046017

代码：

package IO;

import java.io.File;

public class FileD {
    public static void main(String[] args) {
//        m1();
        m2();
    }
//    文件存在就删除，文件不可为目录
    public static void m1(){
        File file =new File("C:\\Users\\lenovo\\Desktop\\hello.txt");
        if (file.exists()){
            if (file.delete()){
                System.out.println("删除成功");
            }else {
                System.out.println("文件属于目录");
            }
        }else {
            System.out.println("文件不存在");
        }
    }
//    目录存在提示，不存在创建
    public static void m2(){
        File file =new File("C:\\Users\\lenovo\\Desktop\\hello");
        if (file.exists()){
            System.out.println("目录已存在");
        }else {
            System.out.println("开始创建目录");
            if (file.mkdir()){
                System.out.println("创建成功");
            }else {
                System.out.println("创建失败");
            }
        }
    }
}

2、IO流原理及流的分类

原理：

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

2.Java程序中，对于数据的输入/输出操作以”流(stream)”的方式进行。

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

4.输入input:读取外部数据(磁盘、光盘等存储设备的数据)到程序(内存)中。

5.输出output:将程序(内存)数据输出到磁盘、光盘等存储设备中

流的分类

按操作数据单位不同分为: 字节流(8 bit)，字符流(按字符)

按数据流的流向不同分为: 输入流，输出流

按流的角色的不同分为: 节点流，处理流/包装流

image-20220926152253320

四个基础抽象类

详细分类：

image-20220926152748914

常用类

InputStream常用的子类：

  1. FilelnputStream:文件输入流
  2. BufferedlnputStream:缓冲字节输入流
  3. ObjectlnputStream:对象字节输入流

InputStream类图：

image-20220926153738976
FileInputStream使用：
package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class InputStreamIO {
    public static void main(String[] args) throws IOException {
        readfile();
        readfile1();
    }
//    1.0 单个字节读取
    public static void readfile() throws IOException {
        String filename = "C:\\Users\\lenovo\\Desktop\\hello.txt";
        int readData = 0;
        char[] cs = new char[20];
        FileInputStream finput = null;
        try {
            finput = new FileInputStream(filename);
            int i = 0;
            while ((readData = finput.read()) != -1) {
                cs[i] = (char) readData;
                i++;
            }
            System.out.println(String.valueOf(cs));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
//            关闭流
            finput.close();
        }
    }
//    2.0 字节数组读取
    public static void readfile1() throws IOException {
        String filename = "C:\\Users\\lenovo\\Desktop\\hello.txt";
        int readlength = 0;
        byte[] buf=new byte[8];
        FileInputStream finput = null;
        try {
            finput = new FileInputStream(filename);
            while ((readlength = finput.read(buf)) != -1) {
                System.out.print(new String(buf));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
    //            关闭流
            finput.close();
        }
    }
}
FileOutputSream使用：
package IO;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class OutputStreamIO {
    public static void main(String[] args) throws IOException {
        outf();
    }
    public static void outf() throws IOException {
        String filename = "C:\\Users\\lenovo\\Desktop\\hello.txt";
        FileOutputStream foutput = null;
        String str="ok";
        try {
//            foutput=new FileOutputStream(filename);//覆盖原内容的写入方式
            foutput=new FileOutputStream(filename,true);//原内容基础上追加的写入方式
            foutput.write(str.getBytes(StandardCharsets.UTF_8));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            foutput.close();
        }
    }
}
文件拷贝：
package IO;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Filecopy {
    public static void main(String[] args) throws IOException {
        copy();
    }
    public static void copy() throws IOException {
        String filenm1="D:\\study.png";
        String filenm2="D:\\study1.png";
        FileInputStream finput=null;
        FileOutputStream foutput=null;

        try {
            finput=new FileInputStream(filenm1);
            foutput=new FileOutputStream(filenm2);
            int length=0;
            byte[] buf=new byte[1024];
            while ((length = finput.read(buf))!=-1){
                foutput.write(buf,0,length);//一定使用此方法
            }
            System.out.println("成功");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            finput.close();
            foutput.close();
        }
    }
}

FileReader和 FileWriter是字符流，即按照字符来操作io

FileReader

FileReader相关方法:

new FileReader(File/String)

read:每次读取单个字符,返回该字符，如果到文件末尾返回-1

read(char[]):批量读取多个字符到数组，返回读取到的字符数,如果到文件末尾返回-1相关API:

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

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

代码：

package IO;

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

public class Filereaders {
    public static void main(String[] args) throws IOException {
        read1();
    }
//    方式一单个字符读取
    public static void read() throws IOException {
        String filename="C:\\Users\\lenovo\\Desktop\\hello.txt";
        FileReader reader=null;
        int a=0;
        try {
            reader=new FileReader(filename);
            while ((a=reader.read())!=-1){
                System.out.print((char)a);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            reader.close();
        }
    }
    //    方式二字符数组读取
    public static void read1() throws IOException {
        String filename="C:\\Users\\lenovo\\Desktop\\hello.txt";
        FileReader reader=null;
        char[] buf=new char[8];
        int length=0;
        try {
            reader=new FileReader(filename);
            while ((length = reader.read(buf))!=-1){
                System.out.print(new String(buf,0,length));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            reader.close();
        }
    }
}
FileWriter

FileWriter常用方法：

new FileWriter(File/String):覆盖模式，相当于流的指针在首端

new FileWriter(File/String,true):追加模式，相当于流的指针在尾端write(int):写入单个字符

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

write(char[],off,len):写入指定数组的指定部分write (string):写入整个字符串

write(string,off,len):写入字符串的指定部分相关APl: String类:toCharArray:将String转换成char[]

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

代码：

package IO;

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

public class Filewriters {
    public static void main(String[] args) throws IOException {
        writer();
    }
    public static void writer() throws IOException {
        String filename="C:\\Users\\lenovo\\Desktop\\hello.txt";
        FileWriter writer=null;
        String str="成功写入\n";
        char[] chars=str.toCharArray();
        try {
            writer=new FileWriter(filename,true);
            writer.write(chars);
            writer.write(chars,0,2);
            writer.write(str);
            writer.write(str,0,2);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            writer.close();
        }
    }
}

3、节点流和处理流

基本介绍：

1.节点流可以从一个特定的数据源读写数据，如FileReader、FileWriter [源码]

2.处理流(也叫包装流)是“连接”在已存在的流（节点流或处理流)之上,为程序提供更为强大的读写功能，如BufferedReader、BufferedWriter [源码]

节点流和处理流一览图

image-20220927155011935

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

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

2、处理流(包装流)包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出。[源码理解]

3、处理流(也叫包装流)对节点流进行包装，使用了修饰器设计模式，不会直接与数据源相连【模拟修饰器设计模式]

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

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

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

***扩展：修饰器设计模式

常用处理流

字符流：BufferedReader和BufferedWriter

BufferedReader:

package IO;

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

public class BufferR {
    public static void main(String[] args) throws IOException {
        String filename="C:\\Users\\lenovo\\Desktop\\hello.txt";
        BufferedReader bufR=new BufferedReader(new FileReader(filename));
        String str="";
        while ((str = bufR.readLine())!=null){
            System.out.println(str);
        }
//         bufR.readLine();按行读取 性能效率高
        bufR.close();
    }
}

BufferedWriter:

package IO;

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

public class BufferW {
    public static void main(String[] args) throws IOException {
        String filename="C:\\Users\\lenovo\\Desktop\\hello1.txt";
        BufferedWriter bufW=new BufferedWriter(new FileWriter(filename,true));
        String str="你好";
        bufW.write(str);
        bufW.newLine();//插入换行
        bufW.write("io流");

        bufW.close();
    }
}

不要去操作二进制文件，会产生损坏的文件

常见二进制文件：声音、视频、doc、PDF

字节流：BufferedInputStream和BufferedOutputStream

代码：

package IO;

import java.io.*;

public class BufferedIN_OUT_copy {
    public static void main(String[] args) throws IOException {
        String filename1="C:\\Users\\lenovo\\Desktop\\XXXX.jpg";
        String filename2="C:\\Users\\lenovo\\Desktop\\XXXX1.jpg";
        BufferedInputStream bis=null;
        BufferedOutputStream bos=null;
        try {
            bis=new BufferedInputStream(new FileInputStream(filename1));
            bos=new BufferedOutputStream(new FileOutputStream(filename2));
            byte[] buf=new byte[1024];
            int length=0;
            while ((length = bis.read(buf))!=-1){
                bos.write(buf,0,length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            bis.close();
            bos.close();
        }
    }
}
对象流：ObjectlnputStream和ObjectOutputStream

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

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

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

​ Serializable //这是一个标记接口,没有方法，一般使用此接口

​ Externalizable

注意事项：

1、读写顺序要一致

2、要求实现序列化或反序列化对象,需要实现 Serializable

3、序列化的类中建议添加SerialVersionUID.为了提高版本的兼容性

4、序列化对象时，默认将里面所有属性都进行序列化，但除了static或**transient（作用就是保证数据不被序列化）**修饰的成员

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

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

ObjectlnputStream：

package IO;

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

/*
* 反序列化读取数据
* */
public class ObjectIN {
    public static void main(String[] args) throws Exception {
        String filename="C:\\Users\\lenovo\\Desktop\\data.dat";
        ObjectInputStream oos=new ObjectInputStream(new FileInputStream(filename));
        System.out.println(oos.readInt());
        System.out.println(oos.readBoolean());
        System.out.println(oos.readChar());
        System.out.println(oos.readDouble());
        System.out.println(oos.readUTF());
        Object dog=oos.readObject();
        System.out.println(dog.toString());
        oos.close();
    }
}

ObjectOutputStream：

package IO;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/*
* 序列化存数据
* */
public class ObjectOUT {
    public static void main(String[] args) throws Exception {
//        dat文件不是纯文本
        String filename="C:\\Users\\lenovo\\Desktop\\data.dat";
        ObjectOutputStream ois=new ObjectOutputStream(new FileOutputStream(filename));
//        存储序列化数据 ,转化为包装类，包装类均实现Serializable接口
        ois.writeInt(100);//int->Integer
        ois.writeBoolean(true);//boolean->Boolean
        ois.writeChar('h');//char->Character
        ois.writeDouble(9.4);//double->Double
        ois.writeUTF("你好");//String
        ois.writeObject(new Dog("旺财",3));
        ois.close();
        System.out.println("保存完毕");
    }
}
class Dog implements Serializable {
    private String name;
    private int age;

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

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
转换流InputStreamReader和 OutputStreamWriter

介绍

1.InputStreamReader:Reader的子类，可以将InputStream(字节流)包装成Reader(字符流)。

2.OutputStreamWriter:Writer的子类,实现将OutputStream(字节流)包装成Writer(字符流)。

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

4.可以在使用时指定编码格式(比如utf-8, gbk , gb2312, ISO8859-1等)

处理编码格式不统一

写入：

package IO;

import java.io.*;

public class OutputStreamW {
    public static void main(String[] args) throws IOException {
        String filename="C:\\Users\\lenovo\\Desktop\\hello2.txt";
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(filename),"gbk"));
        bw.write("怎么说，我是gbk");
        bw.close();
    }
}

读取：

package IO;

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

public class InputStreamR {
    public static void main(String[] args) throws Exception {
        String filename="C:\\Users\\lenovo\\Desktop\\hello1.txt";
//        InputStreamReader转换流指定编码gbk
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filename), "gbk");
        BufferedReader br=new BufferedReader(isr);//使用处理流提高效率
        String s=br.readLine();
        System.out.println(s);
        br.close();
    }
}
打印流 PrintStream,PrintWriter
package IO;

import java.io.IOException;
import java.io.PrintStream;
import java.nio.charset.StandardCharsets;

public class PrintSm {
    public static void main(String[] args) throws IOException {
        PrintStream ps=System.out;
        ps.println("成功");
//        等效方法
        ps.write("也成功".getBytes(StandardCharsets.UTF_8));
        ps.close();
//        修改打印位置
        System.setOut(new PrintStream("C:\\a.txt"));
        System.out.println("hhh");//将写入文件中
    }
}

package IO;

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

public class PrintW {
    public static void main(String[] args) throws IOException {
        PrintWriter pw=new PrintWriter(System.out);//获取系统打印
        PrintWriter pw1=new PrintWriter(new FileWriter("XXXX"));//文件打印
    }
}

4、Properties类

Properties的常见方法:

load:加载配置文件的键值对到Properties对象

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

getProperty(key):根据键获取值

setProperty(key,value):设置键值对到Properties对象

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

读取需求文件：

image-20220928153211323

传统方法

package IO;

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

public class PropertiesR {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("src\\mysql.properties"));
        String line="";
        while ((line=br.readLine())!=null){
           String[] S= line.split("=");
           System.out.println(S[1].replace(" ",""));
        }
        br.close();
    }
}

使用Properties类实现：

package IO;

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

public class PropertiesR1 {
    public static void main(String[] args) throws IOException {
//        1、创建properties类
        Properties p=new Properties();
//        2、加载指定的配置文件
        p.load(new FileReader("src\\mysql.properties"));
//        3、list方法显示键值对,传参PrintStream流
        p.list(System.out);
//        4、通过key值获取value
        System.out.println(p.getProperty("ip"));
//        5、传入键值对，添加数据
        p.setProperty("psw1","12345678");
//        6、将键值对添加到文件中
        p.store(new FileWriter("src\\mysql.properties"),"此参数为添加的注解");//覆盖式添加
        p.list(System.out);
    }
}

  System.out.println(S[1].replace(" ",""));
    }
    br.close();
}

}


###  使用Properties类实现：

```java
package IO;

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

public class PropertiesR1 {
    public static void main(String[] args) throws IOException {
//        1、创建properties类
        Properties p=new Properties();
//        2、加载指定的配置文件
        p.load(new FileReader("src\\mysql.properties"));
//        3、list方法显示键值对,传参PrintStream流
        p.list(System.out);
//        4、通过key值获取value
        System.out.println(p.getProperty("ip"));
//        5、传入键值对，添加数据
        p.setProperty("psw1","12345678");
//        6、将键值对添加到文件中
        p.store(new FileWriter("src\\mysql.properties"),"此参数为添加的注解");//覆盖式添加
        p.list(System.out);
    }
}
爱打辅助的小可爱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java io流学习笔记1
04-20
对于源码级别的理解，你可以深入研究Java的`java.io`包，了解这些流的实现原理。例如，`BufferedInputStream`是如何通过内部缓冲区提高读取效率的，或者`ObjectInputStream`和`ObjectOutputStream`如何实现对象的...
java-demo:java学习笔记，包含多线程，java IO流，java 阻塞IO，非阻塞IO，netty demo
05-26
在这个"java-demo"项目中，我们可以深入学习Java技术，特别是关于多线程、IO流以及两种不同的IO模型——阻塞IO（BIO）和非阻塞IO。此外，还涉及到Netty框架的应用，这是一个高性能、异步事件驱动的网络应用框架，常...
深入理解JavaIO流
梦醒，已千年的专栏
06-17 734
自定义BufferedReader中的readLine()方法无论是读取一行还是读取多个字符。其实最终都是在硬盘上一个个读取。所以最终使用的还是read()方法一次读取一个的方法。class MyBufferedReader { private FileReader r; public MyBufferedReader(FileReader r) { this.r = r
深入IO流--高级IO
追梦的小狼狗
03-16 256
缓冲流 缓冲流也叫高效流，是对4个基本的Filexxx流的增强，按照数据类型分类 字节缓冲流：BufferedInputStream，BufferedOutputStream 字符缓冲流：BufferedReader，BufferedWriter 缓冲流的基本原理，是在创建对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO的次数，从而提高读写的效率 字节缓冲流 构造方法...
Java IO 小结
学哥斌的博客
09-20 613
IO 小结
深入学习IO流
PASSING的专栏
05-16 561
------- android培训、java培训、期待与您交流！ ---------- 在上一章介绍了IO流的一些基本的知识，但是由于其效率问题，在实际应用中我们都不是单独的应用，而是通过类装饰器，包装它们，提高它们的效率。其中的类装饰器指的是缓冲对象。 在解释类装饰器前，先介绍下装饰设计模式：这种模式是为了优化类而存在的，当想要对自己已有的对象进行功能增强时，可以重新定义类，将已有的对象传入
让你深入理解Java IO流
weixin_62421895的博客
08-05 113
一个File对象有可能对应的是目录，也可能是文件；（3） mkdir() 方法：以目录的形式创建出来；（1）java.io.DataOutputStream：数据专属的流；（1）jva.io.PrintStream：标准的字节输出流。（5） getAbsolutePath() 方法：获取当前文件的绝对路径。（3）可以 通过System.setOut()方法改变输出流的方向。（2） creatNewFile() 方法：以文件的形式创建出来。（2）这个流可以 将数据连同数据的类型一并写入文件。...
Java的IO流讲解代码: File 类、RandomAccessFile 类、字节流（文件字节流、缓冲字节流、基本数据类型
06-20
此代码资源的目标是提供简单易懂的示例代码，帮助读者深入理解Java IO流的概念和使用方法。通过研究这些代码示例，读者将能够了解如何使用不同类型的IO类来进行文件读写、字符流、字节流、网络传输等各种常见的IO...
IO操作.pdf
06-19
Java IO（Input/Output）是Java编程语言中用于处理输入输出操作的重要部分，它提供了丰富的类库来实现数据的读写、文件的管理和网络通信等...对于希望深入研究Java IO的开发者来说，这本书无疑是不可多得的参考资料。
图书管理系统IO流升级版
10-20
《图书管理系统IO流升级版》是一款基于Java技术的图书管理软件，旨在提供高效、稳定且易用的图书信息管理解决方案。这款系统通过优化输入/输出...对于希望深入研究Java IO流特性的开发者来说，这是一个理想的实践案例。
JavaSE进阶 | 深入理解Java IO流（目录拷贝、对象专属流、IO和Properties的联合使用）
m0_61933976的博客
08-08 446
JavaSE进阶 | 深入理解Java IO流（目录拷贝、对象专属流、IO和Properties的联合使用）
Java深入理解——IO流
hello world
08-03 329
Java深入理解——IO流Java深入理解——IO流File类FileInputStreamFileOutputStream字符流FileReaderFileWriter缓冲流字节缓冲流字符缓冲流转换流InputStreamReaderOutputStreamWriter序列化流ObjectOutputStreamObjectInputStream打印流PrintStreamProperties属性类 Java深入理解——IO流 输入输出流： Input：输入 Output：输出 IO流是一个水流模型，IO
Java IO 深入学习
JackyCheng2007
03-05 116
IO可算是jdk的一个很基本的东西了，所以打算整理一下我对IO的学习和理解。 IO,当然就是Input和Output的简写，分别代表了读和写两个方面。 流的引入，使我们可以形象的认为数据就像流水一般在各种是被间流走，而不必理会沟渠是怎么铺设的。我们只要关注怎么控制这些字节或者字符的流动就好了。 [size=medium][color=blue][b] InputStream & Outp...
java io学习
Knight_art的博客
06-02 117
package com.glut.util; //import java.io.BufferedInputStream; import java.io.BufferedReader; //import java.io.File; //import java.io.FileInputStream; import java.io.InputStream; import java.io.InputSt...
Java学习十一,IO流
土豆科技的博客
01-12 244
1.什么是流       2.File类的使用 代码如下: package com_imooc.wenjian; import java.io.File; import java.io.IOException; public class file_test { public static void main(String[] args) { //实例化一个fi...
深入理解Java IO流：字节流
最新发布
zhouxiaozheng213的博客
04-21 799
插曲：取 Output 和 Input 单词首字母不就是 IO 吗？输入：内存 —— Output（将内存中的数据写到硬盘中）> 硬盘。输出：硬盘——Input（将硬盘中的数据读取到内存中）> 内存。如不理解，可以把自己比做内存，当我们吃饭喝水时是输入。
深入学习Java IO关闭
刘阳的博客
03-05 3824
写这篇文章主要是本周排查一个问题的时候，看到一段没有正确关闭文件的代码，起初怀疑是这块导致的，最后虽然不是，但是还是有必要学习一下资源关闭的知识。一.正确关闭资源的方式在实际开发中，经常需要在程序中打开一些物理资源，如数据库连接，网络连接，磁盘文件等，打开这些资源之后必须显示关闭，否则将会引起资源泄露。JVM不是提供了垃圾回收机制吗？JVM的垃圾回收机制不会回收这些资源吗？答案是不会，垃圾回收机制...
深入理解Java中的IO
热门推荐
二丁目的丰功笔记
04-21 2万+
深入理解Java中的IO,个人学习总结。
Java IO流学习总结一：输入输出流
weixin_34198881的博客
01-09 3975
Java IO流学习总结一：输入输出流 转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/54292148 本文出自【赵彦军的博客】 Java流类图结构： 流的概念和作用 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。...
深入理解Java IO：第二版
"Java IO 2nd Edition 是一本由 Elliotte Rusty Harold 撰写的书籍，由 O'..."Java IO 2nd Edition" 是一个全面的指南，不仅适合初学者理解Java I/O的基础，也为有经验的开发者提供了深入研究和优化I/O操作的宝贵资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱打辅助的小可爱

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

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

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

打赏作者

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

抵扣说明：

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

余额充值