【JAVA SE】第十一章 正则表达式、包装类和BigDecimal

第十一章 正则表达式、包装类和BigDecimal

文章目录

  • 第十一章 正则表达式、包装类和BigDecimal
  • 一、正则表达式
  • 二、包装类
    • 1.概述
    • 2.装箱与拆箱:
    • 3.基本数据和包装类之间的转换
    • 4.基本数据类型和包装类的转换
    • 5.包装类对象之间的比较:
  • 三、BigDecimal
    • 1.概述
    • 2.常用构造函数
    • 3.常用方法
    • 4.大小比较

一、正则表达式

本篇仅对正则表达式作简单介绍,不做深入解析

正则表达式定义了字符串的模式
正则表达式可以用来搜索、编辑或处理文本
正则表达式并不仅限于某一种语言,在不同语言中有细微的差别

实例:
一个字符串其实就是一个简单的正则表达式,例如 Hello World 正则表达式匹配 “Hello World” 字符串

.(点号)也是一个正则表达式,它匹配任何一个字符如:“a” 或 “1”

this is text
匹配字符串 “this is text”

this\s+is\s+text
注意字符串中的 \s+
匹配单词 “this” 后面的 \s+ 可以匹配多个空格,之后匹配 is 字符串,在之后 \s+ 匹配多个空格然后再跟上 text 字符串
可以匹配这个实例:this is text

^\d+(.\d+)?
^ 定义了以什么开始
\d 匹配一个或多个数字
? 设置括号内的选项是可选的
. 匹配 “.”
可以匹配的实例:“5”,“1.5” 和 “2.21”

Java 正则表达式和 Perl 的是最为相似的

java.util.regex 包主要包括以下三个类:

  • Pattern 类:
    pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象,你必须首先调用其公共静态编译方法,它返回一个 Pattern对象。该方法接受一个正则表达式作为它的第一个参数
  • Matcher 类:
    Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与 Pattern 类一样,Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象
  • PatternSyntaxException:
    PatternSyntaxException 是一个非强制异常类,它表示一个正则表达式模式中的语法错误

以下实例实现了查找字符串中是否包含了 sisyphus 子串:

import java.util.regex.*;
 
class RegexExample1{
   public static void main(String[] args){
      String content = "I am demo" +
        "from sisyphus.com.";
 
      String pattern = ".*sisyphus.*";
 
      boolean isMatch = Pattern.matches(pattern, content);
      System.out.println("字符串中是否包含了 'sisyphus' 子字符串? " + isMatch);
   }
}

运行结果:

字符串中是否包含了 ‘sisyphus’ 子字符串? true

以下实例实现了判断身份证号格式是否正确:

package com.sisyphus.regex;

import java.util.Scanner;

public class TestRegex {
    public static void main(String[] args) {
        //1.接收身份证号
        System.out.println("请输入您的身份证号:");
        String input = new Scanner(System.in).nextLine();

        //2.编辑正则表达式
        //身份证号的规律:一般都是 18 位,前 17 位是数字
        //最后一位可能是数字,也可能是 X
        //单个 \ 在 java 中有特殊的意义,会认为这是一个转义字符
        //如果想使用 \ 需要在 \ 前面再加一个 \ 也就是 \\
        String regex = "\\d{17}[0-9X]";

        //3.判断用户输入的数据是否符合正则的规则
        if (input.matches(regex)){
            System.out.println("身份证号格式正确");
        }else{
            System.out.println("身份证格式错误!");
        }
    }
}

运行结果:

请输入您的身份证号:
12345620001010789X
身份证号格式正确

请输入您的身份证号:
X12345678912345678
身份证格式错误!

二、包装类

1.概述

Java 中的基本数据类型没有属性和方法,而包装类就是为了让它们拥有属性和方法,实现对象化交互

基本类型 对应的包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

数值型包装类都继承自 Number,而字符型和布尔型继承自 Object
【JAVA SE】第十一章 正则表达式、包装类和BigDecimal_第1张图片

2.装箱与拆箱:

  • 装箱:基本数据类型转换为包装类
  • 拆箱:包装类转换为基本数据类型

自动装箱与自动拆箱实例:

package com.sisyphus.temp;

public class Number {
    public static void main(String[] args) {
        //1.定义包装类型的数据
        //回顾:以前创建包装类型的两种方式
        Integer i1 = new Integer(127);
        Integer i2 = Integer.valueOf(127);
        //2.现在的方式
        /**1.自动装箱:编译器会自动把基本类型 int 包装成包装类型 Integer
         * 然后交给 i3 来保存,自动装箱底层发生的阿代码是 Integer.valueOf();
         * valueOf() 的转换方向:int -> Integer*/
        Integer i3 = 5;//不会报错,这个现象就是自动装箱
        /**2.自动拆箱:编译器会自动把包装类型的 i1 拆掉“箱子”,变回基本数据类型
         * 然后交给 i4 来保存,自动拆箱底层发生的代码是 i1.intValue();
         * intValue() 的转换方向:Integer -> int*/
        int i4 = i1;//不会报错,这个现象就是自动拆箱
    }
}

3.基本数据和包装类之间的转换

package com.sisyphus.temp;

public class Number {
    public static void main(String[] args) {
        //1.自动装箱
        int t1 = 1;
        Integer t2 = t1;
        //2.手动装箱
        Integer t3 = new Integer(t1);
        
        System.out.println("int 类型 t1 = " + t1);

        System.out.println("自动装箱,Integer 类型对象 t2 =" + t2);
        System.out.println("手动装箱,Integer 类型对象 t3 =" + t3);


        //1.自动拆箱
        int t4 = t2;
        //2.手动拆箱
        //通过 intValue() 方法返回 int 值
        int t5 = t2.intValue();

        System.out.println("自动拆箱,int 型 t4 = " + t4);
        System.out.println("手动拆箱,int 型 t5 = " + t5);
    }
}

int 类型 t1 = 1
自动装箱,Integer 类型对象 t2 =1
手动装箱,Integer 类型对象 t3 =1
自动拆箱,int 型 t4 = 1
手动拆箱,int 型 t5 = 1

4.基本数据类型和包装类的转换

package com.sisyphus.temp;

public class Number {
    public static void main(String[] args) {
        //1.1将基本数据类型转换为字符串
        int t1 = 12;
        String t2 = Integer.toString(t1);
        System.out.println("int 转换为 String:" + t2);
        //1.2通过 parseInt(),将字符串转换为基本数据类型
        int t3 = Integer.parseInt(t2);


        //2.通过 valueOf(),先把字符串转换为包装类,然后自动拆箱完成转换
        int t4 = Integer.valueOf(t2);

        System.out.println("t3:" + t3);
        System.out.println("t4:" + t4);
    }
}

运行结果:

int 转换为 String:12
t3:12
t4:12

5.包装类对象之间的比较:

package com.sisyphus.temp;

public class Number {
    public static void main(String[] args) {
        Integer one = new Integer(100);
        Integer two = new Integer(100);
        //one 和 two 是两个不同的对象,== 比较的是内存地址,因此结果为 false
        System.out.println("one == two:" + (one == two));

        //自动装箱,实际执行的是 Integer three = Integer.valueOf(100)
        // 这时缓存区没有,会构造一个
        Integer three = 100;
        System.out.println("three == 100:" + (three == 100));//自动拆箱
        //这时缓存区有,就会直接取用
        /**Java 为了提高拆箱效率,在执行过程中提供了一个缓存区(对象池)【类似于常量数组】
         * 如果传入的参数在区间 [-128,127] 之间,就会直接去缓存查找数据,如果有就直接取用
         * 如果没有就隐式调用 new 方法*/
        Integer four = 100;
        System.out.println("three == four:" + (three == four));//之所以加括号是因为 + 的优先级比 == 大

        //测试一下超过 200 的数
        Integer five = 200;
        System.out.println("five == 200:" + (five == 200));
        Integer six = 200;
        System.out.println("five == six:" + (five == six));

    }
}

运行结果:

one == two:false
three == 100:true
three == four:true
five == 200:true
five == six:false

三、BigDecimal

1.概述

Java 在 java.math 包中提供的 API 类 BigDecimal,用来对超过 16 位有效位的数进行精确的运算。双精度浮点型变量 double 可以处理 16 位有效数,但在实际应用中,可能需要对更大或者更小的数进行运算和处理

一般情况下,对于那些不需要精确计算精度的数字,我们可以直接使用 Float 和 Double 处理,但是 Double.valueOf(String) 和 Float.valueOf(String)会丢失精度。所以开发中,如果我们需要精确计算的结果,则必须使用 BigDecimal 类来操作

BigDecimal 所创建的是对象,故我们不能使用传统的 +、-、×、/ 等算术运算符直接对其对象进行数学运算,而必须调用其相对应的方法。方法中的参数也必须是 BigDecimal 对象

2.常用构造函数

  • BigDecimal(int)
    创建一个具有参数所指定整数值的对象
  • BigDecimal(double)
    创建一个具有参数所指定双精度值的对象
  • BigDecimal(long)
    创建一个具有参数所指定长整数值的对象
  • BigDecimal(String)
    创建一个具有参数所指定以字符串表示的数值的对象

实例:

BigDecimal a =new BigDecimal(0.1);
System.out.println("a values is:"+a);
BigDecimal b =new BigDecimal("0.1");
System.out.println("b values is:"+b);

运行结果:

a values is:0.1000000000000000055511151231257827021181583404541015625
b values is:0.1

原因分析:

参数类型为 double 的构造方法的结果有一定的不可预知性,有人可能认为在 Java 中写入 newBigDecimal(0.1) 所创建的 BigDecimal 正好等于 0.1 ,但是它实际上等于 0.1000000000000000055511151231257827021181583404541015625。这是因为 0 无法准确地表示为 double(或者说对于该情况,不能表示为任何有限长度的二进制小数)。这样,传入到构造方法的值不会正好等于 0.1(虽然表面上等于该值)

而String 构造方法是完全可预知的,new BigDecimal(“0.1”) 将创建一个 BigDecimal,它正好等于预期的 0.1.因此,通常建议优先使用 String 构造方法

当 double 必须用作 BigDecmal 的源时,采取以下操作:
先使用 Double.toString(double) 方法,然后使用 BigDecimal(String) 构造方法,最后要获取该结果,使用 static valueOf(double)

package com.sisyphus.bigdecimal;

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

/**本类用作浮点数运算不精确的解决方案*/
public class TestBigDecimal {
    public static void main(String[] args) {
        f2();//使用 BigDecimal 解决浮点数运算不精确的问题
    }

    private static void f1() {
        System.out.println("请输入您要计算的第一个数");
        Scanner scanner = new Scanner(System.in);
        double a = scanner.nextDouble();
        System.out.println("请输入您要计算的第二个数");
        Scanner scanner1 = new Scanner(System.in);
        double b = scanner1.nextDouble();

        //2.创建工具类对象
        BigDecimal bd1 = new BigDecimal(String.valueOf(a));//传 Stirng 类型的参数
        BigDecimal bd2 = new BigDecimal(String.valueOf(b));//传 Stirng 类型的参数

        //3.通过工具类对象进行四则运算
        //定义同类型的 BigDecimal引用类型变量来保存结果
        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);
		//divide(除数,保留位数,舍入方式【四舍五入】)
        bd3 = bd1.divide(bd2,3,BigDecimal.ROUND_HALF_UP);//做除法运算
        System.out.println(bd3);
    }
}

运行结果::

请输入您要计算的第一个小数
请输入您要计算的第一个小数
10
请输入您要计算的第二个小数
3
13.0
7.0
30.00
3.333

3.常用方法

  • add(BigDecimal)
    BigDecimal 对象中的值相加,返回 BigDecimal 对象
  • subtract(BigDecimal)
    BigDecimal 对象中的值相减,返回 BigDecimal 对象
  • multiply(BigDecimal)
    BigDecimal 对象中的值相乘,返回 BigDecimal 对象
  • divide(BigDecimal)
    BigDecimal 对象中的值相除,返回 BigDecimal 对象
  • toString()
    将 BigDecimal 对象中的值转换成字符串
  • doubleValue()
    将 BigDecimal 对象中的值转换成双精度数
  • floatValue()
    将 BigDecimal 对象中的值转换成单精度数
  • longValue()
    将 BigDecimal 对象中的值转换成长整数
  • intValue()
    将 BigDecimal 对象中的值转换成整数

4.大小比较

Java 中对 BigDecimal 比较大小一般用的是 compareTo() 方法

int a = bigdecimal.compareTo(bigdecimal2)

a 的值:

a = -1,表示 bigdecimal 小于 bigdecimal2
a = 0,表示 bigdecimal 等于 bigdecimal2
a = 1,表示 bigdecimal 大于 bigdecimal2

你可能感兴趣的:(JAVA,SE,JAVA,SE)