JavaIo

程序员文章站 2022-06-13 21:20:47

...

1、流的概念和作用

1.1 流的概念
Java中将输入输出抽象称为流，就好像水管，将两个容器连接起来。流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流.

1.2 流的作用
为数据源和目的地建立一个输送通道。

2、Io流的体系及分类

JavaIo
1、File（文件特征与管理）：用于文件或者目录的描述信息，例如生成新目录，修改文件名，删除文件，判断文件所在路径等。
2、InputStream（二进制格式操作）：抽象类，基于字节的输入操作，是所有输入流的父类。定义了所有输入流都具有的共同特征。
3、OutputStream（二进制格式操作）：抽象类。基于字节的输出操作。是所有输出流的父类。定义了所有输出流都具有的共同特征。
4、Reader（文件格式操作）：抽象类，基于字符的输入操作。
5、Writer（文件格式操作）：抽象类，基于字符的输出操作。
6、RandomAccessFile（随机文件操作）：一个独立的类，直接继承至Object.它的功能丰富，可以从文件的任意位置进行存取（输入输出）操作。

字符流和字节流

1、字节流：数据流中最小的数据单元是字节
2、字符流：数据流中最小的数据单元是字符， Java中的字符是Unicode编码，一个字符占用两个字节。
输入流和输出流
1、输入流：程序从输入流读取数据源。数据源包括外界(键盘、文件、网络…)，即是将数据源读入到程序的通信通道(文件—>程序)
2、输出流：程序向输出流写入数据。将程序中的数据输出到外界（显示器、打印机、文件、网络…）的通信通道（程序—>文件）。

3、流的使用

1.1、File类

基本方法的使用

public static void FiletestDemo() {
        System.out.println(File.separator);  //名称分隔符 \(windows)  /(linux 等)
        System.out.println(File.pathSeparator);  //  路径分隔符  ;
 
        //相对路径构建的两种方式
        System.out.println("相对路径！！！！！！！！");
        String path = "E:\\BaiduNetdiskDownload";
        String name = "a.txt";
        //第一种方式：
        File file = new File(path, name);
        //第二种方式
        File file1 = new File(new File(path), name);
 
        //绝对路径的构建方式
        File file2 = new File("E:\\BaiduNetdiskDownload\\a.txt");
    }

遍历文件

/**
 * 递归遍历文件
 */
public static void printName(File src) {
    if (null == src || !src.exists()) {
        return;
    }
    System.out.println(src.getAbsolutePath());
    if (src.isDirectory()) { //文件夹
        for (File sub : src.listFiles()) {
            printName(sub);
        }
 
    }
}

1.2、字节流 (可以处理一切文本，视频，音频等)
输入流：InputStream FileInputStream ByteInputStream

输出流：OutputStream FileOutputStream ByteOutputStream

/**
 * 字节输入流
 */
public class FileStreamDemo {
 
    public static void main(String[] args) throws IOException {
        FileUtil.copyDir(new File("D:\\a"), new File("D:/d"));
    }
 
    /**
     * 读取文件
     */
    public static void readFile(File file) throws IOException {
        InputStream is = new FileInputStream(file);
        byte[] bytes = new byte[1024];
        int len = 0;
        StringBuffer sb = new StringBuffer();
        while (-1 != (len = is.read(bytes))) {
            String str = new String(bytes, 0, len);
            sb.append(str);
        }
        System.out.println(sb.toString());
 
    }
 
    /**
     * 向文件中写入内容
     */
    public static void writeFile(File file) throws IOException {
        OutputStream os = new FileOutputStream(file, true);
        String str = "你好的ad额的的！！！！！！！！！";
        byte[] bytes = str.getBytes();
        os.write(bytes, 0, bytes.length);
        os.close();
    }
 
    /**
     * 源文件
     * 目标文件
     * 拷贝文件
     */
    public static void copyFile(File srcFile, File descFile) {
        try {
            if (srcFile.isFile()) {
                InputStream is = new FileInputStream(srcFile);
                OutputStream os = new FileOutputStream(descFile, true);
                byte[] bytes = new byte[1024];
                int len = 0;
                while (-1 != (len = is.read(bytes))) {
                    os.write(bytes, 0, len);
                }
                os.flush();
                os.close();
                is.close();
            } else {
                throw new RuntimeException("不是文件呢");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }
}

工具类

public class FileUtil {
 
    /**
     * 拷贝文件夹
     * 如果是文件就直接拷贝文件
     * 如果是文件夹就先创建文件夹
     * @param srcFile
     * @param descFile
     */
    public static void copyDir(File srcFile,File descFile){
         if (srcFile.isFile()){
             copyFile(srcFile,descFile);
         }else if (srcFile.isDirectory()){
             descFile.mkdir();
             for (File sub:srcFile.listFiles()){
                 copyDir(sub,new File(descFile,sub.getName()));
             }
         }
    }
 
 
    /**
     * 拷贝文件
     *
     * @param src
     * @param desc
     */
    public static void copyFile(String src, String desc) {
        copyFile(new File(src), new File(desc));
    }
 
    /**
     * 拷贝文件
     *
     * @param srcFile  源文件
     * @param descFile 目标文件
     */
    public static void copyFile(File srcFile, File descFile) {
 
        try {
            if (srcFile.isFile()) {
                InputStream is = new FileInputStream(srcFile);
                OutputStream os = new FileOutputStream(descFile);
                byte[] bytes = new byte[1024];
                int len = 0;
                while (-1 != (len = is.read(bytes))) {
                    os.write(bytes, 0, len);
                }
 
                os.flush();
                os.close();
                is.close();
            }
 
 
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }
}

/** *ByteInputStream ByteOutStream  */
public class otherByteArraysDemo {
    public static void main(String[] args) throws IOException {
        //readArrays(writeArrays());
        byte[] bytes = toFileByteArray(new File("D:\\a\\dsfs\\a.txt"));
        toArrayFile(bytes, "D:\\a\\dsfs\\b.txt");
    }
 
    public static byte[] writeArrays() throws IOException {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        String str = "你是一个好人";
        byte[] bytes = str.getBytes();
        byteArrayOutputStream.write(bytes, 0, bytes.length);
        byte[] re = byteArrayOutputStream.toByteArray();
        byteArrayOutputStream.close();
        return re;
    }
 
    public static void readArrays(byte[] src) throws IOException {
        InputStream is = new BufferedInputStream(new ByteArrayInputStream(src));
        byte[] bytes = new byte[1024];
        int len = 0;
        String strArray = null;
        while (-1 != (len = is.read(bytes))) {
            strArray = new String(bytes, 0, len);
        }
        System.out.println(strArray.toString());
        is.close();
    }
 
    /**
     * 1、文件 -->>>程序->字节数组
     * 以程序为中心 出去就是输出流 ，流入就是输入流
     * 涉及到文件输入流 --->>字节数组输出流
     */
    public static byte[] toFileByteArray(File src) throws IOException {
        InputStream is = new BufferedInputStream(new FileInputStream(src));
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] desc = null;
        byte[] bytes = new byte[1024];
        int len = 0;
        while (-1 != (len = is.read(bytes))) {
            bos.write(bytes, 0, len);
        }
        bos.flush();
        desc = bos.toByteArray();
        is.close();
        bos.close();
        return desc;
 
    }
 
    /**
     * 2、字节数组  --程序->文件
     * 字节数组输入流
     * 文件输出流
     */
    public static void toArrayFile(byte[] src, String destPath) throws IOException {
        InputStream bis = new BufferedInputStream(new ByteArrayInputStream(src));
        OutputStream fs = new BufferedOutputStream(new FileOutputStream(destPath));
        byte[] bytes = new byte[1024];
        int len = 0;
        while (-1 != (len = bis.read(bytes))) {
            fs.write(bytes, 0, len);
        }
        fs.flush();
        fs.close();
        bis.close();
 
    }
}

1.3、字符流（只能处理文本）
字符输入流：Reader　FileReader

字符输出流：Writer FileWriter

/**
 * 字符流，只能处理纯文本
 */
public class ReadWriteDemo {
    /**
     * 读文件
     * @param file
     */
    public static void readerFile(File file) {
        try {
            Reader reader = new FileReader(file);
            char[] chars = new char[1024];
            int len = 0;
            StringBuffer sb = new StringBuffer();
            while (-1 != (len = reader.read(chars))) {
                String str = new String(chars, 0, len);
                sb.append(str);
            }
            System.out.println(sb.toString());
            reader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void writeFile(File file) {
        try {
            Writer writer = new FileWriter(file);
            String str = "aaa@qq.com@@@@";
            writer.write(str);
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
    }
 
    /**
     * 拷贝文件
     * @param src  源文件
     * @param desc 目标文件
     */
    public static void copyFile(File src, File desc) throws IOException {
        try {
            Reader reader = new FileReader(src);
            Writer writer = new FileWriter(desc);
            char[] chars = new char[1024];
            int len = 0;
            while (-1 != (len = reader.read(chars))) {
                String str = new String(chars, 0, len);
                writer.write(str);
            }
            writer.flush();
            writer.close();
            reader.read();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
 
    }
}

1.4、处理流（提高性能增强功能）

解码和编码

/**
 * 编码和解码    *     
 */
public class bMDemo {
    public static void main(String[] args) throws Exception {
        //编码 字符窜----->>字节
        String str = new String("你哈的");
        byte[] bytes = new byte[0];
        try {
            bytes = str.getBytes("GBK");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        System.out.println(Arrays.toString(bytes));
 
        //解码   字节---->>字符
        String strjm = null;
        try {
            strjm = new String(bytes, "GBK");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        System.out.println(strjm);
 
 
    }

转换流（字节流---->字符流）：编码和解码

输入流：InputStreamReader 解码

输入流：OutputStreamWriter 编码

/**
 * 字节流转换成字符流
 */
public class ZhStreamDemo {
 
    public static void main(String[] args) throws IOException {
        BufferedReader bf=null;
        BufferedWriter bw=null;
        try {
            bf=new BufferedReader(new InputStreamReader(new BufferedInputStream(new FileInputStream(new File("D:\\a\\dsfs\\a.txt")))));
            bw=new BufferedWriter(new OutputStreamWriter(new  BufferedOutputStream(new FileOutputStream(new File("D:\\a\\a.txt")))));
            String str=null;
            while (null!=(str=bf.readLine())){
                bw.write(str);
            }
 
            bw.flush();
            bf.close();
            bw.close();
 
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

缓存流：提高性能，代码见上面

输入流：BufferedInputStream（字节） BufferedReader（字符）

输出流： BufferedOutputStream（字节）　BufferedWriter （字符）

处理基本数据类型流：DataInputStream DataOutputStream

/**
 * 处理流 基本数据类型+字符窜
 */
public class dataStreamDemo {
 
    /**
     * 从文件读取数据+类型
     */
    public static void read(String destPath) throws IOException {
        //创建源
        File src = new File(destPath);
        //选择流
        DataInputStream dis = new DataInputStream(
                new BufferedInputStream(
                        new FileInputStream(src)
                )
        );
 
        //操作 读取的顺序与写出一致   必须存在才能读取
        //不一致，数据存在问题
        long num2 = dis.readLong();
        double num1 = dis.readDouble();
        String str = dis.readUTF();
 
        dis.close();
        System.out.println(num2 + "-->" + str);
 
    }
 
    /**
     * 数据+类型输出到文件
     */
    public static void write(String destPath) throws IOException {
        double point = 2.5;
        long num = 100L;
        String str = "数据类型";
 
        //创建源
        File dest = new File(destPath);
        //选择流  DataOutputStream
        DataOutputStream dos = new DataOutputStream(
                new BufferedOutputStream(
                        new FileOutputStream(dest)
                )
        );
        //操作 写出的顺序 为读取准备
        dos.writeDouble(point);
        dos.writeLong(num);
        dos.writeUTF(str);
        dos.flush();
 
        //释放资源
        dos.close();
 
 
    }
}

处理引用类型流：　ObjectInputStream ObjectOutStream

public class User implements Serializable {
    private transient String username;
    private String password;
 
    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }
 
    public String getUsername() {
        return username;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password) {
        this.password = password;
    }
}

/**
 * 序列化和反序列化流
 * 处理引用类型的数据
 */
public class objectStreamDemo {
 
    public static void main(String[] args) throws IOException, ClassNotFoundException {
 
        serial("D:\\a\\dsfs\\a.txt");
        fserial("D:\\a\\dsfs\\a.txt");
    }
 
    /**
     * 反序列化（文件--->程序）
     *
     * @param src
     */
    public static void fserial(String src) throws IOException, ClassNotFoundException {
        ObjectInputStream os = new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File(src))));
        Object o = os.readObject();
        if (o instanceof User) {
            User user = (User) o;
            System.out.println(user.getUsername());
            System.out.println(user.getPassword());
        }
        closeDemo.closaAll(os);
 
    }
 
    /**
     * 序列化(程序--->文件)
     */
    public static void serial(String destPath) throws IOException {
        User user = new User("asd", "123");
        ObjectOutputStream os = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(new File(destPath))));
        os.writeObject(user);
        closeDemo.closaAll(os);
    }
}

关闭流的方法

/**
 * 关闭流的公共调用
 */
public class closeDemo {
 
    public static void closaAll(Closeable... io) {
        for (Closeable temp : io) {
            try {
                if (temp != null) {
                    temp.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    public static <T extends Closeable> void closeAll(T... io) {
        for (Closeable temp : io) {
            try {
                if (null != temp) {
                    temp.close();
                }
            } catch (Exception e) {
            }
        }
    }
}

以下的方法使用新增方法不能发生多态

ByteArrayOutputStream toByteArray()

BufferedReader readerLine()

BufferedWriter newLine();

DataInputStream DataOutputStream

ObjectInputStream ObjectOutputStream

每天进步一丢丢
完成。

相关标签： Java基础篇抽象类 java stream 大数据 python

下一篇： QCustomPlot之光标划过曲线显示点的坐标

JavaIo

1、流的概念和作用

2、Io流的体系及分类

3、流的使用

[十三]JavaIO之PushBackInputStream

[十]JavaIO之FilterInputStream FilterOutputStream

JavaIO流总结

[十]JavaIO之FilterInputStream FilterOutputStream

[十三]JavaIO之PushBackInputStream

[五] JavaIO之InputStream OutputStream简介方法列表说明

[二] JavaIO之File详解以及FileSystem WinNTFileSystem简介

JavaIO流基本操作

【JavaIO流】JavaIO流基础知识

javaIO流(一)

JavaIo

1、流的概念和作用

2、Io流的体系及分类

3、流的使用

[十三]JavaIO之PushBackInputStream

[十]JavaIO之FilterInputStream FilterOutputStream

JavaIO流总结

[十]JavaIO之FilterInputStream FilterOutputStream

[十三]JavaIO之PushBackInputStream

[五] JavaIO之InputStream OutputStream简介 方法列表说明

[二] JavaIO之File详解 以及FileSystem WinNTFileSystem简介

JavaIO流基本操作

【JavaIO流】JavaIO流基础知识

javaIO流(一)

[五] JavaIO之InputStream OutputStream简介方法列表说明

[二] JavaIO之File详解以及FileSystem WinNTFileSystem简介