20200318Java学习笔记：IO

最新推荐文章于 2023-05-15 20:25:11 发布

远行孤帆

最新推荐文章于 2023-05-15 20:25:11 发布

阅读量202

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_44671533/article/details/104979563

版权

I/O

JAVA 的FILE类，以及常用方法

1.创建文件对象

package file;

import java.io.File;

public class Demo01 {
    public static void main(String[] args) {
        File file1=new File("C:\\Users\\Princekin Yan\\Desktop\\Java学习笔记");
        System.out.println(file1.getAbsolutePath());//输出C:\Users\Princekin Yan\Desktop\Java学习笔记
        //以file1作为父目录，创建文件对象
        File file2=new File(file1,"HelloWorld.md");
        System.out.println(file2.getAbsolutePath());//C:\Users\Princekin Yan\Desktop\Java学习笔记\HelloWorld.md
    }
}

2.常用方法

package file;

import java.io.File;
import java.util.Date;

public class Demo01 {
    public static void main(String[] args) {
        File file1=new File("C:\\Users\\Princekin Yan\\Desktop\\Java学习笔记");
        System.out.println(file1.getAbsolutePath());//输出C:\Users\Princekin Yan\Desktop\Java学习笔记
        //以file1作为父目录，创建文件对象
        File file2=new File(file1,"HelloWorld.md");
        System.out.println(file2.getAbsolutePath());//C:\Users\Princekin Yan\Desktop\Java学习笔记\HelloWorld.md


        System.out.println("当前文件是：" +file2);
        //文件是否存在
        System.out.println("判断是否存在："+file2.exists());

        //是否是文件夹
        System.out.println("判断是否是文件夹："+file2.isDirectory());

        //是否是文件（非文件夹）
        System.out.println("判断是否是文件："+file2.isFile());

        //文件长度
        System.out.println("获取文件的长度："+file2.length());

        //文件最后修改时间
        file2.setLastModified(0);
        long time = file2.lastModified();
        Date d = new Date(time);
        System.out.println("获取文件的最后修改时间："+d);
        //设置文件修改时间为1970.1.1 08:00:00
      //重命名文件
       File file3=new File(file1,"new HelloWorld.md");
        file2.renameTo(file3);

    }
}

什么是JAVA 的流 STREAM？

1.什么是流

输入流： InputStream
输出流：OutputStream

当不同的介质之间有数据交互的时候，JAVA就使用流来实现。

以内存为参照，进入内存叫输入，也叫读；从内存中出来叫输出，也叫写。

2. 文件的输入流和输出流

package file;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo02 {
    public static void main(String[] args) {
        try {
            File file=new File("C:\\Users\\Princekin Yan\\Desktop\\Java学习笔记");
            //创建基于文件的输入流，通过这个输入流，就可以把数据从硬盘，读取到Java的虚拟机中来，也就是读取到内存中
            FileInputStream fileInputStream=new FileInputStream(file);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package file;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo02 {
    public static void main(String[] args) {
        try {
            File file=new File("C:\\Users\\Princekin Yan\\Desktop\\Java学习笔记");
            //创建基于文件的输出流用于写文件

            FileOutputStream fileInputStream= new FileOutputStream(file);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件字节流

1.ASCII码概念

所有的数据存放在计算机中都是以数字的形式存放的。所以字母就需要转换为数字才能够存放。
比如A就对应的数字65，a对应的数字97. 不同的字母和符号对应不同的数字，就是一张码表。

2. 以字节读写数据

一次读取一个字节byte，八个二进制位。字节流所有文件都可以读取。

InputStream是字节输入流，同时也是抽象类，只提供方法声明，不提供方法的具体实现。

FileInputStream 是InputStream子类，以FileInputStream 为例进行文件读取。上

package file;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo03 {
    public static void main(String[] args) {
        try {
            //准备文件test.txt其中的内容是AB，对应的ASCII分别是65 66
            File f = new File("C:\\Users\\Princekin Yan\\Desktop\\test.txt");
            //创建基于文件的输入流
            FileInputStream fis = new FileInputStream(f);
            //创建字节数组，其长度就是文件的长度
            byte[] all = new byte[(int) f.length()];
            //以字节流的形式读取文件所有内容
            for(int i=0;i<all.length;i++){
                all[i]= (byte) fis.read();//读文件，把文件内容读进数组中
            }	//也可直接用fis.read(byte[]b),输入流中最多一次将b.length个字节的数据读入数组;
            
            for (byte b : all) {
                //打印出来是65 66
                System.out.println(b);
            }

            //每次使用完流，都应该进行关闭
            fis.close();

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
/*=========================================================================*/
//另一种程序
package file;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Demo03 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            File f = new File("C:\\Users\\Princekin Yan\\Desktop\\test.txt");
             fis = new FileInputStream(f);
            byte[] bytes = new byte[(int) f.length()];
            int readCound=0;

            while ((readCound=fis.read(bytes))!=-1){
                   //读到几个转换几个
                   String str=new String(bytes,0,readCound);
                   System.out.print(str);
                   //System.out.print(new String(bytes,0,readCound));
               }

        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            if(fis!=null) {
               try {
                   fis.close();
               } catch (Exception e) {
                   e.printStackTrace();
               }
            }
        }

    }
}

package file;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo04 {
    public static void main(String[] args) {
        try {
            File f = new File("C:\\Users\\Princekin Yan\\Desktop\\test.txt");
            //创建基于文件的输入流
            FileOutputStream fos = new FileOutputStream(f);
            // 准备长度是2的字节数组，用88,89初始化，其对应的字符分别是X,Y
            byte[] all = {88,89};
            // 创建基于文件的输出流
            fos.write(all);//88,89对应的XY被写入文件,原有内容会被覆盖
            //每次使用完流，都应该进行关闭
            fos.close();

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

复制文件的程序练习

package IOstream;
import java.io.*;

//字节流复制一个文件
public class Demo01 {
    public static void copyFile(String filePath1,String filePath2){
        try {
            //新建一个文件，只有文件才能调用长度函数，用于定义字节数组的长度
            File file=new File(filePath1);
            //定义输入流：读取的源文件，和输出流：被写入的文件，用于读入和写入
            FileInputStream fileInputStream=new FileInputStream(file);
            FileOutputStream fileOutputStream=new FileOutputStream(filePath2);
           //定义一个字节数组
            byte[]bytes=new byte[(int)file.length()];

            int readCount=0;//读到了几位，没有读到的时候返回-1。

            while (-1!=(readCount=fileInputStream.read(bytes))){
                //fileInputStream.read(bytes)读入的内容存入bytes数组
                //bytes数组的内容写入
                fileOutputStream.write(bytes);
            }
            //把写入内存的数据刷到硬盘。
            fileOutputStream.flush();
            fileOutputStream.close();
            fileInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        copyFile("C:\\Users\\Princekin Yan\\Desktop\\test1.txt","C:\\Users\\Princekin Yan\\Desktop\\test2.txt");
    }

}

3. 文件字节输出流：FileOutputStream

文件字符流

一次读取一个字符，方便读取普通的文本。不能读取图片、声音、视频，只能读取普通文本文件，txt。

Reader字符输入流，Writer字符输出流，专门用于字符的形式读取和写入数据。

使用字符流读取和写入文件

package IOstream;
//文件字符流
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Demo02 {
    public static void main(String[] args) {
        try {
            //准备文件test.txt其中的内容是AB
            File file = new File("C:\\Users\\Princekin Yan\\Desktop\\test1.txt");
            //创建基于文件的输入流
            FileReader fis = new FileReader(file);
            //创建字符数组，其长度就是文件的长度
            char[] all = new char[(int) file.length()];
            //以字符流的形式读取文件所有内容
            int readCount=0;
            while (-1!=(readCount=fis.read(all)))
            {
                System.out.println(new String(all));
            }
            //每次使用完流，都应该进行关闭
            fis.close();

        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

package file;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class Demo04 {
    public static void main(String[] args) {
        try {
            File f = new File("C:\\Users\\Princekin Yan\\Desktop\\test.txt");
            FileWriter fos = new FileWriter(f);
            // 准备长度是2的字符数组，用X,Y初始化
            char[] all ={'X','Y'};
            fos.write(all);//XY被写入文件,原有内容会被覆盖
            //每次使用完流，都应该进行关闭
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流复制文本内容编程练习：

package IOstream;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

//文件字符输出流复制文件
public class Demo03 {
    public static void main(String[] args) {
        fileCopy("C:\\Users\\Princekin Yan\\Desktop\\test1.txt","C:\\Users\\Princekin Yan\\Desktop\\test3.txt");
    }
    public static void fileCopy(String filePath1,String filePath2){
        try {
            File file=new File(filePath1);
            FileReader fileReader=new FileReader(file);
            FileWriter fileWriter=new FileWriter(filePath2);

            char[]chars=new char[(int)file.length()];
            int readCount=0;

            while (-1!=(readCount=fileReader.read(chars))){
                fileWriter.write(chars,0,readCount);
            }
            fileWriter.flush();
            fileWriter.close();
            fileReader.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

缓冲流：Buffered

文件字节流和文件字符流都是直接发生在硬盘上的IO操作，读写速度由硬盘的速度决定。

缓冲流可以起到加快读写速度的作用。先把数据缓存到内存中，在对内存进行IO操作。缓冲流的使用要建立在一个文件流的基础上。

用缓冲流复制文件的编程练习：

package IOstream;

import java.io.*;

//缓冲字节流复制文件
public class Demo04 {
    public static void main(String[] args) {
        copyFile("C:\\Users\\Princekin Yan\\Desktop\\test1.txt","C:\\Users\\Princekin Yan\\Desktop\\test4.txt");
    }
    public static void copyFile(String filePath1,String filePath2){
        //建立缓冲输入流,缓冲流要建立在已有流的基础上
        File file=new File(filePath1);
        try {
            FileInputStream fis=new FileInputStream(file);
            BufferedInputStream bis=new BufferedInputStream(fis);
            //直接通过匿名对象建立缓冲输入流
            BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(filePath2));

            byte[] bytes=new byte[(int)file.length()];
            int readCount=0;

            while (-1!=(readCount=bis.read(bytes))){
                bos.write(bytes,0,readCount);
            }
            bos.flush();//把缓存刷到内存中
            bos.close();
            bis.close();
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}
/*=============================================================================*/
package IOstream;

import java.io.*;

//缓冲字符流的文件复制
public class Demo05 {
    public static void main(String[] args) {
        try {
            BufferedReader bfr=new BufferedReader(new FileReader("C:\\Users\\Princekin Yan\\Desktop\\test1.txt"));
            BufferedWriter bfw=new BufferedWriter(new FileWriter("C:\\Users\\Princekin Yan\\Desktop\\test5.txt"));

            char[]chars=new char[100];
            int readCount=0;

            while (-1!=(readCount=bfr.read(chars))){
                bfw.write(chars,0,readCount);
            }
            bfw.flush();
            bfw.close();
            bfr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

转换流

将字节流转换为字符流

当字节流文件中的内容都是字符流的时候，将它转换为字符流进行读写，效率更高。

在转换过程中要注意编码的一致，否则会出现乱码。

package IOstream;

import java.io.*;

//字节流转换字符流
public class Demo06 {
    public static void testInputStreamReader(String filepath) throws Exception{
        //建立一个字节输入流
        FileInputStream fileInputStream=new FileInputStream(filepath);
        //建立转换流，把字节流转换为字符流
        //InputStreamReader inputStreamReader=new InputStreamReader(fileInputStream,"UTF-8");//参数1是输入流，参数2是编码方式
        //编码不同，中文输出为乱码,文件的编码要与转换流的编码一致
        InputStreamReader inputStreamReader=new InputStreamReader(fileInputStream,"GBK");
        char[]chars=new char[100];//本来应该定义为文件的长度，这里简化
        int readCount=0;
        while (-1!=(readCount=inputStreamReader.read(chars))){
            System.out.println(new String(chars,0,readCount));
        }

    }
    public static void testOutputStreamWriter(String filepath) throws Exception{
        FileOutputStream fileOutputStream=new FileOutputStream(filepath);
        OutputStreamWriter outputStreamWriter=new OutputStreamWriter(fileOutputStream,"GBK");
        outputStreamWriter.write("星星你好！");//源文件中的内容会被覆盖
        outputStreamWriter.flush();
        outputStreamWriter.close();
        fileOutputStream.close();
    }
    public static void main(String[] args) {
        try {
            testInputStreamReader("C:\\Users\\Princekin Yan\\Desktop\\test1.txt");
            testOutputStreamWriter("C:\\Users\\Princekin Yan\\Desktop\\test1.txt");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

标准输入输出流

对象流

ObjecInputStream和ObjecOutputStream

将对象转换为一个二进制的字节流，保存在电脑的硬盘上或者通过网络进行传送。要使用这个对象，需要把流转换为对象来使用。保存对象到硬盘（对象的持久化）和对象的网络传输，产生了对象的输入与输出流。

对象写入过程称为对象的序列化，对象的恢复过程称为对象的反序列化。序列化和反序列化针对的是对象的属性，不包括类的属性。

随机存储流(了解)

关闭流

所有的流，无论是输入流还是输出流，使用完毕之后，都应该关闭。如果不关闭，会产生对资源占用的浪费。当量比较大的时候，会影响到业务的正常开展。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O1Fox3H3-1584630550859)(C:\Users\Princekin Yan\AppData\Roaming\Typora\typora-user-images\image-20200313153139728.png)]$