笔记(课12)_fi.read(bufkey)-CSDN博客

本文链接：https://blog.csdn.net/Girl_Cool/article/details/98936344

一阶段：第12天：文件和流（8.7）

一.File类

1.1File类文件属性

        //分号
        System.out.println(File.pathSeparator);//";"结果为String类型
        System.out.println(File.pathSeparatorChar);//';'结果为char类型
        // 反斜杠
        System.out.println(File.separator);//"\"结果为String类型
        System.out.println(File.separatorChar);//'\'结果为char类型

1.2File类方法

1.2.1File类基本方法的使用

    //构造方法的使用
    public static void fileContructor() {
        File file = new File("d:\\gp4.txt");
        System.out.println(file.toString());
        String parent="d:\\mywork";
        File file1=new File("d:\\mywork","haha.txt");
        File file2=new File(parent, "heihei.txt");
    }
    //文件
    public static void fileOpe() throws Exception{
        //创建对象
        File file=new File("d:\\gp4.tet");
        //(1)创建
        if (!file.exists()){
            boolean b=file.createNewFile();
            System.out.println("创建结果："+b);
        }else {
            System.out.println("文件已存在");
        }
        //(2)删除
        /*//直接删除
        boolean b2=file.delete();
        System.out.println("删除结果："+b2);*/
        /*//退出JVM时删除
        Thread.sleep(5000);
        file.deleteOnExit();*/
        //(3)判断
        System.out.println("是否可执行"+file.canExecute());
        System.out.println("是否可读取"+file.canRead());
        System.out.println("是否可写入"+file.canWrite());
        System.out.println("判断是否是文件："+file.isFile());
        System.out.println("判断是否隐藏:"+file.isHidden());
        System.out.println("判断是否是绝对路径："+file.isAbsolute());
        //(4)获取
        System.out.println("获取绝对路径"+file.getAbsolutePath());
        System.out.println("获取规范路径"+file.getCanonicalPath());
        System.out.println("获取名称"+file.getName());
        System.out.println("获取路径"+file.getPath());
        System.out.println("获取长度"+file.length());
        System.out.println("最后一次修改时间"+new Date(file.lastModified()).toLocaleString());
    }
    //目录
    public static void directoryOpe()throws Exception{
        File dir=new File("d:\\aaa\\bbb\\ccc");
        //(1)创建
        if (!dir.exists()){
            //mkdir()创建单级目录
            //mkdirs()创建多级目录
            boolean b=dir.mkdirs();
            System.out.println("创建结果："+b);
        }else {
            System.out.println("已存在");
        }
        /*//(2)删除
        //直接删除（只能删除最里层目录）(只能删除空目录)
        boolean b=dir.delete();
        System.out.println("删除结果："+b);
        //jvm删除
        dir.deleteOnExit();*/
        //(3)判断
        System.out.println("是否是文件夹"+dir.isDirectory());
        //(4)获取目录中文件和子目录
        System.out.println("----list------");
        File mydir=new File("e:\\音乐");
        String[] list=mydir.list();
        //File[] list=mydir.listFiles();
        //mydir.list
        for (String s : list) {//必须保证有该目录，否则会报异常
            System.out.println(s.toString());
        }
        /*for (File f : list) {
            System.out.println(f.toString());
        }*/
        System.out.println("-----过滤list-----");
        String[] list2=mydir.list(new FilenameFilter(){
            @Override
            public boolean accept(File dir, String name) {
                if(name.endsWith(".zip")) {
                    return true;
                }
                return false;
            }
        });
        for (String s : list2) {
            System.out.println(s.toString());
        }
        System.out.println("----------系统根目录-----------");
        File[] files = File.listRoots();
        for (File file : files) {
            System.out.println(file.toString());
        }
    }
    public static void renameTo()throws Exception{
        File file=new File("d:\\haha");
        boolean b=file.mkdirs();
        System.out.println("创建结果"+b);
        //重命名(具有剪切的功能)(若文件里有内容就不能剪切了)
        boolean b2=file.renameTo(new File("d:\\heihei"));
        System.out.println("重命名"+b2);
    }

1.2.2案例


public class Shili1 {
    public static void main(String[] args) {
        //listDir(new File("e:\\小说"),0);
        deleteFile(new File("e:\\aaa"));
    }
    //练习1：递归访问文件夹,列出文件夹内所有内容（包括子文件）
    public static void listDir(File dir,int Level){
        System.out.println(getSeparator(Level)+dir.toString());//输出指定目录
        File[] files=dir.listFiles();
        Level++;
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    listDir(file,Level);
                }
                else {
                    System.out.println(getSeparator(Level)+file.toString());
                }
            }
        }
    }
    //以指定格式输出
    public static String getSeparator(int level){
        StringBuilder sb=new StringBuilder();
        sb.append("|");
        for (int i = 0; i < level; i++) {
            sb.append("__");
        }
        return sb.toString();
    }
    //练习二：递归删除文件夹
    public static void deleteFile(File dir){
        File[] files=dir.listFiles();
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    deleteFile(file);
                }else {//删除文件
                    System.out.println(file.toString()+":"+file.delete());
                }
            }
        }
        //把文件夹删除
        System.out.println(dir.toString()+":"+dir.delete());
    }
}

1.2.3复制文件

1.2.3.1使用字节流复制文件

// 使用字节流复制文件
public class CopyDemo1 {
    public static void main(String[] args) throws Exception{
        //创建字节输入流、输出流
        FileInputStream fis=new FileInputStream("copy.jpg");
        FileOutputStream fos=new FileOutputStream("copy2.jpg");
        //读取和写入
        byte[] buf=new byte[1024*4];
        int len=1;
        while ((len=fis.read(buf))!=-1){
            fos.write(buf,0,len);
        }
        //关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }
}

1.2.3.2使用字符流复制文件

// 使用字符流实现复制
public class CopyDemo2 {
    public static void main(String[] args) throws Exception{
        //创建字符输入流输出流
        FileReader fr=new FileReader("copy.jpg");
        FileWriter fw=new FileWriter("copy3.jpg");
        //读取和写入
        char[] buf=new char[1024];
        int len=0;
        while ((len=fr.read(buf))!=-1){
            fw.write(buf,0,len);
        }
        //关闭
        fr.close();
        fw.close();
        System.out.println("复制完成");
    }
}

1.2.3.3使用缓冲流复制文件

// 使用缓冲流实现文件的复制
public class CopyDemo {
    public static void main(String[] args) throws Exception{
        //创建缓冲流
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("out.txt"));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("out2.txt"));
        //读写
        byte[] buf=new byte[1024*4];
        int len=-1;
        while((len=bis.read(buf))!=-1){
            bos.write(buf,0,len);
            bos.flush();
        }
        //关闭
        bos.close();
        bis.close();
        System.out.println("复制完毕");
    }
}

二.IO流(Input、Output)

2.1概述

reader/write—>字符流
input/output—>字节流
input/output+stream+reader/writer—>字节到字符的转换流
如果复制的文件是文本文件，用字节流和字符流都可以(如果有中文，需要用到转换流)
如果复制的文件是图片、音乐、电影, 使用字节流
输入：从外部存储设备到内存叫输入|读取。输入流：表示将数据读取到java程序（内存）中使用的流。
输出: 从内存到外部存储设备叫输出|写入。输出流：表示从java程序（内存）向外传输使用的流。
当操作完成后，一定要关闭输入输出流
字节流：一次性传输一个字节数据，将数据以字节的形式传输。
字符流：一次性传输一个字符（1、2或3个字节）数据，将数据以字符的形式传输。

2.2输入流

2.2.1字节输入流

InputStream是一个抽象类，不能实例化对象。
文件输入流FileInputStream
 close() 关闭此输入流并释放与该流关联的所有系统资源。
 read() 从输入流中读取数据的下一个字节。
 read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。
 read(byte[] b,int off, int len) 将输入流中最多len个数据字节读入 byte 数组。

/**
 * 使用FileInputStream读取文件
 * ANSI：在中文系统下，指的是GBK
 * 简体中文：GB2312--->GBK--->GB18030
 */
public class Demo1 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        FileInputStream fi=new FileInputStream("e:\\bb.txt");
        //2.读取文件
        /*//2.1一次读取一个字节
        int data=-1;
        while ((data=fi.read())!=-1) {
            System.out.print((char) data);
        }*/
        //2.2一次读取多个
        //byte[] buf=new byte[10];
        byte[] buf=new byte[1024];
        /*int len1=fi.read(buf);//len读取数据长度
        int len2=fi.read(buf);//len读取数据长度
        int len3=fi.read(buf);//len读取数据长度
        System.out.println("第一次读取长度"+len1);
        System.out.println("第二次读取长度"+len2);
        System.out.println("第三次读取长度"len3);*/
        int len=-1;
        while ((len=fi.read(buf))!=-1){
            /*for (byte b : buf) {
                System.out.print((char) b);
            }*/
            //当缓冲区设置值太大时
            for (int i = 0; i < len; i++) {
                System.out.print((char) buf[i]);
            }
        }
        //关闭
        fi.close();
    }
}

2.2.2字符输入流

Reader：是所有字符输入流的父类，为一个抽象类，不能实例化对象，使用它的子类FileReader类

// Reader--->InputStreamReader--->FileReader
// FileReader字符输入流
public class Demo3 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        FileReader reader=new FileReader("e:\\bb.txt");
        //2.读取
        //2.1一次读取一个字符
        /*int data=reader.read();
        System.out.println((char) data);*/
        int data=-1;
        while ((data=reader.read())!=-1){
            System.out.print((char) data);
        }
        //3.关闭
        reader.close();
    }
}

2.3输出流

2.3.1字节输出流

OutputStream是抽象类，不能实例化对象。
文件输出流FileOutputStream
flush() 刷新此输出流并强制写出所有缓冲的输出字节。
write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。
write(byte[] b,int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
write(int b) 将指定的字节写入此输出流。

public class Demo2 {
    public static void main(String[] args) throws Exception{
        //1.创建输出流
        FileOutputStream fos=new FileOutputStream("e:\\bb.txt",true);
        //2.写入
        /*//2.1写入一个
        fos.write(97);*/
        //String content="helloworld";
        String content="helloworld\r\n";//换行
        fos.write(content.getBytes());
        //3.关闭
        fos.close();
        System.out.println("写入完毕");
    }
}

2.3.2字符输出流

Writer：是所有字符输出流的父类，为一个抽象类，不能实例化对象，使用它的子类FileWriter类

// 字符输出流
public class Demo4 {
    public static void main(String[] args) throws Exception{
        //创建字符输出流
        FileWriter fw=new FileWriter("e:\\cc.txt");
        //写入
        for (int i = 0; i < 10; i++) {
            fw.write("好好学习，天天向上\r\n");
            fw.flush();//防止断电，存在缓冲区---断电就没了，及时刷新---将内容放入内存中
        }
        //关闭
        fw.close();
        System.out.println("执行完毕");
    }
}