Java IO

已于 2022-12-20 15:51:06 修改
阅读量374 收藏 2
点赞数
分类专栏： # Java基础 文章标签： java
于 2022-12-19 17:07:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012965203/article/details/128307906
版权

目录

一、File 类

二、RandomAccessFile

三、流类

四、字节流

4.1 、InputStream

4.2、OutputStream

五、字符流

5.1、Reader 类

5.2、Writer 类

六、管道流

七、ByteArrayInputStream 和 ByteArrayOutputStream

八、System.out  和 System.in

九、打印流

十、DataOutputStream 和 DataInputStream

十一、SequenceInputStream

十二、字节流与字符流的转换

十三、IO 包中的类层次关系图

13.1 字节输入流

13.2 字节输出流

13.3 字符输入流

13.4 字符输出流

十四、字符编码

十五、序列化

        Java 开发中，如果程序需要把数据保存到文件中，就可以使用 I/O 输入输出技术。一般应用程序都需要与外部设备进行数据交换，常见的磁盘、键盘和屏幕等都属于外部设备，在程序中，键盘被用做文件输入，显示器被用做文件输出。Java 语言定义了许多专门负责各种方式的输入输出，这些都被放在 Java.io 包。

一、File 类

        File 类是 IO 包处理文件的代表。通过 File 类能够完成创建、删除文件、重命名文件、判断文件的读写权限以及文件是否存在，设置和查询文件最近修改时间等操作。

        File 方法 （JDK1.8）

方法描述
File(String pathname)只有一个参数的构造方法
File(String parent, String child)两个参数的构造方法
File(File parent, String child)两个参数的重写构造方法
File(URI uri)参数为URI构造方法
String getName()获取名称
String getParent()获取上一级路径
File getParentFile()获得上一级路径 ,返回File对象
String getPath()获取路径
boolean isAbsolute() 判断是否绝对路径
String getAbsolutePath()获取绝对路径
File getAbsoluteFile()获取路径获取绝对路径信息，返回File
String getCanonicalPath() throws IOException返回该抽象路径名的规范路径名字符串
File getCanonicalFile() throws IOException返回该抽象路径名的规范形式,返回File对象
URL toURL() throws MalformedURLException将文件对象转换为URL（统一资源定位符）
public URI toURI()将文件对象转换为URL（统一资源标识符）
boolean canRead()判断是否可读权限
boolean canWrite()判断是否可写权限
boolean exists()判断目录或者文件是否存在        
boolean isDirectory()判断否是一个目录
boolean isFile()判断是否一个文件
boolean isHidden()判断文件或者目录是否隐藏
long lastModified()获取文件或者目录的修改时间
long length()获取文件内容长度
boolean createNewFile() throws IOException创建新文件，已经存在不会再创建
boolean delete()根据路径删除文件或目录，删除目录时，目录有文件，删除失败
void deleteOnExit()请求删除操作（虚拟机正常退出的时候删除操作）
String[] list()获取路径下的文件、目录
String[] list(FilenameFilter filter)根据文件过滤器获取路径下的文件、目录,参数文件过滤器（文件名以 .jar 或者 .zap结尾）
File[] listFiles()根据路径获取文件或者目录，返回为File[]，需要详细信息可以用这个方法
File[] listFiles(FileFilter filter)根据文件过滤器获取路径下的文件、目录。参数是一个文件过滤器。 返回为File[]
boolean mkdir()根据路径创建目录，只能是单级目录
boolean mkdirs()根据路径创建目录(可以多级目录),创建之前会判断文件是否存在，创建成功返回true ,失败返回false
boolean renameTo(File dest)目录或者文件重命名，重命名成功返回true,失败返回false 目录或者文件重命名，重命名成功返回true,失败返回false
boolean setLastModified(long time)设置文件或者目录修改时间
boolean setReadOnly()设置文件或者目录只读
boolean setWritable(boolean writable, boolean ownerOnly)设置是否可以可写 。 第一个参数 true 可写 第二个参数 所属人 ，true拥有者 ，false全部用户
boolean setWritable(boolean writable)设置文件或者目录可写
boolean setReadable(boolean readable, boolean ownerOnly)设置是否可以读 。 第一个参数 true 可读 第二个参数 所属人 ，true拥有者 ，false全部用户
boolean setReadable(boolean readable)设置是否可读
boolean setExecutable(boolean executable, boolean ownerOnly) 设置是否有可执行权限
boolean setExecutable(boolean executable)设置是否有可执行文件以及所属用户（系统支持生效）第一个参数： true 可以执行 false不可以执行，返回值true 设置成功 第二个参数： true拥有者 ，false全部用户
boolean canExecute()判断是否可以执行
static File[] listRoots()列出可用的文件系统根目录
long getTotalSpace()获取分区大小,返回单位字节
void getFreeSpace()                 获取分区可用大小,返回单位字节
long getUsableSpace()获取磁盘用户可使用大小,返回单位字节
static File createTempFile(String prefix, String suffix, File directory)创建临时文件
static File createTempFile(String prefix, String suffix) throws IOException创建临时文件
Path toPath() 把File对象转换Path对象

        示例

import sun.misc.JarFilter;

import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Path;
import java.time.Instant;

public class Main {


    public static void main(String[] args) throws Exception {

        //只有一个参数的构造方法
        //file_1();
        // 两个参数的构造方法
        //file_2();
        // 两个参数的重写构造方法
        //file_3();
        // 参数为URI构造方法
        //file_4();
        //  获取名称
        // getName();
        //获取上一级路径
        //getParent();
        //获得上一级路径 ,返回File对象
        //getParentFile();
        // 获取路径
        //getPath();
        //判断是否绝对路径
        //isAbsolute();
        //获取绝对路径
        //getAbsolutePath();
        //  获取路径获取绝对路径信息，返回File
        //getAbsoluteFile();
        // 返回该抽象路径名的规范路径名字符串
        // getCanonicalPath();
        // 返回该抽象路径名的规范形式,返回File对象
        //getCanonicalFile();
        // 将文件对象转换为URL（统一资源定位符）
        //toURL();
        // 将文件对象转换为URL（统一资源标识符）
        //toURI();
        //判断是否可读权限
        //canRead();
        //判断是否可写权限
        // canWrite();
        //判断目录或者文件是否存在
        //exists();
        //判断否是一个目录
        //isDirectory();
        //判断是否一个文件
        // isFile();
        //判断文件或者目录是否隐藏
        //isHidden();
        //获取文件或者目录的修改时间
        //lastModified();
        //获取文件内容长度
        //length();

        //创建新文件，已经存在不会再创建
        //createNewFile();
        //根据路径删除文件或目录，删除目录时，目录有文件，删除失败
        //delete();
        //请求删除操作（虚拟机正常退出的时候删除操作）
        //deleteOnExit();
        // 获取路径下的文件、目录
        //list();
        // 根据文件过滤器获取路径下的文件、目录,参数文件过滤器（文件名以 .jar 或者 .zap结尾）
        //list1();
        //根据路径获取文件或者目录，返回为File[]，需要详细信息可以用这个方法
        //listFiles();
        // 根据文件过滤器获取路径下的文件、目录。参数是一个文件过滤器。 返回为File[]
        //listFiles1();

        //根据路径创建目录，只能是单级目录
        //mkdir();
        //根据路径创建目录(可以多级目录),创建之前会判断文件是否存在，创建成功返回true ,失败返回false
        //mkdirs();
        // 目录或者文件重命名，重命名成功返回true,失败返回false 目录或者文件重命名，重命名成功返回true,失败返回false
        //renameTo();

        //设置文件或者目录修改时间
        //setLastModified();

        //设置文件或者目录只读
        // setReadOnly();

        // 设置文件或者目录可写
        // setWritable();

        // 设置是否可以读 。 第一个参数 true 可读 第二个参数 所属人 ，true拥有者 ，false全部用户
        //  setWritable1();

        //设置是否有可执行权限
        //setExecutable();

        // 设置是否有可执行文件以及所属用户（系统支持生效）第一个参数： true 可以执行 false不可以执行，返回值true 设置成功 第二个参数： true拥有者 ，false全部用户
        //setExecutable1();
        //判断是否可以执行
        // canExecute();

        //  列出可用的文件系统根目录
        //listRoots();
        //获取分区大小
        //getTotalSpace();

        // 获取分区可用大小
        //getFreeSpace();

        //获取磁盘用户可使用大小,返回单位字节
        //getUsableSpace();
        //创建临时文件
        //createTempFile();

        // 创建临时文件.重新方法
        //createTempFile1();
        //把File对象转换Path对象
        //toPath();

    }

    /**
     * 构造方法
     * 只有一个参数，路径(路径可以是一个文件路径，也可以是一个文件路径)。路径可以相对路径也可以绝对路径
     * File(String pathname)
     */
    static void file_1() {

        File f = new File("E:\\file\\1.txt");
        System.out.println(f); // E:\file\1.txt
    }

    /**
     * 构造方法
     * 第一个参数父路径
     * 第二个参数子路径
     * File(String parent, String child)
     */
    static void file_2() {
        File f1 = new File("E:\\file", "1.txt");
        System.out.println(f1); //E:\file\1.txt
    }

    /**
     * 构造方法
     * 第一个参数 File对象（文件父路径 File）
     * 第二个参数 子路径
     * File(File parent, String child)
     */
    static void file_3() {
        File f3 = new File("E:\\file");
        File f4 = new File(f3, "1.txt");
        System.out.println(f4);// /E:\file\1.txt
    }

    /**
     * 构造方法
     * 参数是URI类
     * File(URI uri)
     */
    static void file_4() {
        File f5 = null;
        try {
            f5 = new File(new URI("file:///E://file/1.txt"));
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
        System.out.println(f5);
    }

    /**
     * 获取名称
     * String getName()
     */
    static void getName() {
        File f = new File("E:\\file/1.txt");
        System.out.println(f.getName());
    }

    /**
     * 获得上一级路径
     * String getParent()
     */
    static void getParent() {
        File f = new File("E:\\file/1/");
        System.out.println(f.getParent());
    }

    /**
     * 获得上一级路径 ,返回File对象
     * File getParentFile()
     */
    static void getParentFile() {
        File f = new File("E:\\file/1/");
        System.out.println(f.getParentFile());
    }

    /**
     * 获取路径
     * String getPath()
     */
    static void getPath() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.getPath());
    }

    /**
     * 判断是否绝对路径
     * boolean isAbsolute()
     */
    static void isAbsolute() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.isAbsolute());
    }

    /**
     * 获取绝对路径
     * String getAbsolutePath()
     */
    static void getAbsolutePath() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.getAbsolutePath());
    }

    /**
     * 获取路径获取绝对路径信息，返回File
     * File getAbsoluteFile()
     */
    static void getAbsoluteFile() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.getAbsoluteFile());
    }


    /**
     * 返回该抽象路径名的规范路径名字符串
     * String getCanonicalPath() throws IOException
     */
    static void getCanonicalPath() {
        File f = new File("E:\\file/a/a.txt");
        try {
            System.out.println(f.getCanonicalPath());
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 返回该抽象路径名的规范形式,返回File对象
     * File getCanonicalFile() throws IOException
     */
    static void getCanonicalFile() {
        File f = new File("E:\\file/a/a.txt");
        try {
            System.out.println(f.getCanonicalFile());
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 将文件对象转换为URL（统一资源定位符）
     * URL toURL()
     */
    static void toURL() {
        File f = new File("E:\\file/a/a.txt");
        URL url = null;
        try {
            url = f.toURL();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
        System.out.println(url);
    }

    /**
     * 将文件对象转换为URI（统一资源标识符）
     */
    static void toURI() {
        File f = new File("E:\\file/a/a.txt");
        URI uri = f.toURI();
        System.out.println(uri);
    }

    /**
     * 判断是否可读权限
     * boolean canRead()
     */

    static void canRead() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.canRead());
    }


    /**
     * 判断是否可写权限
     * boolean canWrite()
     */
    static void canWrite() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.canWrite());
    }

    /**
     * 判断目录或者文件是否存在
     * boolean exists()
     */
    static void exists() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.exists());
    }

    /**
     * boolean isDirectory()
     */
    static void isDirectory() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.isDirectory());
    }

    /**
     * 判断是否一个文件
     * boolean isFile()
     */
    static void isFile() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.isFile());
    }

    /**
     * 判断文件或者目录是否隐藏
     * boolean isHidden()
     */
    static void isHidden() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.isHidden());
    }

    /**
     * 获取文件或者目录的修改时间
     * long lastModified()
     */
    static void lastModified() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.lastModified());
    }

    /**
     * 获取文件内容长度
     * long length()
     */
    static void length() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.length());
    }

    /**
     * 创建新文件，已经存在不会再创建
     * boolean createNewFile() throws IOException
     */
    static void createNewFile() {
        File f = new File("E:\\file/a/a.txt");
        try {
            System.out.println(f.createNewFile());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据路径删除文件或目录，删除目录时，目录有文件，删除失败
     * boolean delete()
     */
    static void delete() {
        File f = new File("E:\\file/a/a.txt");
        System.out.println(f.delete());
    }


    /**
     * 请求删除操作（虚拟机正常退出的时候删除操作）
     * <p>
     * void deleteOnExit()
     */
    static void deleteOnExit() {
        File f = new File("E:\\file/a/a.txt");
        f.deleteOnExit();
    }

    /**
     * 获取路径下的文件、目录
     * String[] list()
     */
    static void list() {
        File f8 = new File("E:\\file");
        String[] list = f8.list();
        if (null != list && list.length > 0) {
            for (int i = 0; i < list.length; i++) {
                System.out.println(list[i]);
            }
        }
    }

    /**
     * 根据文件过滤器获取路径下的文件、目录,参数文件过滤器（文件名以 .jar 或者 .zap结尾）
     * String[] list(FilenameFilter filter)
     */
    static void list1() {
        File f9 = new File("E:\\file");
        FilenameFilter ff = new JarFilter();
        String[] list9 = f9.list(ff);
        if (null != list9 && list9.length > 0) {
            for (int i = 0; i < list9.length; i++) {
                System.out.println(list9[i]);
            }
        }
    }

    /**
     * 根据路径获取文件或者目录，返回为File[]，需要详细信息可以用这个方法
     * File[] listFiles()
     */
    static void listFiles() {
        File f9 = new File("E:\\file");
        File[] list10 = f9.listFiles();
        if (null != list10 && list10.length > 0) {
            for (int i = 0; i < list10.length; i++) {
                System.out.println(list10[i]);
            }
        }
    }

    /**
     * 根据文件过滤器获取路径下的文件、目录。参数是一个文件过滤器。 返回为File[]
     * File[] listFiles(FilenameFilter filter)
     */
    static void listFiles1() {
        FilenameFilter ff = new JarFilter();
        File f9 = new File("E:\\file");
        File[] list11 = f9.listFiles(ff);
        if (null != list11 && list11.length > 0) {
            for (int i = 0; i < list11.length; i++) {
                System.out.println(list11[i]);
            }
        }
    }

    /**
     * 根据路径创建目录，只能是单级目录
     * boolean mkdir()
     */
    static void mkdir() {
        File f11 = new File("E:\\file");
        System.out.println(f11.mkdir());
    }

    /**
     * 根据路径创建目录(可以多级目录),创建之前会判断文件是否存在，创建成功返回true ,失败返回false
     * boolean mkdirs()
     */
    static void mkdirs() {
        File f11 = new File("E:\\file");
        System.out.println(f11.mkdirs());
    }

    /**
     * 目录或者文件重命名，重命名成功返回true,失败返回false
     * boolean renameTo(File dest)
     */
    static void renameTo() {
        File f13 = new File("E:\\file/");
        File f14 = new File("E:\\file1/");
        System.out.println(f13.renameTo(f14));
    }

    /**
     * 设置文件或者目录修改时间
     * boolean setLastModified(long time)
     */
    static void setLastModified() {
        File f15 = new File("E:\\file/");
        Instant i = Instant.now();  // 获取当前时间，i.toEpochMilli()获取当前毫秒值，返回值long
        System.out.println(f15.setLastModified(i.toEpochMilli()));
    }

    /**
     * 设置文件或者目录只读
     * boolean setReadOnly()
     */
    static void setReadOnly() {
        File f15 = new File("E:\\file/");
        System.out.println(f15.setReadOnly());
    }

    /**
     * 设置是否可以写
     * boolean setWritable(boolean writable)
     */
    static void setWritable() {
        File f15 = new File("E:\\file/");
        System.out.println(f15.setWritable(true));
    }

    /**
     * 设置是否可写以及所有者
     * 第一个参数  true 是可以读 false 不可以写
     * 第二个参数 true拥有者 ，false全部用户
     */
    static void setWritable1() {
        File f15 = new File("E:\\file/");
        System.out.println(f15.setWritable(true, true));
    }

    /**
     * 设置是否可以读
     * boolean setReadable(boolean readable)
     */
    static void setReadable() {
        File f15 = new File("E:\\file/");
        System.out.println(f15.setReadable(true));
    }

    /**
     * 设置是否有可执行权限
     * boolean setExecutable(boolean executable)
     */
    static void setExecutable() {
        File f15 = new File("E:\\file/");
        System.out.println(f15.setExecutable(true));
    }

    /**
     * 设置是否有可执行文件以及所属用户（系统支持生效）第一个参数： true 可以执行 false不可以执行，返回值true 设置成功 第二个参数： true拥有者 ，false全部用户
     * boolean setExecutable(boolean executable, boolean ownerOnly)
     */
    static void setExecutable1() {
        File f15 = new File("E:\\file/");
        System.out.println(f15.setExecutable(true, true));
    }

    /**
     * 判断是否可以执行
     * boolean canExecute()
     */
    static void canExecute() {
        File f = new File("E:\\file/");
        System.out.println(f.canExecute());
    }

    /**
     * 列出可用的文件系统根目录
     * static File[] listRoots()
     */
    static void listRoots() {
        File[] fileArr = File.listRoots();
        for (int i = 0; i < fileArr.length; i++) {
            // System.out.println(fileArr[i]);
        }

    }


    /**
     * 获取分区大小,返回单位字节
     * long getTotalSpace()
     */
    static void getTotalSpace() {
        File f = new File("E:\\file/a/a.txt");
        long l = f.getTotalSpace() / 1024 / 1024 / 1024;// 单位G
        System.out.println(l);
    }

    /**
     * 获取分区可用大小,返回单位字节
     * long getFreeSpace()
     */
    static void getFreeSpace() {
        File f = new File("E:\\file/a/a.txt");
        long l = f.getFreeSpace() / 1024 / 1024 / 1024;// 单位G
        System.out.println(l);
    }

    /**
     * long getUsableSpace()
     * 获取磁盘用户可使用大小,返回单位字节
     */
    static void getUsableSpace() {
        File f = new File("E:\\file/a/a.txt");
        long l = f.getUsableSpace() / 1024 / 1024 / 1024;// 单位G
        System.out.println(l);
    }

    /**
     * 创建临时文件
     * static File createTempFile(String prefix, String suffix)
     * 第一个参数：文件前缀
     * 第二个参数：文件后缀，null的话值为 .tmp
     */
    static void createTempFile() {
        try {
            File f = File.createTempFile("zzq", null);
            System.out.println(f);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 创建临时文件
     * 第一个参数：文件前缀
     * 第二个参数：文件后缀，null的话值为 .tmp
     * 第三个参数：文件对象，可以理解为临时文件生成的目录
     */
    static void createTempFile1() {
        try {
            File ff = new File("E:\\file");
            File f = File.createTempFile("zzq", null, ff);
            System.out.println(f);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 把File对象转换Path对象
     * Path toPath()
     */
    static void toPath() {
        File f = new File("E:\\file");
        Path path = f.toPath();
        System.out.println(path);
    }


}

二、RandomAccessFile

        RandomAccessFile 类是 Java 语言中功能丰富的文件访问类。提供了许多文件方法的方法。RandomAccessFile 类支持 “随机访问” 方式，可以跳到文件的任意位置读取和写数据。在访问一个文件的时候，不想把文件从头到尾读取，而是希望像访问一个数据库一样方法一个文本文件，可以使用 RandomAccessFile 类就是比较好的选择。

        示例

import java.io.RandomAccessFile;

public class Main {


    public static void main(String[] args) throws Exception {

        /**
         * E://file/1.txt 内容为 12t
         */
        RandomAccessFile  r = new RandomAccessFile("E://file/1.txt","rw");
        r.skipBytes(2); // 跳过2个字节
        System.out.println( r.readLine()); // t

    }


}

三、流类

        Java 的流建立在 4 个抽象类的基础上：InputStream、OutputStream、Reade 和 Writer。

        其中 InputStream、OutputStream 称为字节流。Reade 和 Writer 称为字符流。

        字节流和字符流形参分离的层次结构，处理字符或者字符串使用字符流，处理字节或者二进制对象使用字节流。

        一般操作文件流时，不管字节流还是字符流都是可以安装以下方式进行。

        1、使用 File 类找到一个文件。

        2、通过 File 类对象去实例化字节流或者字符流的子类。

        3、进行字节流或者字符流的读取操作。

        4、关闭流文件。

四、字节流

        字节流为处理字节输入与输出提供了丰富的环境。一个字节流可以和其他任何类型的对象并用，包括二进制数据。

4.1 、InputStream

        InputStream 称为字节输入流，该类的所有方法在出错的都会引发一个 IOException 异常。

        InputStream 扩展方法：

方法描述
int read() throws IOException如果下一个字节可读取则返回一个整型，没有可读返回-1
int read(byte b[]) throws IOException试图读取到内容到 buffer 中，并返回读取的字节数，没有可读返回-1
int read(byte b[], int off, int len) throws IOException试图读从off开始，长度为 len 的内容到 buffer 中，并返回读取的字节数，没有可读返回-1
skip(long n) throws IOException忽略n个输入字节，并且返回忽略的字节数
int available() throws IOException返回当前可读的输入字节数
void mark(int readlimit)在输入流当前放置一个标识
void reset() throws IOException重新设置输入指针到先前设置的标志处
boolean markSupported()判断是否支持mark()/reset() ，支持返回true

        示例

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class Main {

    public static void main(String[] args) throws Exception {
        InputStream input = null;
        try {
            input = new FileInputStream("E:\\file/1.txt");
             定义1024个字节大小的缓冲区
            byte[] b = new byte[1024];
            int n;
            while ((n = input.read(b)) != -1) { // 读取到缓冲区
                System.out.println(new String(b, 0, n));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != input) {
                try {
                    input.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }

}

4.2、OutputStream

        OutputStream称为字节输出流。该类的所有方法在出错的情况下会引发一个 IOException 异常。

       OutputStream 扩展方法：

方法描述
void write(int b) throws IOException向输出流写入单个字节
void write(byte b[]) throws IOException向输出流写一个完整的字节数组
void write(byte b[], int off, int len) throws IOException向输出流写入以 off 开始 长度为 len 的 字节b数组内容

        示例

import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {
        OutputStream  out = null;
        try {
            out = new FileOutputStream("E:\\file/1.txt",true);
            //把字符串转成字节数组
            byte[] b = "Hello world".getBytes();
            // 将 byte 数组写到文件中
            out.write(b);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != out) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }

}

五、字符流

        当需要直接处理字符串等就可以使用字符流处理。

5.1、Reader 类

        Reader 是字符流的输入抽象类，该类的所有方法在出错的情况下会引发一个 IOException 异常。

        Reader 常用方法：

方法描述
int read() throws IOException如果调用的输入流下一个字符可读则返回一个整型，没有可读返回-1
int read(char cbuf[]) throws IOException读取 cbuf字符数组中的字符并且返回字符数，没有可读返回-1
int read(char cbuf[], int off, int len) throws IOException读取 以off开始并且长度为len的cbuf字符数组中的字符并且返回字符数，没有可读返回-1
long skip(long n) throws IOException跳过n个输入字符，并且返回跳过的字符设置输入指针到先前设立的标志处
boolean ready() throws IOException如果下一个输入请求不等待返回true,否则返回false
boolean markSupported()判断流是否支持mark()/reset()，支持返回true,否则返回false
void mark(int readAheadLimit) throws IOException在输入流当前设置一个标志
void reset() throws IOException
 		重新设置输入指针到先前设置的标志处

        示例

import java.io.FileReader;
import java.io.Reader;

public class Main {

    public static void main(String[] args) throws Exception {
        Reader r = new FileReader("E:\\file/1.txt");
        char[] c = new char[1024];
        int i = 0;
        try {
            i = r.read(c);
           String s= new String(c,0,i );
            System.out.println(s);
        }catch (Exception e){

        }
    }

}

5.2、Writer 类

        Writer 是字符流的输出抽象类。该类的所有方法在出错的情况下会引发一个 IOException 异常

        Writer 常用方法：

方法描述
void write(int c) throws IOException 向字符输入流写入c个字符
void write(char cbuf[]) throws IOException向字符输入流写入cbuf字符数组内容
void write(char cbuf[], int off, int len) throws IOException向调用的输出流写入数组cbuf , 以 off开始 长度为len的内容
void write(String str) throws IOException向调用输出流写str内容
void write(String str, int off, int len) throws IOException向调用输出流写str内容，以off开始，长度为len的内容

        示例

import java.io.FileWriter;
import java.io.Writer;

public class Main {

    public static void main(String[] args) throws Exception {
       ;
      try( Writer w = new FileWriter("E:\\file/1.txt",true)){
          w.write("Hello World");
      }
    }

}

六、管道流

        管道流用于连接两个线程间的通信。管道流也分为字节流（PipedInputStream、PipedOutputStream）与字符流（PipedReader、PipedWriter）两种类型。

        例如，一个生产线程与一个消费线程就可以通过管道流通信。

        示例

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {

        Producer p = new Producer();
        Consumer c = new Consumer();

        PipedOutputStream out = p.getInstance();
        PipedInputStream input = c.getInstance();

        out.connect(input);  // 输入与输出流连接管道

        p.start(); // 启动生产者线程
        c.start(); // 启动消费者线程



    }
}

// 生产者
class Producer extends Thread{

    private PipedOutputStream out = new PipedOutputStream();

    public  PipedOutputStream getInstance(){
        return  out;
    }

    @Override
    public void run() {
        String str = new String ("Producer说:消费者你好！");
        try {
            // 写入内容
            out.write(str.getBytes());
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                // 关闭资源
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}


// 消费者
class Consumer extends Thread{

    private PipedInputStream input = new PipedInputStream();

    public  PipedInputStream getInstance(){
        return  input;
    }

    @Override
    public void run() {
        String s = null;
        byte[] byteArr = new byte[1024];

        int len = 0;
        try {
            len = input.read(byteArr);
            s = new String(byteArr,0,len);
            System.out.println("Consumer收到信息----->:"+s);
        } catch (IOException e) {
            e.printStackTrace();
        }


    }
}

七、ByteArrayInputStream 和 ByteArrayOutputStream

        ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含流中读取字节。简单点来说，内部缓冲区就是一个字节数组，而 ByteArrayInputStream 本质就是一个通过字节数组来实现的。

        ByteArrayOutputStream 中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。

        示例


import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {

       byte[] byteArr = "Hello World".getBytes(); // 把字符串转内存块

       ByteArrayInputStream input = new ByteArrayInputStream(byteArr);

       ByteArrayOutputStream out = new ByteArrayOutputStream();

       transfrom(input,out);

       byte[] outResult = out.toByteArray();

       System.out.println(new String(outResult));

    }




    public static void transfrom(ByteArrayInputStream input,ByteArrayOutputStream out){
        int c = 0;
        try {

            while ( (c =input.read()) != -1){
                int C = (int)Character.toUpperCase((char)c);
                out.write(C);

            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }


}

八、System.out  和 System.in

        Java 定义了两个特殊的流对象：System.out 和 System.in 。System.in 对应键盘，属于 InputStream 类型，程序可以使用 System.in 可以读取键盘上输入的数据。

        System.out 属性 PrintStream 类型，PrintStream 是 OutputStream 的一个子类，程序使用

System.out 可以将数据输出到显示器上或者控制台。

        示例


import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {


        while (true) {
            int c = System.in.read();// 键盘输入
            System.out.print( Character.toUpperCase((char)c) +"\t"); // 控制台输出
        }

    }


}

九、打印流

        PrintStream 类提供了一系列的 print 和 println方法，可以实现将基本数据类型的格式转换成字符串输出。程序中大量用到 "System.out.println" 语句中的 “System.out” 就是PrintStream 类的一个实例对象。

        实例：向控制台输出 "Hello World" 字符串。

        示例

import java.io.PrintWriter;

public class Main {

    public static void main(String[] args) throws Exception {

        PrintWriter out = null;
        // 通过System.out 对 PrintWriter 实例化
        out = new PrintWriter(System.out);

        out.print("Hello World");

        out.close();

    }

}

        示例：向文件写入 "Hello World" 内容 。

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

public class Main {

    public static void main(String[] args) throws Exception {

        PrintWriter out = null;
        // 通过System.out 对 PrintWriter 实例化
        out = new PrintWriter(System.out);
        File f  = new File("E:\\file/1.txt");
        out = new PrintWriter(new FileWriter(f));
        out.write("Hello World");
        out.close();

    }

}

十、DataOutputStream 和 DataInputStream

        当需要对数据做一定格式的时候，可以使用DataOutputStream 和 DataInputStream 处理。

        示例

import java.io.*;

public class Main {


    /**
     *
     * 订单信息： 产品名称：鞋子,	数量：10, 	价格：18.99
     * 订单信息： 产品名称：袜子,	数量：10, 	价格：9.22
     * 订单信息： 产品名称：杯子,	数量：20, 	价格：14.22
     * 订单信息： 产品名称：衣服,	数量：39, 	价格：5.22
     * 订单信息： 产品名称：裤子,	数量：40, 	价格：4.21
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        write();
        read();

    }

    public static void write() throws Exception {
        DataOutputStream out = new DataOutputStream(new FileOutputStream("E:\\file/1.txt"));
        // 价格
        double[] prices = {18.99,9.22,14.22,5.22,4.21};

        // 数目
        int[] units = {10,10,20,39,40};

        // 产品名称
        String[] descs = {"鞋子","袜子","杯子","衣服","裤子"};

        for(int i=0; i<prices.length;i++ ){

            // 价格写入
            out.writeDouble(prices[i]);
            out.writeChar('\t');
            // 写入数目
            out.writeInt(units[i]);
            out.writeChar('\t');

            // 写入产品
            out.writeChars(descs[i]);
            out.writeChar('\n');
        }

        out.close();
    }

    public static void read() throws Exception {
        DataInputStream input = new DataInputStream(new FileInputStream("E:\\file/1.txt"));

        double price;
        int unit;
        StringBuffer desc;
        double total = 0.0;
        try {
            while (input.available() != 0){
                // 读书价格
                price = input.readDouble();
                // 跳过tab
                input.readChar();

                // 读出数目
                unit = input.readInt();
                // 跳过tab
                input.readChar();


                char chr;
                // 读出产品
                desc = new StringBuffer();
                while((chr = input.readChar()) != '\n'){
                    desc.append(chr);
                }

                System.out.println("订单信息："+" 产品名称："+desc+",\t数量："+unit+", \t价格："+price);
                total = total +unit * price;

            }

        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("中共需要："+total+"元");
        input.close();

    }

}

十一、SequenceInputStream

        SequenceInputStream 可以实现两个文件合并操作。

        示例：

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

public class Main {

    public static void main(String[] args) throws Exception {

        // 声明两个文件读取流
        FileInputStream input1 = null ,input2 = null;

        // 声明一个合并流
        SequenceInputStream s = null;

        FileOutputStream out = null;

        try {

            // 构造两个被读入文件的文件
            File inputF1 = new File("E:\\file/1.txt");
            File inputF2 = new File("E:\\file/2.txt");

            // 构造一个输出文件
            File outF3 = new File("E:\\file/3.txt");

            input1 =  new FileInputStream(inputF1);
            input2 =  new FileInputStream(inputF2);

            // 将两个输入流合并一个输入流
            s = new SequenceInputStream(input1,input2);

            out = new FileOutputStream(outF3);

            int c;
            while ((c=s.read() )!= -1){
                out.write(c);
            }

        }catch (Exception e){

        }finally {
            input1.close();
            input2.close();
            s.close();
            out.close();
        }

    }
}

十二、字节流与字符流的转换

        Java 支持字节流和字符流，但有时需要在字节流和字符流之间转换。InputStreamReader 和 
OutputStreamWriter ，这两个类是字节流和字符流之间转换的类。

        示例

import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {

        /**
         * 字节流  System.in
         * 转换流  InputStreamReader
         * 字符缓存流  BufferedReader
         */
        BufferedReader readerBuf = new BufferedReader(new InputStreamReader(System.in));


        BufferedWriter writeBuf = new BufferedWriter(new OutputStreamWriter(System.out));

        String str = null;
        while (true) {
            System.out.print("\n请输入内容：");
            str = readerBuf.readLine();
            System.out.print("\n显示内容：");
            writeBuf.write(str);
            writeBuf.flush();
        }


    }
}

十三、IO 包中的类层次关系图

13.1 字节输入流

         InputStream类

13.2 字节输出流

        OutputStream类

13.3 字符输入流

        Reader 类

13.4 字符输出流

        Writer类

        

十四、字符编码

        对于我们使用的计算机而言，只能认识数字，计算机软件里一切都是用数字来表示。

        最开始计算机在美国使用，当时所用到的字符也就是在键盘上的一些字符和少数几个特殊的字符，每一个字符都用一个数字表示，一个字节所能表示的数字范围足以容纳所有字符，实际上表示这些字符的数字的字节最高位（bit）都为 0 ，也就是说这些数字都在 0 到 127 之间，例如字符 a 对应数字 97，b 对应数字98 等，这种字符与数字对应的编码固定下来后，这套编码规则称为 ASCII码（美国标准信息交换码）。

        随着计算机在其他国家的逐渐应用与普及，许多国家都把本地的字符集引入了计算机，这大大扩展了计算机中字符的范围。一个字符所能表示的数字范围不能容纳所有的中文汉字的。中国将每一个中文字符都是用两个中文字符的数字来表示,原有的 ASCII 码 字符的编码保持不变，仍用一个字节表示。为了将一个中文字符与两个 ASCII 码字符区别，中文字符的每个字节的最高位（bit）都是 1，中国大陆为每一个中文字符都指定了一个对应的数字，并作为标准的编码固定了下来，这套编码则称 GBK(国标码) 后面在GBK基础上做了些中文字符（包括繁体）进行了编码，并且命名了GBK2312 。换句话说 GBK 是 GBK2312 的子集。使用中文的国家和地区有很多，同样一个字符例如 “中国” 的 “中” 在中国大陆的编码是十六进制的 D6D0,而台湾地区的编码规则是十六进制的 A4A4 ，台湾地区规则称 BIG5(大五码)。

        在一个国家的本地化系统中出现一个字符，到另外一个国家本地化系统中，看不到原始字符，而是乱码。

        为了解决各个国家和地区使用各自不同本地化编码带来的不便，人们将全世界所有的编码进行了统一，称之为 Unicode 编码。

        示例

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class Main {

    public static void main(String[] args) throws Exception {

      // byte[] b = "你好，Java".getBytes("ISO-8859-1"); // 乱码
       byte[] b = "你好，Java".getBytes();
       OutputStream out = new FileOutputStream(new File("E:\\file/1.txt"));

        out.write(b);
        out.close();

        /**
         * file.encoding=UTF-8
         */
        System.getProperties().list(System.out);



    }



}

十五、序列化

        是指将对象转换成二进制数据流的一种实现。通过序列化，可以很方便实现对象的传输与保存。

import java.io.*;

public class Main {

    public static void main(String[] args) throws Exception {
        File file = new File("E:\\file/1.txt") ;
        serialize(file);
        desSerialize(file);

    }

    /**
     * 序列化对象
     * @param f
     * @throws Exception
     */
    public static void serialize(File f)  throws Exception {
        OutputStream outFile = new FileOutputStream(f) ;
        ObjectOutputStream oos = new ObjectOutputStream(outFile);
        Person p = new Person("张三",22);
        oos.writeObject(p);
        oos.close();
    }

    /**
     * 反序列化
     * @param f
     * @throws Exception
     */
    public static void desSerialize(File f)  throws Exception {
        InputStream inputFile = new FileInputStream(f) ;
        ObjectInputStream ois = new ObjectInputStream(inputFile);
        Person p = (Person)ois.readObject();
        System.out.println(p.toString());
    }



}

class Person implements Serializable{
    private Integer age;
    private String name;

    public Person(String name,Integer age) {
        this.name = name;
        this.age = age;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

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

2014Team
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaIO概述
Freer_von的博客
05-10 2703
一、Java IO(输入输出)介绍： 1、概念： IO是Input（输入）和Output（输出）的首字母缩写。 I（输入Input）：指向Java程序中输入数据，即Java程序从外部获取数据。 O（输出Output）：指的是Java程序向外部输出数据，即Java程序向外部发送数据。 流：在Java程序和外部之间，数据像水流一样按照顺序传输。Java中，流有两种形式，字节流和字符流，下文会讲解。 外部（也就是数据源）包括：源设备 和 目标设备。 源设备：Java程序使用Input（输入）获取数据的来源。 目标
java io ioexception,java.io.IOException
weixin_35351343的博客
03-19 5558
catch(java.io.IOException e){ECLIPSE下LWUIT问题啊？？java.lang.ClassNotFoundException'>java.lang.ClassNotFoundException:prj3_2/CopyOfHelloMidletatcom.sun.midp.midlet.MIDletState.createMIDlet(+29)atcom.su...
Java IO流的种类
程序员
02-20 3173
Java IO流的种类
java IO流之BufferedReader和BufferedWriter
学习笔记，相关教程 分享
04-03 6215
笑霸能看懂的学习笔记
java IO流
热门推荐
D大调奏鸣曲_第七序章_de博客
11-11 8万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
import java.io 是什么意思_Java IO 详解
weixin_34304274的博客
02-17 1万+
Java IO 详解初学java，一直搞不懂java里面的io关系，在网上找了很多大多都是给个结构图草草描述也看的不是很懂。而且没有结合到java7 的最新技术，所以自己来整理一下，有错的话请指正，也希望大家提出宝贵意见。首先看个图：(如果你也是初学者，我相信你看了真个人都不好了，想想java设计者真是煞费苦心啊！)这是java io 比较基本的一些处理流，除此之外我们还会提到一些比较深入的基于i...
Java IO用法详解
KeepLearning的博客
03-19 1万+
一、java io 概述1.1 相关概念Java IOJava IO即Java 输入输出系统。不管我们编写何种应用，都难免和各种输入输出相关的媒介打交道，其实和媒介进行IO的过程是十分复杂的，这要考虑的因素特别多，比如我们要考虑和哪种媒介进行IO（文件、控制台、网络），我们还要考虑具体和它们的通信方式（顺序、随机、二进制、按字符、按字、按行等等）。Java类库的设计者通过设计大量的类来攻克这些难题...
Java IO流
菜鸡的博客
09-25 1万+
1、File类的使用 java.io.File类：文件和文件目录路径的抽象表示形式，与平台无关 File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。 想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。 File对象可以作为参数传递给流的构造器 1.1、常用构造器 public File(String pathname) 以path
java IO流传输图片
不言尘世
09-25 9269
本次传输是基于TCP协议进行传输，其实传输图片的写法和传输文件的写法是差不多的 客户端： package com.day1; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.FileInputStream; import java.io.IOException; imp...
JavaIO总结
05-08
有关Java输入输出流的总结有关Java输入输出流的总结有关Java输入输出流的总结
java IO流精讲
01-29
IO 简介，只看这篇，IO全部搞定，对于初学者来说，不可多得
JAVA IO-NIO 详解
04-24
在Java中，IO（输入/输出）是程序与外部世界进行交互的重要桥梁，而NIO（非阻塞IO）则是Java IO的一个重要扩展，它提供了更为高效、灵活的数据处理方式。 传统的Java IO是阻塞式的，即当程序进行读写操作时，如果...
java IO流详细笔记
07-12
Java IO流详解
java io 2nd
05-06
java i/o putting i/o to work 2nd edition elliotte rusty harold
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 350
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 503
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 575
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 623
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
java io 基础
07-28
Java IO（Input/Output）是Java编程语言中用于处理输入和输出的基础库。它提供了一种方便的方式来读取和写入数据，从而与外部世界进行交互。 Java IO库包含多个类和接口，用于在不同的场景下处理输入和输出。这些类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

2014Team

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

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

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

打赏作者

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

抵扣说明：

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

余额充值