IO流

File类的使用

如何创建实例

1.	File file = new File("hello.txt")
2.	File file1 =new File("D:\\7-Zip","readme.txt");
3.	File file2 =new File(file1,"Licence.txt");

常用方法
4. geiabsolutepth（）；
5. getpath（）；
6. getname（）；
7. getparent（）；获取上层文件路径
8. long length()：获取文件长度（字节数）
9. long lastModified():获取最后一次的修改时间
10. String[] list（）：获取指定目录下的所有文件或者文件目录的名称数组
11. File[] ListFiles（）：获取指定剥下所有文件或者文件目录的FIle数组
判断
12. isDirectory（）判断是否是文件目录
13. isFile（）是否是文件
14. exists（）是否存在
15. canRead（）是否可读
16. canWrite（）是否可写
17. isHidden（）是否隐藏
18. public boolean createNewFile();创建文件，如果文件存在，返回false
19. boolean mkdir（）；船舰文件目录
20. boolean mkdirs（）；创建文件目录如果上层文件目录不存在，一并创建
21. boolean delete（）；删除文件或文件夹。

IO流原理及流的分类
谷歌IO大会

字节流（8bit） 图片视频
字符流（16bit） 文本 （一个文字3个字节）
缓冲流

节点流
读文件

package IO;

import org.junit.Test;

import java.io.*;

/**
 * @autor kevin
 * @detatil
 * read（）理解：返回读入一个字符。如果达到末尾返回-1，但我们不希望读取一个空文件，所以加一个判断。
 * 异常处理需要加入tay-catch-finally避免主动抛出异常，可能会造成资源泄露。
 * @create 2021-03-27-22:07
 */
public class FileRead {



    @Test
    public void method() throws IOException {
        //获取文件路径,在Test测试中默认是当前工程
        File file =new File("src\\IO\\HALLO");
        System.out.println(file.getAbsoluteFile());
        //创建文件流
        FileReader fileReader =new FileReader(file);
        //读数据
        int read = fileReader.read();
        //read():返回读入的字符。如果达到末尾返回-1；
        while (read != -1){
            System.out.println((char) read);
            read =fileReader.read();//读取下一个
        }
        //关闭流，不关闭会导致内存泄露
        fileReader.close();
    }
    @Test //方法二，将所有异常包装try catch finally，这样一定会关闭流。Ctrl alt t。
    public void method2(){
        //获取文件路径,在Test测试中默认是当前工程

        try {
            File file =new File("src\\IO\\HALLO");

            //创建文件流
            FileReader fileReader =new FileReader(file);
            //读数据
            int read = fileReader.read();
            //read():返回读入的字符。如果达到末尾返回-1；
            while (read != -1){
                System.out.println((char) read);
                read =fileReader.read();
            }
            //关闭流，不关闭会导致内存泄露
            fileReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Test //对read方法升级
    public void methd3(){
        FileReader fileRead =null;
        try {
            File file =new File("src\\IO\\HALLO");
            fileRead =new FileReader(file);
            char[] arr =new char[5];
            int len;
            while ((len = fileRead.read(arr)) != -1){
                for (int i = 0; i <len; i++) {
                    //错误写法for(int i =0;i<arr.length:i++)返回值不够，新的格式n会默认覆盖
                    //上一个的前n个数
                    System.out.print(arr[i]);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileRead.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

写文件

package IO;

import org.junit.Test;

import java.io.File;
import java.io.IOException;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-28-13:20
 */
public class FileWriter {


    @Test //如果没文件，自动生成，如果存在对原有文件覆盖.
    public void  method(){
        java.io.FileWriter fileWriter =null;
        try {
            File file =new File("src\\IO\\HALLO");
            fileWriter =new java.io.FileWriter(file,true);//ture添加，false，覆盖
            fileWriter.write("I hava a dream");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

读写

package IO.Fileread;

import org.junit.Test;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @autor kevin
 * @detatil 读写
 * @create 2021-03-28-13:45
 */
public class FileRW {

    @Test
    public void method(){
        File file =new File("src\\IO\\HALLO");
        File file1 =new File("src\\IO\\Fileread\\Write.txt");
        FileReader filereader =null;
        FileWriter fileWriter =null;
        try {
            filereader =new FileReader(file);
            fileWriter =new FileWriter(file1);
            int i  =filereader.read();
            while (i != -1){
                fileWriter.write((char)i);
                i =filereader.read();
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                filereader.close();
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字节的输入输出流（这里出现几个问题1.我使用byte型数组，while方法循环 还加了for循环遍历，其实不需要的，如果是sout输出才需要for循环。）

package IO;

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileLockInterruptionException;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-28-18:55
 */
public class StreamRead {


    @Test
    public void Method(){
        File file =new File("src\\IO\\lyy.jpg");
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            fileInputStream =new FileInputStream(file);
            fileOutputStream =new FileOutputStream("src\\IO\\dcdq.jpg");
            byte read[] =new byte[5];
            int k =0;
            while ((k = fileInputStream.read(read)) != -1){
                    fileOutputStream.write(read,0,k);
                    System.out.println("复制成功");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

缓冲流

package IO;

import org.junit.Test;

import java.io.*;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-28-20:23
 */
public class BufferStream {

    public void Method(String ora,String desc){
        BufferedInputStream bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream(ora));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(desc));
            byte[]arr =new byte[1024];
            int s = 0 ;
            while ((s= bufferedInputStream.read(arr)) !=-1){
                bufferedOutputStream.write(arr,0,s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufferedInputStream != null){
                    bufferedInputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (bufferedOutputStream != null){
                    bufferedOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    @Test
    public void Metest(){
        Long start = System.currentTimeMillis();
        Method("E:\\照片和视频\\大疆全景\\DJI_0047.MP4","C:\\Users\\Administrator\\Desktop\\11.MP4");
        Long end = System.currentTimeMillis();
        System.out.println("花费了="+(end-start));
    }
}

问题

package IO;

import org.junit.Test;

import java.awt.*;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.*;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-28-22:22
 */
public class Practice {
    HashMap<char[], Integer> map = new HashMap<>();
    char arr[] =new char[1];

    public void Method() {
        FileReader fileReader = null;
        try {
            fileReader = new FileReader("src\\IO\\HALLO");
            FileWriter fileWriter = new FileWriter("C:\\Users\\Administrator\\Desktop\\1.txt");
            int i = 0;
            int k = 0;
            while ((k = fileReader.read(arr)) != -1) {
                if (map.containsKey(arr)) {
                    i++;
                    map.put(arr, i);
                } else {
                    map.put(arr, i);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println(map.keySet());
        System.out.println(map.values());
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Practice practice = (Practice) o;
        return Objects.equals(map, practice.map);
    }

    @Override
    public int hashCode() {
        return map != null ? map.hashCode() : 0;
    }

    @Test
    public void mett() {
        Method();
    }
    @Test
    public void text(){
        Character a ='邓';
        Character b ='蔡';
        Character c ='邓';
        System.out.println(a.equals(c));
    }
}

转换流(只有Streaminputreader、Streamoutputwriter)字符流
原理
输入将一个字节流转为字符流
输出将一个字符流转为字节流

InputStreamReader inputStreamReader =
new InputStreamReader(new FileInputStream("src\\IO\\HALLO"),"gbk"

总结

总结
流的分类
所有流都是由4个基类延申出来的
字符流 字节流
FileRead FileInputstream
FileWrite FileOutputstream
缓冲流
BufferInputStream BufferReader
BufferOutputStream BufferWriter
转换流
InputStreamRead
InputStreamWrite

1. 如果只是做读写操作 底层用字节流，字符流都可以。如果做读，取操作 字符流就不行了。（会乱码）。
2. 如果使用数组读取特别是char byte数组，Write的时候需要使用这个方法

char b[] = new char[1024];
byte []c =new byte[1024];
int k;
while ((k =inputStreamReader.read(b)) != -1){
    outputStreamWriter.write(b,0,k);
    //       String a =new String(b,0,k);

}

基类

节点流
FileReader
FileWriter
FileinputStream
FileoutputStream
缓冲流
BufferinputSteram
BufferoutputStream
Bufferreader
Bufferwrite
转换流（字符流）字节流转字符流
原理如输入一个文本文档，用byte接 ，输出char给程序。程序将char给out。
转换流一般用来把文本的字符集转换。

Writer中默认false 可以改成ture改成追加，而不是覆盖。

IDEA如果使用
@Test 工程路径默认在当前module
Main 默认路径在project；

序列化流（可以对对象进行序列化，输入输出，json原理，理解：将数据打散为2进制文件，再反编译回来）

序列化 Objectoutputstream 将对象序列化为计算机文件
反序列化 Objectintputstream 将内存反序列化到计算机缓存
先序列化，在反序列化
注意
1.序列化的类以及类的内部变量需要支持序列化 实现seriariseble 接口。
2.序列化的类需要有uid，否则在序列化后如果修改类的内部内容，反序列化可能会报错
3.静态类或transient不可被序列化（原来是什么样的中间改变其内容，反序列化不会改变）
String的序列化，它已经实现了seria接口，所以可以直接序列化

@Test
    public void METHLD() throws IOException, ClassNotFoundException {
        Person person =new Person();
        ObjectOutputStream objectOutputStream =new ObjectOutputStream(new FileOutputStream("src\\OBJECTINPUTSTREAM\\object.dat"));
        objectOutputStream.writeObject(new String("helloworld"));
        objectOutputStream.flush();
        ObjectInputStream objectInputStream =new ObjectInputStream(new FileInputStream("src\\OBJECTINPUTSTREAM\\object.dat"));
        int i;
        byte c[] =new byte[1024];
        String s = (String) objectInputStream.readObject();
        System.out.println(s);
        objectInputStream.close();
        objectOutputStream.close();
    }
}

自定义Person类的序列化

package OBJECTINPUTSTREAM;

import org.junit.Test;

import java.io.*;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-31-20:55
 */
public class obtest {

    @Test
    public void METHLD() throws IOException, ClassNotFoundException {
        Person person =new Person();
        ObjectOutputStream objectOutputStream =new ObjectOutputStream(new FileOutputStream("src\\OBJECTINPUTSTREAM\\object.dat"));
        objectOutputStream.writeObject(new Person());
        objectOutputStream.flush();
        ObjectInputStream objectInputStream =new ObjectInputStream(new FileInputStream("src\\OBJECTINPUTSTREAM\\object.dat"));
        int i;
        byte c[] =new byte[1024];
        Person P = (Person) objectInputStream.readObject();
        P.method();
        objectInputStream.close();
        objectOutputStream.close();
    }
}

ackage OBJECTINPUTSTREAM;

import java.io.Serializable;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-31-20:56
 */
public class Person implements Serializable {
    public static final long serialVersionUID = 42123456L;
    private String name;
    private int k;
    public void method(){
        System.out.println("nihao");
    }
}

静态类的不可序列化

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-31-20:55
 */
public class obtest {

    @Test
    public void METHLD() throws IOException, ClassNotFoundException {
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("src\\OBJECTINPUTSTREAM\\object.dat"));
        objectOutputStream.writeObject(new Person("kevin",30,new son()));
        objectOutputStream.flush();
        objectOutputStream.close();
    }
        @Test
        public void  latileme() throws IOException, ClassNotFoundException {
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("src\\OBJECTINPUTSTREAM\\object.dat"));
            Person P = (Person) objectInputStream.readObject();
            System.out.println(P.name);
            objectInputStream.close();
        }
    }
    
package OBJECTINPUTSTREAM;

import java.io.Serializable;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-31-20:56
 */
public class Person implements Serializable {
    public static final long serialVersionUID = 42123456L;
    public static String name;
    public int k;
    public son s;

    public Person(String name, int k, son s) {
        this.name = name;
        this.k = k;
        this.s = s;
    }

    public void method(){
        System.out.println("nihao");
    }
    public void me(son s){

    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", k=" + k +
                '}';
    }
}
package OBJECTINPUTSTREAM;

import java.io.Serializable;

/**
 * @autor kevin
 * @detatil
 * @create 2021-03-31-23:08
 */
public class son implements Serializable {
}

随机读取文件流RandomAccess类
可以做输入流也可以做输出流，不继承和其他抽象基类没关系
直接继承Object，和Datainput dataoutput 可以读也可以写
读写例子

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.RandomAccess;

/**
 * @autor kevin
 * @detatil 继承datainput 和dataoutput 既能输入也能输出
 * @create 2021-04-01-21:38
 */
public class rdaftest {
    @Test
    public void Method() throws IOException {
        String a ="r";
        int i =0;
        byte c[] =new byte[1024];
        RandomAccessFile randomAccessFile =new RandomAccessFile(new File("src\\IO\\HALLO"),a);
        RandomAccessFile randomAccessFile1 =new RandomAccessFile(new File("src\\jw"),new String("rw"));
        while ((i=randomAccessFile.read(c)) != -1) {
            randomAccessFile1.write(c,0,i);
        }
        randomAccessFile.close();
        randomAccessFile1.close();
    }
}

做输出流的时候写出的文件如果存在会对原有文件内容进行覆盖，默认从头开始

@Test
public void Method() throws IOException {
        RandomAccessFile randomAccessFile =new RandomAccessFile(new File("src\\HOLLO"),new String("rw"));
        RandomAccessFile randomAccessFile1 =new RandomAccessFile(new File("src\\jk"),new String("rw"));
        randomAccessFile.write("xyz".getBytes());
        randomAccessFile.close();
    }

选择覆盖的位置seek方法

       @Test
    public void Method() throws IOException {
            RandomAccessFile randomAccessFile =new RandomAccessFile(new File("src\\HOLLO"),new String("rw"));
            RandomAccessFile randomAccessFile1 =new RandomAccessFile(new File("src\\jk"),new String("rw"));
            randomAccessFile.seek(3);//指针跳到角标为3的位置
            randomAccessFile.write("abc".getBytes());
        }
}

一个插入的小练习：因为RadomAccessFile只能做覆盖不能插入，所以放到数组里面操作

  @Test
    public void Method() throws IOException {
            //实现插入
            ArrayList <String>list =new ArrayList<>();
            FileReader f =new FileReader("src\\HOLLO");
            int i =0;
            while ((i = f.read()) !=-1){
                char o  =(char) i;
                list.add(String.valueOf(o));
            }
            String l  ="xyz";
            list.add(3,l);
            for (Object o :list
                 ) {
                System.out.print(o);
            }
        }
}

java7IO流新特性
NIO.2 中path、paths、files类的使用
JavaNIO概述：增强读写速度，希望替代IO，但不好用
NIO2概述:对NIO的增强.面向缓冲区.
JavaAPI 提供两套NIO，一套对标输入输出，一套做网络编程。

网络编程跳过
网络编程
IP地址InetAddress
2个常用方法解析域名的IP
@Test
public void method() throws UnknownHostException {
InetAddress address = InetAddress.getByName(“127.0.0.1”);
InetAddress address1 =InetAddress.getLocalHost();//获取本机IP
System.out.println(address1);
}