Java基础 - 10 - File、IO流(一)

admin2024-04-03  0

Java基础 - 10 - File、IO流(一),第1张

Java基础 - 10 - File、IO流(一),第2张

Java基础 - 10 - File、IO流(一),第3张

Java基础 - 10 - File、IO流(一),第4张

 一. File

  File是java.io.包下的类,File类的对象,用于代表当前操作系统的文件(可以是文件或文件夹

  注意:File类只能对文件本身进行操作,不能读写文件里面存储的数据

1.1 创建File类的对象

构造器说明
public File(String pathname)根据文件路径创建文件对象
public File(String parent, String child)根据父路径和子路径名字创建文件对象
public File(File parent, String child)根据父路径对应文件对象和子路径名字创建文件对象

注意

        · File对象既可以代表文件,也可以代表文件夹

        · File封装的对象仅仅是一个路径名,这个路径可以是存在的,也允许是不存在的

public class demo {
    public static void main(String[] args) {
        //文件路径名:
        //路径分隔符: 三种写法
        File f1 = new File("D:/zm/1.txt"); //指代某个具体的文件
        //File f1 = new File("D:\zm\1.txt");
        //File f1 = new File("D:"+File.separator+"zm"+File.separator+"1.txt");
        System.out.println(f1.length()); //文件大小

        File f2 = new File("D:/zm"); //指代某个文件夹
        System.out.println(f2.length());

        File f3 = new File("D:/zm/2.txt"); //指代某个不存在的文件
        System.out.println(f3.length()); //0
        System.out.println(f3.exists()); //false 不存在

        //绝对路径:带盘符的
        //File f4 = new File("D:\code\IJProject\demo\src\wosun.txt");
        //相对路径:不带盘符,默认是直接去工程下寻找文件
        File f4 = new File("demo\src\wosun.txt");
        System.out.println(f4.length());
    }
}

1.2 常用方法:判断文件类型、获取文件信息

方法名称说明
public boolean exists()判断当前文件对象,对应的文件路径是否存在,存在返回true
public boolean isFile()判断当前文件对象指代的是否是文件,是文件返回true,反之false
public boolean isDirectory()判断当前文件对象指代的是否是文件夹,是文件夹返回true,反之false
public String getName()获取文件的名称(包含后缀)
public long length()获取文件的大小,返回字节个数
public long lastModified()获取文件的最后修改时间

public String getPath()

获取创建文件对象时,使用的路径
public String getAbsolutePath()获取绝对路径
public class demo {
    public static void main(String[] args) {
        //创建文件对象,指代某个文件
        File f1 = new File("D:/zm/1.txt");
        //创建文件对象,指代某个文件夹(不存在的)
        File f2 = new File("D:/wosun");

        //1.public boolean exists() 判断当前文件对象,对应的文件路径是否存在,存在返回true
        System.out.println(f1.exists()); //true
        System.out.println(f2.exists()); //false

        //2.public boolean isFile() 判断当前文件对象指代的是否是文件,是文件返回true,反之false
        System.out.println(f1.isFile()); //true

        //3.public boolean isDirectory() 判断当前文件对象指代的是否是文件夹,是文件夹返回true,反之false
        System.out.println(f1.isDirectory()); //false

        //4.public String getName() 获取文件的名称(包含后缀)
        System.out.println(f1.getName()); //1.txt

        //5.public long length() 获取文件的大小,返回字节个数
        System.out.println(f1.length());

        //6.public long lastModified() 获取文件的最后修改时间
        System.out.println(f1.lastModified());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println(sdf.format(f1.lastModified()));

        //7.public String getPath() 获取创建文件对象时,使用的路径
        System.out.println(f1.getPath()); //创建的时候是绝对路径就是绝对路径

        File f3 = new File("src\wosun.txt"); //创建的时候是相对路径就是相对路径
        System.out.println(f3.getPath());

        //8.public String getAbsolutePath() 获取绝对路径
        System.out.println(f3.getAbsolutePath());
    }
}

1.3 常用方法:创建文件、删除文件

方法名称说明
public boolean createNewFile()创建一个新文件(文件内容为空),创建成功返回true,反之false
public boolean mkdir()用于创建文件夹,注意:只能创建一级文件夹
public boolean mkdirs()用于创建文件夹,注意:可以创建多级文件夹
public boolean delete()删除文件或空文件夹,注意:不能删除非空文件夹

注意:delete方法默认只能删除文件和空文件夹,删除后的文件不会进入回收站

public class demo {
    public static void main(String[] args) throws IOException {
        File f1 = new File("D:/zm/2.txt"); // 不存在的文件
        File f2 = new File("D:/zm/bbb/ccc/ddd"); //三级文件夹
        File f3 = new File("D:/zm/aaa"); //一级文件夹

        //1.public boolean createNewFile() 创建一个新文件(文件内容为空),创建成功返回true,反之false
        System.out.println(f1.createNewFile()); //不存在则创建成功,存在则创建失败

        //2.public boolean mkdir() 用于创建文件夹,注意:只能创建一级文件夹
        System.out.println(f2.mkdir()); //false
        System.out.println(f3.mkdir()); //true

        //3.public boolean mkdirs() 用于创建文件夹,注意:可以创建多级文件夹
        System.out.println(f2.mkdirs()); //true

        //4.public boolean delete() 删除文件或空文件夹,注意:不能删除非空文件夹
        System.out.println(f1.delete());
        System.out.println(f3.delete());
        System.out.println(f2.delete()); //删除"D:/zm/bbb/ccc/ddd"中的最后的空文件夹ddd
    }
}

1.4 常见方法:遍历文件夹

方法名称说明
public String[] list()获取当前目录下所有的“一级文件名称”到一个字符串数组中去返回
public File[] listFiles()获取当前目录下所有的“一级文件对象”到一个文件对象数组中去返回

使用listFiles方法时的注意事项:

· 当主调是文件,或者路径不存在时,返回null

· 当主调是空文件夹,返回一个长度为0的数组

· 当主调是一个有内容的文件夹时,将里面所有一级文件和文件夹的路径放在File数组中返回

· 当主调是一个文件夹,且里面有隐藏文件时,将里面所有文件和文件夹的路径放在File数组中返回,包含隐藏文件

· 当主调是一个文件夹,但是没有权限访问该文件夹时,返回null

public class demo {
    public static void main(String[] args) throws IOException {
        File f1 = new File("D:/zm");
        //1.public String[] list() 获取当前目录下所有的“一级文件名称”到一个字符串数组中去返回
        String[] nameList = f1.list();
        for (String s : nameList) {
            System.out.println(s); //文件名称 eg:1.txt
        }

        //2.public File[] listFiles() 获取当前目录下所有的“一级文件对象”到一个文件对象数组中去返回

        //使用listFiles方法时的注意事项:
        //· 当主调是一个有内容的文件夹时,将里面所有一级文件和文件夹的路径放在File数组中返回
        File[] files1 = f1.listFiles();
        for (File file : files1) {
            System.out.println(file); //文件对象 eg:D:\zm.txt
        }

        //· 当主调是文件,或者路径不存在时,返回null
        File f2 = new File("D:/zm/1.txt"); //主调是文件
        File[] files2 = f2.listFiles();
        System.out.println(files2); //null

        File f3 = new File("D:/recourse"); //路径不存在
        File[] files3 = f3.listFiles();
        System.out.println(files3); //null

        //· 当主调是空文件夹,返回一个长度为0的数组
        File f4 = new File("D:/zm/bbb"); //主调是空文件夹
        File[] files4 = f4.listFiles();
        System.out.println(Arrays.toString(files4)); //[]

        //· 当主调是一个文件夹,且里面有隐藏文件时,将里面所有文件和文件夹的路径放在File数组中返回,包含隐藏文件
        //· 当主调是一个文件夹,但是没有权限访问该文件夹时,返回null
        
    }
}

二. 方法递归

        · 递归是一种算法,在程序设计语言中广泛使用

        · 从形式上说:方法调用自身的形式称为方法递归(recursion)

递归的形式

        · 直接递归:方法自己调用自己

        · 间接递归:方法调用其他方法,其他方法又回调方法自己

使用方法递归时需要注意的问题:

        · 递归如果没有控制好终止,会出现递归死循环,导致栈内存溢出错误

public class demo {
    public static void main(String[] args) {
        test1();  //java.lang.StackOverflowError 栈内存溢出错误
    }

    //直接方法递归
    public static void test1(){
        System.out.println("===test1===");
        test1();
    }

    //间接方法递归
    public static void test2(){
        System.out.println("===test2===");
        test3();
    }

    public static void test3(){
        test2();
    }
}

2.1 递归算法三要素

2.2 递归算法案例

2.2.1 案例:n的阶乘

Java基础 - 10 - File、IO流(一),第5张

public class demo {
    public static void main(String[] args) {
        System.out.println("6的阶乘:"+f(6));
    }

    public static int f(int n){
        //终结点
        if(n==1){
            return 1;
        }else{
            return f(n-1)*n;
        }
    }
}

2.2.2 案例:1-n的和

Java基础 - 10 - File、IO流(一),第6张

public class demo {
    public static void main(String[] args) {
        System.out.println("1-100的和:"+f(100));
    }

    public static int f(int n){
        //终结点
        if(n==1){
            return 1;
        }else{
            return f(n-1)+n;
        }
    }
}

2.2.3 猴子吃桃问题

Java基础 - 10 - File、IO流(一),第7张

public class demo {
    public static void main(String[] args) {
        // 猴子吃桃问题
        // f(10)=1
        // f(x)表示f(x+1)的前一天
        // f(x) = 2 * (f(x+1) + 1)
        // 求 f(1)
        System.out.println("猴子第一天摘的桃子个数:" + f(1));
    }

    public static int f(int n){
        //终结点
        if(n==10){
            return 1;
        }else{
            return 2 * (f(n+1) + 1);
        }
    }
}

2.2.4 啤酒问题

问题:啤酒2元一瓶,4个盖子可以换一瓶,2个瓶子可以换一瓶,10块钱可以喝到几瓶?

public class demo {
    public static int totalNum = 0;  //酒的总共数量
    public static int lastBottleNum = 0; //剩余的瓶子数
    public static int lastCoverNum = 0; //剩余的瓶盖数
    public static void main(String[] args) {
        //问题:啤酒2元一瓶,4个盖子可以换一瓶,2个瓶子可以换一瓶,10块钱可以喝到几瓶?
        buy(10);
        System.out.println("购买的酒的数量:"+totalNum);
        System.out.println("剩余瓶盖数:"+lastCoverNum);
        System.out.println("剩余瓶子数:"+lastBottleNum);
    }

    private static void buy(int money) {
        //买酒的数量
        int buyNum = money / 2;
        totalNum += buyNum;

        //当前剩余的瓶子数和瓶盖数
        lastBottleNum += buyNum;
        lastCoverNum += buyNum;

        int allMoney = 0; //可以换的钱数(4个盖子可值2元,2个瓶子可值2元)

        if(lastCoverNum >= 4){
            allMoney += (lastCoverNum/4)*2;
        }
        lastCoverNum = lastCoverNum % 4;

        if(lastBottleNum >= 2){
            allMoney += (lastBottleNum/2)*2;
        }
        lastBottleNum = lastBottleNum % 2;

        if(allMoney>=2){
            buy(allMoney);
        }
    }
}

2.3 递归与File

2.3.1 案例:文件搜索

Java基础 - 10 - File、IO流(一),第8张

public class demo {
    public static void main(String[] args) throws IOException {
        File dir = new File("D:/"); //要搜索的路径(目录)
        String fileName = "QQ.exe"; //要搜索的文件名
        searchFile(dir,fileName);
    }

    /**
     * 去目录下搜索某个文件
     * @param dir 目录
     * @param fileName 要搜索的文件名
     */
    public static void searchFile(File dir,String fileName) throws IOException {
        //拦截非法情况(路径为null,路径不存在)
        if(dir == null || !dir.exists()){
            return; //无法搜索
        }
        //指定路径是一个文件
        if(dir.isFile()){
            //判断该文件名是否是搜索的文件名
            if(dir.getName().equals(fileName)){
                //是,打印路径
                System.out.println(dir.getAbsolutePath());
                return; //跳出方法
            }else{
                return; //搜索失败
            }
        }

        //指定路径dir不是null,且存在,且是一个文件夹(目录)
        //获取当前目录下的全部一级文件对象
        File[] files = dir.listFiles();

        //判断当前目录下是否存在一级文件对象,是否可以拿到一级文件对象
        if(files != null && files.length > 0){
            //遍历全部一级文件对象
            for (File file : files) {
                //判断文件是文件还是文件夹
                if(file.isFile()){
                    //是文件
                    if(file.getName().equals(fileName)){
                        System.out.println(file.getAbsolutePath());

                        //启动该程序
                        Runtime runtime = Runtime.getRuntime();
                        runtime.exec(file.getAbsolutePath());

                        return; //结束方法
                    }
                }else if(file.isDirectory()){
                    //是文件夹  重复该过程
                    searchFile(file,fileName);
                }
            }
        }
    }
}

2.3.2 案例:删除文件夹

Java基础 - 10 - File、IO流(一),第9张

public class demo {
    public static void main(String[] args) throws IOException {
        File dir = new File("D:/桌面/aaa");
        //System.out.println(dir.delete());  //false 非空文件夹不能通过delete()方法删除
        deleteDir(dir);
    }

    //删除非空文件夹
    public static void deleteDir(File dir){
        //指定路径为null或不存在
        if(dir == null || !dir.exists()){
            System.out.println("删除失败,指定路径为null或不存在");
            return;
        }

        //指定路径是文件,直接删除
        if(dir.isFile()){
            dir.delete();
            return;
        }

        //dir存在且是文件夹
        //判断dir是否为空文件夹
            //提取dir目录下的一级文件对象
        File[] files = dir.listFiles();

        //files为null,没有删除权限
        if(files == null){
            System.out.println("没有删除权限");
            return;
        }

        //因为删除内容后依旧要删除自己,所以这一段代码可以省略
//        //files.length为0,说明dir是空文件夹
//        if(files.length == 0){
//            dir.delete();
//            return;
//        }

        //dir是一个有内容的文件夹(先删除里里面的内容再删除自己)
        //先删除里里面的内容
        for (File file : files) {
            if(file.isFile()){
                file.delete();
            }else{
                deleteDir(file);
            }
        }
        //再删除自己
        dir.delete();
    }
}

三. 字符集

3.1 标准ASCII字符集

· ASCII(American Standard Code for Information Interchange):美国信息交换标准代码,包括了英文、数字、符号等

· 标准ASCII使用1个字节存储一个字符,首尾是0,总共可表示128个字符

3.2 GBK(汉字内码扩展规范,国标)

· 汉字编码字符集,包含了2万多个汉字等字符,GBK中一个中文字符编码成两个字节的形式存储

· 注意:GBK兼容了ASCII字符集(英文、数字占1个字节)

· GBK规定:汉字的第一个字节的第一位必须是1

3.3 Unicode字符集(统一码,也叫万国码)

· Unicode是国际组织指定的,可以容纳世界上所有文字、符号的字符集

· UTF-32用4个字节表示一个字符(占存储空间,效率变低)

· UTF-8是Unicode字符集的一种编码方案,采用可变长编码方案,共分四个长度区:1个字节、2个字节、3个字节、4个字节

· UTF-8中英文字符、数字等只占1个字节(兼容标准ASCII编码),汉字字符占用3个字节

Java基础 - 10 - File、IO流(一),第10张

注意:

· 字符编码时使用的字符集,和解码时使用的字符集必须一致,否则会出现乱码

· 英文、数字一般不会乱码,因为很多字符集都兼容了ASCII编码

3.4 字符集的编码、解码

        编码:把字符按照指定字符集编码成字节

        解码:把字节按照指定字符集解码成字符

Java代码完成对字符的编码

String提供了如下方法说明
byte[] getBytes()使用平台的默认字符集将该String编码为一系列字节,将结果存储到新的字节数组中
byte[] getBytes(String charsetName)使用指定的字符集将该String编码为一系列字节,将结果存储到新的字节数组中

Java代码完成对字符的解码

String提供了如下方法说明
String(byte[] bytes)通过使用平台的默认字符集解码指定的字节数组来构造新的String
String(byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来构造新的String
public class demo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //编码
        String data = "a我b";
        byte[] bytes = data.getBytes(); //默认按照平台字符集(UTF-8)进行编码的
        System.out.println(Arrays.toString(bytes));

        //按照指定字符集编码
        byte[] bytes1 = data.getBytes("GBK");
        System.out.println(Arrays.toString(bytes1));

        //解码
        String s1 = new String(bytes); //默认按照平台字符集(UTF-8)进行解码
        System.out.println(s1); //a我b

        String s2 = new String(bytes1); //默认按照平台字符集(UTF-8)进行解码
        System.out.println(s2); //a��b 因为bytes1按照GBK解码,所以按照UTF-8解码会出现乱码

        String s3 = new String(bytes1,"GBK"); //指定字符集解码
        System.out.println(s3); //a我b
    }
}

四. IO流

IO流:输入输出流,用于读写数据

        I指Input,称为输入流:负责把数据读到内存中去

        O指Output,称为输出流:负责写数据出去

IO流的应用场景

Java基础 - 10 - File、IO流(一),第11张IO流的分类

        IO流总体来看就有四大流:字节输入流、字节输出流、字符输入流、字符输出流

Java基础 - 10 - File、IO流(一),第12张

Java基础 - 10 - File、IO流(一),第13张4.1 FileInputStream(文件字节输入流)

· 作用:以内存为基准,可以把磁盘文件中的数据以字节的形式读入到内存中去

构造器说明
public FileInputStream(File file)创建字节输入流管道与源文件接通
public FileInputStream(String pathname)创建字节输入流管道与源文件接通
方法名称说明
public int read()每次读取一个字节返回,如果发现没有数据可读会返回-1
public int read(byte[] buffer)每次用一个字节数组去读取数据,返回字节数组读取了多少个字节,如果发现没有数据可读会返回-1

4.1.1 每次读取一个字节read()

· 使用FileInputStream的read()每次读取一个字节,读取性能较差,并且读取汉字输出会乱码

public class demo {
    public static void main(String[] args) throws Exception {
    //创建文件字节输入流管道,与源文件接通
        //public FileInputStream(File file) 创建字节输入流管道与源文件接通
        InputStream is = new FileInputStream(new File("demo/src/wosun.txt")); //多态
        //简化写法:推荐使用
        //public FileInputStream(String pathname) 创建字节输入流管道与源文件接通
        InputStream fis = new FileInputStream("demo\src\wosun.txt"); //多态

        //开始读取文件的字节数据
        //public int read()	每次读取一个字节返回,如果发现没有数据可读会返回-1
//        int b1 = fis.read();
//        System.out.println((char) b1); //读第一个字节
//
//        int b2 = fis.read();
//        System.out.println((char) b2); //读第二个字节
//
//        int b3 = fis.read();
//        System.out.println(b3); //如果发现没有数据可读会返回-1

        //使用循环改造上述代码
        int b; //用于记住读取的字节
        while((b = fis.read()) != -1){
            System.out.print((char) b);
        }

        //上述方法一次只读一个字节,读取数据的性能很差(频繁调用系统资源)
        //上述方法一次只读一个字节,会导致读取汉字输入会乱码!无法避免!
        //流使用完毕之后,必须关闭!释放系统资源!
        fis.close();
    }
}

4.1.2 每次读取多个字节read(byte[] buffer) 

· 使用FileInputStream的read(byte[] buffer)每次读取多个字节,读取性能得到提升,但读取汉字输出还是会乱码

public class demo {
    public static void main(String[] args) throws Exception {
        //创建一个字节输入流对象代表字节输入流管道与源文件接通
        InputStream fis = new FileInputStream("demo\src\wosun.txt"); //多态

        //开始读取文件的字节数据,每次读取多个字节
        // public int read(byte[] buffer)
        // 每次读取多个字节,用一个字节数组去读取数据,返回字节数组读取了多少个字节,如果发现没有数据可读会返回-1
        //byte[] buffer = new byte[1024];  //每次可以读1024个字节,即1KB
//        byte[] buffer = new byte[3];
//        int len1 = fis.read(buffer);  //每次最多读3个字节
//        String s1 = new String(buffer); //解码
//        System.out.println(s1);
//        System.out.println("当次读取的字节数:"+len1);
//
//        //buffer = [abc]
//        //buffer = [66c] //c没有覆盖,因此需要读取多少倒出多少
//        int len2 = fis.read(buffer);
//        //String s2 = new String(buffer);  //66c
//        String s2 = new String(buffer,0,len2); //66
//        System.out.println(s2);
//        System.out.println("当次读取的字节数:"+len2);
//
//        int len3 = fis.read(buffer);
//        System.out.println("当次读取的字节数:"+len3); //没有字节后读取的字节长度会是-1

        //优化
        byte[] buffer = new byte[3];
        int len; //记录每次读取了多少个字节
        while((len = fis.read(buffer)) != -1){
            String s = new String(buffer,0,len);
            System.out.println("当前读取到的字节:"+s+" 当前读取到的字节数:"+len);
        }

        fis.close();
    }
}

4.1.3 一次读取完全部字节

        可以解决字节流读取中文输出乱码的问题,但是如果文件过大,创建的字节数组也会过大,可能引起内存溢出

一次读取完全部字节的两种方式

· 方式一:自己定义一个字节数组与被读取的文件大小一样大,然后使用该字节数组,一次读完文件的全部字节

Java基础 - 10 - File、IO流(一),第14张

· 方式二:Java官方为InputStream提供了如下方法,可以直接把文件的全部字节读取到一个字节数组中返回

Java基础 - 10 - File、IO流(一),第15张

public class demo {
    public static void main(String[] args) throws Exception {
        //创建一个文件对象
        File f = new File("demo\src\wosun.txt");
        //创建一个字节输入流对象代表字节输入流管道与源文件接通
        InputStream fis = new FileInputStream(f); //多态

        //方式1:自己定义一个字节数组与被读取的文件大小一样大,然后使用该字节数组,一次读完文件的全部字节
//        //length:文件大小
//        long length = f.length();
//        //该方案只适合读相对来说较小的文件(不超过内存容量)
//        byte[] buffer = new byte[(int) length];
//
//        int len = fis.read(buffer); //len:当前读取到的字节数
//        String s = new String(buffer,0,len);
//        System.out.println("当前读取到的字节:"+s+" 当前读取到的字节数:"+len);

        //方式2:Java官方为InputStream提供了read方法,可以直接把文件的全部字节读取到一个字节数组中返回
        byte[] buffer = fis.readAllBytes(); //在jdk9中才出现的
        System.out.println(new String(buffer));

        fis.close();
    }
}

注意:

        读写文本内容更适合用字符流;字节流适合做数据的转移,如文件复制等

4.2 FileOutputStream(文件字节输出流)

· 作用:以内存为基准,把内存中的数据以字节的形式写出到文件中去

构造器说明
public FileOutputStream(File file)创建字节输出流管道与源文件对象接通
public FileOutputStream(String filepath)创建字节输出流管道与源文件路径接通
public FileOutputStream(File file, boolean append)创建字节输出流管道与源文件对象接通,可追加数据
public FileOutputStream(String filepath, boolean append)创建字节输出流管道与源文件路径接通,可追加数据
方法名称说明
public void write(int a)写一个字节出去
public int write(byte[] buffer)写一个字节数组出去
public int write(byte[] buffer, int pos, int len)写一个字节数组的一部分出去
public void close() throws IOException关闭流
public class demo {
    public static void main(String[] args) throws Exception {
        //相对路径
          //以“./”开头,代表当前目录和文件目录在同一个目录里,“./”也可以省略不写!
          //以"../"开头:向上走一级,代表目标文件在当前文件所在的上一级目录;
          //以"../../"开头:向上走两级,代表父级的父级目录,也就是上上级目录,再说明白点,就是上一级目录的上一级目录
          //以"/”开头,代表根目录

        //创建一个字节输出流管道与目标文件接通
          //覆盖管道,会覆盖文件中原有的数据
        //OutputStream os = new FileOutputStream("demo/src/wosun.txt");
          //追加管道,不会覆盖文件中原有的数据
        OutputStream os = new FileOutputStream("demo/src/wosun.txt",true);

        //开始写字节数据出去
        //每次写一个字节
        os.write(97);  //97就是一个字节,代表a
        os.write('b'); //'b'也是一个字节
        //os.write('你'); //乱码,因为write(int a)默认写一个字节,你在系统默认字符集(UTF-8)中占3个字节,因此乱码

        byte[] bytes = "abc你好星期天abc".getBytes();
        os.write(bytes);

        //换行
        os.write("\r\n".getBytes());

        os.write(bytes,3,15); //从3开始,写入15个字节,正好是“你好星期六”

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

4.3 字节流案例:文件复制

        字节流非常适合做一切文件的复制操作(任何文件的底层都是字节,字节流做副职,是一字不漏的转移完全部字节,只要复制后的文件格式一致就没有问题)

Java基础 - 10 - File、IO流(一),第16张

public class demo {
    public static void main(String[] args) throws Exception {
        //文件复制
        //需要创建一个字节输入流管道与原文件接通
        InputStream is = new FileInputStream("D:/zm/1.jpg");
        //创建一个字节输出流管道与目标位置接通
        OutputStream os = new FileOutputStream("D:/zm/aaa/1.jpg"); //要自己填写文件名
        //创建一个字节数组,负责转移字节数据
        byte[] buffer = new byte[1024];  //一次可以读取1KB
        //从字节输入流中读取字节数据,然后写到字节输出流中,读多少写多少
        //每次读取多个字节read(byte[] buffer)
        int len; //用来记录每次读取了多少字节
        while((len = is.read(buffer)) != -1){
            os.write(buffer,0,len);
        }
        //后创建的流先关闭,先创建的流后关闭
        os.close();
        is.close();
        System.out.println("复制完成");
    }
}


//用try-catch-finally改良后的文件复制
public class demo {
    public static void main(String[] args) {
        InputStream is = null;
        OutputStream os = null;
        try {

            System.out.println(10/0); //出现异常

            //文件复制
            //需要创建一个字节输入流管道与原文件接通
            is = new FileInputStream("D:/zm/1.jpg");
            //创建一个字节输出流管道与目标位置接通
            os = new FileOutputStream("D:/zm/aaa/1.jpg"); //要自己填写文件名

            System.out.println(10/0); //出现异常

            //创建一个字节数组,负责转移字节数据
            byte[] buffer = new byte[1024];  //一次可以读取1KB
            //从字节输入流中读取字节数据,然后写到字节输出流中,读多少写多少
            //每次读取多个字节read(byte[] buffer)
            int len; //用来记录每次读取了多少字节
            while((len = is.read(buffer)) != -1){
                os.write(buffer,0,len);
            }

            System.out.println("复制完成");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //释放资源的操作
            try {
                if(os != null){
                    os.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            try {
                if(is != null){
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4.4 释放资源的方式

4.4.1 try-catch-finally

Java基础 - 10 - File、IO流(一),第17张

public class demo {
    public static void main(String[] args) throws Exception {
        try{
            System.out.println(10/2); //没有异常,也会执行finally中的代码
            // System.out.println(10/0); //出现异常,也会执行finally中的代码
            // return; //跳出方法的执行,也会执行finally中的代码
            // System.exit(0); //虚拟机jvm挂掉,就不会执行finally中的代码
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println("======finally执行了一次======");
        }

        System.out.println(chu(10, 2)); //111
    }

    public static int chu(int a,int b){
        try{
            return a/b;
        }catch (Exception e){
            e.printStackTrace();
            return -1;
        }finally {
            //千万不要在finally里返回数据
            return 111;
        }
    }
}

4.4.2 try-with-resource

Java基础 - 10 - File、IO流(一),第18张

public class demo {
    public static void main(String[] args) {
        //文件复制
        try(
                //需要创建一个字节输入流管道与原文件接通
                InputStream is = new FileInputStream("D:/zm/1.jpg");
                //创建一个字节输出流管道与目标位置接通
                OutputStream os = new FileOutputStream("D:/zm/aaa/1.jpg"); //要自己填写文件名

                //注意:这里只能放置资源对象(流对象)
                //什么是资源?
                    // 资源都是会实现AutoCloseable接口,资源都会有一个close方法
                    // 并且资源放到这里(try()里面)后,当它用完之后,会被自动调用其close方法完成资源的释放操作
                
                ) {

            //创建一个字节数组,负责转移字节数据
            byte[] buffer = new byte[1024];  //一次可以读取1KB
            //从字节输入流中读取字节数据,然后写到字节输出流中,读多少写多少
            //每次读取多个字节read(byte[] buffer)
            int len; //用来记录每次读取了多少字节
            while((len = is.read(buffer)) != -1){
                os.write(buffer,0,len);
            }

            System.out.println("复制完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明原文出处。如若内容造成侵权/违法违规/事实不符,请联系SD编程学习网:675289112@qq.com进行投诉反馈,一经查实,立即删除!