day26-java

时帆

已于 2023-03-01 20:50:33 修改

阅读量183

点赞数 1

分类专栏： Java 文章标签： java

于 2023-03-01 17:41:50 首次发布

本文链接：https://blog.csdn.net/agjnhga/article/details/129286471

版权

Java 专栏收录该内容

63 篇文章 0 订阅

订阅专栏

文章详细介绍了Java中File类的使用，包括创建、删除文件及获取文件信息的方法。同时，文章涵盖了字符集的概念，如何进行字符编码和解码。此外，还讨论了递归的基本原理并给出了几个递归案例。关于IO流，文章讲解了字节输入流和输出流的使用，字符输入流和输出流的读写操作，以及如何进行文件拷贝。最后，文章提到了资源释放的最佳实践，包括try-catch-finally结构和JDK7及9的资源管理方式。

摘要由CSDN通过智能技术生成

File类

概述

package com.itheima.file;

import java.io.File;

/**
 * 创建File类对象
 * public File(String pathname)	根据文件路径创建文件对象
 * public File(String parent, String child)	根据父路径名字符串和子路径名字符串创建文件对象
 * public File(File  parent, String child)	根据父路径对应文件对象和子路径名字符串创建文件对象
 */
public class Demo01Overview {
    public static void main(String[] args) {
        //根据父路径名字符串和子路径名字符串创建文件对象
        File file = new File("C:\\code","itheima-data.txt.log");
        //输出文件的字节数
        System.out.println(file.length());
        //删除该文件
        file.delete();


        /*根据文件路径创建文件对象，路径使用\时必须转义，
        使用/则不需要，还可使用File.separator作为分隔符，
        以适应不同系统的使用的分隔符不相同
         */
        File file3 = new File("C:" + File.separator + "code");
        File file1 = new File("C:\\code");
        //0，无法直接获取文件夹的字节数，只能遍历其中文件大小再相加
        System.out.println(file1.length());

        //根据父路径对应文件对象和子路径名字符串创建文件对象
        File file2 = new File(file1, "itheima-data.txt.log");
        //false,文件已被删除
        System.out.println(file2.exists());

        //创建File对象支持相对路径和绝对路径（重点）
        //绝对路径
        File file4 = new File("c:/code");
        //判断文件、文件夹是否存在
        System.out.println(file4.exists());
        /*
        相对路径，一般用于定位模块中的文件，存在于盘符中的文件依托于此电脑
        将文件存放于项目中，项目才拥有更好的移植性
        创建File对象使用相对路径时，默认是相对到当前工程目录下查找文件
        所以路径应从模块名开始
         */
        File file5 = new File("day09-file-io/src/data.txt");
        //3，输出文件字节数
        System.out.println(file5.length());
    }
}

File类API

package com.itheima.file;

import java.io.File;
import java.text.SimpleDateFormat;

/**
 * File类常用API
 * public boolean isDirectory()	判断此路径名表示的File是否为文件夹
 * public boolean isFile()	判断此路径名表示的File是否为文件
 * public boolean exists()	判断此路径名表示的File是否存在
 * public long length()	返回文件的大小（字节数量）
 * public String getAbsolutePath()	返回文件的绝对路径
 * public String getPath()	返回定义文件时使用的路径
 * public String getName()	返回文件的名称，带后缀
 * public long lastModified()	返回文件的最后修改时间（时间毫秒值）
 */
public class Demo02API {
    public static void main(String[] args) {
        //使用绝对路径创建file对象
        File file = new File("c:/code");
        //使用相对路径创建file对象
        File file1 = new File("day09-file-io/src/data.txt");

        //1.获取文件对象的绝对路径
        System.out.println(file.getAbsoluteFile());//c:\code
        System.out.println(file1.getAbsoluteFile());//H:\JavaLearning\JavaSEAdvance\day09-file-io\src\data.txt

        //2.获取对象定义时使用的路径
        System.out.println(file.getPath());//c:\code
        System.out.println(file1.getPath());//day09-file-io\src\data.txt

        //3.获取文件名（带后缀）
        System.out.println(file.getName());//code
        System.out.println(file1.getName());//data.txt

        //4.获取文件字节数
        System.out.println(file.length());//0
        System.out.println(file1.length());//39

        //5.获取文件最后修改时间，毫秒数
        System.out.println(file.lastModified());
        System.out.println(file1.lastModified());
        System.out.println("最后修改时间："+new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(file.lastModified()));
        System.out.println("最后修改时间："+new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(file1.lastModified()));

        //6.判断是文件还是文件夹
        System.out.println(file.isFile());//false
        System.out.println(file1.isFile());//true
        System.out.println(file.isDirectory());//true
        System.out.println(file1.isDirectory());//false

        //7.判断文件、文件夹是否存在
        System.out.println(file.exists());//true
        System.out.println(file1.exists());//true
    }

}

package com.itheima.file;

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

/**
 * File类删除文件、创建文件方法
 * public boolean createNewFile()	创建一个新的空的文件
 * public boolean mkdir()	只能创建一级文件夹
 * public boolean mkdirs()	可以创建多级文件夹
 * public boolean delete()	删除由此抽象路径名表示的文件或空文件夹
 */
public class Demo03API {
    public static void main(String[] args) throws IOException {
        //创建一个File类对象
        File file = new File("day09-file-io/src/data1.txt");

        //1.创建一个新的空的文件
        if (!file.exists()) {
            //true,创建成功
            System.out.println(file.createNewFile());
        }

        //2.创建一级文件夹
        File file1 = new File("day09-file-io/lib");
        //true，创建成功
        System.out.println(file1.mkdir());

        //3.创建多级文件夹
        File file2 = new File("D:/aaa/bbb/ccc");
        if (!file2.exists()) {
            //true
            System.out.println(file2.mkdirs());
        }

        //4.删除文件或空文件夹，文件被占用也能删除
        File file3 = new File("day09-file-io/src/data1.txt");
        //true，delete方法不走回收站，直接删除
        System.out.println(file3.delete());
        //true，删除空文件夹
        System.out.println(file2.delete());
        //false,不能删除非空文件夹
        System.out.println(new File("d:/aaa").delete());
    }
}

package com.itheima.file;

import java.io.File;
import java.util.Arrays;

/**
 * File类的遍历功能
 * public String[] list()	获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回。
 * public File[] listFiles()(常用)	获取当前目录下所有的"一级文件对象"到一个文件对象数组中去返回（重点）
 * 注意：
 * 当文件不存在时或者文件夹不存在时，返回null
 * 当文件对象代表一个空文件夹时，返回一个长度为0的数组
 * 当文件对象是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
 * 当文件对象是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
 * 当没有权限访问该文件夹时，返回null
 */
public class Demo04API {
    public static void main(String[] args) {
        //定位一个文件夹
        File file = new File("d:/aaa");
        File file1 = new File("d:/aaa/ccc");
        file1.mkdir();

        //获取当前目录下所有的"一级文件名称"
        String[] names = file.list();
        System.out.println(Arrays.toString(names));

        //获取当前目录下所有的"一级文件对象"
        File[] files = file.listFiles();
        for (File f : files) {
            System.out.println(f.getName());
            System.out.println(f.getAbsoluteFile());
        }

    }
}

字符集

package com.itheima.charset;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/**
 * 字符集：
 * 英文和数字在任何国家的字符集中都占一个字节
 * GBK字符中一个中文字符占两个字节
 * UTF-8编码中一个中文字符占三个字节
 * 编码前后的字符集必须一致，否则除了英文和数字会乱码
 * 文字的解码和编码
 */
public class Demo01 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //编码
        String s = "A1时帆";
        String ss = "A2戏言";

        //以代码默认字符集编码，即UTF-8
        byte[] bytes = s.getBytes();

        //以GBK字符集编码
        byte[] gbks = ss.getBytes("GBK");
        //6,一个英文和数字占一个字节，GBK中一个中文字符占2个字节
        System.out.println(gbks.length);
        System.out.println(Arrays.toString(gbks));

        //8，一个英文和数字占一个字节，UTF-8中一个中文字符占3个字节
        System.out.println(bytes.length);
        System.out.println(Arrays.toString(bytes));

        //解码
        //以代码默认字符集解码，即UTF-8
        String s1 = new String(bytes);
        System.out.println(s1);

        //以GBK字符集解码
        String gbk1 = new String(bytes, "GBK");
        //A1鏃跺竼，编码前解码后所使用字符集不一致，出现乱码
        System.out.println(gbk1);
        String gbk2 = new String(gbks, "GBK");
        //A2戏言
        System.out.println(gbk2);
    }
}

递归

导学案例

package com.itheima.recursion;

/**
 * 递归导学案例：
 * 递归三要素：
 * 1.递归的公式
 * 2.递归的终点
 * 3.递归的方向要走向终点
 */
public class Demo01 {
    public static void main(String[] args) {
        System.out.println(factorial(10));
        System.out.println(sum(10));
    }

    /**
     * 求1-n的阶乘
     * @param n
     * @return
     */
    public static int factorial(int n){
        if (n==0){
            return n;
        }else if (n==1){
            return n;
        }else {
            return n*factorial(n-1);
        }
    }

    /**
     * 求1-n的和
     * @param n
     * @return
     */
    public static int sum(int n){
        if (n==0){
            return n;
        }else if (n==1){
            return 1;
        }else {
            return n+sum(n-1);
        }
    }
}

package com.itheima.recursion;

/**
 * 案例：猴子吃桃
 * 猴子第一天摘下若干桃子，当即吃了一半，觉得好不过瘾，于是又多吃了一个
 * 第二天又吃了前天剩余桃子数量的一半，觉得好不过瘾，于是又多吃了一个
 * 以后每天都是吃前天剩余桃子数量的一半，觉得好不过瘾，又多吃了一个
 * 等到第10天的时候发现桃子只有1个了。
 * 需求：请问猴子第一天摘了多少个桃子？
 * 典型的规律化递归问题
 * 公式:f(x)-f(x)/2-1=f(x+1)
 * f(x)=2f(x+1)+2
 * f(10)=1
 */
public class Demo02Case {
    public static void main(String[] args) {
        System.out.println(f(1));
    }
    public static int f(int n){
        if (n==10){
            return 1;
        }else {
            return f(n+1)*2+2;
        }
    }
}

package com.itheima.recursion;

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

/**
 * 案例：
 * 文件搜索
 * 在H盘搜索Ant.exe
 */
public class Demo03Case {
    public static void main(String[] args) {
        File file = new File("h:/");
        searchFile(file,"Ant.exe");
    }
    public static void searchFile(File dir,String fileName){
        File[] files = dir.listFiles();
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    searchFile(file,fileName);
                }else if (file.isFile()){
                    if (file.getName().equals(fileName)) {
                        System.out.println(file.getAbsoluteFile());
                        System.out.println("启动"+fileName);
                        //启动该软件
                        Runtime r = Runtime.getRuntime();
                        try {
                            r.exec(file.getAbsolutePath());
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

package com.itheima.recursion;

/**
 * 案例：啤酒问题
 * 啤酒2元1瓶，4个盖子可以换一瓶，2个空瓶可以换一瓶，
 * 请问10元钱可以喝多少瓶酒，剩余多少空瓶和盖子。
 */
public class Demo04Case {
    //购买的总瓶数
    private static int totalNumber;
    //每轮剩下的瓶子数量
    private static int lastBottleNumber;
    //每轮剩下的盖子数量
    private static int lastCoverNumber;
    public static void main(String[] args) {
        buy(10);
        System.out.println(totalNumber);
        System.out.println(lastCoverNumber);
        System.out.println(lastBottleNumber);
    }
    public static void buy(int money){
        //最多买的瓶数
        int buyNumber = money/2;
        totalNumber+=buyNumber;
        //每轮总盖子数
        int coverNumber = buyNumber+lastCoverNumber;
        //每轮总瓶子数
        int bottleNumber = buyNumber+lastBottleNumber;

        lastBottleNumber = bottleNumber%2;
        lastCoverNumber = coverNumber%4;
        //每轮剩下的总金额
        int allMoney = buyNumber%2+(coverNumber/4)*2+(bottleNumber/2)*2;
        if (allMoney>=2){
            buy(allMoney);
        }
    }
}

package com.itheima.recursion;

import java.io.File;

/**
 * 练习：删除非空文件夹
 * 分析：
 * ①：File默认不可以删除非空文件夹
 * ②：我们需要遍历文件夹，先删除里面的内容，再删除自己。
 */
public class Demo05Exercise {
    public static void main(String[] args) {
        deleteFile(new File("d:/aaa"));
    }

    private static void deleteFile(File file) {
        File[] files = file.listFiles();
        if (files.length!=0&&files!=null){
            for (File f : files) {
                if (f.isFile()){
                    f.delete();
                }else {
                    deleteFile(f);
                }
            }
        }else{
            file.delete();
        }
        file.delete();
    }

}

IO流

字节输入流

package com.itheima.io.fileinputstream;

import java.io.FileInputStream;

/**
 目标：字节输入流的使用。

 IO流的体系：
 字节流                                   字符流
 字节输入流            字节输出流               字符输入流        字符输出流
 InputStream          OutputStream           Reader           Writer  (抽象类)
 FileInputStream      FileOutputStream       FileReader       FileWriter(实现类，可以使用的)

 文件字节输入流：FileInputStream
 -- 作用：以内存为基准，把磁盘文件中的数据以字节的形式读取到内存中去。
 按照字节读文件数据到内存中。
 -- 构造器：
 public FileInputStream(File file):创建字节输入流管道与源文件对象接通
 public FileInputStream(String pathname)：创建字节输入流管道与源文件路径接通。
 -- 方法：
 public int read(): 每次读取一个字节返回，读取完毕返回-1。

 小结：
 一个一个字节读取中文数据输出其实是被淘汰的，性能极差！
 一个一个字节读取中文数据输出，会出现截断中文字节的情况，无法避免读取中文输出乱码的问题。

 */
public class FileInputStreamDemo01 {
    public static void main(String[] args) throws Exception {
        //创建文件字节输入流管道
//        FileInputStream in = new FileInputStream(new File("day09-file-io\\src\\data.txt"));
        //底层同样是创建了File对象
        FileInputStream in = new FileInputStream("day09-file-io\\src\\data.txt");

        //读取第一个字节
        int i = in.read();
        //S
        System.out.println((char) i);

        //循环读取剩下还没有读取的所有字节
        int a ;
        while ((a = in.read()) != -1) {
            //HIFT+F6 åŒæ—¶ä¿®æ”¹æ‰€æœ‰åŒåå˜é‡
            System.out.print((char)a);
        }
        //关闭流
        in.close();
    }
}

package com.itheima.io.fileinputstream;

import java.io.FileInputStream;

/**
 目标：使用文件字节输入流每次读取一个字节数组的数据。
 读取中文还是无法避免乱码问题
 */
public class FileInputStreamDemo02 {
    public static void main(String[] args) throws Exception {
        //创建一个字节输入流管道连通源文件
        FileInputStream in = new FileInputStream("day09-file-io\\src\\111.txt");

        //定义一个字节数组，用于存储读取的数据
        byte[] b = new byte[3];
/*        //一次读取一个字符数组，返回读取的字节长度
        int len = in.read(b);
        //解码
        String s = new String(b);
        //3
        System.out.println("读取的字节数："+len);
        //abc
        System.out.println(s);

        int len1 = in.read(b);
        //String s1 = new String(b);
        //2
        System.out.println("读取的字节数："+len1);
        *//*cdc,只读取到两个字节，第三个字节是上一次读取的残留数据
        可在解码时给定起始位置和读取字节长度以排除上次读取的残留数据
         *//*
        //cd
        String s1 = new String(b, 0, len1);
        System.out.println(s1);

        int len2 = in.read(b);
        String s2 = new String(b);
        //-1，没有读取到字节，返回-1
        System.out.println("读取的字节数："+len2);
        //cdc,数组中数据为上一次读取所留下
        System.out.println(s2);*/

        //使用循环读取
        int i;
        while (( i =in.read(b)) != -1) {
            String s = new String(b, 0, i);
            System.out.print(s);
        }
        //关闭流
        in.close();
    }
}

package com.itheima.io.fileinputstream;


import java.io.File;
import java.io.FileInputStream;

/**
   目标：使用文件字节输入流一次读完文件的全部字节。可以解决乱码问题。
           */
public class FileInputStreamDemo03 {
    public static void main(String[] args) throws Exception {
        //相对路径创建文件对象
        File f = new File("day09-file-io\\src\\111.txt");
        //创建一个字节输入流管道连通源文件
        FileInputStream in = new FileInputStream(f);

        /*定义一个与文件一样大的字节数组,文件长度为long类型
        若文件过大，定义的字节数组可能会导致内存溢出
         */
/*        byte[] b = new byte[(int) f.length()];
        int len = in.read(b);
        //5
        System.out.println("读取的字节长度："+len);
        //5
        System.out.println("文件的字节长度："+f.length());
        String s = new String(b);
        //abccd
        System.out.println(s);*/

        //使用readAllBytes方法一次读取全部字符
        byte[] c = in.readAllBytes();
        String s1 = new String(c);
        //abccd
        System.out.println(s1);
        //关闭流
        in.close();
    }
}

字节输出流

package com.itheima.io.fileoutputstream;


import java.io.FileOutputStream;
import java.io.OutputStream;

/**
 目标：字节输出流的使用。

    FileOutputStream文件字节输出流。
 -- 作用：以内存为基准，把内存中的数据，按照字节的形式写出到磁盘文件中去。
 简单来说，把内存数据按照字节写出到磁盘文件中去。
 -- 构造器：
 public FileOutputStream(File file):创建一个字节输出流管道通向目标文件对象。
 public FileOutputStream(String file):创建一个字节输出流管道通向目标文件路径。
 public FileOutputStream(File file , boolean append):创建一个追加数据的字节输出流管道通向目标文件对象。
 public FileOutputStream(String file , boolean append):创建一个追加数据的字节输出流管道通向目标文件路径。
 -- 方法：
 public void write(int a):写一个字节出去 。
 public void write(byte[] buffer):写一个字节数组出去。
 public void write(byte[] buffer , int pos , int len):写一个字节数组的一部分出去。
 参数一，字节数组；参数二：起始字节索引位置，参数三：写多少个字节数出去。
 小结：
 记住。
 换行：  os.write("\r\n".getBytes()); // 换行
 追加数据管道： OutputStream os = new FileOutputStream("day10_demo/out01.txt" , true); // 追加管道！！
 */
public class FileOutStreamDemo04 {
    public static void main(String[] args) throws Exception {
        //创建一个字节输出流管道连通源文件,先清空文件内容再写入新数据
        //OutputStream ot = new FileOutputStream("day09-file-io\\src\\111.txt");
        //创建一个字节输出流追加数据管道连通源文件，在文件原内容后面追加数据
        OutputStream ot = new FileOutputStream("day09-file-io\\src\\111.txt", true);

        //写入一个字节
        ot.write('a');
        ot.write('c');
        //换行
        ot.write("\r\n".getBytes());
        //�
        //ot.write('蒙');

        //写入一个字节数组
        byte[] b = {'a','c',96,};
        ot.write(b);
        ot.write("\r\n".getBytes());

        //编码
        byte[] b1 = "中国人".getBytes();
//        byte[] b2 = "中国人".getBytes("GBK");写进去是乱码
        ot.write(b1);
        ot.write("\r\n".getBytes());

        //写入字节数组的一部分，写入前两个字节
        ot.write(b,0,2);
        ot.write("\r\n".getBytes());

        //刷新流，让数据成功写入，刷新后流可以继续使用
//        ot.flush();
        //关闭流，关闭前会自动刷新，关闭后流无法继续使用
        ot.close();
    }
}

案例：文件拷贝

package com.itheima.io.fileoutputstream;

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

/**
 * 案例：文件拷贝
 */
public class CopyDemo05 {
    public static void main(String[] args) throws Exception {
        //创建文件输入流管道接通源文件
        InputStream in = new FileInputStream("H:\\JavaLearning\\document\\JavaSE课程\\进阶\\day09、File、递归、IO流(一)\\视频\\02、File类常用方法.mp4");
        //创建文件输出流管道接通目标文件
        FileOutputStream out = new FileOutputStream("h:/new.mp4");

        //定义字节数组存储读取写入的数据
        byte[] buffer = new byte[1024];
        //定义整型存储每次读取的字节数
        int len;
        while ((len = in.read(buffer)) != -1) {
            //读取多少字节就写入多少字节
            out.write(buffer,0,len);
        }
        System.out.println("复制完成");
        out.close();
        in.close();
    }
}

字符输入流

package com.itheima.io.charsetstream;

import java.io.FileReader;
import java.io.Reader;

/**
 目标：字符输入流的使用。
 FileReader:文件字符输入流。
 -- 作用：以内存为基准，把磁盘文件的数据以字符的形式读入到内存。
 简单来说，读取文本文件内容到内存中去。

 -- 构造器：
 public FileReader(File file):创建一个字符输入流与源文件对象接通。
 public FileReader(String filePath):创建一个字符输入流与源文件路径接通。

 -- 方法：
 public int read(): 读取一个字符的编号返回！ 读取完毕返回-1
 public int read(char[] buffer):读取一个字符数组，读取多少个字符就返回多少个数量，读取完毕返回-1
 小结：
 字符流一个一个字符的读取文本内容输出，可以解决中文读取输出乱码的问题。
 字符流很适合操作文本文件内容。
 但是：一个一个字符的读取文本内容性能较差！！
 */
public class CharsetStreamDemo01 {
    public static void main(String[] args) throws Exception {
        //创建一个字符输入流对象与源文件接通
        Reader fr = new FileReader("day09-file-io\\src\\data.txt");

        //读取一个字符，返回字符编号，读取完毕返回-1
        int x = fr.read();
        System.out.println((char) x);

        //使用循环读取剩下的字符
        while ((x = fr.read()) != -1) {
            System.out.print((char) x);
        }
        //关闭流
        fr.close();
    }
}

package com.itheima.io.charsetstream;

import java.io.FileReader;
import java.io.Reader;

/**
 目标：字符输入流的使用。
 FileReader:文件字符输入流。
 -- 作用：以内存为基准，把磁盘文件的数据以字符的形式读入到内存。
 简单来说，读取文本文件内容到内存中去。

 -- 构造器：
 public FileReader(File file):创建一个字符输入流与源文件对象接通。
 public FileReader(String filePath):创建一个字符输入流与源文件路径接通。

 -- 方法：
 public int read(): 读取一个字符的编号返回！ 读取完毕返回-1
 public int read(char[] buffer):读取一个字符数组，读取多少个字符就返回多少个数量，读取完毕返回-1
 小结：
 字符流一个一个字符的读取文本内容输出，可以解决中文读取输出乱码的问题。
 字符流很适合操作文本文件内容。
 但是：一个一个字符的读取文本内容性能较差！！
 */
public class CharsetStreamDemo02 {
    public static void main(String[] args) throws Exception {
        //创建一个字符输入流对象与源文件接通
        Reader fr = new FileReader("day09-file-io\\src\\data.txt");

        //读取一个字符数组，返回读取的字符数量，读取完毕返回-1
        char[] chars = new char[3];
        int a = fr.read(chars);
        String s = new String(chars,0,a);
        System.out.println(s);

        //使用循环读取剩下的字符
        while ((a = fr.read(chars)) != -1) {
            String s1 = new String(chars, 0, a);
            System.out.print(s1);
        }
        //关闭流
        fr.close();
    }
}

字符输出流

package com.itheima.io.charsetstream;

import java.io.FileWriter;

/**
     FileWriter文件字符输出流的使用。
             -- 作用：以内存为基准，把内存中的数据按照字符的形式写出到磁盘文件中去。
             简单来说，就是把内存的数据以字符写出到文件中去。
             -- 构造器：
public FileWriter(File file):创建一个字符输出流管道通向目标文件对象。
public FileWriter(String filePath):创建一个字符输出流管道通向目标文件路径。
public FileWriter(File file,boolean append):创建一个追加数据的字符输出流管道通向目标文件对象。
public FileWriter(String filePath,boolean append):创建一个追加数据的字符输出流管道通向目标文件路径。
        -- 方法：
        a.public void write(int c):写一个字符出去
        b.public void write(String c)写一个字符串出去：
        c.public void write(char[] buffer):写一个字符数组出去
        d.public void write(String c ,int pos ,int len):写字符串的一部分出去
        e.public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
        小结：
        字符输出流可以写字符数据出去，总共有5个方法写字符。
        覆盖管道：
        Writer fw = new FileWriter("Day10Demo/src/dlei03.txt"); // 覆盖数据管道
        追加数据管道：
        Writer fw = new FileWriter("Day10Demo/src/dlei03.txt",true); // 追加数据管道
        换行：
        fw.write("\r\n"); // 换行
        结论：读写字符文件数据建议使用字符流。复制文件建议使用字节流。
 */
public class CharsetStreamDemo03 {
    public static void main(String[] args) throws Exception {
        //创建一个字符输出流管道连通目标文件（覆盖数据管道）
        //FileWriter fw = new FileWriter("day09-file-io/src/111.txt");
        //创建一个字符输出流管道连通目标文件（追加数据管道）
        FileWriter fw = new FileWriter("day09-file-io/src/111.txt",true);

        //写一个字符出去
        fw.write('a');
        fw.write(33);
        fw.write('程');
        fw.write("\r\n");

        //写一个字符串出去
        fw.write("昨日之深渊，今日之浅谈");
        fw.write("\r\n");

        //写一个字符数组出去
        char[] arr = {'嗨','害','嗨'};
        fw.write(arr);
        fw.write("\r\n");

        //写字符串的一部分出去
        fw.write("爱滴魔力转圈圈",2,5);
        fw.write("\r\n");

        //写字符数组的一部分出去
        fw.write(arr,1,2);

        //关闭流
        fw.close();
    }
}

资源释放方式

package com.itheima.io.releaseresource;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 *   目标：学会使用finally释放资源。
 *   finally代码块是一定会被执行的，除非JVM结束
 *   适合用来释放资源，比如关闭流
 */
public class TryCatchFinallyDemo06 {
    public static void main(String[] args) {
        //创建文件输入流管道
        InputStream in = null;
        //创建文件输出流管道
        FileOutputStream out = null;
        try {
//            System.out.println(10/0);
            //接通源文件
             in = new FileInputStream("H:\\JavaLearning\\document\\JavaSE课程\\进阶\\day09、File、递归、IO流(一)\\视频\\02、File类常用方法.mp4");
            //接通目标文件
            out = new FileOutputStream("h:/new.mp4");

            //除非这里关闭JVM,否则finally代码块一定执行
//            System.exit(0);

            //定义字节数组存储读取写入的数据
            byte[] buffer = new byte[1024];
            //定义整型存储每次读取的字节数
            int len;
            while ((len = in.read(buffer)) != -1) {
                //读取多少字节就写入多少字节
                out.write(buffer,0,len);
            }
            System.out.println("复制完成");

            //如果关闭流之前出现了异常，流将无法关闭
//            System.out.println(10/0);
//            out.close();
//            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //无论代码是正常结束还是出现异常，最后都要执行finally代码块
            System.out.println("----------finally-------------");
            try {
                //如果管道还没有接通目标文件就出现了异常，这里就会出现空指针异常
                if (out!=null) out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                //如果管道还没有接通源文件就出现了异常，这里就会出现空指针异常
                if (in!=null)in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //1，哪怕前面存在return语句，finally代码块也要先执行
        //开发中不建议在finally代码块中加return语句，否则返回的永远是finally中的数据
        System.out.println(add(1, 2));
    }

    /**
     * 面试题
     * @param a
     * @param b
     * @return
     */
    private static int add(int a,int b){
        try {
            return a+b;
        } catch (Exception e) {
            e.printStackTrace();
            return -100000;
        } finally {
            return 1;
        }
    }
}

package com.itheima.io.releaseresource;

import java.io.*;

/**
 *   目标：学会使用JDK 7的新方式释放资源
 *   资源:实现了Closeable接口的实现类对象
 */
public class TryCatchResourceDemo07 {
    public static void main(String[] args) {
        try (
                // 这里面只能放置资源对象，用完会自动关闭：自动调用资源对象的close方法关闭资源（即使出现异常也会做关闭操作）
                //创建文件输入流管道接通源文件
                InputStream in = new FileInputStream("H:\\JavaLearning\\document\\JavaSE课程\\进阶\\day09、File、递归、IO流(一)\\视频\\02、File类常用方法.mp4");
                //创建文件输出流管道接通目标文件
                FileOutputStream out = new FileOutputStream("h:/new.mp4");
//                int a = 10这里只能放资源对象
                MyConnection m =new MyConnection()
                ){
            //定义字节数组存储读取写入的数据
            byte[] buffer = new byte[1024];
            //定义整型存储每次读取的字节数
            int len;
            while ((len = in.read(buffer)) != -1) {
                //读取多少字节就写入多少字节
                out.write(buffer,0,len);
            }
            System.out.println("复制完成");

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class MyConnection implements Closeable {

    @Override
    public void close() throws IOException {
        System.out.println("资源已关闭");
    }
}

package com.itheima.io.releaseresource;

import java.io.*;

/**
 *   目标：JDK 9释放资源的方式：可以了解下。
 */
public class TryCatchResourceDemo08 {
    public static void main(String[] args) throws Exception {
        //创建文件输入流管道接通源文件
        InputStream in = new FileInputStream("H:\\JavaLearning\\document\\JavaSE课程\\进阶\\day09、File、递归、IO流(一)\\视频\\02、File类常用方法.mp4");
        //创建文件输出流管道接通目标文件
        FileOutputStream out = new FileOutputStream("h:/new.mp4");
        try (//这里只放资源对象名
                in;out){
            //定义字节数组存储读取写入的数据
            byte[] buffer = new byte[1024];
            //定义整型存储每次读取的字节数
            int len;
            while ((len = in.read(buffer)) != -1) {
                //读取多少字节就写入多少字节
                out.write(buffer,0,len);
            }
            System.out.println("复制完成");

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