java -io流

目录

一、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();
    }
}