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("该文件不存在");
    }
}