java文件

File

File创建

		1.根据路径构建File
        File file = new File("d:\\1.txt");
        2.根据父目录文件+子路径构建文件
        File parentFile = new File("d:\\");
        String fileName = "2.txt";
        File file = new File(parentFile, fileName);
        3.父目录+子路径构建
        String parentPath = "d:\\";
        String fileName = "3.txt";
        File file = new File(parentPath, fileName);
        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

File的基本方法

 		File file = new File("d:\\2.txt");
        file.getName();//获取文件名
        file.getAbsolutePath();//文件绝对路径
        file.getParent();//得到文件的父级目录
        file.length();//文件大小 字节(utf-8 汉字3个字节)
        file.exists();//文件是否存在
        file.isDirectory();//是否是目录
        file.isFile();//是否是文件
        file.mkdir();//创建目录
        file.mkdirs();//创建多级目录
        file.delete();//删除文件、空目录

I/O

字节流：二进制文件
字符流：文本文件
都是抽象类，使用的时候都要创建子类使用

字节流

FileInputStream 文件输入流

一个字节读取

	public static void main(String[] args) {
        String path = "d:\\2.txt";//hello world
        int data;
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(path);
            while ((data=fileInputStream.read())!= -1){ //读取一个字节  遇到汉字乱码
                System.out.print((char)(data));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

多个字节读取

public static void main(String[] args) {
        String path = "d:\\2.txt";//hello world
        byte[] data = new byte[8];
        int readLen =0;
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(path);
            while ((readLen = fileInputStream.read(data))!= -1){ //读取正常 返回实际读取的字节数
                System.out.println(new String(data,0,readLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

FileOutputStream 文件输出流

文件不存在的话会创建,write会覆盖前面的内容，使用new FileOutputStream(filePath,true);创建则会追加

@Test
    public void writeFile(){
        FileOutputStream fileOutputStream = null;
        String filePath = "d:\\hello.txt";
        try {
            fileOutputStream = new FileOutputStream(filePath);
//            fileOutputStream.write('H');
            String s = "hello,world"; //String.getBytes
//            fileOutputStream.write(s.getBytes(StandardCharsets.UTF_8));
            fileOutputStream.write(s.getBytes(),0,s.length());
        }  catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

文件拷贝(File)

 @Test
    public void copyFile(){
        String srcPath = "d:\\胡歌.jpeg";
        String descPath = "e:\\1.jpeg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            fileInputStream = new FileInputStream(srcPath);
            fileOutputStream = new FileOutputStream(descPath);
            byte[] buffer = new byte[1024];
            int readLen = 0;
            while ((readLen = fileInputStream.read(buffer)) != -1){
                fileOutputStream.write(buffer,0,readLen);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(fileInputStream != null){
                    fileInputStream.close();
                }
                if(fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

字符流

FileReader

使用单个字符读取文件

public void fileReader(){
        FileReader fileReader = null;
        int data =0;
        try {
            fileReader = new FileReader("d:\\2.txt");
            while ( (data = fileReader.read()) != -1){
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(fileReader != null){
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

字符数组读取文件

public void fileReader(){
        FileReader fileReader = null;
        int dataLen =0;
        char[] buff = new char[8];
        try {
            fileReader = new FileReader("d:\\2.txt");
            while ( (dataLen = fileReader.read(buff)) != -1){
                System.out.print(new String(buff,0,dataLen));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(fileReader != null){
                    fileReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

FileWriter

使用FileWriter 一定要close 或者 flush 方法 否则数据写不进去
writeBytes();

  public static void main(String[] args) {
        String path = "d:\\hello.txt";
        char[] chars = {'a','b','c'};
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(path,true);
            fileWriter.write('h');//写入单个字符
            fileWriter.write(chars);//写数组
            fileWriter.write("往者不可谏".toCharArray(),0,2);//写入数组指定部分
            fileWriter.write("来者犹可追");//写入字符串
            fileWriter.write("今天你好",0,2);//指定字符串
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fileWriter.close();
//                fileWriter.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

节点流和处理流

1.节点流可以从一个特定的数据源读写数据，如FileReader 、FileWriter
2.处理流（也叫包装流）是连接在已存在的流（节点流或者处理流）之上为程序提供更为强大的读写功能，如BufferedReader bufferedWriter
（bufferedReader类中有属性Reader，可以封装一个节点流，只要是Reader的子类就可以）

节点流和处理流的区别

1.节点流是底层流/低级流，直接跟数据源连接
2.处理流（包装流）包装节点流，既可以消除不同节点流的实现差异，也可以提供更方便的方法来完成输入输出。
3.处理流对节点流进行包装，使用修饰器设计模式 不会直接与数据源相连

处理流的功能主要体现在以下两个方面：
1.性能的提高：主要增加缓冲的方式来提高输入输出的效率。
2.操作的便捷：处理流可以提供一系列的便捷方法来一次输入输出大批量的数据，使用更加灵活方便。

关闭只需要关闭外层流 bufferedReader.close();

 public void close() throws IOException {
        synchronized (lock) {
            if (in == null)
                return;
            try {
                in.close(); //Reader
            } finally {
                in = null;
                cb = null;
            }
        }
    }

模拟修饰器设计模式

父类 Reader_

public abstract class Reader_ {
//     abstract void readFile(); //如果写的是抽象方法，则子类要实现全部的抽象方法
//     abstract void readString();
    void readFile(){ //子类重写父类的方法
        System.out.println("read_file");
    };
    void readString(){
        System.out.println("read_string");
    };
}

public class FileReader_ extends Reader_ {
    public void readFile(){
        System.out.println("readFile");
    }
}

public class StringReader_ extends Reader_ {
    public void readString(){
        System.out.println("readString");
    }
}

public class BufferedReader_ extends Reader_ {
    private Reader_ reader_;

    public BufferedReader_(Reader_ reader_) { //调用子类的
        this.reader_ = reader_;
    }


    public void readFiles(){
        this.reader_.readFile();
    }

    public void readStrings(){
        this.reader_.readString();
    }
}

public class Test {
    public static void main(String[] args) {
        BufferedReader_ bufferedReader_ = new BufferedReader_(new FileReader_());
        bufferedReader_.readFiles(); //readFile
        bufferedReader_.readFile(); //read_file
        BufferedReader_ bufferedReader_1 = new 	BufferedReader_(new StringReader_());
        bufferedReader_1.readStrings();//readString
        bufferedReader_1.readString();//read_string
    }
}

bufferedReader

@Test
    public void bufferedReader_(){
        BufferedReader bufferedReader = null;
        String path = "d:\\2.txt";
        try {
            bufferedReader = new BufferedReader(new FileReader(path));
            String line;//按行读取
            while( (line = bufferedReader.readLine()) != null){
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
            	if(bufferedReader != null){
                	bufferedReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

bufferedWriter

public void bufferedWriter_(){
        String path = "d:\\3.txt";
        BufferedWriter bufferedWriter = null;
        try {
            bufferedWriter =new BufferedWriter(new FileWriter(path,true));//追加方式 在节点流加true
            bufferedWriter.write("时间就像火车一样，飞速驶离，但我却象在车厢内熟睡的乘客般毫无知觉。一旦醒来，已经错过很多的东西，甚至错过停靠的站。");
            bufferedWriter.newLine();//插入和系统相关的换行
            bufferedWriter.write("在不了解一个人之前，不要轻易下结论，在了解一个人之后，也不要轻易下结论。人这么复杂，岂是你一句结论就能概全的？");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
            	if(bufferedWriter != null){
            		bufferedWriter.close();
				}
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

处理流拷贝(bufferedReader bufferedWriter)

 @Test
    public void bufferedCopy(){
        String srcPath ="d:\\2.txt";
        String descPath = "d:\\4.txt";
        BufferedReader bufferedReader = null;
        BufferedWriter bufferedWriter = null;
        try {
            bufferedReader = new BufferedReader(new FileReader(srcPath));
            bufferedWriter = new BufferedWriter(new FileWriter(descPath));
            String line;
            while ((line = bufferedReader.readLine()) != null){
                bufferedWriter.write(line);
                bufferedWriter.newLine();//得加上换行符 要不然格式会乱
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(bufferedReader != null) {
                    bufferedReader.close();
                }
                if(bufferedWriter != null) {
                    bufferedWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

 

bufferedInputStream

bufferedOutputStream

处理流拷贝(bufferedInputStream bufferedOutputStream)

   @Test
    public void bufferedCopy2(){
        String srcPath ="d:\\5.doc";
        String descPath = "d:\\6.doc";
        BufferedInputStream  bufferedInputStream = null;
        BufferedOutputStream bufferedOutputStream = null;
        byte[] data = new byte[1024];
        int len;
        try {
            bufferedInputStream = new BufferedInputStream(new FileInputStream(srcPath));
            bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(descPath));

            while ((len = bufferedInputStream.read(data)) != -1){
                bufferedOutputStream.write(data,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(bufferedInputStream != null) {
                    bufferedInputStream.close();
                }
                if(bufferedOutputStream != null) {
                    bufferedOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

对象处理流

序列化和反序列化
序列化：保存数据的时候保存数据的值和数据类型。
反序列化：恢复数据的时候恢复数据的值和数据类型。

对象要能序列化 要实现 Serializable Externalizable中的一个，建议Serializable

ObjectOutputStream

public static void main(String[] args) {
        //序列化的格式不是纯文本的 按照他的格式保存的
        String path = "d:\\1.bat";
        ObjectOutputStream objectOutputStream = null;
        try {
            objectOutputStream = new ObjectOutputStream(new FileOutputStream(path));
            objectOutputStream.writeInt(100);//int --Integer
            objectOutputStream.writeBoolean(true);
            objectOutputStream.writeChar('h');
            objectOutputStream.writeDouble(1.1);
            objectOutputStream.writeUTF("没有人是生来就无情的，都是经历并看到了太多自己不想看到的，而最终选择了关上自己的某扇门。");
            objectOutputStream.writeObject(new A(1));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
                try {
                    if(objectOutputStream != null) {
                        objectOutputStream.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
class A implements Serializable {
    private int n;

    public A(int n) {
        this.n = n;
    }
}

ObjectInputStream

@Test
    public void readObject(){
        String path = "d:\\1.bat";
        ObjectInputStream objectInputStream = null;
        try {
            objectInputStream = new ObjectInputStream(new FileInputStream(path));
            //防范序列化的顺序得和序列化顺序一致
            System.out.println(objectInputStream.readInt());
            System.out.println(objectInputStream.readBoolean());
            System.out.println(objectInputStream.readChar());
            System.out.println(objectInputStream.readDouble());
            System.out.println(objectInputStream.readUTF());
            System.out.println(objectInputStream.readObject().getClass());//Object-->A (class的位置得一致)
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {

                try {
                    if (objectInputStream != null) {
                     objectInputStream.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }

注意事项

标准输入输出流

System.in

 public final static InputStream in = null;

编译类型 InputStream
运行类型 BufferedInputStream

System.out

public final static PrintStream out = null;

编译类型 PrintStream
运行类型 PrintStream

转换流（乱码问题）字节流–>字符流

inputStreamReader

中文乱码问题

默认文件是UTF-8 如果是其他格式 用fileReader 会乱码 所以FileInputStream–>inputStreamReader 字节–>字符

   public void code(){
        String path = "d:\\7.txt"; //默认文件是UTF-8 如果不是用fileReader 会乱码 所以FileInputStream-->inputStreamReader 字节-->字符

        BufferedReader bufferedReader = null;
        String readLine;
        try {
            InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(path),"gbk");
            bufferedReader = new BufferedReader(inputStreamReader);
           while( (readLine = bufferedReader.readLine())!=null){
               System.out.println(readLine);
           }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(bufferedReader != null) {
                    bufferedReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

outputStreamWriter

默认writer保存文件utf8 可以使用字节流 指定格式 转换为字符流

@Test
    public void code2(){
        String path = "d:\\8.txt";
        OutputStreamWriter outputStreamWriter = null;
        try {
            outputStreamWriter = new OutputStreamWriter(new FileOutputStream(path),"gbk");//utf8  utf-8
            outputStreamWriter.write("人应该支配习惯，而决不能让习惯支配人；一个人不能去掉他的坏习惯，那简直一文不值。");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (outputStreamWriter != null) {
                    outputStreamWriter.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

字节打印流 PrintStream

@Test
    public void printf() throws IOException{
        PrintStream printStream = System.out;
        printStream.print("hello");
        printStream.write("world".getBytes());
        printStream.close();

//        System.setOut(new PrintStream(""));//可以修改打印输出的位置
    }

字符打印流 PrintWriter

//        PrintWriter printWriter = new PrintWriter(System.out);
        PrintWriter printWriter = new PrintWriter("d:\\9.txt");
        printWriter.write("haha");
        printWriter.close();

properties

@Test
    public void readProperties() throws IOException{
        String readLine ;
        BufferedReader bufferedReader = new BufferedReader(new FileReader("E:\\java_han\\src\\my.properties"));
       while((readLine =bufferedReader.readLine()) != null){
           System.out.println(readLine);
       }
       bufferedReader.close();
    }

    @Test
    public void readProperties02() throws IOException{
        Properties properties = new Properties();
        properties.load(new FileReader("E:\\java_han\\src\\my.properties"));//加载
        properties.list(System.out);
        System.out.println(properties.get("user"));

        properties.setProperty("name","tom");//可以增加
        properties.setProperty("user","jack"); //可以修改
//        properties.store();  保存
        properties.list(System.out);
    }