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

/**
 * 
 * @author leak File类只能操作文件本身，但是不能操作文件内容 例如：你可以把一个txt文档增删改查，但是不能对txt里面的内容增删改查
 */
public class Test {
    public static void main(String[] args) {
    // 1访问文件名
        // 这个时候对象f就是abc.txt文件
        // 文件路径的反斜杆\和斜杆/，如果是\那么需要\\两个，一个做转义符作用D:\\abc
        // 如果是斜杆D:/ABC/ABC.TXT，一个就够了
        // File f = new File("文件路径");把文件转为对象操作
        File f = new File("D:/abc/abc.txt");
        // 创建文件对象有两种方式，一种上面的直接加路径
        // 一种就是File f1 = new File("父路径","子路径");
//        File f1 = new File("D:/abc","abc.txt");

        // 使用相对路径来创建file对象
        File f5 = new File("/Test1/src/org/chen/day12/Test.java");
        // 获取当前的文件名，如果是路径，那么就是获取最后一级目录名
        System.out.println(f.getName());
        // 如果new File对象的路径是相对路径，那么getPath就是获取相对路径地址
        // 如果是绝对路径，那么getPath就是获取绝对的地址
        System.out.println(f.getPath());
        // 获取当前文件/夹的路径，是完整的路径（绝对路径）
        System.out.println(f.getAbsolutePath());

        System.out.println(f5);// 打印文件的相对路径
        // 返回一个用当前的文件的绝对路径构建的file对象
        System.out.println(f5.getAbsoluteFile());

        // 返回当前文件/夹的父级路径，也就是文件的前面的完整路径，比如：D:\abc\abc.txt就是获取D:\abc父级路径
        System.out.println(f.getParent());

        // 文件重命名
        f.renameTo(new File("D:/abc/rename.txt"));
        System.out.println("====================");
        
        
    // 2文件检测
        File f6 = new File("D:/abc/favicon.ico");
        // exists()判断文件/夹是否存在，返回布尔值
        System.out.println(f6.exists());

        // canWrite()判断文件/夹是否可写，canRead()判断文件/夹是否可读
        System.out.println(f6.canWrite());
        System.out.println(f6.canRead());

        // 判断当前的file对象是不是文件
        System.out.println(f6.isFile());
        // 判断当前的filed对象是不是文件夹/目录
        System.out.println(f6.isDirectory());

        // 获取文件最后修改的时间，返回的是一个毫秒数
        System.out.println(f6.lastModified());
        // 返回文件的长度，单位是字节数
        System.out.println(f6.length());
        System.out.println("====================");
        
        
    // 3文件/夹操作
        File f3 = new File("D:/abc/abc.txt");
        System.out.println(f3.exists());
        // 如果文件不存在，则创建
        if (!f3.exists()) {
            try {
                f3.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        // 删除文件
        f3.delete();

        File f2 = new File("D:/abc/cc");
        System.out.println(f2.exists());
        if (!f2.exists()) {
            // 创建单层目录，如果使用mkdir方法创建多层目录，只能一层层的执行mkdir方法
            f2.mkdir();
        }

        File f4 = new File("D:/abc/dd/aa/ee");
        if (!f4.exists()) {
            // 创建多层目录，注意是mkdirs()，上面的mkdir少了s
            f2.mkdirs();
        }

        File f7 = new File("D:/abc");
        // list()返回当前文件夹的子集的名称，包括目录和文件名
        String[] flist = f7.list();
        for (String name : flist) {
            System.out.println(name);
        }
        
        // listFiles()返回当前文件夹的子集的file对象，包括目录和文件名
        //就是返回子集里面所有的文件名/目录的绝对路径，例如： D:\abc\cc, D:\abc\favicon.ico
        File[] files = f7.listFiles();
        for(File file : files) {
            System.out.println(file);
        }
    }
}

import java.io.File;

public class Test2 {
    public static void main(String[] args) {
        
    }
    //递归的引出
    public void findAllFiles(File file) {
        if(file.isFile()) {
            System.out.println(file.getAbsoluteFile()+"是一个文件");
        }else {
            //是文件夹则继续遍历里面的文件和目录
            System.out.println(file.getAbsolutePath()+"是文件夹");
            //获取文件夹中的所有目录/文件，使用file数组接收
            File[] files = file.listFiles();
            //遍历数组里面的文件/目录
            for(File f : files) {
        //如果是文件则打印文件，      下面开始第一层重复
                if(file.isFile()) {
                    System.out.println(file.getAbsoluteFile()+"是一个文件");
                }else {
                    //如果是文件夹则继续遍历里面的文件和目录
                    System.out.println(file.getAbsolutePath()+"是文件夹");
                    //获取文件夹中的子集，包含文件/目录
                    File[] files2 = file.listFiles();
                    //遍历数组里面的文件/目录
                    for(File f2 : files) {
        //如果是文件则打印文件，   这里的下面是第二层重复
                        if(file.isFile()) {
                            System.out.println(file.getAbsoluteFile()+"是一个文件");
                        }else {
                            //如果是文件夹则继续遍历里面的文件和目录
                            System.out.println(file.getAbsolutePath()+"是文件夹");
                            //获取文件夹中的子集，包含文件/目录
                            File[] files3 = file.listFiles();
                            //然后继续遍历files3数组里面的文件和目录，如果是目录那么继续遍历
                            //这里就不重复写代码了，for循环后面都是一样的代码，这样一直遍历，不知道要写多少层，是死循环代码
        //下面是第三层重复代码，就不写了，如果是重复的代码，而且不知道写到几层，就应该使用递归方法。递归就是方法调用本身，方法调用自己
                        }
                    }
                }
            }
        }
    }
}

import java.io.File;

public class Test3 {
    public static void main(String[] args) {
        //创建一个目录对象
        File file = new File("D:/abc");
        //然后把目录对象，传给findAllFiles()方法遍历该目录底下的所有层级的目录/文件
        new Test3().findAllFiles(file);
    }
    //递归遍历所有的目录/文件，每一层
        public void findAllFiles(File file) {
            if(file.isFile()) {
                System.out.println(file.getAbsoluteFile()+" 是一个file");
            }else {
                //是文件夹则继续遍历里面的文件和目录
                System.out.println(file.getAbsolutePath()+" 是一个文件夹");
                //获取文件夹中的所有目录/文件，使用file数组接收
                File[] files = file.listFiles();
                //遍历数组里面的文件/目录
                for(File f : files) {
                    //重点在这里，递归：自己调用自己，直到遍历完所有文件/目录，否则重复调用findAllFiles(f);
                    findAllFiles(f);
                }
            }
        }
    }

import java.io.FileInputStream;

public class Test4 {
    public static void main(String[] args) {
        Test4.readFile("D:/abc/rename.txt");
    }
    //读取文件的方法
    public static void readFile(String path) {
        try {
            //把文件转为输入流
            FileInputStream in = new FileInputStream(path);
            
            //设置byte数组接收读取的文件的内容
            byte[] b = new byte[10];
            
            //设置临时变量存储每次读取的长度，也就是in.read(10)返回的长度
            //肯定有人说为什么不直接使用in.read(10)的返回值，而是要新创建变量len去接收返回值再使用
            //因为每次执行in.read(b)方法时，都会读取一次文件，每次返回的值都不一样
            //比如下面的len = in.read(b)第一次返回10，但是你在循环体中输出in.read(b)的长度就不是10了，因为又执行了一遍读操作
            int len = 0;
            
            //因为byte数组固定了长度为10，所以需要循环读取文件，每次读取10个字符
            //补充：read()方法是读取一个字节，返回字节如果是字母就返回ASCII码，比如文件内容第一个字节是a就返回97
            //read(byte[] b)方法是返回每次读取字节数的个数,个数根据byte数组长度决定，所以下面使用read(byte[] b)方法，而不使用上面的read()方法
            while((len = in.read(b))!=-1) {
                System.out.println(len);
//                System.out.println(in.read(b));//这里注释掉了，如果想了解len变量为什么要存在，可以取消注释，测试一下
                //new String(缓冲的数组,数组里面的字符串转换起始坐标,每次转换的长度)，这里是把每次读取的数据转为字符串输出
                System.out.println(new String(b,0,len));    
            }
            //每次读取数据都要关闭输入流，因为流操作的时候凡是跨出虚拟机边界的资源都要求程序员自己关闭，不要指望垃圾回收。
            in.close();//你读一个文件，忘记关闭了流，你在操作系统里对这个文件的写，删除等操作就会报错，告诉你这个文件被某个进程占用。
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.FileOutputStream;

public class Test5 {
    public static void main(String[] args) {
        //传一个文件过去，写进数据
        Test5.writeFile("D:/abc/abc.txt");
    }
    public static void writeFile(String absoluteFile) {
        //创建输出流
        try {
            FileOutputStream out = new FileOutputStream(absoluteFile);
            //创建要写入的数据
            String str = "abcdefghijklmnopkrstuvwxyz";
            //把数据写入到输出流,因为OutputStream是二级制流，所以str需要转换为Byte类型才能写入到输出流
            out.write(str.getBytes());//把数据写入到内存
            out.flush();//把数据从内存刷进硬盘
            //关闭输出流
            out.close();
            
            
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Test6 {
    public static void main(String[] args) {
        //sAbsoluteFile是要获取的文件路径,前面变量名的s是start
        String sAbsoluteFile = "D:/abc/a.jpg";
        //eAbsoluteFile是要输出的文件路径，前面变量首字母e是end
        String eAbsoluteFile = "D:/abc/cc/sui.jpg";
        //把sAbsoluteFile文件复制到eAbsoluteFile中去
        Test6.copyFile(sAbsoluteFile, eAbsoluteFile);
    }
    /**
     * 复制文件到指定位置
     * @param sAbsoluteFile 源文件路径
     * @param eAbsoluteFile    复制到文件夹位置
     */
    public static void copyFile(String sAbsoluteFile,String eAbsoluteFile) {
        try {
            //创建输入流获取要复制的文件内容,也就是要读取的源文件
            FileInputStream in = new FileInputStream(sAbsoluteFile);
            //创建输出流，输出到指定位置，也就是要复制到哪里
            FileOutputStream out = new FileOutputStream(eAbsoluteFile);
            //创建接收的数组
            byte[] b = new byte[100];
            //创建临时变量接收返回每次读取文件的长度
            int len = 0;
            //循环读取数据，注意read()方法和read(byte[] b)的区别，一个是返回字节，一个是返回每次读取字节的个数
            while((len = in.read(b)) != -1) {
                //把读取到的数据通过输出流写入
                out.write(b, 0, len);//把数据写入到内存
            }
            //把内存中的数据刷入硬盘
            out.flush();
            //关闭输出/输入流
            out.close();
            in.close();
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.FileReader;

public class Test7 {
    public static void main(String[] args) {
        String inPath = "D:/abc/abc.txt";
        Test7.testFileReader(inPath);
    }
    
    /**
     *     文件字符输入流FileReader
     * @param inPath 源文件路径
     */
    public static void testFileReader(String inPath) {
        try {
            //创建文件字符输入流的对象
            FileReader fr = new FileReader(inPath);
            
            //创建临时存数据的字符数组
            char[] ch = new char[10];
            
            //定义临时变量存储每次读取数据的长度
            int len = 0;
            
            //循环遍历字符输入流
            while((len = fr.read(ch)) != -1) {
                System.out.println(new String(ch,0,len));
            }
            //关闭输入流
            fr.close();
        }catch(Exception e) {
            e.printStackTrace();
        }
    }

import java.io.FileWriter;

public class Test8 {
    
    public static void main(String[] args) {
        //传一个文件过去，写进数据
        Test8.TestFileWriter("D:/abc/abc.txt");
    }
    public static void TestFileWriter(String absoluteFile) {
        //创建输出流
        try {
            FileWriter out = new FileWriter(absoluteFile);
            //创建要写入的数据
            String str = "abcdefghijklmnopkrstuvwxyz";
            //把数据写入到输出流
            out.write(str);//把数据写入到内存
            out.flush();//把数据从内存刷进硬盘
            //关闭输出流
            out.close();
            
        }catch(Exception e) {
            e.printStackTrace();
        }
    }

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

public class Test9 {
    public static void main(String[] args) {
        String inPath = "D:/abc/abc.txt";
        String outPath = "D:/abc/cc/ss.txt";
        Test9.copyFile(inPath, outPath);
    }

    /**
     * 
     * @param inPath  源文件路径
     * @param outPath 传输到指定目录
     */
    public static void copyFile(String inPath, String outPath) {
        FileReader fr = null;
        FileWriter fw = null;
        
        try {
            // 创建字符输入流
            fr = new FileReader(inPath);
            // 创建字符输出流
            fw = new FileWriter(outPath);
            
            //创建临时数组接收数据
            char[] ch = new char[10];//因为是字符流所以使用char数组
            int len = 0;
            
            //循环遍历读取文件，然后写入到内存中
            while((len = fr.read(ch)) != -1) {
                fw.write(ch,0,len);
            }
            //把内存的数据刷入硬盘
            fw.flush();
        
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭流
            try {
                fw.close();
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.io.BufferedInputStream;
import java.io.FileInputStream;

public class Test {
    public static void main(String[] args) {
        Test.testBufferedInputStream();
    }
    
    /**
     * 缓冲字节输入流
     *     BufferedInputStream
     */
    public static void testBufferedInputStream() {
        try {
            //文件字节输入流
            FileInputStream in = new FileInputStream("E:\\workspace-sts\\Test1\\src\\org\\chen\\day13\\tt.txt");
            //把文件字节输入流放到缓冲字节输入流,BufferedInputStream(InputStream类/子类)
            BufferedInputStream br = new BufferedInputStream(in);
            
            //创建临时数组接收数据，下面的注释就不写了，操作都差不多
            byte[] b = new byte[10];
            int len = 0;
            while((len = br.read(b)) != -1) {
                System.out.println(new String(b,0,len));
            }
            //关闭流的时候，本着一个最晚开的最早关，依次关闭
            br.close();//关闭缓冲流
            in.close();//关闭输入流
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class Test2 {
    public static void main(String[] args) {
        Test2.testBufferedOutputStream();
    }
    
    /**
     * 缓冲字节输出流
     * BufferedOutputStream
     */
    public static void testBufferedOutputStream() {
        try {
        //创建输出流
        FileOutputStream out = new FileOutputStream("E:\\workspace-sts\\Test1\\src\\org\\chen\\day13\\tt.txt");
        //缓冲字节输出流
        BufferedOutputStream bos = new BufferedOutputStream(out);
        
        //把内容写入到文件中，注意写入的文件如果名字一样，内容会被覆盖
        String str = "需要被写入的内容。。。。。谢谢谢谢谢谢";
        //写入到内存中,write方法只能写入字节，所以str转换byte写入
        bos.write(str.getBytes());
        
        bos.flush();//刷到硬盘上
        //先开后关原则。
        bos.close();
        out.close();
        
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Test4 {
    public static void main(String[] args) {
        String inPath = "D:/abc/a.jpg";
        String outPath = "D:/abc/cc/tou.jpg";
        Test4.copyFile(inPath, outPath);
    }
    /**
     * 缓冲流实现文件的复制
     * @param inPath 源文件
     * @param outPath 复制到指定路径
     */
    public static void copyFile(String inPath,String outPath) {
        try {
        //创建输入流
        FileInputStream fs = new FileInputStream(inPath);
        //缓冲输入流
        BufferedInputStream bis = new BufferedInputStream(fs);
        
        //创建输出流
        FileOutputStream fo = new FileOutputStream(outPath);
        //缓冲输出流
        BufferedOutputStream bos = new BufferedOutputStream(fo);
        
        //临时数组
        byte[] b = new byte[10];
        int len = 0 ;
        //循环读取缓冲输入流
        while((len = bis.read(b)) != -1) {
            //读取的数据写入到缓冲输出流
            bos.write(b,0,len);
        }
        //刷到硬盘中
        bos.flush();
        //先开后关原则
        bos.close();
        fo.close();
        bis.close();
        fs.close();    
        
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
/**
 * 缓冲字符流
 * BufferedReader
 * @author leak
 *
 */
public class Test5 {
    public static void main(String[] args) {
        String file = "D:/abc/abc.txt";
        Test5.testBufferedReader(file);
    }
    /**
     * 
     * @param file 源文件 
     * 
     */
    public static void testBufferedReader(String file) {
        try {
            //创建字符输入流
            FileReader fr = new FileReader(file);
            //创建字符缓冲流
            BufferedReader br = new BufferedReader(fr);
            //创建临时数组
            char[] ch = new char[10];
            int len = 0;
            while((len = br.read(ch)) != -1) {
                System.out.println(new String(ch,0,len));
            }
            //关闭流
            br.close();
            fr.close();
            
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedWriter;
import java.io.FileWriter;

/**
 * 字符缓冲输出流
 * BufferedWriter
 * @author leak
 *
 */
public class Test6 {
    public static void main(String[] args) {
        String file = "D:/abc/abc.txt";
        Test6.testBufferedWriter(file);
    }
    
    public static void testBufferedWriter(String file) {
        try {
            //创建字符输出流
            FileWriter fw = new FileWriter(file);
            //字符缓冲流
            BufferedWriter bw = new BufferedWriter(fw);
            String str = "需要录入的 字符。。。";
            bw.write(str);//把内容写进内存
            bw.flush();//把数据刷入硬盘
            //先开后关原则，先开的字符输出流，最后才关字符输出流
            bw.close();
            fw.close();
            
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

public class Test7 {
    public static void main(String[] args) {
        String inPath = "D:/abc/abc.txt";
        String outPath = "D:/abc/cc/add.txt";
        Test7.copyFile(inPath, outPath);
    }

    /**
     * 文件复制
     * 
     * @param inPath  源文件
     * @param outPath 复制到指定的路径
     */
    public static void copyFile(String inPath, String outPath) {
        try {
            // 创建字符输入流
            FileReader fr = new FileReader(inPath);
            // 字符缓冲流
            BufferedReader br = new BufferedReader(fr);
            // 创建字符输出流
            FileWriter fw = new FileWriter(outPath);
            //字符缓冲流
            BufferedWriter bw = new BufferedWriter(fw);
            
            //临时数组
            char[] ch = new char[100];
            int len = 0;
            
            //循环读取数据
            while((len = br.read(ch)) != -1) {
                bw.write(ch,0,len);//把数据写入内存
            }
            bw.flush();//刷入硬盘
            //关闭流
            bw.close();
            fw.close();
            br.close();
            fr.close();    
            
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class Test8 {
    public static void main(String[] args) {
        /**
         * 所有文件都有编码格式
         * 对我们来说，txt和Java文件一般都有三种编码
         * ISO8859-1，西欧编码，是纯英文编码，不适应汉字
         * GBK和UTF-8,这两编码适用于中文和英文
         * 一般使用UTF-8编码
         */
        String inPath = "D:/abc/abc.txt";
        String charsetName = "UTF-8";
        Test8.testInputStreamReader(inPath, charsetName);
    }
    /**
     * 字节输入流转换字符输入流
     * @param inPath 源文件
     * @param charsetName 编码格式
     * 注意，在转换字符流的时候，设置的字符集编码要与读取文件的数据的编码一致
     * 不然会出现乱码，比如，你要读取的文件编码是GBK，但是你转为字符流设置了UTF-8，那么读取的内容就会乱码 显示
     */
    public static void testInputStreamReader(String inPath, String charsetName) {
        try {
            // 字节输入流
            FileInputStream fs = new FileInputStream(inPath);
            // 字节流转换字符流 
            InputStreamReader isr = new InputStreamReader(fs, charsetName);//参数1是字节流，参数2编码
            // 缓冲流
            BufferedReader br = new BufferedReader(isr);
            // 临时数组
            char[] ch = new char[100];
            int len = 0;

            while ((len = br.read(ch)) != -1) {
                System.out.println(new String(ch, 0, len));
            }
            //关闭流
            br.close();
            isr.close();
            fs.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

public class Test9 {
    public static void main(String[] args) {
        String inPath = "D:/abc/abc.txt";
        String charsetName = "UTF-8";
        Test9.testOutputStreamWirter(inPath, charsetName);
        
    }
    
    /**
     * 字节输出流转字符输出流
     * @param inPath 源文件
     * @param charsetName 编码格式
     */
    public static void testOutputStreamWirter(String inPath,String charsetName) {
        try {
        //创建字节流
        FileOutputStream fs = new FileOutputStream(inPath);
        //转换流
        OutputStreamWriter os = new OutputStreamWriter(fs,charsetName);
        //缓冲流
        BufferedWriter bw = new BufferedWriter(os);
        String str = "需要写入的数据。嘻嘻嘻嘻嘻嘻嘻嘻";
        bw.write(str);//写入内存
        //刷入硬盘
        bw.flush();
        //关闭流
        bw.close();
        os.close();
        fs.close();
        
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;

/**
 * 
 * @author leak
 *    标准输入和输出流
 */
public class Test10 {
    public static void main(String[] args) {
        Test10.testSystemIn();
    }
    /**
     * 标准的输入流
     */
    public static void testSystemIn() {
        try {
            //创建一个接收键盘输入数据的输入流
            InputStreamReader ir = new InputStreamReader(System.in);
            //缓冲流
            BufferedReader br = new BufferedReader(ir);
            //创建临时接收数据的变量,因为是字符缓冲流，所以使用String
            String str = "";
            //循环读取键盘输入的数据，每读取一次就放到str变量中，知道读取完数据，就会返回null
            //注意readLine()是读取一行的数据，以回车符结束当前读取的数据
            while((str = br.readLine()) != null) {
                System.out.println(str);
            }
            
            br.close();
            ir.close();
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.InputStreamReader;

//把控制台输入的内容写到指定的TXT文件中，当接收到字符串over，就结束程序的运行。
public class Test11 {
    public static void main(String[] args) {
        String fileName = "D:/abc/abc.txt";
        Test11.inWrite(fileName);
    }
    
    public static void inWrite(String fileName) {
        try {
            // 创建输入流
            System.out.println("请输入要写入文件的内容，如果结束输入，请回车后输入 over，再回车结束程序：");
            InputStreamReader fr = new InputStreamReader(System.in);
            //缓冲流
            BufferedReader br = new BufferedReader(fr);
            
            //创建输出流
            FileWriter ow = new FileWriter(fileName);
            //缓冲流
            BufferedWriter bw = new BufferedWriter(ow);
            //创建临时变量接收每次读取一行的数据。
            String str = "";
            
            
            //循环读取键盘输入
            //readLine读取一行数据，遇到回车符返回一行数据
            while((str = br.readLine()) != null) {
                //读取到over结束写入的数据
                if("over".equals(str)) {
                    break;
                }
                else {
                    bw.write(str);//写入内存
                }
            }
            bw.flush();//刷入硬盘
            //关闭流
            bw.close();
            ow.close();
            br.close();
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Test12 {
    /**
     * 
     * 在一个TXT文件中，写一组用户名和密码，通过控制台输入用户名和密码，
     * 与TXT文件中的用户名密码做对比，如果一样就在打印登录成功，
     * 如果不一致，就打印用户名密码错误。
     */
    public static void main(String[] args) {
        String fileName = "D:/abc/rename.txt";
        Test12.login(fileName);
        
    }
    
    /**
     *  该方法获取数据的前提：
     *  txt内容格式必须是{key:value},{key:value}形式存放，
     *  最后一个键值对，后面不能留逗号，类似json二维数组格式，但是没有""双引号
     *    核心是字符串截取，这里把下面输出语句都注释了，如果看不懂字符串截取代码，可以取消注释看输出
     */
    public static void login(String fileName) {
            //创建标准输入流
            Scanner in = new Scanner(System.in);
            //之所以放在try外面，是为了在finally后面关闭流
            FileReader fw = null;
            BufferedReader bw = null;
        try {
            
            //创建输入流接收文件数据
            fw = new FileReader(fileName);
            
            //缓冲流
            bw = new BufferedReader(fw);
            //存放账号密码的键值对
            Map<String,String> data = new HashMap<String,String>();
            
            //读取文件一行数据，每循环一次，就读一行
            String str = "";
            //循环读取文件
            while((str = bw.readLine()) != null) {
                //文件每行的键值对
                System.out.println(str);
                //分隔的索引位置
                int index = -1;
                
                //遍历判断是否到最后的键值对，如果到最后返回-1
                while((index = str.indexOf("}")) != -1){
                    //str的前一部分，比如{account:123,pw:aaa
                    //从1开始就截取不到{号了，index是}号，但是substring不包含结束，所以只截取{account:123,pw:aaa
                    String leadStr = str.substring(1,index);//这里每次截取，只截取了{}里面的数据
//                    System.out.println(leadStr+"截取到");
                    
                    //split(",|:")多字符同时切割，首先根据逗号切割成 两个键值对，比如account:789  pw:ccc
                    //然后再根据冒号切割成键值对，变成了4个单独的字符串，比如   account,789,pw,ccc  account是0，依次类推
                    String[] keyValue = leadStr.split(",|:");
//                    System.out.println("账号的value："+keyValue[1]+",密码的value："+keyValue[3]);
                    
                    //最后把账号和密码的value放进map集合
                    data.put(keyValue[1], keyValue[3]);
                    
                    //截取str的后一部分，就是剩下的字符串
                    //不过要进行判断，如果到了最后一个键值对，就不截取后面的，因为没有字符串可截取，再强行截取会越界
                    if(str.contains(",{")) {//这里判断的是是否到了最后一个键值对
                        
                        //截取str的后一部分，就是剩下的字符串
                        //index+2是因为index是}号，所以+2就到了{号，为什么不+3呢，直接取括号里面的数据，因为上面str截取前一部分从1开始，所以要保留{号
                        str = str.substring(index+2,str.length());
                        //假设这里已经是最后一个键值对，比如{account:789,pw:ccc}，
                        //那么再次循环，就已经不包含,{ 所以就不截取，跳到else停止截取
//                        System.out.println("截取完后的str"+str);
                    }
                    else {
                        break;
                    }
                }
            }
            
            
            while(true) {
                //接收用户输入的账号，密码
                System.out.println("请输入账号：");
                String account = in.nextLine();
                
                System.out.println("请输入密码：");
                String pw = in.nextLine();
                
                //根据get(account)根据key获取value，然后拿value比较输入的pw，然后正确登录成功
                //如果get()获取不到账号，会返回字符串null，对比pw也会不正确
                if(pw.equals(data.get(account))) {
                    System.out.println("登录成功");
                    break;
                }
                else {
                    System.out.println("账号或密码错误");
                }
            }
            
        }catch(Exception e) {
            e.printStackTrace();
        }finally {
            //关闭流
            try {
                in.close();
                bw.close();
                fw.close();
            }catch(IOException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Test13 {
    public static void main(String[] args) {
        Test13.testDataOutputStream();
        Test13.testDataInputStream();
    }
    /**
     * 数据输出流
     * DataOutputStream
     * DataOutputStream()需要一个OutputStream或者其子类。
     *     用数据输出流写到文件中的基本数据类型的数据，是乱码的，不能直接辨认出来，需要数据的输入流读取。
     */
    public static void testDataOutputStream() {
        try {
            DataOutputStream out = new DataOutputStream(new FileOutputStream("D:/abc/abc.txt"));
//            out.writeBoolean(true);//把true写入文件，以字节流的方式，但是文件内容会显示乱码。
            out.writeDouble(1.35d);//也是乱码
//            out.writeInt(100);//文件内容也是乱码
            
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();

        }
    }
    
    /** 数据输入流
     * 用数据输出流写到文件中的基本数据类型的数据，是乱码的，不能直接辨认出来，需要数据的输入流读取。
     * 用数据输入流读取数据输出流写到文件中的数据时，要保证使用和当前写入的数据类型一致的类型来读取，否则读取也会乱码，如果读取的数据类型不存在，会报EOFException异常
     * 也就是说，如果写的时候是writeDouble，那么读的时候就的是readDouble
     * DataInputStream
     */
    public static void testDataInputStream() {
        try {
            DataInputStream in = new DataInputStream(new FileInputStream("D:/abc/abc.txt"));
            
//            System.out.println(in.readInt());
            System.out.println(in.readDouble());
            in.close();
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

//需要序列化的类
import java.io.Serializable;

/**
 *     可以序列化与反序列化的对象
 * @author leak
 *
 */
public class Person implements Serializable{

    /**
     * 一个表示序列化版本标识符的静态变量
     * 表明类的不同版本间的兼容性
     */
    private static final long serialVersionUID = 1L;
    String name;
    int age;
}

//测试类的对象序列化和反序列化
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 序列化和反序列化
 * 注意：对象的序列化和反序列化使用的类要严格一致，包名，类名，类结构等待所有都要一致
 * 比如，你序列化了一个day13包下的Person类，但是你反序列化时，使用的是day12包下的Person类，会报类型转换异常，哪怕类结构一致。
 * 所以，只要序列化和反序列化的对象前后的任何东西发生改变，都会报异常。
 * 也就是你序列化的对象，反序列化时，必须保证这个反序列化的对象是之前序列化的对象，而且这个对象不能有任何改动
 * @author leak
 *
 */
public class Test14 {

    public static void main(String[] args) {
        // 序列化
        Test14.testSerialize();
        // 反序列化
        Test14.testDeserialize();
    }

    /**
     * 序列化方法
     */
    public static void testSerialize() {
        try {
            // 定义对象的输出流，把对象序列化之后的流指定的文件中
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:/abc/a.txt"));

            Person p = new Person();
            p.name = "猪头";
            p.age = 22;

            // 把对象通过数据流存储到文件中，注意只是做存储的作用，是以二进制存储的，所以查看内容是乱码
            out.writeObject(p);
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 对象的反序列化
     */
    public static void testDeserialize() {
        try {
            // 创建对象输入流对象，从指定的文件中把对象反序列化读取出来
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:/abc/a.txt"));

            Object obj = in.readObject();
            Person p = (Person) obj;
            System.out.println(p.name + p.age);

            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.io.RandomAccessFile;

/**
 * 文件的随机读取 程序可以直接跳到文件的任意地方来读，写文件
 * @author leak
 *
 */
public class Test15 {
    public static void main(String[] args) {
        Test15.testRandomAccessFileRead();
        Test15.testRandomAccessFileWrite();
    }

    /**
     * 随机读文件
     */
    public static void testRandomAccessFileRead() {
        // RandomAccessFile的构造有两个参数，参数1是读写文件的路径
        /** 参数2是指定RandomAccessFile的访问模式
         *     r:以只读方式打开 
         *     rw：打开以便读取和写入
         *  rwd:打开以便读取和写入；同步文件内容的更新 
         *  rws:打开以便读取和写入；同步文件内容和元数据的更新
         */
        try {
            //RandomAccessFile是字节流读取
            RandomAccessFile ra = new RandomAccessFile("D:/abc/abc.txt", "r");
            
            //每一行后面还有两个隐藏的符，/t/n，来达到从文件的任意位置读取
            ra.seek(0);//设置读取文件内容的起始点
            
            //因为是字节流，所以使用byte数组
            byte[] b = new byte[1024];
            
            int len = -1;
            //循环读取文件
            while((len = ra.read(b)) != -1) {
                //把字节流通过new String方法把内容打印
                System.out.println(new String(b,0,len));
            }
            ra.close();
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 文件随机写
     */
    public static void testRandomAccessFileWrite() {
        try {
            
            RandomAccessFile ra = new RandomAccessFile("D:/abc/abc.txt", "rw");
            
            //注意：如果是在文件开头或中间的某个位置开始写的话，就会用写的内容覆盖等长度的原内容
            ra.seek(0);//设置写的起始点，0代表从开头写
//            ra.seek(ra.length());//设置写的起始点，ra.length()代表从文件的结尾写，也就是文件的追加
            
            ra.write("你好".getBytes());//把字符转换byte写进去
            
            ra.close();
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}