JavaSE-day12

StringBuilder和StringBuffer

一般用于字符串的拼接，使用append（）方法

String字符串具有不可变性，当字符串重新赋值时，不会在原地址上修改，而是会重新分配新的地址值进行赋值，同理字符串的每一次拼接都会重新分配新的地址值

StringBuilder和StringBuffer：若现有容量不够时，创建一个新的 char 数组，将现有容量扩大一倍再加上2，如果还是不够大则直接等于需要的容量大小。扩容完成之后，将原数组的内容复制到新数组，最后将指针指向新的 char 数组

public class TestString3 {
    public static void main(String[] args) {
//        需求：将26个字母拼接一万次
        String s="abcdefghigklmnopqrstuvwxyz";
//        method1(s);//测试普通字符串的拼接
        method2(s);//测试StringBuilder或者StringBuffer的字符串拼接
    }
    public static void method2(String s){
        //1.创建工具类对象
//        StringBuffer sb=new StringBuffer();
        StringBuilder sb2=new StringBuilder();
        //4.添加计时功能
        long l = System.currentTimeMillis();
        for (int i = 0; i <10000 ; i++) {
            sb2.append(s);//拼接字符串
        }
        long l2 = System.currentTimeMillis();
        //3.输出拼接的效果
        System.out.println(sb2);
        //4.2打印花费的时间
        System.out.println(l2-l);//8毫秒
    }
    //使用方法一拼接字符串
    public static void method1(String s){
//        1.创建变量来保存最终拼接好的效果
        String result="";
        //5.给程序添加一个计时功能
        //5.1获取循环开始时间
        long l1 = System.currentTimeMillis();
        //2.创建循环执行10000次
        for (int i = 0; i < 10000; i++) {
            //3.进行字符串的拼接
            result+=s;
        }
        //5.2获取循环结束时间
        long l2 = System.currentTimeMillis();
        //4.将拼接的结果打印输出
        System.out.println(result);
        //5.3打印拼接花费的时间
        System.out.println(l2-l1);//2428毫秒
    }
}

包装类

8大基本类型与之对应的包装类

byte--Byte short--Short int--Integer long--Long char--Character float--Float

double--Double boolean--Boolean

Integer类型

创建int类型对应的包装类型Integer对象--方式一：Integer i1 = new Integer(5);

创建int类型对应的包装类型Integer对象--方式二：Integer i2 = Integer.valueOf(4);

Integer对象创建方式二有一个高效的效果，但是要求：

1.是Integer类型的

2.使用valueOf()的创建方式

3.数据在-128~127范围内

只要满足以上三个条件，相同的数据只会存一次，后续再存都是使用之前创建好的数据

public class TestNumber {
    //1.定义成员变量注意要设置成静态的，因为静态只能调用静态
    static Integer i0;
    public static void main(String[] args) {
        //2.打印Integer的默认值测试：引用类型的默认值都是null
        System.out.println(i0);//null
        //3.创建int类型对应的包装类型Integer对象--方式一
        Integer i1 = new Integer(5);
        Integer i11 = new Integer(5);
        System.out.println(i1==i11);//false
        System.out.println(i1.equals(i11));

        //3.2创建int类型对应的包装类型Integer对象--方式二
        /*Integer对象创建方式二有一个高效的效果，但是要求：
        * 1.是Integer类型的
        * 2.使用valueOf()的创建方式
        * 3.数据在-128~127范围内
        * 只要满足以上三个条件，相同的数据只会存一次，后续再存都是使用之前创建好的数据*/
        Integer i2 = Integer.valueOf(4);
        Integer i22 = Integer.valueOf(4);

        Integer i3=Integer.valueOf(900);
        Integer i33=Integer.valueOf(900);
        System.out.println(i1==i2);//false
        System.out.println(i2==i22);//true
        System.out.println(i3==i33);//false

        //4.创建Double包装类对象
        Double d1=new Double(3.14);
        Double d11=new Double(3.14);
        System.out.println(d1==d11);//false

        /*只有Integer才有高效的效果，Double是没有的*/
        Double d2=Double.valueOf(3.14);
        Double d22=Double.valueOf(3.14);
        System.out.println(d1==d2);//false
        System.out.println(d2==d22);//false
        //把String类型的数据转为int类型的数据
        System.out.println(i1.parseInt("600")+10);//810
        System.out.println(d1.parseDouble("2.2")+3.3);//5.5
    }
}

自动装箱与自动拆箱

1.自动装箱的现象：

编译器会自动把基本类型int 127，包装成包装类型Integer

然后交给Integer类型的变量i3来保存，底层发生的代码：Integer.valueOf(127)

自动装箱的方向：int【基本类型】->Integer【包装类型】

Integer i3=127;

2.自动拆箱现象：

编译器会自动把包装类型i3拆掉“箱子”，变回基本类型的数据127

然后交给基本类型的变量i4来保存，底层发生的代码：i3.intValue()

自动拆箱的方向：Integer【包装类型】->int【基本类型】

int i4=i3;

BigDecimal：

用于解决浮点数运算不精确的方法

构造方法：

BigDecimal(int) 创建一个具有参数所指定整数值的对象。

BigDecimal(long) 创建一个具有参数所指定长整数值的对象。

BigDecimal(double) 创建一个具有参数所指定双精度值的对象。 //不推荐使用

BigDecimal(String) 创建一个具有参数所指定以字符串表示的数值的对象。//推荐使用

/*本类用于解决浮点数运算不精确的问题*/
public class TestBigDecimal {
    public static void main(String[] args) {
//        f1();//使用普通的 + - * / 四则运算，暴露运算不精确的问题
        f2();
    }
    //本方法用来解决浮点数运算不精确的问题
    private static void f2() {
        //1.提示用户输入两个小数
        System.out.println("请输入要计算的两个小数：");
        double a=new Scanner(System.in).nextDouble();
        double b=new Scanner(System.in).nextDouble();

        //2.创建工具类对象,把基本类型的a与b交给工具类对象来保存
        /*1.最好不要使用double作为构造函数的参数类型，不然还会有不精确的问题
        * 2.推荐使用String类型参数，double转Sting，直接拼个空串就可以*/
        BigDecimal bd1 = new BigDecimal(a+"");
        BigDecimal bd2 = new BigDecimal(b+"");

        //3.1定义变量用来保存结果
        BigDecimal bd3;
        bd3=bd1.add(bd2);//+
        System.out.println(bd3);

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

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

//        bd3=bd1.divide(bd2);
        /*divide()方法在除不尽时会抛出算数异常：因为没有方法精确表示结果
        * 解决方案：需要额外设置除不尽时的保留位数和舍入方式
        * divide(a,b,c):
        * a是要除的数，b是保留位数，c舍入方式，这里是四舍五入*/
        bd3=bd1.divide(bd2,3,BigDecimal.ROUND_HALF_UP);
        System.out.println(bd3);

    }
    private static void f1() {
        //1.提示用户输入两个小数
        System.out.println("请输入要计算的两个小数：");
        double a=new Scanner(System.in).nextDouble();
        double b=new Scanner(System.in).nextDouble();

        //2.做运算
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b);
    }
}

File类

file.length()--打印文件中所含的字节数

file.isDirectory()--判断当前file对象是不是文件夹

file.isFile()--判断当前file是不是一个文件

file.getName()--返回文件名称

file.getParent()--获取文件父级路径

file.getAbsolutePath()--获取带盘符的绝对路径

file.exists()--判断当前file对象指定的路径是否存在

file.mkdir()--创建当前不存在的单层文件夹

file.mkdirs()--创建当前不存在的多层文件夹

file.delete()只能删除文件或者空的文件夹

/*本类用于测试文件类File*/
public class TestFile {
    public static void main(String[] args) throws IOException {
        //1.创建file类的对象
        /*1.ready文件夹与1.txt需要自己手动创建
        * 2.File需要导包：import java.io.File;
        * 3.路径pathname是String类型的数据，必须写正确，不然找不到文件报错
        * 4.完整的文件名包含两部分：文件名+后缀名*/
        File file=new File("D:\\ready\\1.txt");

        System.out.println(file.length());//文件中的数据是abc,所有打印3字节
        System.out.println(file.isDirectory());//false,判断当前File对象是不是文件夹
        System.out.println(file.isFile());//true,判断当前File对象是一个文件吗？
        System.out.println(file.getName());//1.txt,返回文件名称
        System.out.println(file.getParent());//D:\ready,获取文件父级路径
        System.out.println(file.getAbsolutePath());//D:\ready\1.txt，获取带盘符的绝对路径
        System.out.println(file.exists());//true,判断当前file对象指定的路径是否存在
        
        //2.2测试File的创建于删除
        /*new只会帮我们在内存中创建一个File类型的对象
        * 并不会帮我们在磁盘对应的路径下创建一个真实存在的2.txt文件*/
        File file2=new File("D:\\ready\\2.txt");

        //创建一个之前不存在的文件2.txt，如果创建成功，返回true
        /*如果指定创建文件的路径不对，会抛出异常：IOException
        * 所以需要提取处理这个问题，我们暂时选择在main（）上抛出
        * 这个IO异常是我们目前遇到的强制要求必须预先处理的异常
        * 如果不处理，方法调用会报错，通不过编译*/
        System.out.println(file2.createNewFile());

        //创建当前不存在的单层文件夹
        File file3=new File("D:\\ready\\n");
        System.out.println(file3.mkdir());
        //创建当前不存在的多层文件夹
        file3=new File("D:\\ready\\a\\b\\c");
        System.out.println(file3.mkdirs());

        /*delete()只能删除文件或者空的文件夹*/
        System.out.println(file2.delete());//2.txt被删除
        System.out.println(file3.delete());//最里层的c文件夹被删除了

        //2.3展示文件
        File file4=new File("D:\\ready");
        String[] list = file4.list();
        System.out.println(Arrays.toString(list));

        File[] fs = file4.listFiles();
        System.out.println(Arrays.toString(fs));
        //[D:\ready\1.txt, D:\ready\a, D:\ready\n]
        System.out.println(fs[0].delete());
    }
}