IO流,File类,序列化,字符流,字节流,简单基础学习

1.File类

        //----------------------------------File类---------------------------------------------------
        
        File file = new File("D:\\图片");
        File file1 = new File("D:\\", "图片1");
        File file2 = new File(file1, "1.jpg");
        File file3 = new File("D:\\方雨欣.txt");
        File file4 = new File("D:\\鹿鼎记.txt");
        File file5 = new File("D:\\鹿鼎记.txt副本");
        File file6 = new File("鹿鼎记.txt");
        File file7 = new File("D:\\学习代码");
//        System.out.println(file);
//        System.out.println(file1);
//        System.out.println(file2);
//        System.out.println(file3);
//        boolean newFile = file3.createNewFile();  //不存在的文件夹创建
//        System.out.println(newFile);

        //判断文件是否存在
//        boolean exists = file.exists();
//        System.out.println(exists);
//        System.out.println(file4.exists());

        //删除文件
//        boolean delete = file5.delete();
//        System.out.println("判断文件是否删除:" + delete);

        //获取路径相关
//        String absolutePath = file6.getAbsolutePath(); //获取当前文件所在位置的绝对路径
//        System.out.println(absolutePath);
//
//        String path = file6.getPath();  //获取相对路径
//        System.out.println(path);

        //获取文件最后修改时间
//        long l = file4.lastModified();
//        System.out.println("文件最后修改时间:" + l);
//        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss:");
//        String format = simpleDateFormat.format(l);
//        System.out.println("文件最后修改时间:" + format);

        //遍历文件
        //第一种: 无过滤,返回目录下所有文件和目录的文件名
//        String[] list = file7.list();
        //第二种: 无过滤,返回文件对象数组
//        File[] files = file7.listFiles();
//        String string = Arrays.toString(list);
//        System.out.println(Arrays.toString(files));

        //第三种:  只要c开头的文件(目录)
//        String[] list1 = file.list(new FilenameFilter() {
//            @Override
//            public boolean accept(File dir, String name) {
//                return name.startsWith("c") || name.startsWith("C");
//            }
//        });
//        System.out.println(Arrays.toString(list1));

        //第四种: 无过滤,返回文件对象数组
//        File[] files = file.listFiles(new FilenameFilter() {
//            @Override
//            public boolean accept(File dir, String name) {
//                if (name.contains(".")){
//                    return true;
//                }
//                return false;
//            }
//        });
//        System.out.println(Arrays.toString(files));

        //第五种: 按照文件对象过滤,返回文件对象数组
//        File[] files1 = file.listFiles(new FileFilter() {
//            @Override
//            public boolean accept(File pathname) {
//                String name = pathname.getName();
//                return name.contains(".");
//            }
//        });
//        System.out.println(Arrays.toString(files1));

2.序列化

//-------------------------------------------序列化-------------------------------------------------------------------

//        File file = new File("D:\\学习文件流.txt");
//        String str = "你好,小雨,我是义浩!";

        //序列化(ObjectOutputStream)-->用它写到硬盘上需要(FileOutputStream)
//        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
//        out.writeObject(str);
//        out.close();
//        System.out.println("文件写入成功!");

        //反序列化(ObjectInputStream) -->从文件中将对象反序列化回来(FileInputStream)
//        ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
//        Object o = in.readObject();
//        System.out.println(o.getClass());
//        System.out.println(o);
//        in.close();
//        System.out.println("文件读出成功!");

3.字符流

//---------------------------------------字符流---------------------------------------------------

//        File file = new File("D:\\鹿鼎记.txt");
//        Reader reader = new InputStreamReader(new FileInputStream(file), "UTF-8");

        //复制文件
//        File dstFile = new File(file.getParent(), file.getName() + "副本");
//        Reader reader1 = new InputStreamReader(new FileInputStream(file), "utf-8");
//        Writer writer = new OutputStreamWriter(new FileOutputStream(dstFile), "utf-8");
//        int data = -1;
//        while ((data = reader1.read()) != -1){
//            writer.write(data);
//        }
//        reader1.close();
//        writer.close();
//        System.out.println("文件复制成功!");

        //自己加缓冲功能
//        char[] buffer = new char[1024];
//        int len = -1;
//        int count = 0;
//        while ((len = reader.read(buffer)) != -1){
//            String data = new String(buffer, 0, len);
//            System.out.print(data);
//            count++;
//        }
//        System.out.print("我是count:  " + count);
//        reader.close();

        //以字符流逐字读取文件内容
//        int data = -1;
//        int count = 0;
//        while ((data = reader.read()) != -1){
//            System.out.print((char)data);
//            count++;
//        }
//        System.out.println("我是count:  " + count);
//        reader.close();

4.字节流

//-----------------字节流---------------ByteArrayStream------------------------------------------

        //ByteArrayOutputStream: 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可以变长度的字节数组.
//        InputStream in = new BufferedInputStream(new FileInputStream(file4));
//        ByteArrayOutputStream byteArray = new ByteArrayOutputStream();
//        OutputStream out = new BufferedOutputStream(byteArray);
//
//        int data = -1;
//        while((data = in.read()) != -1){
//            out.write(data);
//        }
//        byte[] result = byteArray.toByteArray();
//        System.out.println("字节数:" + result.length);
//        System.out.print("前100个字节" + new String(result, 0, 101, "utf-8"));
//
//        in.close();
//        out.close();


        //ByteArrayInputStream: 在构造的时候，需要接收数据源, 而且数据源是一个字节数组。
//        String msg = "我是一个sb!";
//        InputStream in = new ByteArrayInputStream(msg.getBytes());
//        OutputStream out = new FileOutputStream(file3);
//        in = new BufferedInputStream(in);
//
//        int data = -1;
//        while ((data = in.read()) != -1){
//            out.write(data);
//        }
//        System.out.println("写入成功!");
//        in.close();
//        out.close();

//--------------------------BufferedOutputStream---------------------------------------------------------
        //简单的不带缓冲区的输出流
//        String msg = "我喜欢编程,不喜欢打游戏!";
//        OutputStream out = new FileOutputStream(file3, true); //以追加的方式写文件,默认是直接覆盖
//        out.write(msg.getBytes("utf-8")); //将文本用指定的编码转成字节数组
//        out.close();

//        for(int i = 0; i < 1000; i++) {
//            BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file3, true));
//            out.write(msg.getBytes("utf-8"));
//            out.close();
//        }


//------------------------------------BufferedInputStream---------------------------------------
        //1. in.read(); 一次读取一个字节
        //2. in.read(byte buffer)  一次读取一个byte数组的数据(这个byte也叫缓冲区)
        //3. in.read(byte buffer, int offer, int length)
        // 一次读取一部分数据,将数据填充到缓冲区,(从offset,填充length个字节 字节流操作

        //缓冲输入流是在其它流的基础上,包装一层缓冲的功能
//        BufferedInputStream in = new BufferedInputStream(new FileInputStream(file3));
//
//        byte[] allData = new byte[1024];
//        int data = -1;
//        int idx = 0;
//        while ((data = in.read()) != -1) {
//            allData[idx] = (byte) data;
//            idx++;
//            if (idx >= 1024) {
//                System.out.println(new String(allData, 0, idx, "UTF-8"));
//                idx = 0;
//            }
//        }
//        in.close();