Java大数据开发和安全开发
- (一)Java的IO流文件读写
- 1.1 转换流
- 1.1.1 InputStreamReader字符输入转换流
- 1.1.1 OutputStreamWriter字符输出转换流
 
- 1.2 打印流
- 1.2.1 PrintStream打印流
- 1.2.2 PrintWriter打印流
- 1.2.3 PrintStream和PrintWriter的区别
- 1.2.4 打印流的应用
 
- 1.3 数据流
- 1.3.1 DataOutputstream数据输出流
- 1.3.2 Datalnputstream数据输入流
 
- 1.4 序列流
- 1.4.1 ObjectOutputstream对象字节输出流
- 1.4.2 Objectlnputstream对象字节输入流
 
- 1.5 IO框架
- 1.5.1 commons-io导入
- 1.5.1 Commons-IO框架
 
 
(一)Java的IO流文件读写
1.1 转换流
InputStreamReader和OutputStreamWriter
 
1.1.1 InputStreamReader字符输入转换流
InputStreamReader(字符输入转换流)
- 解决不同编码时,字符流读取文本内容乱码的问题。
解决思路:
- 先获取文件的原始字节流,再将其按真实的字符集编码转成字符输入流,这样字符输入流中的字符就不乱码了

import java.io.*;
public class ZhuanhuangLei {
    public static void main(String[] args) {
        try (
                // 1、得到文件的原始字节流(6BK的字节流形式)
                InputStream is = new FileInputStream("lianxi\\src\\com\\qianxin\\file\\1.txt");
                // 2、把原始的字节输入流按照指定的字符集编码转换成字符输入流
                Reader isr = new InputStreamReader(is, "utf-8");
                // 3、把字符输入流包装成缓冲字符输入流
                BufferedReader br = new BufferedReader(isr);
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
1.1.1 OutputStreamWriter字符输出转换流
字符输出转换流是控制写出去的字符使用什么字符集进行编码
方法1、调用String提供的getBytes方法解决
 
 方法2、OutputStreamWriter使用字符输出转换流实现
解决思路:
- 获取字节输出流,再按照指定的字符集编码将其转换成字符输出流,以后写出去的字符就会用该字符集编码了
  
import java.io.*;
public class ZhuanhuangLei {
    public static void main(String[] args) {
        try(
                // 1、创建一个文件字节输出流
                OutputStream os = new FileOutputStream("lianxi\\src\\com\\qianxin\\file\\1.txt");
                //2、把原始的字节输出流,按照指定的字符集编码转换成字符输出转换流。
                Writer osw = new OutputStreamWriter(os,"GBK");
                //13、把字符输出流包装成缓冲字符输出流
                BufferedWriter bw = new BufferedWriter(osw);
        ) {
            bw.write("我是中国人abc");
            bw.write("我爱你中国123");
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}
我是中国人abc我爱你中国123
1.2 打印流
PrintStream/PrintWriter(打印流)
- 作用:打印流可以实现更方便、更高效的打印数据出去,能实现打印啥出去就是啥出去

1.2.1 PrintStream打印流
- PrintStream提供的打印数据的方案

 
import java.io.*;
import java.nio.charset.Charset;
public class ZhuanhuangLei {
    public static void main(String[] args) {
        try (
                // 1、创建一个打印流管道
                PrintStream ps =
                        new PrintStream("lianxi\\src\\com\\qianxin\\file\\1.txt", Charset.forName("GBK"));
        ) {
            ps.println(97);
            ps.println('a');
            ps.println("我爱你中国abc");
            ps.println(true);
            ps.println(99.5);
            ps.write( 97);//'a'
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
1.2.2 PrintWriter打印流
PrintWriter提供的打印数据的方案
 
import java.io.*;
import java.nio.charset.Charset;
public class ZhuanhuangLei {
    public static void main(String[] args) {
        try (
                // 1、创建一个打印流管道
                PrintWriter ps =
                        new PrintWriter("lianxi\\src\\com\\qianxin\\file\\1.txt");
        ) {
            ps.println(97);
            ps.println('a');
            ps.println("我爱你中国abc");
            ps.println(true);
            ps.println(99.5);
            ps.write( 97);//'a'
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
低级流才可以追加内容
    try (
                // 1、创建一个打印流管道
                PrintWriter ps =
                        new PrintWriter(new FileOutputStream("lianxi\\src\\com\\qianxin\\file\\1.txt"),true);//低级流才可以追加内容
        ) {
        }
1.2.3 PrintStream和PrintWriter的区别
- 打印数据的功能上是一模一样的:都是使用方便,性能高效(核心优势)
- PrintStream继承自字节输出流OutputStream,因此支持写字节数据的方法
- PrintWriter继承自字符输出流Writer,因此支持写字符数据出去,
1.2.4 打印流的应用
- 输出语句的重定向
  
System.out.println out其实就是打印流的对象
import java.io.*;
import java.nio.charset.Charset;
public class ZhuanhuangLei {
    public static void main(String[] args) {
        System.out.println("老骥伏枥");
        System.out.println("志在千里");
        try (
                PrintStream ps= new PrintStream("lianxi\\src\\com\\qianxin\\file\\1.txt");
        ){
            // 把系统默认的打印流对象改成自己设置的打印流
            System.setOut(ps);
            System.out.println("烈士暮年");
            System.out.println("壮心不已");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

1.3 数据流
- 分为DataOutputstream数据输出流和Datalnputstream数据输入流

1.3.1 DataOutputstream数据输出流
- 允许把数据和其类型一并写出去

import java.io.*;
import java.nio.charset.Charset;
public class ZhuanhuangLei {
    public static void main(String[] args) {
        try (DataOutputStream dos =
                     new DataOutputStream(new FileOutputStream("lianxi\\src\\com\\qianxin\\file\\1.txt"));
        ){
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF( "黑马程序员666!");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
写进去的的数据不是乱码,写进去的数据不是用来看的,要想读使用下面的Datalnputstream来反向读取
   a@X�      榛戦┈绋嬪簭鍛�666!
1.3.2 Datalnputstream数据输入流
Datalnputstream(数据输入流)
- 用于读取数据输出流写出去的数据。

public class ZhuanhuangLei {
    public static void main(String[] args) {
        try (DataInputStream dos =
                     new DataInputStream(new FileInputStream("lianxi\\src\\com\\qianxin\\file\\1.txt"));
        ){
            int i = dos.readInt();
            System.out.println(i);
            double d = dos.readDouble();
            System.out.println(d);
            boolean b = dos.readBoolean();
            System.out.println(b);
            String rs = dos.readUTF();
            System.out.println(rs);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
97
99.5
true
黑马程序员666!
1.4 序列流
需要将java对象写出去到文件中存起来,然后再读出来
- 对象序列化:把Java对象写入到文件中去
- 对象反序列化:把文件里的Java对象读出来
  
1.4.1 ObjectOutputstream对象字节输出流
- 可以把Java对象进行序列化:把Java对象存入到文件中去

要把对象写进文件中去就先创建一个对象

package com.qianxin.file;
public class Student implements Serializable{
    private String name;
    private String LoginName;
    private int age;
    private String passwd;
    public Student() {
        
    }
    public Student(String name, String loginName, int age, String passwd) {
        this.name = name;
        LoginName = loginName;
        this.age = age;
        this.passwd = passwd;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getLoginName() {
        return LoginName;
    }
    public void setLoginName(String loginName) {
        LoginName = loginName;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getPasswd() {
        return passwd;
    }
    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", LoginName='" + LoginName + '\'' +
                ", age=" + age +
                ", passwd='" + passwd + '\'' +
                '}';
    }
}
序列化对象
import java.io.*;
public class ZhuanhuangLei {
    public static void main(String[] args) {
        try(
                // 2、创建一个对象字节输出流包装原始的字节 输出流。
                ObjectOutputStream oos =
                    new ObjectOutputStream(new FileOutputStream("lianxi\\src\\com\\qianxin\\file\\3.txt"));
        ){
            Student student = new Student("admin","lisi",23,"123456");
            // 2、创建一个对象字节输出流包装原始的字节 输出流。
            oos.writeObject(student);
            System.out.println("序列化对象成功!!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
序列化对象成功!!
1.4.2 Objectlnputstream对象字节输入流
- 可以把Java对象进行反序列化:把存储在文件中的Java对象读入到内存中来
  
 如果不想将密码写进序列化文件中可以使用参数 transient 这个成员变量将不参与列化
// transient 这个成员变量将不参与列化
private transient String passWord;]
import java.io.*;
public class ZhuanhuangLei {
    public static void main(String[] args) {
        try(
                // 1、创建一个对象字节输入流管道,包装 低级的字节输入流与源文件接通
                ObjectInputStream ois
                        =new ObjectInputStream(new FileInputStream("lianxi\\src\\com\\qianxin\\file\\3.txt"));
        ){
            // 2、创建一个对象接收字节输入流包装原始的字节 输出流。
            Student u=(Student) ois.readObject();
            System.out.println(u);
            System.out.println("反序列化对象成功!!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
Student{name='admin', LoginName='lisi', age=23, passwd='123456'}
反序列化对象成功!!
如果要一次序列化多个对象
- 用一个ArrayList集合存储多个对象,然后直接对集合进行序列化即可注意:ArrayList集合已经实现了序列化接口
1.5 IO框架
什么是框架?
- 解决某类问题,编写的一套类、接口等,可以理解成一个半成品,大多框架都是第三方研发的。
- 好处:在框架的基础上开发,可以得到优秀的软件架构,并能提高开发效率
- 框架的形式:一般是把类、接口等编译成class形式,再压缩成一个jar结尾的文件发行出去
什么是IO框架?
 封装了Java提供的对文件、数据进行操作的代码,对外提供了更简单的方式来对文件进行操作,对数据进行读写等。
1.5.1 commons-io导入
下载
 https://commons.apache.org/io/download_io.cgi
 
 选择核心文件导入项目
 
导入commons-io-2.11.0.jar框架到项目中去。
- 在项目中创建一个文件夹:lib
- 将commons-io-2.6.jar文件复制到lib文件夹
- 在jar文件上点右键,选择 Add as Library ->点击OK
- 在类中导包使用
  
  
  
  
1.5.1 Commons-IO框架
Commons-io是apache开源基金组织提供的一组有关10操作的小框架,目的是提高I0流的开发效率。
 
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
public class FileTest4 {
    public static void main(String[] args) throws Exception {
            FileUtils.copyFile(new File("lianxi\\src\\com\\qianxin\\file\\4.txt"),newFile("lianxi\\src\\com\\qianxin\\file\\5.txt"));
            FileUtils.copyDirectory(new File("lianxi\\src\\com\\qianxin\\file"),new File("lianxi\\src\\com\\qianxin\\file1"));
            FileUtils.deleteDirectory(new File("lianxi\\src\\com\\qianxin\\file1"));
            // Java提供的原生的一行代码搞定很多事情
            //Files.copy(Path.of("io-app2\\src|litheima01.txt"), Path.of("io-app2\\srcllb.txt"));
            System.out.println(Files.readString(Path.of("io-app2\\src\\litheima01.txt")));
    }
}



















