一篇文章带你深入了解javaIO基础

一.认识IO

1.IO的分类

(1)BIO:同步阻塞IO

(2)NIO:同步非阻塞IO

(3)AIO:异步阻塞IO

注意: 这里主要介绍BIO

2.IO的方式

IO本质就是对数据的操作

(1)网络IO

(2)本地IO

3.IO读写的方式

一篇文章带你深入了解javaIO基础_第1张图片

4.IO的特性

(1)本质上属于数据传输

(2)涉及两个设备间的传输方向(一般,自己写java程序的时候,只关注自己程序的一方)

(3)数据流

一篇文章带你深入了解javaIO基础_第2张图片

(4)java进程的IO操作,对进程的影响:

  • 1.阻塞IO 会导致进程在运行态和阻塞态之间转变,由操作系统完成后序的IO操作
  • 2.java进程,在内核态和用户态之间切换:性能会收到影响(下降)

(5)IO缓冲流

一篇文章带你深入了解javaIO基础_第3张图片

不使用缓冲流:java程序每次都从主机内存读写数据,每次都直接读取数据/发送数据。write()/read()

使用/不使用缓冲区的区别:

例如:循环10000次,每次write1个字节数据到本地文件

不使用缓冲区:每次循环都是IO操作,都涉及进程状态由运行态变为阻塞态,由用户态变为内核态(10000次影响)

使用缓冲区:每次write复制数据到缓冲区,flush才算IO操作(一定要记得)(一次影响)性能更好

二.文件操作

1.文件的构成

(1)文件的头信息(Metadata)

(2)文件的内容

注意: java.io.File 不是对文件的内容操作,知识对文件本身或者头信息操作

2.文件的创建

在这里插入图片描述

new操作时的注意事项:

  • 1.既可以指定文件,也可以指定文件夹
  • 2.通过路径创建File:可以使用绝对路径/相对路径
  • 3.不管路径上是否存在这个文件/文件夹,java都可以创建得到一个File对象(但是对这个File操作时,可能会抛出异常)

3.文件操作的API使用

一篇文章带你深入了解javaIO基础_第4张图片

文件操作示例:遍历某个目录下,所有的子文件/子文件夹

  public static void main(String[] args) {
        File file=new File("C:\\Users\\26905\\Desktop\\javaCode");
        List list=listDir(file);
//        for (int i = 0; i  
 

方法一: 效率不高

public static List listDir(File dir){
        List list=new ArrayList<>();
        if(dir.isFile()){
            list.add(dir);//效率不太好的地方,如果是文件,返回的list只存放一个元素
        }else {
            File[] children=dir.listFiles();
            for(File file:children){
                List files=listDir(file);
                list.addAll(files);
            }
        }
        return list;
    }

方法二: 效率较高

 public static List  listDir2(File dir){
        List list=new ArrayList<>();
        if(dir.isDirectory()){
            //获取目录下一级的子文件和子文件夹
            File[] children=dir.listFiles();
            if(children!=null){
                for(File file:children){
                    if(file.isDirectory()){
                        //如果子文件还是文件夹,递归调用
                        list.addAll(listDir2(file));
                    }else{
                        list.add(file);
                    }
                }
            }
        }
        return list;
    }

三.IO流

1.流的分类

一篇文章带你深入了解javaIO基础_第5张图片

一篇文章带你深入了解javaIO基础_第6张图片

一篇文章带你深入了解javaIO基础_第7张图片

2.流的创建

一篇文章带你深入了解javaIO基础_第8张图片

3.流的使用

一篇文章带你深入了解javaIO基础_第9张图片

<1>输入流

import java.io.*;
public class  FileInput {
    /**
     * 字节文件:C:\Users\26905\Desktop\画图笔记\JavaWeb\JSON和ajax简单介绍.png
     * 字符文件:C:\Users\26905\Desktop\论文,ppt,作业,笔记,图片等\java笔记.txt
     * @param args
     */
    public static void main(String[] args) throws IOException {
        //图片文件,以二进制的方式操作
        File file1=new File("C:\\Users\\26905\\Desktop\\画图笔记\\JavaWeb\\JSON和ajax简单介绍");
        File file =new File("C:\\Users\\26905\\Desktop\\论文,ppt,作业,笔记,图片等\\比特草稿本.txt");

        //1.文件输入字节流
        FileInputStream fis=new FileInputStream(file);
        //不知道文件有多 大,先定义一个一定大小的字节数组,然后不停读入,每次刷新以下就好
        byte[] bytes=new byte[1024*8];
        //输入流读取的固定写法:读取到一个字节/字符数组,定义read的返回值变量,while
        int len=0;
        //len表示读入字节的长度
        //如果不等于-1,说明读取未结束
        while ((len=fis.read(bytes)) !=-1){
            //读取到的长度,数组可能读满,也可能没有读满
            //当次读取,一般使用数组[0,len]表示读取内容
            //字节数组转字符串
            String str=new String(bytes,0,len);
           // System.out.println(str);
        }
        //一般来说,输入输出流使用完,一定要关闭,关闭的关系是反向关系
        //例如:创建的时候是从里往外创建,则关闭的时候就是从外往内关闭
        fis.close();

        //2.文件的字符输入流
        FileReader fr=new FileReader(file);
        char []chars=new char[1024];
        int lenFr=0;
        while ((lenFr=fr.read(chars))!=-1){
             String strFr=new String(chars,0,lenFr);
            //System.out.println(strFr);
        }
        fr.close();

        //3.缓冲流:缓冲字节输入,缓冲字符输入
        FileInputStream FIS=new FileInputStream(file);//文件字节输入流
        //字节流转字符流一定要经过字节字符转换流来转换,并且还可以指定编码
        InputStreamReader isr=new InputStreamReader(FIS);
        //缓冲流
        BufferedReader br=new BufferedReader(isr);
        String str;
        //读取,当字符串为空时,结束
        while ((str=br.readLine()) !=null){
            System.out.println(str);
        }
        br.close();
        isr.close();
        FIS.close();
    }
}

<2>输出流

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
public class FileOutput {
    public static void main(String[] args) throws IOException {
        /**
         * D:\java代码\1.txt
         */
        //路径上没有该文件,new File不会报错,但是在操作输出流会抛出FileNotFoundException
        File file2=new File("D:\\java代码\\1.txt");
        //把a-z换行输出到某个文件,需要考虑文件是否存在的问题
        if(!file2.exists()){
            file2.createNewFile();
        }
        //new FileWriter()  文件的不带缓冲的字符输出
        //new FileWriter()  文件的不带缓冲的字节输出
        //new BufferedWriter() 带缓冲的字符输出
        //new PrintWriter()    打印输出流

        //缓冲的字符输出
//        BufferedWriter bw=new BufferedWriter(new FileWriter(file2));
//        bw.write("\n");

        //打印输出流
        //PrintWriter pw=new PrintWriter(new FileWriter(file));
        PrintWriter pw =new PrintWriter(new FileOutputStream(file2));
        //快速打印a-z
        for (int i = 'a'; i <='z' ; i++) {
            pw.println((char)i);
        }
        pw.flush();
    }
}

<3>实例:文件的复制

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileCopy {
    public static void main(String[] args) throws IOException {
        //文件复制
        File input=new File("D:\\java代码\\1.txt");
        File output=new File("D:\\java代码\\2.txt");
        if(!output.exists()){
            output.createNewFile();
        }
        //定义输入输出流
        //输入流
        FileInputStream fis=new FileInputStream(input);
        // 输出流
        FileOutputStream fos=new FileOutputStream(output);
        byte[]bytes=new byte[1024*8];
        int len;
        while ((len=fis.read(bytes))!=-1){//每次从输入流读取到byte[]的内容,直接输出到某个文件,就是复制
            //bytes可能没存满,需要指定长度
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();
    }
}

总结

本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注脚本之家的更多内容!

你可能感兴趣的:(一篇文章带你深入了解javaIO基础)