java IO流（Java基础学习笔记）

最新推荐文章于 2024-09-15 09:47:04 发布
最新推荐文章于 2024-09-15 09:47:04 发布
阅读量74 收藏
点赞数
分类专栏： java基础 文章标签： java
原文链接：https://blog.csdn.net/weixin_43907062/article/details/108444799
版权

java IO流

一 File类的使用：

1.File类的理解

  •   1. File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)

  •   2. File类声明在java.io包下

  •   3. File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，
  并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。

  •   4. 后续File类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点".

2.File的实例化

2.1 常用构造器

File(String filePath)
File(String parentPath,String childPath)
File(File parentFile,String childPath)

2.2 路径的分类

相对路径：相较于某个路径下，指明的路径。
绝对路径：包含盘符在内的文件或文件目录的路径

说明：
IDEA中：

如果大家开发使用JUnit中的单元测试方法测试，相对路径即为当前Module下。
如果大家使用main()测试，相对路径即为当前的Project下。

Eclipse中：

不管使用单元测试方法还是使用main()测试，相对路径都是当前的Project下。

2.3 路径分隔符

windows和DOS系统默认使用“\”来表示
UNIX和URL使用“/”来表示

3.File类的常用方法
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

二 IO流概述：

1.流的分类

  •   1.操作数据单位：字节流、字符流

  •   2.数据的流向：输入流、输出流

  •   3.流的角色：节点流、处理流

图示：

在这里插入图片描述

2.流的体系结构
在这里插入图片描述

说明：

红框对应的是IO流中的4个抽象基类。
蓝框的流需要大家重点关注。

3.重点说明的几个流结构
在这里插入图片描述

4.输入、输出的标准化过程

4.1 输入过程

① 创建File类的对象，指明读取的数据的来源。（要求此文件一定要存在）
② 创建相应的输入流，将File类的对象作为参数，传入流的构造器中
③ 具体的读入过程：
创建相应的byte[] 或 char[]。
④ 关闭流资源
说明：程序中出现的异常需要使用try-catch-finally处理。
4.2 输出过程
① 创建File类的对象，指明写出的数据的位置。（不要求此文件一定要存在）
② 创建相应的输出流，将File类的对象作为参数，传入流的构造器中
③ 具体的写出过程：
write(char[]/byte[] buffer,0,len)
④ 关闭流资源
说明：程序中出现的异常需要使用try-catch-finally处理。

三 节点流（或文件流）：

1.FileReader/FileWriter的使用：

1.1 FileReader的使用

/*
将day09下的hello.txt文件内容读入程序中，并输出到控制台

说明点：

1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
3. 读入的文件一定要存在，否则就会报FileNotFoundException。

 */
@Test
public void testFileReader1()  {
    FileReader fr = null;
    try {
        //1.File类的实例化
        File file = new File("hello.txt");

        //2.FileReader流的实例化
        fr = new FileReader(file);

        //3.读入的操作
        //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
        char[] cbuf = new char[5];
        int len;
        while((len = fr.read(cbuf)) != -1){
            //方式一：
            //错误的写法
//                for(int i = 0;i < cbuf.length;i++){
//                    System.out.print(cbuf[i]);
//                }
            //正确的写法
//                for(int i = 0;i < len;i++){
//                    System.out.print(cbuf[i]);
//                }
            //方式二：
            //错误的写法,对应着方式一的错误的写法
//                String str = new String(cbuf);
//                System.out.print(str);
            //正确的写法
            String str = new String(cbuf,0,len);
            System.out.print(str);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(fr != null){
            //4.资源的关闭
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

}

1.2 FileWriter的使用

/*
从内存中写出数据到硬盘的文件里。

说明：

1. 输出操作，对应的File可以不存在的。并不会报异常
2.
 File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
 File对应的硬盘中的文件如果存在：
       如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原文件的覆盖
       如果流使用的构造器是：FileWriter(file,true):不会对原文件覆盖，而是在原文件基础上追加内容

 */
@Test
public void testFileWriter() {
FileWriter fw = null;
try {
    //1.提供File类的对象，指明写出到的文件
    File file = new File("hello1.txt");

    //2.提供FileWriter的对象，用于数据的写出
    fw = new FileWriter(file,false);

    //3.写出的操作
    fw.write("I have a dream!\n");
    fw.write("you need to have a dream!");
} catch (IOException e) {
    e.printStackTrace();
} finally {
    //4.流资源的关闭
    if(fw != null){

        try {
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

}
1.3 文本文件的复制：

@Test
public void testFileReaderFileWriter() {
    FileReader fr = null;
    FileWriter fw = null;
    try {
        //1.创建File类的对象，指明读入和写出的文件
        File srcFile = new File("hello.txt");
        File destFile = new File("hello2.txt");

        //不能使用字符流来处理图片等字节数据
//            File srcFile = new File("爱情与友情.jpg");
//            File destFile = new File("爱情与友情1.jpg");


        //2.创建输入流和输出流的对象
         fr = new FileReader(srcFile);
        fw = new FileWriter(destFile);


        //3.数据的读入和写出操作
        char[] cbuf = new char[5];
        int len;//记录每次读入到cbuf数组中的字符的个数
        while((len = fr.read(cbuf)) != -1){
            //每次写出len个字符
            fw.write(cbuf,0,len);

        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4.关闭流资源
        //方式一：
//            try {
//                if(fw != null)
//                    fw.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }finally{
//                try {
//                    if(fr != null)
//                        fr.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
        //方式二：
        try {
            if(fw != null)
                fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            if(fr != null)
                fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

2.FileInputStream / FileOutputStream的使用：

  •   1. 对于文本文件(.txt,.java,.c,.cpp)，使用字符流处理

  •   2. 对于非文本文件(.jpg,.mp3,.mp4,.avi,.doc,.ppt,...)，使用字节流处理

/*
实现对图片的复制操作
*/

@Test
public void testFileInputOutputStream()  {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
    //1.造文件
    File srcFile = new File("爱情与友情.jpg");
    File destFile = new File("爱情与友情2.jpg");

    //2.造流
    fis = new FileInputStream(srcFile);
    fos = new FileOutputStream(destFile);

    //3.复制的过程
    byte[] buffer = new byte[5];
    int len;
    while((len = fis.read(buffer)) != -1){
        fos.write(buffer,0,len);
    }

} catch (IOException e) {
    e.printStackTrace();
} finally {
    if(fos != null){
        //4.关闭流
        try {
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    if(fis != null){
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

}

【注意】

相对路径在IDEA和Eclipse中使用的区别？
IDEA:
如果使用单元测试方法，相对路径基于当前的Module的。
如果使用main()测试，相对路径基于当前Project的。

Eclipse:

单元测试方法还是main(),相对路径都是基于当前Project的。

四 缓冲流的使用：

1.缓冲流涉及到的类：

  •   BufferedInputStream

  •   BufferedOutputStream

  •   BufferedReader

  •   BufferedWriter

2.作用：
作用：

提供流的读取、写入的速度
提高读写速度的原因：内部提供了一个缓冲区。默认情况下是8kb

在这里插入图片描述

3.典型代码

3.1 使用BufferedInputStream和BufferedOutputStream:处理非文本文件

//实现文件复制的方法

  public void copyFileWithBuffered(String srcPath,String destPath){
    BufferedInputStream bis = null;
    BufferedOutputStream bos = null;

    try {
        //1.造文件
        File srcFile = new File(srcPath);
        File destFile = new File(destPath);
        //2.造流
        //2.1 造节点流
        FileInputStream fis = new FileInputStream((srcFile));
        FileOutputStream fos = new FileOutputStream(destFile);
        //2.2 造缓冲流
        bis = new BufferedInputStream(fis);
        bos = new BufferedOutputStream(fos);

        //3.复制的细节：读取、写入
        byte[] buffer = new byte[1024];
        int len;
        while((len = bis.read(buffer)) != -1){
            bos.write(buffer,0,len);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4.资源关闭
        //要求：先关闭外层的流，再关闭内层的流
        if(bos != null){
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        if(bis != null){
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略.
//        fos.close();
//        fis.close();
    }
}

3.2 使用BufferedReader和BufferedWriter：处理文本文件

@Test
public void testBufferedReaderBufferedWriter(){
    BufferedReader br = null;
    BufferedWriter bw = null;
    try {
        //创建文件和相应的流
        br = new BufferedReader(new FileReader(new File("dbcp.txt")));
        bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));

        //读写操作
        //方式一：使用char[]数组
//            char[] cbuf = new char[1024];
//            int len;
//            while((len = br.read(cbuf)) != -1){
//                bw.write(cbuf,0,len);
//    //            bw.flush();
//            }

        //方式二：使用String
        String data;
        while((data = br.readLine()) != null){
            //方法一：
//                bw.write(data + "\n");//data中不包含换行符
            //方法二：
            bw.write(data);//data中不包含换行符
            bw.newLine();//提供换行的操作

        }


    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //关闭资源
        if(bw != null){

            try {
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(br != null){
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

}

五 转换流的使用：

1.转换流涉及到的类：

属于字符流
InputStreamReader：将一个字节的输入流转换为字符的输入流
解码：字节、字节数组  --->字符数组、字符串

OutputStreamWriter：将一个字符的输出流转换为字节的输出流
编码：字符数组、字符串 ---> 字节、字节数组

说明：

编码决定了解码的方式

2.作用：

提供字节流与字符流之间的转换

3.图示：
在这里插入图片描述

4.典型实现：

@Test
public void test1() throws IOException {

    FileInputStream fis = new FileInputStream("dbcp.txt");
//        InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
    //参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保存时使用的字符集
    InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//使用系统默认的字符集

    char[] cbuf = new char[20];
    int len;
    while((len = isr.read(cbuf)) != -1){
        String str = new String(cbuf,0,len);
        System.out.print(str);
    }

    isr.close();

}

/*
此时处理异常的话，仍然应该使用try-catch-finally

综合使用InputStreamReader和OutputStreamWriter
 */
@Test
public void test2() throws Exception {
//1.造文件、造流
File file1 = new File("dbcp.txt");
File file2 = new File("dbcp_gbk.txt");

FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);

InputStreamReader isr = new InputStreamReader(fis,"utf-8");
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");

//2.读写过程
char[] cbuf = new char[20];
int len;
while((len = isr.read(cbuf)) != -1){
    osw.write(cbuf,0,len);
}

//3.关闭资源
isr.close();
osw.close();


}

5.说明：

文件编码的方式（比如：GBK），决定了解析时使用的字符集（也只能是GBK）。

编码集：
1.常见的编码表

ASCII：美国标准信息交换码。
用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表
用一个字节的8位表示。
GB2312：中国的中文编码表。最多两个字节编码所有字符
GBK：中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码
Unicode：国际标准码，融合了目前人类使用的所字符。为每个字符分配唯一的字符码。所有的文字都用两个字节来表示。
UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。

2.对后面学习的启示

客户端/浏览器端    <---->  后台(java,GO,Python,Node.js,php)   <----> 数据库

要求前前后后使用的字符集都要统一：UTF-8.

六 其他流的使用：

  1. 标准的输入输出流：

     System.in:标准的输入流，默认从键盘输入
 System.out:标准的输出流，默认从控制台输出

修改默认的输入和输出行为：

System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的流。

  1. 打印流：

    PrintStream 和PrintWriter
    说明：

     提供了一系列重载的print()和println()方法，用于多种数据类型的输出
 System.out返回的是PrintStream的实例

  2. 数据流：

     DataInputStream 和 DataOutputStream

作用：

	用于读取或写出基本数据类型的变量或字符串

示例代码：

/*
练习：将内存中的字符串、基本数据类型的变量写出到文件中。

注意：

处理异常的话，仍然应该使用try-catch-finally.
 */
@Test
public void test3() throws IOException {
//1.
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
//2.
dos.writeUTF("刘建辰");
dos.flush();//刷新操作，将内存中的数据写入文件
dos.writeInt(23);
dos.flush();
dos.writeBoolean(true);
dos.flush();
//3.
dos.close();


}

/*
将文件中存储的基本数据类型变量和字符串读取到内存中，保存在变量中。

注意点：

读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！

 */
@Test
public void test4() throws IOException {
//1.
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
//2.
String name = dis.readUTF();
int age = dis.readInt();
boolean isMale = dis.readBoolean();

System.out.println("name = " + name);
System.out.println("age = " + age);
System.out.println("isMale = " + isMale);

//3.
dis.close();

}

七 对象流的使用：

1.对象流：

ObjectInputStream 和 ObjectOutputStream

2.作用：

ObjectOutputStream:内存中的对象--->存储中的文件、通过网络传输出去：序列化过程
ObjectInputStream:存储中的文件、通过网络接收过来 --->内存中的对象：反序列化过程

3.对象的序列化机制：

对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘
上，或通过网络将这种二进制流传输到另一个网络节点。//当其它程序获取了这种二进制流，就可以恢复成原来的
Java对象

4.序列化代码实现：

@Test
public void testObjectOutputStream(){
ObjectOutputStream oos = null;

try {
    //1.
    oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
    //2.
    oos.writeObject(new String("我爱北京天安门"));
    oos.flush();//刷新操作

     oos.writeObject(new Person("王铭",23));
    oos.flush();

    oos.writeObject(new Person("张学良",23,1001,new Account(5000)));
    oos.flush();

} catch (IOException e) {
    e.printStackTrace();
} finally {
    if(oos != null){
        //3.
        try {
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

}
5.反序列化代码实现：

@Test
public void testObjectInputStream(){
ObjectInputStream ois = null;
try {
    ois = new ObjectInputStream(new FileInputStream("object.dat"));

    Object obj = ois.readObject();
    String str = (String) obj;

    Person p = (Person) ois.readObject();
    Person p1 = (Person) ois.readObject();

    System.out.println(str);
    System.out.println(p);
    System.out.println(p1);

} catch (IOException e) {
    e.printStackTrace();
} catch (ClassNotFoundException e) {
    e.printStackTrace();
} finally {
    if(ois != null){
        try {
            ois.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}



}

6.实现序列化的对象所属的类需要满足：

  •   1.需要实现接口：Serializable

  •    2.当前类提供一个全局常量：serialVersionUID

  •   3.除了当前Person类需要实现Serializable接口之外，还必须保证其内部所属性
   也必须是可序列化的。（默认情况下，基本数据类型可序列化）

  •   补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

八 RandomAccessFile的使用：

1.随机存取文件流：

RandomAccessFile

2.使用说明：

  •   1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口

  •   2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流

  •   3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。
  如果写出到的文件存在，则会对原文件内容进行覆盖。（默认情况下，从头覆盖）

  •   4. 可以通过相关的操作，实现RandomAccessFile“插入”数据的效果。seek(int pos)

3.典型代码1：

@Test
public void test1() {

RandomAccessFile raf1 = null;
RandomAccessFile raf2 = null;
try {
    //1.
    raf1 = new RandomAccessFile(new File("爱情与友情.jpg"),"r");
    raf2 = new RandomAccessFile(new File("爱情与友情1.jpg"),"rw");
    //2.
    byte[] buffer = new byte[1024];
    int len;
    while((len = raf1.read(buffer)) != -1){
        raf2.write(buffer,0,len);
    }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    //3.
    if(raf1 != null){
        try {
            raf1.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    if(raf2 != null){
        try {
            raf2.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
}

典型代码2：

/*
使用RandomAccessFile实现数据的插入效果
*/

@Test
public void test3() throws IOException {

RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");

raf1.seek(3);//将指针调到角标为3的位置
//保存指针3后面的所数据到StringBuilder中
StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
byte[] buffer = new byte[20];
int len;
while((len = raf1.read(buffer)) != -1){
    builder.append(new String(buffer,0,len)) ;
}
//调回指针，写入“xyz”
raf1.seek(3);
raf1.write("xyz".getBytes());

//将StringBuilder中的数据写入到文件中
raf1.write(builder.toString().getBytes());

raf1.close();

//思考：将StringBuilder替换为ByteArrayOutputStream
}

九 Path、Paths、Files的使用：

1.NIO的使用说明：

Java NIO (New IO，Non-Blocking IO)是从Java 1.4版本开始引入的一套新的IO API，可以替代标准的Java
IO AP。
NIO与原来的IO同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的(IO是面向流的)、基于
通道的IO操作。
NIO将以更加高效的方式进行文件的读写操作。
随着 JDK 7 的发布，Java对NIO进行了极大的扩展，增强了对文件处理和文件系统特性的支持，以至于我们称他们为 NIO.2。

2.Path的使用

jdk7提供

2.1Path的说明：

Path替换原有的File类。

2.2如何实例化：
在这里插入图片描述

2.3常用方法：
在这里插入图片描述

3.Files工具类

jdk7提供

3.1作用：

操作文件或文件目录的工具类

3.2常用方法：

在这里插入图片描述
在这里插入图片描述

ccboy001
关注
专栏目录
详述Java中IO流
qq_46384325的博客
05-03 381
什么是IO流 I是指Input（输入）,O是指Output（输出）。 在Java中，文件的输入和输出是通过流（Stream）来实现的，流的概念源于Unix中管道（pipe）的概念。在Unix系统中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。 一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。对于流而言，我们不用关心数据是如何传输的，只需要向源端输入数据，向目的端获取数据即可。 流按照处理数据的单位，可
IO流--字节/字符流
weixin_44079370的博客
12-09 442
12.8号知识点 1、IO流概述 I：input 输入（读取）把硬盘中的数据，读取到内存中使用 O：output 输出（写入）把内存中的数据写入到硬盘中保存 流：数据（字符，字节）1字符=2字节 1字节=8二进制位 2、字节流 2.1 一切皆为字节 一切文件数据存储时，都是以二进制数字的形式保存，都是一个一个字节，传输时也一样；字节流可以传输任意文件数据，操作流时，无论使用什么样的流对象，底层都是以二进制数据进行传输。 2.2 字节输出流 OutputStream java.io.OutputStream抽
十、IO流
陈大大的博客
09-07 161
一、IO流的分类       IO流按照数据单位的不同分为字节流（8 bit）和字符流（16 bit），其中字节流适合传输图片和视频；字符流适合传输文本文件。按照数据流的流向不同分为输入流和输出流；按照流的角色不同分为节点流和处理流。       输入流：InputStream（字节流），Reader(字符流）       输出流
黑马程序员————IO流(一)
feitianmao627的博客
05-13 335
一：IO流： IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都在IO包中 流按操作数据分为两种：字符流和字节流 流按流向分为：输入流和输出流。 二：字符流 特点：Writer,Reader Writer:​ ​用于操作文件的Writer子类对象。FileWriter。后缀名是父类。前缀名是该类对象
关于Java IO流 你知道多少
03-10 155
下面是我近一段时间，复习IO流的一些知识点： 一.分类： 1. 按流向分类: 输入流：程序可以从中读取数据的流； 如：InputStream/Reader 输出流：程序可以向其写入数据的流； 如：OutputStream/Writer 2.按数据传输单位分类： 字节流：...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java IO流学习笔记
12-12
### Java IO流学习笔记 #### 异常处理与IO流操作 在进行Java IO流的学习过程中，异常处理是非常重要的一个方面。本节将详细介绍如何在Java中处理异常，...以上就是关于Java IO流的基础学习笔记，希望对大家有所帮助。
java IO流学习笔记——(1)文件字节流
12-21
java IO流学习笔记——(1) IO流总述 • 输入流：数据源到程序(InputStream、Reader读进来) • 输出流：程序到目的地(OutputStream、Writer写出去) 流分类 : • 节点流：可以直接从数据源或目的地读写数据 • 处理...
Java 的 IO流笔记.md
03-08
### Java IO流学习笔记 #### 一、IO流的四大抽象类 - **InputStream/OutputStream**：字节的输入输出流的抽象类。 - 数据单位：字节（8比特，范围0-255） - **Reader/Writer**：字符的输入输出流的抽象类。 - ...
java io流学习笔记1
04-18
Java IO流是Java编程语言中处理输入输出操作的重要部分，尤其在数据传输、文件读写等方面发挥着核心作用。本文将深入探讨Java IO流的基本概念、类型以及它们在实际开发中的应用。 首先，理解IO流的基本概念至关重要...
Java中File文件的创建，读写
十三月的博客
05-09 1708
1.创建一个文件 @Test public void test6() throws IOException { File file1 = new File("C:\\IDEA\\h1.txt"); if(!file1.exists()){//文件不存在 file1.createNewFile(); System.out.println("创建成功"); }else{//文件存在
FileWriter类
qq_320922199的博客
12-28 486
java.io.FileWriter 类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。 构造方法 FileWriter(File file) ： 创建一个新的 FileWriter，给定要读取的File对象。 FileWriter(String fileName) ： 创建一个新的 FileWriter，给定要读取的文件的名称。 当你创建一个流对象时，必须传入一个文件路径，类似于FileOutputStream。 构造举例，代码如下 public
java 写文件filewriter_JAVA FileWriter写数据到文本文件
weixin_39616090的博客
02-24 256
FileWriterFileWriter写数据的一般步骤：使用java.io.FileWriter类可以将数据写到文本文件当中：创：1.调用构造方法来创建一个FileWriter对象：public FilerWriter(String file Name):构造参数为文件路径名。写：2.调用写数据的成员方法向文件中写入数据：public void write(String text):参数为需要写...
IO的几个概念
wxg6203的专栏
08-24 643
在数据库优化和存储规划过程中，总会提到IO的一些重要概念，在这里就详细记录一下，个人认为对这个概念的熟悉程度也决定了对数据库与存储优化的理解程度，以下这些概念并非权威文档，权威程度肯定就不能说了。 读/写IO，最为常见说法，读IO，就是发指令，从磁盘读取某段扇区的内容。指令一般是通知磁盘开始扇区位置，然后给出需要从这个初始扇区往后读取的连续扇区个数，同时给出动作是读，还是写。磁盘收到这条指令...
java byte char io流_Java基础进阶 IO流之字节流
weixin_29535345的博客
02-13 255
1、IO流1.1、概述之前学习的File类它只能操作文件或文件夹，并不能去操作文件中的数据。真正保存数据的是文件，数据是在文件中。而File类它只是去对文件本身做操作，不能对文件中的数据进行操作。如果要操作文件中的数据，这时必须使用Java中提供的IO流技术完成。IO可以实现数据的传输，把数据比作是像水一样在流动。IO：input/outputIO流：它的功能就是专门操作文件中的数据。2.2、IO...
Java-网络
2301_81543552的博客
09-14 754
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
自动生成不重复的订单id
ClaireCheney的博客
09-13 327
【代码】自动生成不重复的订单id。
Gradle
最新发布
xiaocaij_icai的博客
09-15 228
");
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
m0_66572126的博客
09-14 731
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
马士兵Java IO流详解与实战笔记
马士兵的Java IO流笔记和分析是对Java高级IO操作的深入学习资料，主要针对初学者在学习过程中可能遇到的理解难点进行讲解。以下是核心知识点的详细阐述： 1. **基础概念**： - Java中的流（Stream）是一种数据传输...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值