IO-文件&字节流

已于 2024-09-07 16:12:07 修改
阅读量990 收藏 20
点赞数 29
文章标签： java 开发语言
于 2024-09-07 15:53:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71174751/article/details/141924756
版权

一、IO流

图解

1、数据存储的方式

它们都是内存中的数据容器它们记住的数据，在断电，或者程亭终止时会丢失。

2、File

2.1、概念

1.File是java.io.包下的类，File类的对象，用于代表当前操作系统的文件（可以是文件、或文件夹）。

2.java.io.File 类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作。

2.2、构造方法

2.2.1、方法

public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。

public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。

public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。

      // 文件路径名
        String pathname = "D:\\aaa.txt";
        File file1 = new File(pathname);
// 文件路径名
        String pathname2 = "D:\\aaa\\bbb.txt";
        File file2 = new File(pathname2);
// 通过父路径和子路径字符串
        String parent = "d:\\aaa";
        String child = "bbb.txt";
        File file3 = new File(parent, child);
// 通过父级File对象和子路径字符串
        File parentDir = new File("d:\\aaa");
        String child1 = "bbb.txt";
        File file4 = new File(parentDir, child);
2.2.2、注意

小贴士：

一个File对象代表硬盘中实际存在的一个文件或者目录。

无论该路径下是否存在文件或者目录，都不影响File对象的创建。

2.3 常用方法

2.3.1、获取功能的方法

public String getAbsolutePath() ：返回此File的绝对路径名字符串。

public String getPath() ：将此File转换为路径名字符串。

public String getName() ：返回由此File表示的文件或目录的名称。

public long length() ：返回由此File表示的文件的长度。 方法演示，代码如下：

public class FileGet {
    public static void main(String[] args) {
        File f = new File("d:/aaa/bbb.java");     
        System.out.println("文件绝对路径:"+f.getAbsolutePath());
        System.out.println("文件构造路径:"+f.getPath());
        System.out.println("文件名称:"+f.getName());
        System.out.println("文件长度:"+f.length()+"字节");

        File f2 = new File("d:/aaa");     
        System.out.println("目录绝对路径:"+f2.getAbsolutePath());
        System.out.println("目录构造路径:"+f2.getPath());
        System.out.println("目录名称:"+f2.getName());
        System.out.println("目录长度:"+f2.length());
    }
}
输出结果：
文件绝对路径:d:\aaa\bbb.java
文件构造路径:d:\aaa\bbb.java
文件名称:bbb.java
文件长度:636字节
！
目录绝对路径:d:\aaa
目录构造路径:d:\aaa
目录名称:aaa
目录长度:4096

API中说明：length()，表示文件的长度。但是File对象表示目录，则返回值未指定。

2.3.2、绝对路径和相对路径

绝对路径：从盘符开始的路径，这是一个完整的路径。

相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用。

代码运行结果：

public class FilePath {
    public static void main(String[] args) {
          // D盘下的bbb.java文件
        File f = new File("D:\\bbb.java");
        System.out.println(f.getAbsolutePath());
          
        // 项目下的bbb.java文件
        File f2 = new File("bbb.java");
        System.out.println(f2.getAbsolutePath());
    }
}
输出结果：
D:\bbb.java
D:\idea_project_test4\bbb.java

2.3.3、判断功能的方法

public boolean exists() ：此File表示的文件或目录是否实际存在。

public boolean isDirectory() ：此File表示的是否为目录。

public boolean isFile() ：此File表示的是否为文件。

public class FileIs {
    public static void main(String[] args) {
        File f = new File("d:\\aaa\\bbb.java");
        File f2 = new File("d:\\aaa");
          // 判断是否存在
        System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists());
        System.out.println("d:\\aaa 是否存在:"+f2.exists());
          // 判断是文件还是目录
        System.out.println("d:\\aaa 文件?:"+f2.isFile());
        System.out.println("d:\\aaa 目录?:"+f2.isDirectory());
    }
}
输出结果：
d:\aaa\bbb.java 是否存在:true
d:\aaa 是否存在:true
d:\aaa 文件?:false
d:\aaa 目录?:true

2.3.4、创建删除功能的方法

public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。

public boolean delete() ：删除由此File表示的文件或目录。

public boolean mkdir() ：创建由此File表示的目录。

public boolean mkdirs() ：创建由此File表示的目录，包括任何必需但不存在的父目录。

方法演示，代码如下：

public class FileCreateDelete {
    public static void main(String[] args) throws IOException {
        // 文件的创建
        File f = new File("aaa.txt");
        System.out.println("是否存在:"+f.exists()); // false
        System.out.println("是否创建:"+f.createNewFile()); // true
        System.out.println("是否存在:"+f.exists()); // true
        
         // 目录的创建
          File f2= new File("newDir");	
        System.out.println("是否存在:"+f2.exists());// false
        System.out.println("是否创建:"+f2.mkdir());	// true
        System.out.println("是否存在:"+f2.exists());// true

        // 创建多级目录
          File f3= new File("newDira\\newDirb");
        System.out.println(f3.mkdir());// false
        File f4= new File("newDira\\newDirb");
        System.out.println(f4.mkdirs());// true
      
          // 文件的删除
           System.out.println(f.delete());// true
      
          // 目录的删除
        System.out.println(f2.delete());// true
        System.out.println(f4.delete());// false
    }
}

API中说明：delete方法，如果此File表示目录，则目录必须为空才能删除。

2.3.5、 目录的遍历

public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。

public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。

public class FileFor {
    public static void main(String[] args) {
        File dir = new File("d:\\java_code");
      
          //获取当前目录下的文件以及文件夹的名称。
        String[] names = dir.list();
        for(String name : names){
            System.out.println(name);
        }
        //获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
        File[] files = dir.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }
}

小贴士：

调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历。

2.4字符集

2.4.1、字符编码

计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字

等字符是二进制数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。反之，

将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码 。比如说，按照A规则存储，

同样按照A规则解析，那么就能显示正确的文本符号。反之，按照A规则存储，再按照B规则解析，

就会导致乱码现象。

编码:字符(能看懂的)--字节(看不懂的)

解码:字节(看不懂的)-->字符(能看懂的)

字符编码Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。编码表:生活

中文字和计算机中二进制的对应规则

2.4.2、字符集

字符集 Charset：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、

图形符号、数字等。

计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符

编码。常见字符集有ASCII字符集、GBK字符集、Unicode字符集等。

可见，当指定了编码，它所对应的字符集自然就指定了，所以编码才是我们最终要关心的。

2.4.3、标准ASCII字符集

ASCII(American Standard Code for Information Interchange):美国信息交换标准代码，包括了英文、符号等。

标准ASCII使用1个字节存储一个字符，首尾是0，总共可表示128个字符，对美国佬来说完全够用。

2.4.4、GBK（汉字内码扩展规范，国标）

汉字编码字符集，包含了2万多个汉字等字符，GBK中一个中文字符编码成两个字节的形式存储。

注意：GBK兼容了ASCII字符集。

GBK规定：汉字的第一个字节的第一位必须是1。

2.4.5、Unicode字符集(统一码，也叫万国码)

nicode是国际组织制定的，可以容纳世界上所有文字、符号的字符集。

2.4.6、UTF-8

是Unicode字符集的一种编码方案，采取可变长编码方案，共分四个长度区：1个字节，2个字节，3个字节，4个字节

英文字符、数字等只占1个字节（兼容标准ASCII编码），汉字字符占用3个字节。

注意：技术人员在开发时都应该使用UTF-8编码！

2.4.7、常见字符集有哪些？各自存储数据的特点是什么？

ASCII字符集：只有英文、数字、符号等，占1个字节。

GBK字符集：汉字占2个字节，英文、数字占1个字节。

UTF-8字符集：汉字占3个字节，英文、数字占1个字节。

2.4.8、编码

String类下的方法：

byte[]getBytes（）：使用默认字符集编码

byte[]getBytes(StringcharsetName)：使用指定字符集编码

2.4.9、解码

String类的构造器：

String(byte［bytes)：使用默认字符集解码

String(byte[]bytes，String charsetName)）：使用指定字符集解码

3、IO流

3.1、io流的概述

生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了ctrl+s ，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里。那么数据都是在哪些设备上的呢？键盘、内存、硬盘、外接设备等等。

我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为输入input 和输出output ，即流向内存是输入流，流出内存的输出流。

Java中I/O操作主要是指使用java.io包下的内容，进行输入、输出操作。输入也叫做读取数据，输出也叫做作写出数据。

3.2、IO的分类

根据数据的流向分为：输入流和输出流。

输入流 ：把数据从其他设备上读取到内存中的流。

输出流 ：把数据从内存 中写出到其他设备上的流。

格局数据的类型分为：字节流和字符流。

字节流 ：以字节为单位，读写数据的流。

字符流 ：以字符为单位，读写数据的流。

3.3、顶级父类们

输入流

输出流

字节流

字节输入流
InputStream

字节输出流
OutputStream

字符流

字符输入流
Reader

字符输出流
Writer

4、字节流

4.1、字节输入流【InputStream】

java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。

public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。

public abstract int read()： 从输入流读取数据的下一个字节。

public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

4.2、FileInputStream类

java.io.FileInputStream 类是文件输入流，从文件中读取字节。

4.2.1、构造方法

FileInputStream(File file)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。

FileInputStream(String name)： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException 。

构造举例，代码如下：

public class FileInputStreamConstructor throws IOException{
    public static void main(String[] args) {
        	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileInputStream fos = new FileInputStream(file);
      
        // 使用文件名称创建流对象
        FileInputStream fos = new FileInputStream("b.txt");
    }
}
4.2.2、读取字节数据

读取字节：read方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回-1，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
          // 使用文件名称创建流对象
           FileInputStream fis = new FileInputStream("read.txt");
          // 读取数据，返回一个字节
        int read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
        read = fis.read();
        System.out.println((char) read);
          // 读取到末尾,返回-1
           read = fis.read();
        System.out.println( read);
        // 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e
-1

循环改进读取方式，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
          // 使用文件名称创建流对象
           FileInputStream fis = new FileInputStream("read.txt");
          // 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fis.read())!=-1) {
            System.out.println((char)b);
        }
        // 关闭资源
        fis.close();
    }
}
输出结果：
a
b
c
d
e

小贴士：

  1. 虽然读取了一个字节，但是会自动提升为int类型。
  2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。

使用字节数组读取：read(byte[] b)，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回-1 ，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
          // 使用文件名称创建流对象.
           FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
          // 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
               // 每次读取后,把数组变成字符串打印
            System.out.println(new String(b));
        }
        // 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
ed

 错误数据d，是由于最后一次读取时，只读取一个字节e，数组中，上次读取的数据没有被完全替换，所以要通过len ，获取有效的字节，代码使用演示：

public class FISRead {
    public static void main(String[] args) throws IOException{
          // 使用文件名称创建流对象.
           FileInputStream fis = new FileInputStream("read.txt"); // 文件中为abcde
          // 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
               // 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
        }
        // 关闭资源
        fis.close();
    }
}

输出结果：
ab
cd
e

小贴士：

使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

4.3、字节输出流【OutputStream】

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。

public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。

public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。

public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。

public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。

public abstract void write(int b) ：将指定的字节输出流。

小贴士：

close方法，当完成流的操作时，必须调用此方法，释放系统资源。

4.4、FileOutputStream类

OutputStream有很多子类，我们从最简单的一个子类开始。

java.io.FileOutputStream 类是文件输出流，用于将数据写出到文件。

4.4.1、构造方法

public FileOutputStream(File file)：创建文件输出流以写入由指定的 File对象表示的文件。

public FileOutputStream(String name)： 创建文件输出流以指定的名称写入文件。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有这个文件，会创建该文件。如果有这个文件，会清空这个文件的数据。

构造举例，代码如下：

public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
        	// 使用File对象创建流对象
        File file = new File("a.txt");
        FileOutputStream fos = new FileOutputStream(file);
      
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("b.txt");
    }
}
4.4.2、写出字节数据

写出字节：write(int b) 方法，每次可以写出一个字节数据，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
          // 写出数据
          fos.write(97); // 写出第1个字节
          fos.write(98); // 写出第2个字节
          fos.write(99); // 写出第3个字节
          // 关闭资源
        fos.close();
    }
}
输出结果：
abc

小贴士：

  1. 虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
  2. 流操作完毕后，必须释放系统资源，调用close方法，千万记得。
4.4.3、写出字节数组

write(byte[] b)，每次可以写出数组中的数据，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
          // 字符串转换为字节数组
          byte[] b = "喜欢你".getBytes();
          // 写出字节数组数据
          fos.write(b);
          // 关闭资源
        fos.close();
    }
}
输出结果：
喜欢你
4.4.4、写出指定长度字节数组

write(byte[] b, int off, int len) ,每次写出从off索引开始，len个字节，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
          // 字符串转换为字节数组
          byte[] b = "abcde".getBytes();
        // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b,2,2);
          // 关闭资源
        fos.close();
    }
}
输出结果：
cd
4.4.5、数据追加续写

经过以上的演示，每次程序运行，创建输出流对象，都会清空目标文件中的数据。如何保留目标文件中数据，还能继续添加新数据呢？

public FileOutputStream(File file, boolean append)： 创建文件输出流以写入由指定的 File对象表示的文件。

public FileOutputStream(String name, boolean append)： 创建文件输出流以指定的名称写入文件。

这两个构造方法，参数中都需要传入一个boolean类型的值，true 表示追加数据，false 表示清空原有数据。这样创建的输出流对象，就可以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt"，true);     
          // 字符串转换为字节数组
          byte[] b = "abcde".getBytes();
        // 写出从索引2开始，2个字节。索引2是c，两个字节，也就是cd。
        fos.write(b);
          // 关闭资源
        fos.close();
    }
}
文件操作前：cd
文件操作后：cdabcde
4.4.6、写出换行

Windows系统里，换行符号是\r\n 。把

以指定是否追加续写了，代码使用演示：

public class FOSWrite {
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");  
          // 定义字节数组
          byte[] words = {97,98,99,100,101};
          // 遍历数组
        for (int i = 0; i < words.length; i++) {
              // 写出一个字节
            fos.write(words[i]);
              // 写出一个换行, 换行符号转成数组写出
            fos.write("\r\n".getBytes());
        }
          // 关闭资源
        fos.close();
    }
}

输出结果：
a
b
c
d
e
  • 回车符\r和换行符\n ：
    • 回车符：回到一行的开头（return）。
    • 换行符：下一行（newline）。
  • 系统中的换行：
    • Windows系统里，每行结尾是 回车+换行 ，即\r\n；
    • Unix系统里，每行结尾只有 换行 ，即\n；
    • Mac系统里，每行结尾是 回车 ，即\r。从 Mac OS X开始与Linux统一。

菜菜新手学Java
关注
  • 29
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
文件IO流
m0_65587787的博客
02-24 219
文件IO流，我们可以这样理解：文件是用来保存数据的，文件的抽象类是File，创建File对象用于在JAVA程序中文件和目录的创建、文件的查找和文件的删除。这时候问题来了，是如何将代码和文件联系，来进行操作呢？这样的目的是什么？
io流创建文件的3种方式
a2916709001的博客
11-19 350
213
编程程序实现使用io流，在本地建立一个文本文件(user.txt)，文件内容是5000行字符英文字符串，每行有3-15 随机字母组成的词汇，第一个词汇首字母大写，每个词汇之间用空格隔开，最后一个词汇尾
sgblwmbsa的博客
08-11 223
编程程序实现使用io流，在本地建立一个文本文件(user.txt)，文件内容是5000行字符英文字符串，每行有3-15 随机字母组成的词汇，第一个词汇首字母大写，每个词汇之间用空格隔开，最后一个词汇尾...
通过IO流给指定的文件夹创建文件
Java 领域技术分享
06-06 239
通过IO流给指定的文件夹创建文件
JAVA IO流——创建文件
weixin_59796310的博客
08-12 1713
保姆级喂饭 JAVA IO流——创建文件
commons-io-1.4.jar.zip_io流jar
09-23
Java IO流体系结构分为四类：字节流（Byte Stream）、字符流（Character Stream）、对象流（Object Stream）和套接字流（Socket Stream）。字节流处理单个8位的字节，而字符流基于Unicode编码，处理16位的字符。对象...
Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
Java IO流按照功能可以分为字节流和字符流，根据流向又分为输入流和输出流。字节流处理的是8位的字节，而字符流处理的是16位的Unicode字符。基础流类包括InputStream/OutputStream（字节流）和Reader/Writer（字符...
IO流文件操作字节流使用
01-20
什么是IO流 I input 输入流 read 读取数据 O output 输出流 write 写入数据 一般情况下都是按照当前程序使用的内存为参照物来考虑数据的走向问题。 文件操作为例 从内存中保存数据到硬盘 output 从硬盘中读取...
java-io流-文件流
最新发布
08-05
IO流体系可以分为两大类：字节流和字符流。 字节流 字节流是最基本的IO流，用于读取和写入字节数据。它可以分为两大类：字节输入流和字节输出流。 * 字节输入流（InputStream）：从外部来源（如磁盘、网络）读取...
IO流——文件操作字节流常用方法一览
12-22
总的来说，`FileInputStream` 和 `FileOutputStream` 是Java中处理文件字节流的基本工具，它们提供了一种高效且灵活的方式来读取和写入二进制文件。理解并熟练掌握这两个类的方法对于进行文件操作至关重要。
IO流文件创建的三种方式
lyllzcllf的博客
02-10 862
import org.junit.jupiter.api.Test; import java.io.File; import java.io.IOException; public class FileCreate { public static void main(String[] args) { } //方式一： new File(String pathname) @Test public void createNewFile(){ Str...
学习博客：IO流之创建文件的三种方法
Aurinko324的博客
03-19 1038
import org.junit.jupiter.api.Test; import java.io.File; import java.io.IOException; public class Demo01 { public static void main(String[] args) { } //创建文件 //方法1： new File(String pathname) @Test public void create1(){ St
几种IO流读写文件
zhao_yu_lei的博客
05-31 4万+
一、超类： 字节流： InputStream（读入流） OutputStream(写出流） 字符流： Reader（字符 读入流） Writer （字符写出流） 二、文件操作流 字节流： FileInputStream ，FileOutputStream 字符流： FileReader, FileWriter(用法与字节流基本相同，不写） //1.指定要读
关键IO流中自动创建文件路径
醉梦洛的博客
11-30 1632
直接上代码： import java.io.*; public class ServiceHello { public synchronized void getValue(String fileName,byte[] content) { // TODO Auto-generated method stub File f = null; OutputStream out ...
使用IO流创建文件并写入数据
ajsyipsc40270的博客
12-13 364
/* 字符流和字节流： 字节流两个基类： InputStream OutputStream 字符流两个基类： Reader Writer 既然IO流是用于操作数据的， 那么数据的最常见体现形式是：文件。 那么先以操作文件为主来演示。 需求:在硬盘上，创建一个文件并写入一些文字数据。 找到一个专门用于操作文件的Writer子类对象。F...
java IO流创建文件并读写
纯白色的大鹦鹉的博客
07-07 970
public static void main(String[] args) throws Exception{ File fileName=new File("/Users/panhao/Downloads/Txt/aaa.txt"); createFile(fileName); writeFile(fileName); readFile(fileNa...
Java API之IO创建文件、文件夹！
lu677521的博客
01-07 5956
1 、File类有三种构造方法： 1）File(File parent,String child) 根据parent抽象路径名和child路径名字符串创建一个File实例。 package com.file; import java.io.File; public class FileCreate { public static void main(String[] args) {
Java实现文件写入——IO流（输入输出流详解）
热门推荐
张博在读
09-09 14万+
输入输出的重要性： &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;输入和输出功能是Java对程序处理数据能力的提高，Java以流的形式处理数据。流是一组有序的数据序列，根据操作的类型，分为输入流和输出流。 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;程序从输入流读取数据，向输出流写入数据。Java是面向对象的程序语言，每一个数据流都是一个对象，它们提供了各种支持“...
IO流简单的创建、读取、写入文件的操作
小四是个程序猿的博客
12-14 4867
IO流简单的创建、读取、写入文件的操作 java的IO是指针对对文件系统、用户输入、输出一系列操作的一套处理类，比如文件读取或者文件保存到磁盘都有Input输入和Output输出，在Java中用流来处理。流的概念和水流一样，有发源地，有目的地，从发源地流向目的地，文件的读取也一样，从磁盘读到内存会产生输入流，从内存保存到磁盘会产生输出流。 这里我只讲一点简单的创建目录，创建文件，读取文件内容，写入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值