Java 持久化之 -- IO 全面整理（看了绝不后悔）

目录：

一、java io 概述

什么是IO？

IO包括输入流和输出流，输入流指的是将数据以字符或者字节形式读取到内存 分为字符输入流和字符输入流

输入流指的是从内存读取到外界 ，分为字符输入流和字节输出流

Java IO即Java 输入输出系统。不管我们编写何种应用，都难免和各种输入输出相关的媒介打交道，其实和媒介进行IO的过程是十分复杂的，这要考虑的因素特别多，比如我们要考虑和哪种媒介进行IO（文件、控制台、网络），我们还要考虑具体和它们的通信方式（顺序、随机、二进制、按字符、按字、按行等等）。Java类库的设计者通过设计大量的类来攻克这些难题，这些类就位于java.io包中。

什么是流？

在Java IO中，流是一个核心的概念。流从概念上来说是一个连续的数据流。你既可以从流中读取数据，也可以往流中写数据。流与数据源或者数据流向的媒介相关联。在Java IO中流既可以是字节流(以字节为单位进行读写)，也可以是字符流(以字符为单位进行读写)

二、Java IO类库的框架

2.1 Java IO的类型

虽然java IO类库庞大，但总体来说其框架还是很清楚的。从是读媒介还是写媒介的维度看，Java IO可以分为：

1. 输入流：InputStream和Reader

2. 输出流：OutputStream和Writer

而从其处理流的类型的维度上看，Java IO又可以分为：

1. 字节流：InputStream和OutputStream

2. 字符流：Reader和Writer

01：File

创建文件   删除文件 修改文件 删除文件信息

02：字节流    InputStream            OutputStream     基类（父类）

03：字符流    Reader                Writer

04：缓冲流    BufferReader           BufferWriter  依赖于 Reader  Writer

05：二进制流  DataInputStream        DataOutputStream 依赖于InputStream OutputStream

06：序例化    objectInputStream      ObjectOutputStream 依赖于InputStream OutputStream

我们的程序需要通过InputStream或Reader从数据源读取数据，然后用OutputStream或者Writer将数据写入到目标媒介中。其中，InputStream和Reader与数据源相关联，OutputStream和writer与目标媒介相关联。 以下的图说明了这一点：

三、Java IO的基本用法

3.1 Java IO ：字节流（字节流对应的类应该是InputStream和OutputStream）

例1，用字节流写文件

package com.dzq;
import java.io.*;
/**
 * 字节流    InputStream            OutputStream
 */
public class ByteDemo {
    public static void main(String[] args) {
        //创建输入流和输出流对象
        InputStream inputStream=null;
        OutputStream outputStream=null;
        try {
            inputStream=new FileInputStream("e:/aaa.txt");
            //true代表是否向文件拼接，不能删除之前的内容
            outputStream=new FileOutputStream("e:/aaa.txt",true);
           //向文件写入内容
            outputStream.write("54321".getBytes());
            //read方法0-255，如果流读到了最后，将返回-1
            int num=0;//int -1   字符串 null
            while ((num=inputStream.read())!=-1){
                System.out.println((char)num);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            inputStream.close();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3.2 Java IO ：字符流（字符流对应的类应该是Reader和Writer）

例3，用字符流写文件

package com.dzq;
import java.io.*;
/*
 * 字符流    Reader                Writer
 */
public class CharDemo{
    public static void main(String[] args) {
        //创建字符流输出和输入
        Reader reader=null;
        Writer writer=null;
        try {
            reader=new FileReader("e:/aaa.txt");
            writer=new FileWriter("e:/aaa.txt",true);
            writer.write("我爱我家！");
            writer.write("我爱我家？");
            writer.write("我爱我家！！");
            writer.write("我爱我家？？");
            writer.flush();
            writer.write("我爱我家!!!!");
            writer.close();
            //读取
            //创建一次性读取多个字符
            char[] bytes =new char[1024];
            int num=0;
            StringBuffer stringBuffer=new StringBuffer();
            while((num=reader.read(bytes))!=-1){
                stringBuffer.append(bytes);
            }
            System.out.println(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                writer.close();
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        }
}

3.3 Java IO  :二进制流( DataInputStream DataOutputStream 依赖于 InputStream  和  OutputStream ）

package com.dzq;
import java.io.*;
/*
 *二进制流  DataInputStream        DataOutputStream
 */
public class DataDemo {
   public static void main(String[] args) {
       //创建输入流和输出流对象
        InputStream inputStream=null;
        OutputStream outputStream=null;
        DataInputStream dataInputStream=null;
        DataOutputStream dataOutputStream=null;
        try {
            //获取输入流
            inputStream=new FileInputStream("e:/aaa.txt");
            dataInputStream=new DataInputStream(inputStream);//封装
            //获取输出流
            outputStream=new FileOutputStream("e:/aaa.txt");
            dataOutputStream=new DataOutputStream(outputStream);
            //读取
            int num=0;
            while ((num=dataInputStream.read())!=-1){
                dataOutputStream.write(num);//复制
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                dataOutputStream.close();
                dataInputStream.close();
                outputStream.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.4 Java IO(缓冲流BufferReader  BufferWriter 依赖于Reader 和Writer)

package com.dzq;
import java.io.*;
/**
 *缓冲流    BufferReader           BufferWriter
 */
public class BufferDemo {
    public static void main(String[] args) {
        //创建字符流输出和输入
        Reader reader = null;
        Writer writer = null;
        BufferedReader bufferReader=null;
        BufferedWriter bufferedWriter=null;
        try {
            //写入
            writer=new FileWriter("e:/aaa.txt") ;
           bufferedWriter=new BufferedWriter(writer);//封装
            bufferedWriter.write("我爱我家1");
            bufferedWriter.write("我爱我家2");
            bufferedWriter.write("我爱我家3");
            bufferedWriter.newLine();//换行
            bufferedWriter.write("我爱我家4");
            reader.close();
            bufferedWriter.close();//如果不关闭后两行出不来
            //读取
            reader=new FileReader("e:/aaa.txt") ;
            bufferReader=new BufferedReader(reader);//封装
            //拼接
            String line=null;
            StringBuffer stringBuffer=new StringBuffer();
            while((line=bufferReader.readLine())!=null){
                stringBuffer.append(line);
            }
            System.out.println(stringBuffer.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                bufferReader.close();
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    }

3.5 Java IO序列化和非序列化

User类：

package com.cd;
import java.io.Serializable;
public class User implements Serializable{
    public String username;
    public String password;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }
    public User(){
    }
}

各方法：

package com.cd;
/**
 * 序列化和非序列化
 */
import java.io.*;
import java.util.Scanner;
public  class ObjectDemo {
   static Scanner input=new Scanner(System.in);
    //创建输出流和输入流
    static  InputStream inputStream=null;
    static  OutputStream outputStream=null;
    static ObjectInputStream objectInputStream=null;
    static ObjectOutputStream objectOutputStream=null;
    public static void main(String[] args) {
           //登录
          Login();
          //注册
          register();
    }
    //注册
    private static void register() {
        User user =new User();
        System.out.println("请输入你的用户名");
        user.setUsername(input.next());
        System.out.println("请输入你的密码");
        user.setPassword(input.next());
        try {
         outputStream=new FileOutputStream("e:/aaa.txt");
           objectOutputStream=new ObjectOutputStream(outputStream);
            //把对象输出到文件中
            objectOutputStream.writeObject(user);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                objectOutputStream.close();
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //登录
    private static void Login() {
        try {
            inputStream=new FileInputStream("e:/user.txt");
            objectInputStream=new ObjectInputStream(inputStream);
            //读取对象
            User user= (User) objectInputStream.readObject();
            System.out.println(user);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                objectInputStream.close();
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.6 Java IO ：字节流转换为字符流（InputStreamReader）

public static void convertByteToChar() throws IOException{
 File file= new File( "d:/test.txt");
//获得一个字节流 InputStream is= new FileInputStream( file);
 //把字节流转换为字符流，其实就是把字符流和字节流组合的结果。
 Reader reader= new InputStreamReader( is);
 char [] byteArray= new char[( int) file.length()];
int size= reader.read( byteArray);
System. out.println( "大小:"+size +";内容:" +new String(byteArray));
 is.close();
reader.close();
 }

3.7 File 操作文件

DEMO:

public class FileDemo
{
    static  Scanner input =new Scanner(System.in);
    public static void main( String[] args )
    {
        System.out.println( "***********欢迎进入文件操作系统*******************" );
        System.out.println(" *******************1：创建文件*******************" );
        System.out.println( "*******************2：删除文件*******************" );
        System.out.println( "*******************3：修改文件*******************" );
        System.out.println( "*******************4：创建文件夹*******************" );
        System.out.println( "*******************5：删除文件夹*******************" );
        System.out.println( "*******************6：查询文件夹下所有的列表*******************" );
        int choose =input.nextInt();
        switch(choose){
            case 1://创建文件
                createNewFile();
                break;
            case 2://删除文件
                deleteNewFile();
                break;
            case 3://修改文件
                updateNewFile();
                break;
            case 4://创建文件夹
                mkdirs();
                break;
            case 5://删除文件夹
                deletemkdirs();
                break;
            case 6://查询文件夹下所有的列表
                findFileList();
                break;
        }
    }
 

创建文件

private static void createNewFile()
{
    System.out.println("请输入文件的名称：（默认为E：/）");
    String fileName=input.next();
    //创建文件
    File file=new File("E:/"+fileName);//默认的路径
    if(file.exists()){
        System.out.println("该文件已存在！");
    }else{
        try {
            boolean flag =file.createNewFile();
            if(flag){
                System.out.println("文件夹创建成功");
            }else{
                System.out.println("文件夹创建失败");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
 

删除文件

private static void deleteNewFile()
{
    System.out.println("请输入你要删除的文件名称：（默认为E：/）");
    String fileName=input.next();
    //创建File对象
    File file =new File("E:/"+fileName);
    if (file.exists()){
        boolean flag =file.delete();
        if(flag)
        {
            System.out.println("删除成功");
        }else{
            System.out.println("删除失败");
        }
    }else{
        System.out.println("该文件不存在");
    }
}

修改文件

private static void updateNewFile()
{
    System.out.println("请你输入需要修改的文件的名称：（默认为E：/）");
    String oldFileName=input.next();
    System.out.println("请你输入文件的新名称：（默认为E：/）");
    String newFileName=input.next();
    //创建File对象
    File oldFile=new File("E:/"+oldFileName);
    File NewFile=new File("E:/"+newFileName);
    if(oldFile.renameTo(NewFile)){
        System.out.println("修改成功");
    }else{
        System.out.println("修改失败");
    }
}

创建文件夹

private static void mkdirs() {
    System.out.println("请输入你要创建的文件名称：（默认为E：/）");
    String fileName=input.next();
    //创建File对象
    File file =new File("E:/"+fileName);
    if (file.mkdirs()){
            System.out.println("创建成功");
        }else{
            System.out.println("创建失败");
        }
}

删除文件夹

一：删除文件夹的方法（先删除文件夹里面的东西在删除文件）

public static void delFolder(String folderPath) {
    try {
        delAllFile(folderPath); //删除完里面所有内容
        String filePath = folderPath;
        filePath = filePath.toString();
        java.io.File myFilePath = new java.io.File(filePath);
        myFilePath.delete(); //删除空文件夹
    } catch (Exception e) {
        e.printStackTrace();
    }
}

二：删除文件夹的方法

public static boolean delAllFile(String path) {
    boolean flag = false;
    File file = new File(path);
    if (!file.exists()) {
        return flag;
    }
    if (!file.isDirectory()) {
        return flag;
    }
    String[] tempList = file.list();
    File temp = null;
    for (int i = 0; i < tempList.length; i++) {
        if (path.endsWith(File.separator)) {
            temp = new File(path + tempList[i]);
        } else {
            temp = new File(path + File.separator + tempList[i]);
        }
        if (temp.isFile()) {
            temp.delete();
        }
        if (temp.isDirectory()) {
            delAllFile(path  + tempList[i]);//先删除文件夹里面的文件
            delFolder(path  + tempList[i]);//再删除空文件夹
            flag = true;
        }
    }
    return flag;
}

三：删除文件夹的终极方法

private static void deletemkdirs() {
    System.out.println("请输入你要删除的文件夹名称：（默认为E：/）");
    String fileName=input.next();
    //创建File对象
    File file =new File("E:/"+fileName);
    if (file.exists()){
        boolean flag = delAllFile("E:/qqq");
        if(flag)
        {
            System.out.println("删除失败");
        }else{
            file.delete();
            System.out.println(" 删除成功");
        }
    }else{
        System.out.println("该文件不存在");
    }
}