IO： 功能流: 缓冲流 ：字节缓冲流 字符缓冲流 ， Data流，Object 流, 序列号,CommonsIO ,集合

按照功能分:
    节点流 : 真实做读入写出
    功能流 : 加强性能

    功能流都要包裹节点流使用

 缓冲流 : 功能流
    作用: 提高读写效率

    字节节点流:
        FileInputStream 文件流 | ByteArrayInputStream 字节数组流
        FileOutputStream | ByteArrayOutputStream

    字节缓冲流 : 字节流功能流的一种
        BufferedInputStream 字节输入缓冲流
        BufferedOutputStream 字节输出缓冲流

        无新增功能,可以发生多态

    字符节点流
        FileReader
        FileWriter
    字符缓冲流
        BufferedReader
        BufferedWriter

//字节缓冲流 
public class Class001_Buffered {
    public static void main(String[] args) throws IOException {
        //1.创建流
        InputStream is = new BufferedInputStream(new FileInputStream("D://test.txt"));
        OutputStream os = new BufferedOutputStream(new FileOutputStream("D://heihei.txt"));
        //2.拷贝
        byte[] car = new byte[1024];
        int len = -1;
        while((len=is.read(car))!=-1){
            os.write(car,0,len);
        }

        //3.刷出
        os.flush();

        //4.关闭
        os.close();
        is.close();
    }
}

字符缓冲流
    BufferedReader
    BufferedWriter

    存在新增方法: 不能发生多态
        readLine()
        newLine()//换行

public class Class002_Buffered {
    public static void main(String[] args) throws IOException {
        //1.创建流
        BufferedReader rd = new BufferedReader(new FileReader("D://test.txt"));
        BufferedWriter rw = new BufferedWriter(new FileWriter("D://b.txt"));
        //2.读写
        String msg = null;
        while((msg = rd.readLine())!=null){
            rw.write(msg);
            rw.newLine();
            //rw.write("\n\r");
        }

        //3.刷出
        rw.flush();
        //4.关闭
        rw.close();
        rd.close();
    }
}

基本数据类型流|Data流
    功能: 功能流   操作单元: 字节流
    作用: 保留数据已经数据类型(基本数据类型+String)

    DataInputStream
        新增功能:  readXxx()
    DataOutputStream
        新增功能:  writeXxx()

 注意:
    读入与写出的顺序要保持一致
    java.io.EOFException : 读入的文件不是源文件

public class Class001_Data {
    public static void main(String[] args) throws IOException {
        readFromFile("D:/d.txt");
    }

    //读入
    public static void readFromFile(String path) throws IOException {
        //1.创建流
        DataInputStream is = new DataInputStream(new BufferedInputStream(new FileInputStream(path)));

        //2.读入
        int i = is.readInt();
        boolean flag = is.readBoolean();
        char ch = is.readChar();
        String s = is.readUTF();

        //3.处理数据
        System.out.println(i);
        System.out.println(flag);
        System.out.println(ch);
        System.out.println(s);

        //4.关闭
        is.close();
    }

    //写出
    public static void writeToFile(String path) throws IOException {
        //1.创建输出流
        DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));

        //2.准备数据
        int i = 1;
        boolean flag = false;
        char ch = 'c';
        String str = "哈哈";

        //3.写出
        out.writeInt(i);
        out.writeBoolean(flag);
        out.writeChar(ch);
        out.writeUTF(str);

        //4.刷出
        out.flush();

        //5.关闭
        out.close();
    }
}

Object 流| 对象流 | 引用数据类型流
        作用: 读写对象数据|引用数据类型的数据(包含基本数据类型)
        ObjectInputStream  反序列化输入流
            新增功能: readObject()
        ObjectOutputStream 序列化输出流
            新增功能: writeObject(Object obj)

        序列化: 将对象数据转换一个可存储或者可传输的状态过程

        先序列化后反序列化
        不能所有的类型都能序列化  java.io.Serializable
        不是所有的属性都需要序列化
        静态的内容不会序列化
        如果父类实现序列化,子类没有实现,可以序列化所有的成员
        如果子类实现序列化,父类实现,只能序列化子类成员
 
public class Class001_Object {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        writeToFile("D://e.txt");
        readFile("D://e.txt");
    }

    //反序列化
    public static void readFile(String path) throws IOException, ClassNotFoundException {
        //1.输入流
        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(new FileInputStream(path)));

        //2.读入
        User obj1 = (User) in.readObject();
        int[] arr = (int[]) in.readObject();

        //3.处理数据
        System.out.println(obj1);
        System.out.println(Arrays.toString(arr));

        //4.关闭
        in.close();

    }

    //序列化输出
    public static void writeToFile(String path) throws IOException {
        //1.输出流
        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(path)));

        //2.数据
        User user = new User("zhangsan",18,"123");
        int[] arr = {1,2,3,4};

        //3.写出
        out.writeObject(user);
        out.writeObject(arr);

        //4.刷出
        out.flush();

        //5.关闭
        out.close();

        //修饰user对象的成员,静态
        user.username = "lisi";
        user.password = "4321";
    }
}

class User implements Serializable{
    public String username;
    //transient 修饰的字段不会序列化
    public transient int age;
    public static String password;

    public User() {
    }

    public User(String username, int age, String password) {
        this.username = username;
        this.age = age;
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                ", password='" + password + '\'' +
                '}';
    }
}

通过序列号控制版本不一致问题:
     1.实现Serializable接口的类型默认生成序列号,序列号会根据成员的修改做更新  serialVersionUID = -5204947308809070324
     2.控制版本的统一问题: 控制类型修改之前与之后序列不变
     3.通过工具生成序列号: 1.实现Serializable接口  2.setting设置  3.选中类名->alt+enter->生成序列号

 

CommonsIO 是apache的一个开源的工具包,封装了IO操作的相关类,使用Commons IO可以很方便的读写文件,url源代码等。

使用第三方组件的方式|步骤:
    1.下载源码资源,找到核心jar包
    2.项目下新建文件夹lib,放入jar包
    3.commons-IO 需要加入classpath 的第三方 jar 包内的 class 文件才能在项目中使用
      选中jar包右键->add as lib...

public class Class001_CommonsIO {
    public static void main(String[] args) throws IOException {
        //1.创建File对象
        File src = new File("D://a.txt");
        File dest = FileUtils.getFile("D://f.txt");

        //FilenameUtils
        //isExtension(String fileName, String text) // 判断fileName是否是text后缀名
        //FilenameUtils.getBaseName(String filename) // 去除目录和后缀后的文件名
        System.out.println(FilenameUtils.getBaseName("D://DDD/haha.txt"));;
        System.out.println(FilenameUtils.getName("D://DDD/haha.txt"));;
        System.out.println(FilenameUtils.isExtension("D://DDD/haha.txt","txt"));;

        //FileUtils
        //FileUtils.copyFile(File srcFile, File destFile)` // 复制文件
        FileUtils.copyFile(src,dest);


        // **复制文件夹**
        //FileUtils.copyDirectory(File srcDir, File destDir)` // 复制文件夹（文件夹里面的文件内容也会复制）
        FileUtils.copyDirectory(new File("D://DDD"), new File("D://hehe/DDD"));
        //FileUtils.copyDirectory(File srcDir, File destDir, FileFilter filter)` // 复制文件夹，带有文件过滤功能
        FileUtils.copyDirectory(new File("D://DDD"),  new File("D://houhou/DDD"), FileFilterUtils.fileFileFilter());

        //**把字符串写入文件**
        //`FileUtils.writeStringToFile(File file, String data, String encoding)`  // 字符串以指定的编码写到文件
        //`FileUtils.writeStringToFile(File file, String data, String encoding, boolean append)`// 指定知否追加
        FileUtils.writeStringToFile(src,"yyds!!!!","UTF-8",true);
    }
}

se阶段重点内容:
    方法
    面向对象
    集合

数组 : 存储多个数据

特点:
    1.引用数据类型
    2.定长的,长度一旦确定不可改变
    3.存储相同数据类型的数据
    4.有序,根据索引操作数组中的数据

 需求: --> 容器|集合
    1.容量跟随内容的多少进行动态的增删
    2.存储任意引用类型数据

 手动简单封装容器类型:
    数组

public class Class001_App {
    public static void main(String[] args) {
        //容器类型
        ArrayList list = new ArrayList();

        list.add("zhangsan");
        list.add(123);
        System.out.println(list.size());
        System.out.println(list.get(0));
        System.out.println(list.get(1));

        MyContainer my = new MyContainer();
        my.add("abc");
        my.add("efg");
        System.out.println(my.size());
        my.add("efg");
        System.out.println(my.size());
        System.out.println(my.get(0));
        System.out.println(my.get(1));
        System.out.println(my.get(2));
    }
}

//封装自定义容器类型 : 只能存储字符串类型的数据
class MyContainer{
    //存储数据的结构
    private String[] elementData;
    //存储数据的个数
    private int size;

    public MyContainer() {
    }

    //添加方法
    public void add(String value) {
        //判断是否为第一次添加数据
        if(elementData==null && size==0){
            //创建新数组
            elementData = new String[1];
            //直接把value放入数组
            elementData[0] = value;
            //长度+1
            size++;
            return;
        }
        //备份原数组: 用来做数组数据拷贝
        String[] temp = elementData;
        //创建新数组
        elementData = new String[size+1];
        //1)数组数据的拷贝 i作为新数组与原数组索引
        for(int i=0;i<size;i++){
            elementData[i] = temp[i];
        }
        //2)添加新数据
        elementData[size++] = value;
        //长度+1
    }

    //size
    public int size(){
        return this.size;
    }

    /**
     * 根据索引获取数据
     * @param index 索引
     * @return index索引位置的数据
     */
    public String get(int index) {
        if(index<0 || index>=size){
            throw new IndexOutOfBoundsException("索引越界啦!!!");
        }
        return elementData[index];
    }

    //根据索引删除
    //修改制定索引位置的数据
}

Collection
        集合层次结构中的根接口。 集合表示一组对象，称为其元素 。
 
public class Class001_Collection {
    public static void main(String[] args) {
        //集合
        Collection col = new ArrayList();
        Collection col2 = new ArrayList();
        //常用方法
        //boolean add(E e) 确保此集合包含指定的元素（可选操作）。
        //boolean addAll(Collection<? extends E> c) 将指定集合中的所有元素添加到此集合中（可选操作）。
        col.add("abc");
        col.add(false);
        col.add(100);

        col2.add("aaa");
        col2.add("bbb");

        System.out.println(col);
        col.addAll(col2);
        System.out.println(col);

        //boolean contains(Object o) 如果此collection包含指定的元素，则返回 true 。
        //boolean containsAll(Collection<?> c) 如果此集合包含指定集合中的所有元素，则返回 true 。
        System.out.println(col.contains(100));
        col2.add("ccc");
        System.out.println(col.containsAll(col2));

        //boolean remove(Object o) 从此集合中移除指定元素的单个实例（如果存在）（可选操作）。
        //boolean removeAll(Collection<?> c) 删除此集合的所有元素，这些元素也包含在指定的集合中（可选操作）。
        System.out.println(col.remove(100));
        System.out.println(col);
        //System.out.println(col.removeAll(col2));
        //System.out.println(col);

        //boolean retainAll(Collection<?> c) 仅保留此集合中包含在指定集合中的元素（可选操作）。
        System.out.println(col.retainAll(col2));
        System.out.println(col);
        System.out.println(col2);

        //Object[] toArray() 返回包含此集合中所有元素的数组。
        System.out.println(Arrays.toString(col.toArray()));
    }
}

遍历
        1.foreach
        2.iterator迭代器
 */
public class Class002_Each {
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add("aaa");
        col.add("bbb");
        col.add("ccc");
        col.add("ddd");

        //1.增强for
        for(Object s:col){
            System.out.println(s);
        }

        //2.迭代器
        //1)获取迭代器对象
        Iterator it = col.iterator();
        //2)判断是否存在下一个数据
        while(it.hasNext()){
            //3)获取下一个数据
            System.out.println(it.next());
        }

    }
}