JAVA新手小白学正则表达式、包装类、自动装箱/自动拆箱以及BigDecimal

package cn.tedu.api;

import java.util.Scanner;

/*本类用于正则表达式入门案例*/

//需求：接收用户输入的身份证号，并将判断的结果输出

public class TestRegex {

     public static void main(String[] args) {

         //1.编辑正则表达式

         //身份证号的规律：一共是18位，前17位是数子，第18位有可能是数字，也有可能是X

         //String regex = "[0-9]{17}[0-9X]";

         /*单个\在Java中有特殊的含义，表示转义符号，不认为是一个斜杠

          * 所以如果想要表示斜杠，需要在它的前面加一个用来转义的\

          * 也就是\\才表示成一个单纯的斜杠

          * \t -- 制表符  \r回车符 \n换行符*/

         String regex = "\\d{17}[0-9X]" ;

         //2.定义变量用来接收用户输入的身份证号：

         String input;

         //3.判断用户输入的数据是否符合正则表达式，如果不正确，继续输入

         do {

             System.out.println( "请输入您的身份证号：" );

             input = new Scanner(System.in).nextLine();

             if (input.matches(regex)) { //如果身份证号正确

                 System.out.println( "恭喜你！输入正确！" );

                 return ; //结束本方法

             }

         } while (!input.matches(regex)); //只要不符合正则表达式，就继续输入

     }

}

package cn.tedu.api;

/*本类用于测试包装类*/

public class TestNumber {

     //1.定义成员变量，注意要设置成静态的，因为静态只能调用静态

     static Integer i0;

     public static void main(String[] args) {

         //2.打印Integer的默认值进行测试

         System.out.println(i0); //默认值为null

         //3.创建int类型对应的包装类Integer类型的对象--方式一

         Integer i1 = new Integer( 5 );

         Integer i11 = new Integer( 5 );

         System.out.println( i1 == i11 ); //false,==对于引用类型，比较的是地址值

         //4.创建int类型对应的包装类Integer类型的对象--方式二

         /*Integer有一个高效的效果，数据在：(-128~127)

         * 在此范围内，相同的数据只会存一次，后续再存都是使用之前存过的数据*/

         Integer i2 = Integer.valueOf( 127 );

         Integer i3 = Integer.valueOf( 127 );

         System.out.println(i1 == i2); //false

         System.out.println(i2 == i3); //true

         //满足高效效果的3个条件：Integer valueOf() -128~127

         Integer i4 = Integer.valueOf( 300 );

         Integer i5 = Integer.valueOf( 300 );

         System.out.println(i4 == i5); //false

     }

}

package cn.tedu.api;

/*本类用于测试基本类型的包装类*/

public class TestNumber {

     public static void main(String[] args) {

         //1.创建int包装类Integer对象的方式1

         Integer i1 = new Integer( 100 );

         Integer i11 = new Integer( 100 );

         System.out.println(i1 == i11); //false,new了两次，是两个不同的对象，地址值不同

         //2.创建int包装类Integer对象的方式2

         /*Integer有一个高效的效果，但是必须满足3个条件：

         * 1.是Integer类型

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

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

         * 满足以上条件，相同的数据只会存一次，后续再使用都是以前存过的数据*/

         Integer i2 = Integer.valueOf( 100 );

         Integer i22 = Integer.valueOf( 100 );

         System.out.println(i2 == i22); //true

         Integer i3 = Integer.valueOf( 300 );

         Integer i33 = Integer.valueOf( 300 );

         System.out.println(i3 == i33); //false 超出高效的数据范围-128~127

         //3.创建double包装类Double对象的方式1

         Double d1 = new Double( 3.14 );

         Double d11 = new Double( 3.14 );

         System.out.println(d1 == d11); //false，创建两个不同的对象，地址值不同

         //4.创建double包装类Double对象的方式2

         /*只有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);

         //5.测试常用方法

         //这个方法的作用就是把传入的String类型的数据转成int

         /*对象是什么类型的，就可以使用这个类的所有资源

         i1是Integer类型的对象，所以可以使用parseInt()将String类型的数据转为int类型

         d1是Double类型的对象，所以可以使用parseDouble()将String类型的数据转为double类型*/

         System.out.println(i1.parseInt( "800" )+ 8 ); //808->int+int

         System.out.println(d1.parseDouble( "2.2" )+ 3.1 ); //5.300000000000001->double+double

     }

}

package cn.tedu.api;

/*本类用于测试自动装箱和自动拆箱*/

public class TestBox {

     public static void main(String[] args) {

         //1.定义包装类型的数据

         //回顾:以前创建包装类型的两种方式

         Integer i1 = new Integer( 127 );

         Integer i2 = Integer.valueOf( 127 );

         //2.现在的方式:

         /*1.自动装箱:编译器会自动把基本类型int 5,包装成包装类型Integer

         * 然后交给i3来保存,自动装箱底层发生的代码Integer.valueOf(5);

         * valueOf()的方向: int --> Integer*/

         Integer i3 = 5 ; //不会报错,这个现象就是自动装箱

         /*2.自动拆箱:编译器会自动把包装类型的i1拆掉"箱子",变回基本类型数据127

         * 然后交给i4来保存,自动拆箱底层发生的代码:i1.intValue();

         * intValue()的方向:Integer -> int

         * */

         int i4 = i1; //不会报错,这个现象就是自动拆箱

     }

}

package cn.tedu.api;

import java.math.BigDecimal;

import java.util.Scanner;

public class TestBigDecimal {

     public static void main(String[] args) {

         //f1();//使用普通的 +-*/ 四则运算,暴露出浮点数运算不精确的问题

         f2(); //使用BigDecimal来解决浮点数运算不精确的问题

     }

     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交给工具类对象BigDecimal来保存

         /*1.最好不要用double作为构造函数的参数,不然还会有不精确的现象,有坑!!!*/

         /*2.最好使用重载的,参数类型是String的构造函数

         * double转String,直接拼个空串就可以*/

         BigDecimal bd1 = new BigDecimal(a+ "" );

         BigDecimal bd2 = new BigDecimal(b+ "" );

         //3.通过BigDecimal的对象来调用其方法,实现精确运算

         //3.1 定义BigDecimal类型的引用类型变量来保存结果

         BigDecimal bd3;

         //3.2 Add(BigDecimal bd) : 做加法运算

         bd3 = bd1.add(bd2);

         System.out.println(bd3);

         //3.3 Subtract(BigDecimal bd) : 做减法运算

         bd3 = bd1.subtract(bd2);

         System.out.println(bd3);

         //3.4 Multiply(BigDecimal bd) : 做乘法运算

         bd3 = bd1.multiply(bd2);

         System.out.println(bd3);

         //3.5 Divide(BigDecimal bd) : 做除法运算,除不尽时会抛异常

         /*3.除法运算,除不尽时会抛出异常ArithmeticException*/

         //方案一:(除不尽时有问题)

         //bd3 = bd1.divide(bd2);

         /*divide(m,n,o)

         m是要除以哪个对象,n指要保留几位,o指舍入方式(比如四舍五入)*/

         //方案二:

         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); //不精确

     }

}