java基础Day12--IO-CSDN博客

本文链接：https://blog.csdn.net/weixin_52114888/article/details/113735744

1.BigDecimal/BigInteger

1.1 概述

BigDecimal：常用来解决精确的浮点数运算
BigInteger：常用来解决超大的整数运算

1.2 创建对象

BigDecimal.valueOf(2);

1.3 常有方法

add(BigDecimal bd)：做加法运算
substract(BigDecimal bd)：做减法运算
multiply(BigDecimal bd)：做乘法运算
divide(BigDecimal bd)：做除法运算
divide(BigDecimal bd,保留位数,舍入方式)：除不尽使用
setScale(保留位数,舍入方式)：同上
pow(int n)：求数据的几次幂

1.4 练习：测试常有方法

package cn.tedu.test;

import java.math.BigDecimal;
import java.util.Scanner;

public class Big {
    public static void main(String[] args) {
        double a = new Scanner(System.in).nextDouble();
        double b = new Scanner(System.in).nextDouble();
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);//不精确

        System.out.println("===上面的除法不精确===");
        BigDecimal bd1 = BigDecimal.valueOf(a);
        BigDecimal bd2 = BigDecimal.valueOf(b);
        BigDecimal bd3;
        bd3 = bd1.add(bd2);
        System.out.println(bd3.doubleValue());

        bd3 = bd1.subtract(bd2);
        System.out.println(bd3.doubleValue());

        bd3 = bd1.multiply(bd2);
        System.out.println(bd3.doubleValue());

        //bd3=bd1.divide(bd2);//报错除不尽
        //保留位数和舍入方式
        bd3 = bd1.divide(bd2,5,BigDecimal.ROUND_HALF_UP);
        bd3 = bd3.setScale(2,BigDecimal.ROUND_HALF_UP);//保留两位
        System.out.println(bd3.doubleValue());
    }
}

2.IO简介

2.1 继承结构

in/out相对于程序而言的输入(读取)和输出(写出)的过程
在Java中，根据处理的数据单位不同，分为字节流和字符流

ava.io包：
File
字节流：针对二进制文件
InputStream
--FileInputStream
--BufferedInputStream
--ObjectInputStream
OutputStream
--FileOutputStream
--BufferedOutputStream
--ObjectOutputStream
字符流：针对文本文件。读写容易发生乱码现象，在读写时最好指定编码集为utf-8
Writer
--BufferedWriter
--OutputStreamWriter
Reader
--BufferedReader
--InputStreamReader
--PrintWriter/PrintStream

2.2 流的概念

数据的读写抽象成数据，在管道中流动
流只能单方向流动
输入流用来读取in
输出流用来写出Out
数据只能从头到尾顺序的读写一次
在这里插入图片描述

3.File文件流

3.1 概述

封装一个磁盘路径字符串，对这个路径可以执行一次操作
可以用来封装文件路径、文件夹路径、不存在的路径

3.2 创建对象

File(String pathname):通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例

3.3 常有方法

文件、文件夹属性

length()：文件的字节量
exists()：是否存在，存在返回true
isFile()：是否为文件，是文件返回true
isDirectory()：是否为文件夹，是文件夹返回true
getName()：获取文件/文件夹名
getParent()：获取父文件夹的路径
getAbsolutePath()：获取文件的完整路径

创建、删除

createNewFile()：新建文件，文件夹不存在会异常，文件已经存在返回false
mkdirs()：新建多层不存在的文件夹\a\b\c
mkdir()：新建单层不存在的文件夹\a
delete()：删除文件，删除空文件夹

文件夹列表

list()：返回String[]，包含文件名
listFiles()：返回File[]，包含文件对象

3.4 练习：测试常用方法

package cn.tedu.io;

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

public class IO_File {
    public static void main(String[] args) throws IOException {
        //创建File对象，读取了指定位置的文件
        File f = new File("F:\\teach\\a.txt");

        //文件夹列表list() listFiles()
        String[] names = f.list();
        System.out.println(Arrays.toString(names));

        File[] files = f.listFiles();//推荐，更常见
        System.out.println(Arrays.toString(files));

        //TODO 常用方法
        System.out.println(f.createNewFile());//新建文件，文件夹不存在会异常，文件已经存在返回false
        System.out.println(f.mkdir());//新建单层不存在的文件夹
        System.out.println(f.mkdirs());//新建多层不存在的文件夹
        System.out.println(f.delete());//删除文件，删除空文件夹

        System.out.println();

        System.out.println(f.length());//文件的字节量
        System.out.println(f.exists());//是否存在，存在返回true
        System.out.println(f.isFile());//是否为文件，是文件返回true
        System.out.println(f.isDirectory());//是否为文件夹，是文件夹返回true
        System.out.println(f.getName());//获取文件/文件夹名
        System.out.println(f.getParent());//获取父文件夹的路径
        System.out.println(f.getAbsolutePath());//获取文件的完整路径
    }
}

3.5 练习：递归求目录总大小

递归：不断的调用方法本身

递归：统计文件大小，删除文件
求目录的总大小：
1、把指定目录封装成File对象
2、把文件夹列表列出来
3、判断，如果是文件，直接把f.length()相加
4、判断，如果是文件夹，继续列表，继续判断，如果是文件相加，如果又是文件夹，继续列表，继续判断，如果是文件相加......
5、如果是文件夹，递归调用方法本身的业务逻辑
package cn.tedu.io;

import java.io.File;

public class DiGui {
    public static void main(String[] args) {
        //1、把指定目录封装成File对象
        File file = new File("D:\\teach\\a.txt");
        int size = count(file);
        System.out.println(size);
    }

    private static int count(File file) {
        //2、把文件夹列表列出来
        File[] files = file.listFiles();

        //2.1 遍历数组里的每个资源
        int sum = 0;//记录文件的大小
        for(int i=0;i<files.length;i++){
            //3、判断，如果是文件，直接把f.length()相加
            //files[i]表示每次遍历到的资源
            if(files[i].isFile()){
                sum+=files[i].length();//求文件的大小
            }else if (files[i].isDirectory()){
                //4、判断，如果是文件夹，继续列表，继续判断，如果是文件相加，如果又是文件夹，继续列表，继续判断，如果是文件相加......
                //5、如果是文件夹，递归调用方法本身的业务逻辑
                sum+=count(files[i]);//把当前遍历到的文件夹继续循环判断求和
            }
        }
        return sum;
    }
}

4.扩展

4.1 常见字符编码表

在这里插入图片描述
测试

@Test
    public void code() throws IOException {
       String s = "我爱你中国";
       System.out.println(s.getBytes("utf-8").length);//15--unicode/u8一个汉字3字节存储
       System.out.println(s.getBytes("gbk").length);//10--中文双字节
       System.out.println(s.getBytes("unicode").length);//12--双字节+2
       System.out.println(s.getBytes("iso-8859-1").length);//5--单字节
    }

4.2 JDK1.7新特性之IO关流

try(){}catch(){}

private static void customBufferStreamCopy(File source, File target) {
    InputStream fis = null;
    OutputStream fos = null;
    try {
        fis = new FileInputStream(source);
        fos = new FileOutputStream(target);
        byte[] buf = new byte[8192];
        int i;
        while ((i = fis.read(buf)) != -1) {
            fos.write(buf, 0, i);
        }
    }
    catch (Exception e) {
        e.printStackTrace();
    } finally {
        close(fis);
        close(fos);
    }
}
private static void close(Closeable closable) {
    if (closable != null) {
        try {
            closable.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
上述代码对于异常处理十分复杂，
对于资源的关闭也很麻烦，那么可以和下面的进行对比：
private static void customBufferStreamCopy(File source, File target) {
    try (InputStream fis = new FileInputStream(source);
        OutputStream fos = new FileOutputStream(target)){
        byte[] buf = new byte[8192];
        int i;
        while ((i = fis.read(buf)) != -1) {
            fos.write(buf, 0, i);
        }
    }catch (Exception e) {
        e.printStackTrace();
    }
}