Java中的IO流以及使用进行文件加密和解密

Io流

IO流概述

I:

input输入,指的是"把数据从硬盘拿到内存中",也叫做"读".

O:

Output输出,指的是"把数据从内存写到硬盘上",也叫做"写".

IO流分类

根据流向分:

输入流:

把数据从硬盘拿到内存中.方法一定是read

输出流:

把数据从内存写到硬盘上.方法一定是write

根据单位分:

字节流:

读和写的时候,操作的都是字节. 字节流可以操作"任何文件".

字符流:

读和写的时候,操作的都是字符. 字符流只能操作"文本文件(可以用记事本正常打开的文件)".

字节流

字节输出流

构造

public FileOutputStream(String file);  //指定要书写的位置,如果文件不存在就创建,如果文件存在就覆盖.
public FileOutputStream(String file, boolean append); //append表示是否追加,如果是true就表示"不覆盖而是追加"

方法

public void write(int by);  	//写出一个字节
public void write(byte[] bys);	//写出一个字节数组(把数组中的所有字节都写出去)
public void write(byte[] bys,int off,int len); //写出字节数组的一部分(从off索引处开始,写len个)
public void close();	//关闭流(释放资源)

字节输入流

构造

public FileInputStream(String file);  //指定要读取的位置,如果文件不存在就报错

方法

public int read();	//读取一个字节,返回字节对应的编码. 如果读取不到,则返回-1
public int read(byte[] bys); //读取一个字节数组. 返回读取到的字节的个数. 如果读取不到,则返回-1
public void close();	//关闭流(释放资源)

拷贝文件

单字节拷贝

//1.定义字节输入流,指定要拷贝的文件
FileInputStream fis = new FileInputStream("XXX文件夹\\xxx.jpeg");
//2.定义字节输出流,指定要拷贝到的位置(也是一个文件)
FileOutputStream fos = new FileOutputStream("XXX文件夹\\xxx.jpeg");
//3.定义变量,用来存储每次拷贝的字节
int by;
//4.输入流读取字节,判断是否读到末尾(读到-1则表示读到末尾)
while((by = fis.read()) != -1){
    //5.输出流写
    fos.write(by);
}
//6.关闭输入流
fis.close();
//7.关闭输出流
fos.close();

字节数组拷贝

//1.定义字节输入流,指定要拷贝的文件
FileInputStream fis = new FileInputStream("XXX文件夹\\xxx.java");
//2.定义字节输出流,指定要拷贝到的位置(也是一个文件)
FileOutputStream fos = new FileOutputStream("XXX文件夹\\xxx.java");
//3.定义数组,用来存储每次拷贝的字节
byte[] bys = new byte[1024 * 10];
//4.定义变量,用来存储每次拷贝到的字节的个数
int len;
//5.输入流读取多个字节,存入数组中,判断是否读到末尾(读到-1则表示读到末尾)
while((len = fis.read(bys)) != -1){
    //6.输出流写
    fos.write(bys,0,len);
}
//7.关闭输入流
fis.close();
//8.关闭输出流
fos.close();

try-catch-finally

语法格式

try {
    //可能出现异常的代码
    //如果不出现异常,则正常执行
    //如果出现异常,则立即跳转到catch中执行,try中后续代码不再执行.
} catch(异常类型 变量) {
    //如果try中出现异常,则执行catch中代码
    //如果try中不出现异常,则不执行catch中的代码
} finally {
    //不论try中是否出现异常,最终都要执行finally中的代码
    //finally一般用来"释放资源".
}

IO流标准写法

//1.创建输出流对象,并给予初始化值
FileOutputStream fos = null;
try {
    //2.指定要操作的文件
    fos = new FileOutputStream("XXX文件夹\\xxxx.txt");
    //3.向文件中书写内容
    fos.write(97);
    fos.write(98);
} catch (IOException e) {
    e.printStackTrace();
} finally {
    //4.判断输出流是否创建成功(如果没有创建成功,则就没有必要关闭了)
    if (fos != null) {
        try {
            //5.释放资源
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字节缓冲流

缓冲流的拷贝原理

字节缓冲输入流

概述:

字节缓冲输入流 = 字节输入流 + 8K数组(缓冲区).

构造:

public BufferedInputStream(InputStream is); //根据一个字节流,生成一个字节缓冲流

方法:

	public int read() 	//从该输入流读取一个字节的数据。
    public int read(byte[] b) //从该输入流读取最多"b.length"个字节的数据到一个字节数组。
    public void close() //关闭此文件输入流并释放与流相关联的任何系统资源。  

字节缓冲输出流

概述:

字节缓冲输出流 = 字节输出流 + 8K数组(缓冲区).

构造:

public BufferedOutputStream(OutputStream os); //根据一个字节流,生成一个字节缓冲流

方法:

public void write(int b) //将指定的字节写入此文件输出流。
	public void write(byte[] b, int off, int len) //将b数组中,从off位置开始的"len个字节"写入此文件输出流。
	public void close() //关闭流

自定义数组拷贝原理

使用字节流进行文件加密

public static void main(String[] args) throws Exception {
    String s="D:\\XXX文件夹\\xxx.txt";
    encryption(s);
    Scanner sc=new Scanner(System.in);
    System.out.println("是否要解密");
    String c=sc.next();
    if(c.equals("是")){
        decode(s);
    }
}
    //#### 题目: 文件加密
    //**需求背景**：为了保证磁盘文件数据的安全性，就需要对原始文件进行加密存储，再使用的时候再对其进行解密处理。
    //加密原理：对原始文件中的每一个字节数据进行更改，然后将更改以后的数据存储到新的文件中。
    //解密原理:  读取加密后的文件,把每个字节数据进行还原,然后将还原后的数据存储的新文件中.
    //**实现提示**：
    public static  void decode(String s) throws IOException {
        //   //1.把"要解密的文件"的字符串,转换为"解密文件File对象"
        File f=new File(s);
        //   //2.获取"解密文件File对象"所在的文件夹getParent()
        String s2=f.getParent();
        //   //3.根据"解密文件File对象"创建文件输入流FileInputStream
        FileInputStream fis=new FileInputStream(f);
        //   //4.创建"解密后文件"对象(文件名任意,例如jm.bak,但所在文件夹为"解密文件File对象"所在的文件夹)
        File eFile = new File(s2, "jm.bak");
        //     File file = new File(parent, "jm.bak");
        //   //5.根据"解密后文件"对象,创建文件输出流FileOutputStream
        FileOutputStream fos=new FileOutputStream(eFile);
        //   //6.使用输入流读,使用输出流写,进行文件复制

        int a;
        while ((a=fis.read())!=-1){        //   //7.一次读取一个文件
            fos.write(a^/*你要解密的密码*/);   //8.每次读取一个字节后,先加密(比如让每个字节"异或10"),然后再写入
        }
        //9.关闭输入流和输出流
        fis.close();
        fos.close();
        //10.删除要加密的源文件
        f.delete();
        //11.把"加密后文件"重命名为源文件
        //加密后文件File对象.renameTo(源文件File对象);
        eFile.renameTo(f);
        //     file.renameTo(dfile);
    }

    //注意: 加密和解密所使用的异或运算,一定要保持一致
public static void encryption(String s) throws Exception {
    //   //1.把"要加密的原文件的绝对路径"的字符串,转换为"源文件File对象"
    File f1=new File(s);
    System.out.println(f1);
    //   //2.获取"源文件File对象"所在的文件夹getParent
    String s2=f1.getParent();
    System.out.println(s2);
    //   //3.根据"源文件File对象"创建文件输入流FileInputStream
    FileInputStream fis=new FileInputStream(f1);
    System.out.println(fis);
    //   //4.创建"加密后文件"对象(文件名任意,例如jm.bak,但所在文件夹为"源文件File对象"所在的文件夹)
    File eFile=new File(s2,"jm.bak");
    //     File eFile = new File(parent, "jm.bak");
    //   //5.根据"加密后文件"对象,创建文件输出流FileOutputStream
    FileOutputStream fos=new FileOutputStream(eFile);
    //   //6.使用输入流读,使用输出流写,进行文件复制
    int a;
    while ((a=fis.read())!=-1){        //   //7.一次读取一个文件
        fos.write(a^/*你要加密的密码*/);   //8.每次读取一个字节后,先加密(比如让每个字节"异或10"),然后再写入
    }
    //9.关闭输入流和输出流
    fis.close();
    fos.close();
    //10.删除要加密的源文件
    f1.delete();
    //11.把"加密后文件"重命名为源文件
    //加密后文件File对象.renameTo(源文件File对象);
    eFile.renameTo(f1);
}