SE_File文件、IO字节流

• file出现的意义即永久保存数据
• file是对问文件及文件夹路径的抽象表示,file封装的对象路径可以存在也可以不存在
• 之所以封装file对象是为了使用其方法
• 路径可分为绝对路径:即从盘符开始的路径,相对路径:即相对于某个点来说
• file方法

public class Test05 {
    public static void main(String[] args) throws IOException {
        //file创建方法演示
        File file = new File("D:\\file\\x.txt");
        //调用createNewFile创建一个文件
        boolean newFile = file.createNewFile();
        System.out.println(newFile);

        File file1 = new File("D:\\file\\ddd\\fff\\kkk");
        //调用mkdirs创建多级目录
        boolean mkdirs = file1.mkdirs();
        System.out.println(mkdirs);

        File file2 = new File("D:\\file\\x.txt");
        //delete删除文件
        boolean delete = file2.delete();
        System.out.println(delete);

        File file3 = new File("D:\\file");
        //delete只能删除空的文件夹,有内容文件夹不能直接删除
        boolean delete1 = file3.delete();
        System.out.println(delete1);



        //file类判断和获取方法

        File file4 = new File("D:\\file\\a.txt");
        //isFile方法判断当前file对象是否为文件
        boolean file10 = file4.isFile();
        System.out.println(file);

        File file5 = new File("D:\\file");
        //isDirectory判断当前对象是否为文件夹
        boolean directory = file5.isDirectory();
        System.out.println(directory);

          File file6 = new File("D:\\file\\c.txt");
          //exists 判断当前对象表示的文件或者文件夹是否存在
        boolean exists = file6.exists();
        System.out.println(exists);

        File file7 = new File("D:\\file\\b.txt");
        //getName返回当前对象的文件或者文件夹,无论是否存在都会返回
        String name = file7.getName();
        System.out.println(name);


        //file类高级获取方法
        File file8 = new File("D:\\");
        //listFiles进入文件夹,获取当前文件夹下所有的文件夹、文件,以及隐藏内容
        //返回值类型为数组,遍历获取每一个值
        File[] files = file8.listFiles();
        for (File file9 : files) {
            System.out.println(file);
        }
    }
}

• IO流可分为输出流、输入流 (即操作文件内容)
• 字节流:可操作所有类型文件,音频.视频.图片等等
• 字符流:只能操作纯文本文件,即能用电脑自带记事本打开且能看懂的文件
• 字节输出入方法

public class Test06 {
    public static void main(String[] args) throws IOException {
        //IO流演示

        //创建输出流对象  (单个输入)  true即不覆盖原来的内容
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\file\\v.txt",true);
        //调用write,往里面填写数据
        fileOutputStream.write(99);
        //"\r\n"换行的意思 因为是字符串,所以调用getBytes转化成字节数组
        //在调用write,传进去
        byte[] bytes1 = "\r\n".getBytes();
        fileOutputStream.write(94);
        fileOutputStream.write(95);
        
        //释放资源
       // fileOutputStream.close();

        //以数组的形式往里面输入,效率提高
        byte[] bytes = {1,4,6,7,8,9,5};
        fileOutputStream.write(bytes);
        //根据条件进行截取
        fileOutputStream.write(bytes,0,3);
        fileOutputStream.close();
    }
}

• try…catch…finally 异常

public class Test03 {
    public static void main(String[] args) {
        //演示无论碰到什么异常,close都能释放资源

        //提高作用域
        FileOutputStream fileOutputStream=null;
        try {
            //出现算数异常
            //System.out.println(2/0);
            //创建对象并指明输出的文件路径
            //重新赋值
            fileOutputStream = new FileOutputStream("itzhangsong-inherit\\b.txt\\");

            //调用write方法进行写
            fileOutputStream.write(99);
            //释放资源

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //finally中判断的目的,即为了防止出现以上情况,即出现null值
            //因为为了提高作用域,把变量先赋值为null,避免在给重新赋值前出现错误,进而跳过没有重新赋值
            //即对象没有创建成功
            //既然没有对象,也没释放资源一说
            if (fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

• 字节输入流

public class Test07 {
    public static void main(String[] args) throws IOException{
       // 字节流读取数据
        //创建对象
        FileInputStream fileInputStream = new FileInputStream("D:\\file\\v.txt");

        //调用read进行读取,每次读一个
        int read = fileInputStream.read();
        System.out.println(read);

//        当不清楚文件中有多少字节时,声明一个变量
//        进行while循环,把得到的结果赋值为声明的变量,条件设成不等于-1
        //因为当文件中内容取出完后,在继续取便是-1
        int b ;
        while ((b=fileInputStream.read())!=-1){
            System.out.println(b);
        }

        //把一个文件复制到另一个文件上
        //创建输入流
        FileInputStream fileInputStream1 = new FileInputStream("D:\\file\\v.txt");
        //创建输出流
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\file\\u.txt");

        //定义变量用于接收读取到的值
        int c;
        while ((b=fileInputStream.read())!=-1){
            fileOutputStream.write(b);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }
}

public class Test03 {
    public static void main(String[] args) throws IOException {
        //一次读N个字节演示

        //创建读取对象
        FileInputStream fileInputStream = new FileInputStream("D:\\file\\c.avi");
        //创建写入对象
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\file\\d.avi");

        //定义一个byte类型数组,即类似于篮子,可以一次性读取多个字节
        //把读到的字节放入数组中
        byte[] bytes = new byte[1024];

        //定义一个变量用于记录读取后的字节
        int b ;
        //线下面代码意思即每次读取的字节放入数组,然后在赋值给b,b的容量即数组存的字节容量
        while ((b=fileInputStream.read(bytes))!=-1){
            //bytes代表,装入数组的字节,0代表从头开始读,b代表取出的个数,因为数组中字节赋值为b,所以b能代表所读取到的所有字节
           fileOutputStream.write(bytes,0,b);
        }
        fileInputStream.close();
        fileOutputStream.close();
    }
}

• 字节缓冲流(提高读和写的效率)

ublic class Test04 {
    public static void main(String[] args) throws IOException {
        //字节缓冲流

        //创建字节缓冲输出流
        //底层会创建8192字节数组长度
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("D:\\file\\d.avi"));

        //创建字节输入流
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("D:\\file\\s.avi"));

        //定义一个变量用于记录的到字节
        int b;
        while ((b=bufferedInputStream.read())!=-1){
            bufferedOutputStream.write(b);
        }
        bufferedInputStream.close();
        bufferedOutputStream.close();
    }
}