Java复习——IO操作

IO操作

文件操作类File

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

public class Temp {
    public static void main(String[] args){
        try {
            File file = new File("D:" + File.separator + "Java" + File.separator + "javaFile.txt");
            if (!file.getParentFile().exists()) {
                /**
                 * java.io.File.mkdir()：只能创建一级目录，且父目录必须存在，否则无法成功创建一个目录。
                 *
                 * java.io.File.mkdirs()：可以创建多级目录，父目录不一定存在。
                 */
                file.getParentFile().mkdirs();
            }
            if (file.exists()) {
                System.out.println("该文件已经存在啦");
                File newFileName = new File("D:" + File.separator + "Java" + File.separator + "javaFile2.txt");
                file.renameTo(newFileName);// 为文件重命名为javaFile2.txt
            } else {
                file.createNewFile();//创建文件
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

---

import java.io.File;

public class Temp {
    public static void main(String[] args){
        File rootFile = new File("D:\\Program Files");
        print(rootFile);
    }

    private static void print(File rootFile) {
        if (rootFile.isDirectory()) {
            File[] files = rootFile.listFiles();
            if (files != null) {
                for (int i =0;i < files.length;i++){
                    print(files[i]);
                }
            }
        } else {
            System.out.println(rootFile.getName());
        }
    }
}

##字节流
###字节输出流OutputStream
OutputStream是一个抽象类，一般使用子类FileOutputStream完成初始化

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Temp {

    public static void main(String[] args){
        OutputStream out = null;
        try {
            File file = new File("D:" + File.separator + "Java" + File.separator + "javaFile.txt");
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
            if (!file.exists()) {
                file.createNewFile();
            }
            out = new FileOutputStream(file);
            out.write("Hello World".getBytes());
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();// 一定要关闭资源
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

字节输入流InputStream

与OutputStream类似，也是一个抽象类，通常由FileInputStream实例化

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class Temp {

    public static void main(String[] args){
        InputStream in = null;
        try {
            File file = new File("D:" + File.separator + "Java" + File.separator + "javaFile.txt");
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
            if (!file.exists()) {
                file.createNewFile();
            }
            in = new FileInputStream(file);
            byte[] data = new byte[1024];
            int temp = -1;
            int index = 0;
            while ((temp = in.read()) != -1 ) {// 未读到末尾
                data[index] = (byte) temp;
                index++;
            }
            System.out.println(new String(data));
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();// 一定要关闭资源
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

---

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class Temp {

    public static void main(String[] args){
        InputStream in = null;
        try {
            File file = new File("D:" + File.separator + "Java" + File.separator + "javaFile.txt");
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
            if (!file.exists()) {
                file.createNewFile();
            }
            in = new FileInputStream(file);
            byte[] data = new byte[1024];
            int index = in.read(data); // 一次性读完
            System.out.println(new String(data,0,index));
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            if (in != null) {
                try {
                    in.close();// 一定要关闭资源
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

字符流

字符输出流Writer

同样是一个抽象类，通常由FileWriter实例化，相比于OutputStream，可直接输出字符串数据

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

public class Temp {

    public static void main(String[] args){
        Writer writer = null;
        try {
            File file = new File("D:" + File.separator + "Java" + File.separator + "javaFile.txt");
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
            if (!file.exists()) {
                file.createNewFile();
            }
            writer = new FileWriter(file);
            writer.write("r u ok111?");
        } catch (IOException e){
            e.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.close();// 一定要关闭资源,否则数据不会写入文件中
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

字符输入流Reader

同样是一个抽象类，通常由FileReader实例化，相比于OutputStream，方法基本一致

字节流和字符流的区别

首先，大多数情况下，优先使用字节流！

字节流在进行IO操作时，直接针对的是操作的数据终端（如文件）。而字符流操作时，不是直接针对于终端，而是针对于缓存区（理解为内存）的操作，而后由缓存区操作终端（如文件），这属于间接操作。按照这样的方式，如果在使用字节流时不关闭最后的输出流操作，也可以将所有的内容输出。但字符流不关闭，则意味着缓冲区的内容不会被输出，当然，用户可以手动去调用flush()进行强制性的手工清除。

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

public class Temp {

    public static void main(String[] args){
        Writer writer = null;
        try {
            File file = new File("D:" + File.separator + "Java" + File.separator + "javaFile.txt");
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
            if (!file.exists()) {
                file.createNewFile();
            }
            writer = new FileWriter(file);
            writer.write("r u ok111?");
            writer.flush();
        } catch (IOException e){
            e.printStackTrace();
        }
    }
}

转换流

OutputStream --> Writer : OutputStreamWriter(非抽象类、非接口，Writer的子类)
InputStream --> Reader : InputStreamReader(非抽象类、非接口，Reader的子类)

内存操作流

如果现在某个操作必须发生IO行为，但是又不希望有一些临时文件的产生，那么现在肯定无法使用之前的文件操作流。为了解决这样的问题，提供了内存操作流，即以内存进行操作的终端，以发生IO操作关系。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class Temp {

    public static void main(String[] args){
        ByteArrayInputStream byteArrayInputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;
        try {
             byteArrayInputStream = new ByteArrayInputStream("hello world".getBytes());
             byteArrayOutputStream = new ByteArrayOutputStream();
            int temp = 0;
            while ((temp = byteArrayInputStream.read()) != -1) {
                byteArrayOutputStream.write(Character.toUpperCase(temp));
            }
            String string = byteArrayOutputStream.toString();
            System.out.println(string);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (byteArrayInputStream != null) {
                    byteArrayInputStream.close();
                }
                if (byteArrayOutputStream != null) {
                    byteArrayOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }
}

序列化

包名、类名和属性可以被序列化，方法和构造器不会被序列化。

静态属性不会被序列化

属性会被递归序列化，也就是一个类中有引用类型的属性，如果这个属性对应的类实现了Serializable接口，在对象序列化时，也同样会对这个类中的属性进行对象序列化，如果没有实现Serializable接口，则会抛出异常

网络中传递对象必须实现序列化

trasient关键字

默认情况下，当一个类的对象被序列化时，这个类中的所有属性都被保存下载，如果现在的某些属性不希望被保存，那么可以使用transient进行声明