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

湛蓝之海

这篇文章主要介绍了java 基础知识之IO总结的相关资料,Java中的I/O分为两种类型，一种是顺序读取，一种是随机读取，需要的朋友可以参考下，希望对你有帮助
一.认识IO

1.IO的分类
（1）BIO：同步阻塞IO
（2）NIO：同步非阻塞IO
（3）AIO:异步阻塞IO
注意： 这里主要介绍BIO

2.IO的方式
IO本质就是对数据的操作
（1）网络IO
（2）本地IO

3.IO读写的方式

4.IO的特性
（1）本质上属于数据传输
（2）涉及两个设备间的传输方向（一般，自己写java程序的时候，只关注自己程序的一方）
（3）数据流

（4）java进程的IO操作，对进程的影响：

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

（5）IO缓冲流

不使用缓冲流：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使用

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

public static void main(String[] args) {
    File file=new File("C:Users26905DesktopjavaCode");
    List<File> list=listDir(file);
//    for (int i = 0; i <list.size() ; i++) {
//      System.out.println(list.get(i));
//    }
    //jdk1.8集合框架使用Stream操作，可以使用lambda表达式打印
    list.stream().forEach(System.out::println);
  }

方法一： 效率不高

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

方法二： 效率较高

public static List<File>  listDir2(File dir){
    List<File> 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.流的分类

2.流的创建

3.流的使用

<1>输入流

import java.io.*;
public class  FileInput {
  /**
   * 字节文件：C:Users26905Desktop画图笔记JavaWebJSON和ajax简单介绍.png
   * 字符文件:C:Users26905Desktop论文，ppt，作业，笔记，图片等java笔记.txt
   * @param args
   */
  public static void main(String[] args) throws IOException {
    //图片文件，以二进制的方式操作
    File file1=new File("C:Users26905Desktop画图笔记JavaWebJSON和ajax简单介绍");
    File file =new File("C:Users26905Desktop论文，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("
");
    //打印输出流
    //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();
  }
}

总结
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注CodeAE代码之家的更多内容！
原文链接：https://blog.csdn.net/qq_45704528/article/details/115123442