走近Java之IO流（一）_数据

文件

文件，文件是保存数据的地方，如word文档，excel表格文件，txt文件等。他可以保存图片、声音、视频等数据。

文件在程序中是以流的形式来操作的

走近Java之IO流（一）_数据_02

流：数据在数据源（文件）和程序（内存）之间经历的路径

输入流：数据从数据源（文件）到程序（内存）的路径

输出流：数据从程序（内存）到数据源（文件）的路径

常用的文件操作

创建文件对象相关构造器和方法

new File(String pathName)//根据路径构建一个File对象

new File(File parent,String child)//根据父目录文件+子路径构建

new File(String parent,String child)//根据父目录+子路径构建

createNewFile 创建新文件

package com.study.srv.demo17;

import org.junit.Test;

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

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/4/28 16:52
 * 演示创建文件
 */
public class Demo01 {
    public static void main(String[] args) {

    }
    //方式1 new File(String filePath)
    @Test
    public void create01(){
        String filePath="D:\\new1.txt";
        File file = new File(filePath);
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //方式2 new File(File parent,String child)
    //根据父目录文件+子路径构建
    @Test
    public void create02(){
        File file = new File("D:\\");
        String fileName="new2.txt";
        File file1 = new File(file,fileName);
        //这里的file对象，在Java程序中，只是一个对象
        //只有执行了creatNewFile方法，才会真正的在磁盘创建该文件
        try {
            file1.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //方式3 new File(String parent ,String child)//根据父目录+子路径构建
    @Test
    public void create03(){
        String parentPath="D:\\";
        String fileName="new3.txt";
        File file = new File(parentPath,fileName);
        //这里的file对象，在Java程序中，只是一个对象
        //只有执行了creatNewFile方法，才会真正的在磁盘创建该文件
        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

走近Java之IO流（一）_System_03

 获取文件相关信息

方法名

方法说明

getName()

获取文件名

getAbsolutePath()

获取绝对路径

getParent()

获取文件父级目录

length()

获取文件大小（字节）

exists()

判断文件是否存在

isFile()

判断是不是一个文件

isDirectory()

判断是不是一个目录

package com.study.srv.demo17;

import org.junit.Test;

import java.io.File;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/4/28 17:40
 */
public class Demo02 {
    public static void main(String[] args) {

    }

    @Test
    public void info() {
        //先创建文件对象
        File file = new File("D:\\new1.txt");

        //调用相应的方法，得到对应信息
        //文件名
        System.out.println("文件名=" + file.getName());
        //绝对路径
        System.out.println("文件绝对路径=" + file.getAbsolutePath());
        //文件父级目录
        System.out.println("文件父级目录=" + file.getParent());
        //文件大小（字节）
        System.out.println("文件大小（字节）=" + file.length());
        //文件是否存在
        System.out.println("文件是否存在=" + file.exists());
        //是不是一个文件
        System.out.println("是不是一个文件=" + file.isFile());
        //是不是一个目录
        System.out.println("是不是一个目录=" + file.isDirectory());
    }
}

走近Java之IO流（一）_数据_04

目录的操作和文件删除

mkdir创建一级目录、mkdirs创建多级目录、delete删除空目录或文件

mkdir()     返回类型boolean

mkdirs()   返回类型boolean

package com.study.srv.demo17;

import org.junit.Test;

import java.io.File;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/4/29 10:34
 */
public class Demo03 {
    public static void main(String[] args) {

    }
    //判断D:\\new1.txt是否存在，如果存在就删除。
    @Test
    public void m1() {
        String pathName="D:\\\\new1.txt";
        File file = new File(pathName);
        if (file.exists()){
            if (file.delete()){
                System.out.println("文件删除成功！");
            }else {
                System.out.println("文件删除失败！");
            }
        }else {
            System.out.println("文件不存在！");
        }
    }
    //判断D:\\demo03是否存在，存在就删除，否则提示不存在并创建
    @Test
    public void m2() {
        String pathName="D:\\demo02";
        File file = new File(pathName);
        if (file.exists()){
            if (file.delete()){
                System.out.println("目录删除成功！");
            }else {
                System.out.println("目录删除失败！");
            }
        }else {
            System.out.println("目录不存在！");
            if (file.mkdir()){
                System.out.println("目录创建成功！");
            }else {
                System.out.println("目录创建失败！");
            }
        }
    }
    //判断D:\\demo03\\a\\b\\c目录是否存在，如果存在提示存在，否则就创建
    @Test
    public void m3() {
        String pathName="D:\\demo03\\a\\b\\c";
        File file = new File(pathName);
        if (file.exists()){
            System.out.println("目录存在！");
        }else {
            System.out.println("目录不存在！");
            if (file.mkdirs()){//mkdir创建一级目录、mkdirs创建多级目录
                System.out.println("目录创建成功！");
            }else {
                System.out.println("目录创建失败！");
            }
        }
    }
}

走近Java之IO流（一）_数据_05

IO流原理及流的分类

Java IO流原理

  1. I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理数据传输。读/写文件，网络通讯等。
  2. Java程序中，对于数据的输入/输出操作以“流(stream)”的方式进行。
  3. java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据。
  4. 输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
  5. 输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

流的分类

  • 按操作数据单位不同分为：字节流（8 bit） 二进制文件，字符流（按字符）文本文件。
  • 按数据流的流向分为：输入流，输出流。
  • 按流的角色的不同分为：节点流，处理流/包装流。

（抽象基类）

字节流

字符流

输入流

InputStream

Reader

输出流

OutputStream

Wirter

  1. Java的IO流共涉及40多个类，实际上非常规则，都是从如上的4个抽象基类派生的。
  2. 由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

IO流体系图-常用的类

IO流体系图

走近Java之IO流（一）_数据_06

package com.study.srv.demo17;

import org.junit.Test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/5/12 10:40
 *
 * FileInputStream输入流
 */
public class Demo04 {
    public static void main(String[] args) {

    }

    /**
     * 使用FileInputStream的read方法读取的是单个字节，效率比较低。
     * 此时我们可以使用read(byte[] b)读取文件
     */
    @Test
    public void readFile(){

        String path="D:\\new2.txt";
        FileInputStream fileInputStream=null;
        int read=0;
        try {
            //创建FileInputStream对象，用于读取文件
            fileInputStream = new FileInputStream(path);
            //FileInputStream中的read方法
            //从该输入流读取一个字节的数据。如果没有输入可用，此方法将被阻止。
            //如果返回-1，表示已经到末尾，表示读取完毕
            while ((read=fileInputStream.read())!=-1) {
                System.out.print((char) read);//将int转为char显示
            }
        }  catch (IOException e) {
            e.printStackTrace();
        }finally {
            //最后一定要关闭文件流 ，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 使用read(byte[] b)方法读取文件
     */
    @Test
    public void readFile2(){
        String path="D:\\new2.txt";
        FileInputStream fileInputStream=null;
        //字节数组
        byte[] bytes = new byte[3];//一次读取3个字节
        int read=0;
        try {
            //创建FileInputStream对象，用于读取文件
            fileInputStream = new FileInputStream(path);
            //FileInputStream中的read(byte[] b)方法
            //从该输入流读取最多b.length字节的的数据到字节数组。此方法将被阻塞，直到某些输入可用
            //如果返回-1，表示已经到末尾，表示读取完毕
            //fileInputStream.read(bytes)读取正常，返回的是实际读取到的字节数
            while ((read=fileInputStream.read(bytes))!=-1) {
                //但是这样写会被偏移量所限制，
                System.out.print(new String(bytes,0,read));
                //也可以直接new String对象
                String str=new String(bytes);
                System.out.print(str);
                //将int转为char显示
            }
        }  catch (IOException e) {
            e.printStackTrace();
        }finally {
            //最后一定要关闭文件流 ，释放资源
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

走近Java之IO流（一）_数据_07

 FileOutputStream介绍

package com.study.srv.demo17;

import org.junit.Test;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/5/12 14:15
 * FileOutputStream输出流
 */
public class Demo05 {
    public static void main(String[] args) {

    }

    /**
     * 使用FileOutputStream将数据写入到文件中
     * 若文件不存在，则创建该文件
     */
    @Test
    public void writeFile01(){
        //创建FileOutputStream对象
        String path="d:\\a.txt";
        FileOutputStream fileOutputStream=null;
        try {
            //得到一个FileOutputStream对象
            fileOutputStream=new FileOutputStream(path);
            //正常创建的的FileOutputStream对象通过write方法写入数据，会把原本的数据覆盖掉。
            //所以可以在创建对象时加入true，表示数据拼接。
//            fileOutputStream=new FileOutputStream(path,true);
            //写入一个字节
//            fileOutputStream.write('h');
            //写入字符串
            String str="hello,你好！";
//            fileOutputStream.write(str.getBytes());
            //str.getBytes()会把字符串->字节数组
            //write(byte[] b,int off,int len)将len字节从位于偏移量off的的指定字节数组写入此文件输出流。
            //即从字节数组下标为off的位置到之后len数量的字节写入到文件输出流之中。
            fileOutputStream.write(str.getBytes(),2,3);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

走近Java之IO流（一）_Test_08

  文件拷贝

利用输入流读取文件数据再利用输出流将读取的数据写入到目标文件。

package com.study.srv.demo17;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/5/12 15:35
 * 文件拷贝
 */
public class Demo06 {
    public static void main(String[] args) {
        //完成文件拷贝，将D:\\1.gif拷贝到E:\\
        //思路：先读数据，再把读取的数据保存到目标文件
        //1.创建文件输入流，将文件读入到程序
        //2.创建文件的输出流，将读取到的文件数据写入到指定文件
        String pathA="D:\\1.gif";
        String pathB="E:\\3.gif";
        //定义一个字节数组，提高读取效率
        byte[] bytes=new byte[1024];
        int len=0;
        FileInputStream fileInputStream=null;
        FileOutputStream fileOutputStream=null;
        try {
            fileInputStream=new FileInputStream(pathA);
            fileOutputStream=new FileOutputStream(pathB);
            while ((len=fileInputStream.read(bytes))!=-1) {
                //读取到后，就写入文件，即边读边写。
                //不能用 fileOutputStream.write(bytes);因为有可能最后读取不够字节，这样会导致文件无法使用
                //一定要用write(byte[] b,int off,int len)
                fileOutputStream.write(bytes,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (fileInputStream!=null) {
                    fileInputStream.close();
                }
                if (fileOutputStream!=null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

走近Java之IO流（一）_System_09

FileReader相关方法

  1. new FileReader(File/String) ：创建FileReader对象。
  2. read:每次读取单个字符，返回该字符，如果到文件末尾返回-1.
  3. read(char[]):批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1.
  4. new String(char[]):将char[]数组转换成String。
  5. new String(char[],off,len):将char[]的指定部分转换为String。

FileWriter常用方法

  1. new FileWriter(File/String):覆盖模式，相当于流的指针在首段，将原本的数据覆盖掉。
  2. new FileWriter(File/String,true):追加模式，相当于流的指针在尾端，写到原本的数据之后。
  3. writer(int):写入单个字符。
  4. writer(char[]):写入指定数组。
  5. writer(char[],off,len):写入指定数组的指定部分。
  6. writer(string):写入整个字符串。
  7. writer(sting,off,len):写入字符串的指定部分。toCharArray:将String转换成char[]

FileWriter使用后，必须要关闭(close)或刷新(flush),否则写入不到指定的文件。

FileReader和FileWriter应用

package com.study.srv.demo17;

import org.junit.Test;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/5/12 17:34
 * FileReader
 */
public class Demo07 {
    public static void main(String[] args) {

    }

    @Test
    public void fileReader1(){
        String path="D:\\new3.txt";
        FileReader fileReader=null;
        int data=' ';
        try {
            fileReader=new FileReader(path);
            //读取数据 使用read（单个字符）
            while ((data=fileReader.read())!=-1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    @Test
    public void fileReader2(){
        String path="D:\\new3.txt";
        FileReader fileReader=null;
        char[] chars=new char[1024];
        int data=' ';
        try {
            fileReader=new FileReader(path);
            //读取数据 使用read(char[]),返回的是实际读取到的字符数
            //如果返回-1，说明读到文件结尾
            while ((data=fileReader.read(chars))!=-1){
                System.out.print(new String(chars,0,data));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

走近Java之IO流（一）_数据_10

package com.study.srv.demo17;

import org.junit.Test;

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

/**
 * @author Wen先森
 * @version 1.0
 * @date 2022/5/12 17:53
 * FileWriter
 */
public class Demo08 {
    public static void main(String[] args) {

    }

    @Test
    public void fileWriter(){
        //创建FileWriter对象
        FileWriter fileWriter=null;
        char[] chars={'a','b','c'};
        try {
            fileWriter=new FileWriter("E:\\c.txt",true);
            fileWriter.write("Java程序设计\n");
            fileWriter.write("数据结构\n");

//            writer(int):写入单个字符。
            fileWriter.write('h');
//            writer(char[]):写入指定数组。
            fileWriter.write(chars);
//            writer(char[],off,len):写入指定数组的指定部分。
            fileWriter.write(chars,1,1);
//            writer(string):写入整个字符串。
            fileWriter.write("\n计算机算法与导论");
//            writer(sting,off,len):写入字符串的指定部分。toCharArray:将String转换成char[]
            fileWriter.write("数据库概论\n",0,6);
            fileWriter.write("数据库概论\n".toCharArray(),0,6);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //FileWriter一定要关闭流，或者flush才能真正的将数据写入到文件。
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}