Java之IO

1.流

概念：内存与存储设备间传输数据的通道

分类：
按方向：输入（存储设备->内存），输出（内存->存储设备）

按单位：字节流（字节为单位，可读所有），字符流（字符为单位，只读文本）
按功能：节点流（读写功能），过滤流（节点流上增加功能）

2.字节流

文件字节流

FileInputStream和FileOutputStream是InputStream和OutputStream的子类。

单字节读取

public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\\hehe.txt");

        int data = 0;

        while ((data = fis.read() )!= -1){
            System.out.print((char)data);
        }
        fis.close();
    }

一次性读取多个字节

public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\\hehe.txt");

        byte[] buf = new byte[1024];

        int count = fis.read(buf);

        System.out.println(new String(buf));
        System.out.println(count);

        fis.close();
    }

一次性写入一个字符串

 public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("D:\\test\\bbb.txt");

        String word = "helloworld";

        fos.write(word.getBytes());

        fos.close();

    }

文件的复制

public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("D:\\test\\bbb.txt");

        FileOutputStream fos = new FileOutputStream("D:\\test\\aaa.txt");

        byte[] buf = new byte[1024];

        int count = 0;

        while ((count = fis.read(buf)) != -1){
            fos.write(buf,0,count);
        }

        fis.close();
        fos.close();
        
    }

BufferedInputStream

public static void main(String[] args) throws IOException {

        FileInputStream fis = new FileInputStream("D:\\test\\aaa.txt");

        BufferedInputStream bis = new BufferedInputStream(fis);

        for (int data = 0;data != -1;data = bis.read()){
            System.out.print((char)data);
        }

        bis.close();
    }

BufferedOutputStream

 public static void main(String[] args) throws Exception{

        FileOutputStream fos = new FileOutputStream("D:\\test\\ccc.txt");

        BufferedOutputStream bos = new BufferedOutputStream(fos);

        for (int i = 0; i < 10; i++) {
            bos.write("helloworld".getBytes());
            bos.flush();
        }

        bos.close();
    }

序列化和反序列化

Java序列化是把 对象 转换为 字节序列 的过程,用ObjectOutputStream实现
Java反序列化是把 字节序列 恢复为 对象过程，用,用ObjectInputStream实现

要求：序列化的类必须实现Serializable接口。

public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("d:\\test\\stu.bin");

        ObjectOutputStream oos = new ObjectOutputStream(fos);

        Student student = new Student("张三",20);

        oos.writeObject(student);

        oos.close();

        System.out.println("完成");
    }

反序列化

public static void main(String[] args) throws Exception {

        FileInputStream fis = new FileInputStream("d:\\test\\stu.bin");

        ObjectInputStream ois = new ObjectInputStream(fis);

        Student student =(Student) ois.readObject();

        ois.close();
    }

序列化版本ID：保证序列化和反序列化的类是同一个类
使用transient修饰的属性，不能被序列化
’序列化多个对象，用集合实现

乱码出现的原因：编码和解码的方式不一样

3.字符流

字节流遇到的问题：读3个汉字，12字节，字节流一个字节一个字节读导致乱码

单个字符读取

public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("D:\\test\\ccc.txt");

        int data = 0;
        while ((data=fr.read()) != -1){
            System.out.print((char) data);
        }
    }

字符数组读取

public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("D:\\test\\ccc.txt");

        char[] buf = new char[1024];

        int count = 0;
        while ((count=fr.read(buf)) != -1){
            System.out.print(new String(buf,0,count));
        }
    }

字符流的写

 public static void main(String[] args) throws Exception{
        FileWriter fw = new FileWriter("D:\\test\\dd.txt");

        for (int i = 0; i < 10; i++) {
            fw.write("java是最好语言\n");
        }

        fw.close();
    }

字符流复制

public void charCopy() throws Exception{
        FileReader fr = new FileReader("D:\\test\\dd.txt");

        FileWriter fw = new FileWriter("D:\\test\\ddd.txt");

        int data = 0;

        while ((data = fr.read()) != -1){
            fw.write(data);
            fw.flush();
        }

        fr.close();
        fw.close();

    }

 @Test
    public void BufferedReaderTest() throws Exception{

        FileReader reader = new FileReader("D:\\test\\dd.txt");

        BufferedReader br = new BufferedReader(reader);

        char[] buf = new char[1024];

        int count;

        while ((count = br.read(buf)) != -1){
            System.out.println(new String(buf,0,count));
        }

        br.close();
    }

    @Test
    public void BufferedReaderTest2() throws Exception{

        FileReader reader = new FileReader("D:\\test\\dd.txt");

        BufferedReader br = new BufferedReader(reader);

        String line = null;

        while ((line = br.readLine())!= null){
            System.out.println(line);
        }

        br.close();

    }


    @Test
    public void BufferedWriter() throws Exception{

        FileWriter fileWriter = new FileWriter("D:\\test\\write.txt");

        BufferedWriter bw = new BufferedWriter(fileWriter);

        bw.write("我凑");

        bw.close();

    }


    /**
     * 打印流
     * @throws Exception
     */
    @Test
    public void printWriter() throws Exception{
        PrintWriter pw = new PrintWriter("D:\\test\\pw.txt");

        pw.println("true");
        pw.println(123);

        pw.close();
    }

    /**
     *转换流，硬盘上的字节流和内存的字符流之间的转换
     * 可设置编码格式
     */
    @Test
    public void InputStreamReader() throws Exception{

        FileInputStream fis = new FileInputStream("D:\\test\\dd.txt");

        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");

        int data = 0;

        while ((data = isr.read())!= -1){
            System.out.print((char) data);
        }

        isr.close();
    }


    @Test
    public void OutputStreamWriter() throws Exception{

        FileOutputStream fos = new FileOutputStream("D:\\test\\tt.txt");

        OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");

        osw.write("qqqqqq吾问无为谓吾问无为谓");

        osw.close();
    }

文件的操作

import org.junit.Test;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.Date;

public class FileTest {


    @Test
    public void FileOpe() throws Exception {
        File file = new File("D:\\test\\fileeeee.txt");
        //System.out.println(file.toString());

        if (!file.exists()){
            file.createNewFile();
        }

        System.out.println(file.getAbsolutePath());

        System.out.println(file.getName());

        System.out.println(file.getParent());

        System.out.println(new Date(file.lastModified()).toLocaleString());

        System.out.println(file.isFile());
        //file.delete();
    }

    @Test
    public void DirOpe() throws Exception {

        File dir = new File("D:\\test");

        if (!dir.exists()){
            dir.mkdirs();
        }

        //dir.delete();

        System.out.println(dir.isDirectory());
        String[] list = dir.list();

//        for (String s:list
//             ) {
//            System.out.println(s);
//        }

        File[] jpgs = dir.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith("txt")) {
                    return true;
                } else {
                    return false;
                }
            }
        });

        for (File f: jpgs
             ) {
            System.out.println(f.getName());
        }

    }

    @Test
    public void listDirRun(){
        File dir = new File("D:\\test1");
        delDir(dir);
    }


    public void listDir(File dir){

        File[] files = dir.listFiles();


        if (files!=null&&files.length>0){

            for (File f:files
                 ) {
                if (f.isDirectory()){
                    listDir(f);
                } else {
                    System.out.println(f.getAbsolutePath());
                }
            }
        }

    }


    public void delDir(File dir){
        File[] files = dir.listFiles();

        if (files!=null&&files.length>0) {
            for (File f : files
            ) {
                if (f.isDirectory()) {
                    delDir(f);
                } else {
                    System.out.println(f.getAbsolutePath()+"删除");
                    f.delete();
                }
            }
        }
        System.out.println(dir.getAbsolutePath()+"删除");
        dir.delete();
    }

}

properties
  @Test
    public void propertiesTest() throws Exception {
        Properties properties = new Properties();

        properties.setProperty("username","张三");

        properties.setProperty("age","20");

        Set<String> pronames = properties.stringPropertyNames();

        for (String s:pronames
             ) {
            System.out.println(s + properties.getProperty(s));
        }

//        PrintWriter pw = new PrintWriter("D:\\test\\pro.txt");
//        properties.list(pw);
//        pw.close();

//        FileOutputStream fos = new FileOutputStream("D:\\test\\store.properties");
//        properties.store(fos,"comments");
//        fos.close();

        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("D:\\test\\store.properties");
        properties2.load(fis);
        System.out.println(properties2);
    }