java -io流

已于 2022-04-09 20:42:50 修改
阅读量145 收藏
点赞数
文章标签： java javaee
于 2022-03-29 13:15:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51500673/article/details/123815617
版权

目录

一、File类

构造器：

常用方法：

示例：

二、io流

三、字节流

     示例：

四、字节和字符桥接流

        手动编写字符间的转换

        使用字节到字符的转换流

五、字符流

六、缓冲流

        带有缓冲区的字节流

        带有缓冲区的字符流 

七、打印流

键盘输入流：

八、数据流

内部原理：

九、对象流

序列化：

反序列化：

一、File类

可以通过file类获取文件或者文件夹的相关属性。

构造器：

File file = new File(String filePath);

常用方法：

1.isFile():j检测file是否为文件

2.isDirectory:检测file是否为文件夹

3.createNewFile()：在指定的路径下创建文件,文件所在的目录必须存在

4.mkdir():创建目录,只能创建一级目录，无法创建多级目录

5.mkdirs():用于创建多级目录

6.delete():删除指定的文件，可以删除文件和文件夹(目录),但如果目 录中存在内容则无法删除，必须先删除目录中的内容才能删除目录

7.getAbsolutePath():获得文件的绝对路径

8.getName():获得文件名

9.istFiles():获得指定目录的所有子目录或文件的 File 对象

示例：

        

package com.jiazhong.io;

import java.io.File;
/*
* 编写Java程序：打印一个文件夹下的文件和目录名，并注明是文件还是目录。
* */
public class ioDemo1 {
    public static void main(String[] args) {
        File file = new File("E:/加中/javaWeb/4.24 IO流-File类/4.24 IO流-File类");
        if(file.isDirectory()){
            File[] files = file.listFiles();
            if(files!=null&&files.length!=0) {
                for (File file1 : files) {
                    if (file1.isDirectory()) {
                        System.out.println(file1.getName()+":是文件夹");
                    }else{
                        System.out.println(file1.getName()+":是文件");
                    }
                }
            }
        }else {
            System.out.println(":该文件是文件~");
        }
    }
}


package com.jiazhong.io;

import java.io.File;

/*
* 编写Java程序：删除指定的文件或文件夹，如果文件夹中有文件或子文件夹也一并删除。
* */

public class ioDemo2 {
    public static void main(String[] args) {
        File file = new File("E:/bbb");
        delete(file);
    }


    public static void delete(File file){
        if (file.exists()){
            File[] files = file.listFiles();
            if(files!=null&&files.length!=0){
                for (File file1 : files) {
                    delete(file1);
                }
                file.delete();
            }else {
                file.delete();
            }
        }else {
            System.out.println("该文件不存在！");
        }
    }
}

package com.jiazhong.io;

import java.io.File;

/*
* 编写Java程序：扫描整个硬盘中的所有文件，将文件的对象路径打印到控制台上
* */
public class ioDemo3 {
    public static void main(String[] args) {
        //获得磁盘中所有盘符的根目录
        File[] roots = File.listRoots();
        for (File root : roots) {
            selectAll(root);
        }
      // selectAll(new File("D:/app/"));
    }

    public static void selectAll(File file){
        if(file.exists()){
            if(file.isDirectory()){
                File[] files = file.listFiles();
                if(files!=null&&files.length!=0){
                    for (File file1 : files) {
                        selectAll(file1);
                    }
                }
            }else {
                System.out.println(file.getAbsolutePath());
            }
        }
    }
}

package com.jiazhong.io;

import java.io.File;

/*
* 查找某个文件夹的所有同类型文件
* */

public class ioDemo4 {
    public static void main(String[] args) {
        File[] roots = File.listRoots();
        for (File root : roots) {
            selectById(root);
        }

      /* File file = new File("D:/app");
       selectById(file);*/
    }

    //查找某类文件
    public static void selectById(File file) {
        if (file.exists()) {
            if (file.isDirectory()) {
                File[] files = file.listFiles();
                if (files != null && files.length != 0) {
                    for (File file1 : files) {
                        selectById(file1);
                    }
                }
            } else {
                String fileName = file.getName();
                String ext = fileName.substring(fileName.lastIndexOf(".")+1);
                if (ext.equals("docx") || ext.equals("doc")) {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}

package com.jiazhong.io;

import java.io.File;
import java.io.FilenameFilter;

/*
* 查找某个文件夹下的某个文件用过滤器
* */
public class ioDemo5 {
    public static void main(String[] args) {
        File file = new File("D:/");
        File[] files = file.listFiles(new FilenameFilter() {
            /*
             * file 当前要遍历的文件对象
             * fileName 当前要遍历的文件的文件名
             * */
            @Override
            public boolean accept(File file, String fileName) {
                //获取文件拓展名
                String ext = fileName.substring(fileName.lastIndexOf(".") + 1);
                return ext.equalsIgnoreCase("doc") || ext.equalsIgnoreCase("docx");
            }
        });

        for (File file1 : files) {
            System.out.println(file1.getAbsolutePath());
        }
    }
}

二、io流

        输入流：指将外部文件中的数据读入到程序（内存）中的流

        输出流：指将程序中的数据写入到外部文件（磁盘）中的流

        io流是一个管道，可以将外部文件读入到内存中，也可以将内存中数据写入外部文件中去

三、字节流

        字节流操作文件时，使用 InputStream(字节输入流)和 OutputStream(字节输出 流)这两个类来实现，由于 InputStream 和 OutputStream 都是抽象类，在实际开发中 更多的使用子类实现 FileInputStream(文件字节输入流)和 FileOutputStream(文件字节 输出流);

        是以字节码的形式存储数据，更适合操作二进制文件（视频，音频）

     示例：

        

package com.jiazhong.字节流;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/*
* 字节输入流
* */
public class FileInputStream {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = new java.io.FileInputStream("E:/new1.txt");
        byte[] bytes = new byte[1024];
        int len;//获取每次读取的长度，当没有可读取的内容时返回-1
        while ((len=inputStream.read(bytes))!=-1){
            String s = new String(bytes, 0, len);
            System.out.println(s);
        }
    }
}

package com.jiazhong.字节流;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Scanner;

/*
* 字节输出流
* */
public class OutPutStream {
    public static void main(String[] args) throws IOException {
        OutputStream outputStream = new FileOutputStream("E:/new2.txt",true);//追加管道
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请输入一段字符串：");
            String s = sc.next();
            outputStream.write(s.getBytes());
            outputStream.write("\r\n".getBytes());
            if(s.equals("n")){
                break;
            }
            outputStream.flush();//刷新，强行将管道中的数据写入磁盘中
        }
        outputStream.close();
    }
}

package com.jiazhong.字节流;

import java.io.*;
import java.io.FileInputStream;

/*
* 使用输入输出流进行文件复制
* */
public class copy {
    public static void main(String[] args) throws IOException {
        //创建输入流管道
        InputStream inputStream =new FileInputStream("E:\\加中\\JavaWeb开发.pdf");
        //创建输出流管道
        OutputStream outputStream =new FileOutputStream("E:/new.pdf");
        long start = System.currentTimeMillis();
        //定义字节数组
        byte[] bytes = new byte[1024];
        //定义变量
        int len;
        while ((len=inputStream.read(bytes))!=-1){
            outputStream.write(bytes,0,len);
        }
        long end = System.currentTimeMillis();
        System.out.println("复制花费时间："+(end-start)+"毫秒");
        outputStream.close();
        inputStream.close();
    }
}

在使用输出流时一定要实现flush()方法；刷新管道，强行将管道中的数据写入磁盘中

四、字节和字符桥接流

        当外部文件与程序编码不同时，读写操作就可能会产生乱码问题。

        手动编写字符间的转换

        

package com.jiazhong.字节到字符的桥接流;

import java.io.*;

public class 手动转码 {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = new FileInputStream("E:/a.txt");
        byte[] bytes = new byte[1024];
        int len=inputStream.read(bytes);
        //解码，将文件编码方式转换java中Unicode的编码方式（默认UTF-8）
        String string = new String(bytes,"GBK");
        System.out.println(string);

        OutputStream outputStream = new FileOutputStream("E:/a.txt",true);
        //编码，将java数据编码为UTF-8字节数组（默认情况）
        outputStream.write("你好吗".getBytes("GBK"));
        outputStream.close();
        inputStream.close();
    }
}

        使用字节到字符的转换流

  Java.io 提供的两个转换流(处理流) InputStreamReader:将字节输入流转换为字符输入流                                                              OutputStreamWriter:将字节输出流转换为字符输出流来更好的解决此问题

package com.jiazhong.字节到字符的桥接流;


import java.io.*;

/*
*   Java.io 提供的两个转换流(处理流)
    InputStreamReader:将字节输入流转换为字符输入流
    OutputStreamWriter:将字节输出流转换为字符输出流 需要时可以直接进行解码或编码
* */
public class 使用字节到字符的转换流 {
    public static void main(String[] args) throws IOException {
        //创建一个字节到字符转换流对象
        Reader reader = new InputStreamReader(new FileInputStream("E:/b.txt"),"GBK");
        char[] chars = new char[1024];
        int read = reader.read(chars);
        String s = new String(chars);
        System.out.println(s);

        Writer writer =new OutputStreamWriter(new FileOutputStream("E:/b.txt",true),"GBK");
        writer.write("你好吗？");
        writer.close();
        reader.close();
    }
}

五、字符流

字符流是以字符为单位读取数据，适合于读写文本文件

Reader 用于读取字符流的基础类，Writer 用于写入字符流的基础类

package com.jiazhong.字符流;


import java.io.*;

public class 字符流操作 {
    public static void main(String[] args) throws IOException {
        File file = new File("E:/h.txt");
        if(file.exists()){
            System.out.println("该文件已存在");
        }else {
            //新建文件
            file.createNewFile();
        }
        Writer writer = new FileWriter(file);
        writer.write("你好吗？");
        writer.close();

        Reader reader = new FileReader(file);
        char[] chars = new char[1024];
        int len = reader.read(chars);
        String s = new String(chars, 0, len);
        System.out.println(s);
    }
}

package com.jiazhong.字符流;

import java.io.*;

public class 文件复制 {
    public static void main(String[] args) throws IOException {
        Reader reader = new FileReader("E:/a.txt");
        Writer writer =new FileWriter("E:/f.txt");

        char[] chars = new char[1024];
        int len;
        while ((len=reader.read(chars))!=-1){
            writer.write(chars,0,len);
        }
        writer.close();
        reader.close();
    }
}

六、缓冲流

        缓冲流是对基础流的一个包装流(处理流),主要用于提高 IO 流的读写效率;

        Java 中针对字节流和字符流都提供了缓冲流

        带有缓冲区的字节流

package com.jiazhong.带有缓冲区的流;

/*
* 带有缓冲区的流相对效率较高
* */

import javax.swing.*;
import java.io.*;

public class 带有缓冲区的字节流 {
    public static void main(String[] args) throws IOException {
        //创建一字节输入流对象
        InputStream inputStream = new FileInputStream("E:\\加中\\javaWeb\\4.15 JSTL的基本使用.rar");
        //将字节输入流包装成一个带有缓冲区的字节输入流
        BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);

        OutputStream outputStream =new FileOutputStream("E:/a.rar");
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
        int len;
        byte[] bytes = new byte[1024];
        while ((len=bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,len);
        }
        bufferedOutputStream.close();
        bufferedInputStream.close();
    }
}

        带有缓冲区的字符流 

package com.jiazhong.带有缓冲区的流;

import java.io.*;

public class 带有缓冲区的字符流 {
    public static void main(String[] args) throws IOException {
        Reader reader = new FileReader("E:/a.txt");
        BufferedReader bufferedReader = new BufferedReader(reader);

        Writer writer = new FileWriter("E:/e.txt");
        BufferedWriter bufferedWriter = new BufferedWriter(writer);

        //readline:读取一行 若没有数据则返回null
        String len;
        while ((len=bufferedReader.readLine())!=null){
            bufferedWriter.write(len);
            bufferedWriter.newLine();//换行
        }
        bufferedWriter.close();
        bufferedReader.close();
        writer.close();
        reader.close();
    }
}

七、打印流

        该流也是带有缓冲区的

        该流提供两个比较方便的方法:print(),println()

package com.jiazhong.打印流;

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

public class 打印流实例 {
    public static void main(String[] args) throws IOException {
        PrintWriter printWriter = new PrintWriter(new FileWriter("D:/a.txt"));
        printWriter.print("你好");
        printWriter.print(123);
        printWriter.print(0.12);
        printWriter.flush();
        printWriter.close();
    }
}

键盘输入流：

        自定义键盘输入流与new Scanner(System.in);实现的作用是一样的，都是从控制台输入内容

package com.jiazhong.打印流;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class 键盘输入流 {
    public static void main(String[] args) throws IOException {
        //创建键盘输入流对象
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("请输入内容：");
        String s = bufferedReader.readLine();
        System.out.println(s);
    }
}

八、数据流

        要用于读写基本类型的数据:DataInputStream、DataOutputStream 这两个用 于对文件中的基本类型数据进行读写操作.

         数据流根据要读取的数据的类型不同而一次性从文件中读写相对应的字节的数 据，来提高对基本类型的读写效率

内部原理：

        DataInputStream或DataOutputStream在读写数据时，会根据数据的类型不同， 在数据流内部将读取到的字节组装为该类型的数据 然后在一次性的输出

public class Demo {
    public static void main(String[] args) throws IOException {
        DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream("D:/b.num"));
        dataOutputStream.writeInt(123);
        dataOutputStream.flush();
        dataOutputStream.close();

        DataInputStream dataInputStream = new DataInputStream(new FileInputStream("D:/b.num"));
        int i = dataInputStream.readInt();
        System.out.println(i);
        dataInputStream.close();
    }
}

九、对象流

        对象流是用于将 Java 对象写出到硬盘或读入到程序

        Java 中的对象流使用 ObjectInputStream 和 ObjectOutputStream 来实现

        ObjectInputStream 和 ObjectOutputStream 都是基于字节流实现的

注意：在Java中的一个对象要想通过对象流进行写出或读入操作,则这个Java对象必须实现Serializable接口 

        Serializable接口中没有任何成员，它是一个标识接口，当JVM检测到一个对象实现该接口后，就允许该对象进行“序列化”和“反序列化”操作。

package com.jiazhong.对象流;

import java.io.Serializable;

public class User implements Serializable {
    private String name;
    private String password;
    private int age;


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

    public User() {

    }

    public String getName() {
        return name;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

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

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

public class demo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        File file = new File("D:/c.tvr");
        User user = new User("张三","1234",18);
        //对象输出流（反序列化）
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(file));
        objectOutputStream.writeObject(user);
        objectOutputStream.flush();

        //对象输入流（序列化）
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
        User user1 = (User) objectInputStream.readObject();
        System.out.println(user1);
        objectInputStream.close();
        objectOutputStream.close();
    }
}

序列化：

        指将java对象流化，允许将一个java对象转化为字节码，并将字节码写到磁盘上

反序列化：

        指将字节码对象转化为java对象

董哩哩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值