正则表达式 包装类 自动装箱自动拆箱 IO（2021.10.20）

正则表达式

package cn.tedu.api;
/*本类用于测试正则表达式*/

import java.util.Scanner;

/**
 * @create 2021-10-20-11:37
 */
public class TestRegex {
    public static void main(String[] args) {
        //1.编辑正则表达式
        //身份证号规律：一共是18位，前17位是数字，第18位有可能是数字
        String regex = "[0-9]{17}[0-9X]";
        //2.定义变量接收用户输入的身份证号
        String input;

        //3.判断
        do{
            System.out.println("请输入身份证号：");
            input = new Scanner(System.in).nextLine();
            if(input.matches(regex)){//input 数据是否匹配matches(正则表达式)
                System.out.println("恭喜您，搞正确了");
                return;//结束本方法
            }
        } while(!input.matches(regex));//不符合就继续输入

    }
}

package cn.tedu.api;
/*本类用于复写身份证号验证案例*/

import java.util.Scanner;

/**
 * @create 2021-10-20-14:00
 */
public class TestRegex2 {
    public static void main(String[] args) {
        //String regex = "[0-9]{17}[0-9X]";
        /*单个\在java中有特殊含义，表示转义符号，不认为这是一个单纯的斜杠
        * 所以，如果想要单纯的表示一个斜杠，需要在它的前面再加一个斜杠用来转义
        * 也就是\\才单纯的表示为一个斜杠*/
        String regex2 = "\\d{17}[0-9X]";

        System.out.println("请输入身份证号：");
        String input = new Scanner(System.in).nextLine();

        if(input.matches(regex2)){
            System.out.println("输入正确");
        }else{
            System.out.println("输入错误");
        }
    }
}

包装类

package cn.tedu.api;
/*本类用于测试包装类*/
/**
 * @create 2021-10-20-14:20
 */
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);

        //3.2
        /*Integer对象创建方式2有一个高效的的效果，但是要求：
        * 1.是Integer类型
        * 2.使用valueOf()的创建方式
        * 3.数据要在-128~127范围内
        *只要满足以上三个条件，相同的数据只会存一次，后续再存都是使用之前创建好的数据*/
        Integer i2 = Integer.valueOf(127);
        Integer i22 = Integer.valueOf(127);
        Integer i3 = Integer.valueOf(300);
        Integer i33 = Integer.valueOf(300);
        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("800")+10);//810
        //把String类型的数据转为double类型的数据
        System.out.println(d1.parseDouble("2.2")+3.3);//5.5
    }
}

自动装箱与自动拆箱

package cn.tedu.api;
/*本类测试自动装箱与自动拆箱*/
/**
 * @create 2021-10-20-15:15
 */
public class TestBox {
    public static void main(String[] args) {
        Integer i1 = new Integer(127);
        Integer i2 = Integer.valueOf(127);

        /*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;
    }
}

解决浮点数计算不精确的问题

package cn.tedu.api;
/*本类用于解决浮点数计算不精确的问题*/

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

/**
 * @create 2021-10-20-15:31
 */
public class TestBigDecimal {
    public static void main(String[] args) {
        //f1();
        f2();
    }

    private static void f2() {
        System.out.println("请输入要计算的两个小数：");
        double a =new Scanner(System.in).nextDouble() ;
        double b =new Scanner(System.in).nextDouble();

        //2.
        /*1.最好不要使用double作为构造函数的参数类型，不然还会有不精确的问题
        * 2.推荐使用String类型参数，double转String，直接拼个空串就可以*/
        BigDecimal bd1= new BigDecimal(a+"");
        BigDecimal bd2= new BigDecimal(b+"");
        //3.1
        BigDecimal bd3;
        //3.2
        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);
    }
}

IO