正则,包装类,Math,BigInteger BigDecimal

目录

正则表达式

包装类

Math 数学类

BigInteger  BigDecimal

---

正则表达式

字符串的格式匹配

        正则表达式-独立的技术

String类中提供了支持正则表达式的方法

        public boolean matches(String regex)--验证当前字符串内容是否满足正则表达式格式要求

        public String replaceAll(String regex, String replacement)

根据正则表达式进行字符串内容的替换

        public String[] split(String regex)

正则表达式的语法规则

        单个字符的匹配   x      匹配字符x

[abc]	a, b, or c (simple class)
[a-z]	小写字母
[0-9]	数字
[A-Z]	大写字母
[a-zA-Z]	字母
[^abc]	除a b c以外其他的字符
.	任意字符
\d	数字0-9
\D	非数字
\s	空白字符
\S	非空白字符
\w	字母 数字 _
\W	[^\w]
^	以指定内容开头
$	以指定内容结束
X?	至多一次
X*	次数没有要求
X+	至少一次
{n}	精确出现n次
{n,}	至少出现n次
{n,m}	至少出现n次 但是不能超过m次
()	捕获组

注意：

[]只能匹配一个字符

包装类

Java数据类型：

        基本数据类型

        byte short int long float double char boolean

引用数据类型

        数组  类  接口

概念；

是基本数据类型的包装

byte	short	int	long	float	double	char	boolean
Byte	Short	Integer	Long	Float	Double	Character	Boolean

以Integer为例进行讲解，其他包装类参考Integer学习即可

Integer：

继承结构：

java.lang.Object

-java.lang.Number

-java.lang.Integer

Number 是表示数值类  子类有：Byte Short Integer Long Float Double

构造方法：

        Integer(int value)

        构建了一个新分配的 Integer表示指定的 int价值。 

Integer(String s)

        构建了一个新分配的 Integer表示 int值表示的 String参数。 

注意：如果字符串无法转为整数，可能会出现NumberFormatException

方法：

        将Integer对象转为其他基本数据类型的方法

byteValue()

doubleValue()

intValue()--将Integer对象转为int值

equals方法

比较两个对象的int值是否相等

重写了Object中的equals方法

hashCode()

重写了Object中的hashCode方法

Integer对象的哈希码值就是int值本身

求两个整数的最值的方法

Integer.max(int i1,int i2)--获取最大值

Integer.min(int i1,int i2)--获取最小值

public static int parseInt(String s)

字符串转十进制的int值

例如：

String age = "18";

           //String->int

           int age1 = Integer.parseInt(age);

          System.out.println(age1);

注意：如果参数字符串无法转为数值，则会抛出异常NumberFormatException

public static int parseInt(String s,int radix)

根据指定的进制来读取字符串进行转换

parseInt("-FF", 16) returns -255

parseInt("1100110", 2) returns 102

int->String:

public static String toBinaryString(int i)--转为二进制

public static String toOctalString(int i)-转为八进制

public static String toHexString(int i)--转为十六进制

valueOf()--转为Integer 静态的

public static Integer valueOf(int i)

public static Integer valueOf(String s)

总结：

int<->Integer:

int->Integer:

new Integer(int i)

Integer.valueOf(int i)

Integer->int:

intValue()

int<->String:

int->String:

""+5

Integer.toString(5)---String

String->int:

Integer.parseInt(String s)

Integer<->String:

Integer->String:

toString()

String->Integer:

new Integer(String s)

Integer.valueOf(String s)

JDK1.5--JDK5 提供了很多新特性

自动装箱 自动拆箱

自动装箱：

基本数据类型包装成了包装类的对象

例如：

  int num = 5;

        Integer i1 = num;

        System.out.println(i1);

自动拆箱：

包装类的对象拆成了基本数据类型

例如：

  Integer i2 = new Integer(8);

        int num = i2;

        System.out.println(num);

原理：

自动装箱原理：

底层实际调用了Integer.valueOf(int i)实现的

Integer中设计了一个缓存数组  -128~127

valueOf源码：

public static Integer valueOf(int i) {

        if (i >= IntegerCache.low && i <= IntegerCache.high)

            return IntegerCache.cache[i + (-IntegerCache.low)];

i=1  1在不在-128~127范围内

return IntegerCache.cache[129];

        return new Integer(i);

    }

class Integer{

IntegerCache  私有的静态内部类

private static class IntegerCache {

static final int low = -128;

static final int high;//127

static final Integer[] cache;//Integer数组 cache

static{

int h = 127;

high = h;

cache = new Integer[(high - low) + 1];//127+128+1=256

            int j = low;//j=-128;

            for(int k = 0; k < cache.length; k++)//遍历cache数组

                cache[k] = new Integer(j++);

cache[0] = new Integer(-128); j=-127  0x1

cache[1] = new Integer(-127); j=-126  0x2

cache[255] = new Integer(127);

            // range [-128, 127] must be interned (JLS7 5.1.7)

            assert IntegerCache.high >= 127;

}

}

}

总结：

如果通过自动装箱创建Integer对象，整数值在-128~127范围之内，则是直接获取缓存数组中的对象，无论获取多少次都是拿到同一个对象；

如果超出了范围，则每次自动装箱都会创建一个新的对象。

例如：

  Integer i1 = new Integer(8);

        Integer i2 = new Integer(8);

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

        Integer i3 = 1;//return IntegerCache.cache[129]

        Integer i4 = 1;//return IntegerCache.cache[129]

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

 Integer i5 = 128;//Integer.valueOf(128);--new Integer(128);

       Integer i6 = 128;//Integer.valueOf(128);--new Integer(128);

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

Math 数学类

属性：

        静态常量

        public static final double E = 2.7182818284590452354;

        public static final double PI = 3.14159265358979323846;

        构造方法是private修饰的  无法创建对象

静态方法：

取整的方法：

        public static double ceil(double a)-向上取整

        public static double floor(double a)-向下取整

        public static long round(double a)-四舍五入

获取最值

        public static int max(int a, int b)

        public static int min(int a,int b)

求幂次：

        public static double pow(double a,double b)--求ab

        sqrt()-求平方根

        cqrt()-求立方根

获取随机数：

        public static double random()-产生在[0.0,1.0)范围内的随机浮点数

获取[0.0,10.0)范围内的随机浮点数：

Math.random()*10

获取[0,10)范围内的随机整数：

(int)(Math.random()*10)

获取[0,10]范围内的随机整数：等同于[0,11)

(int)(Math.random()*11)

获取[2,10)范围内的随机整数：[0.0,8.0)+2

(int)(Math.random()*(10-2))+2

获取[a,b)范围内的随机整数：

(int)(Math.random()*(b-a))+a

获取[a,b]范围内的随机整数：

(int)(Math.random()*(b-a+1))+a

Random类也可以产生随机数

工具类：

        Math

        Arrays

要求：

        私有化构造方法  不允许创建对象

        提供静态的工具方法，通过类名直接调用

BigInteger  BigDecimal

BigInteger  :

大整数

构造方法：

        public BigInteger(String val)

方法：

        + - * /

提示：通过对象调用相应的方法实现相应的运算

BigDecimal:

浮点数精确运算

构造方法：

        BigDecimal(double val)

        翻译成 BigDecimal double的 double二进制浮点值的小数表示

        public BigDecimal(String val)--可以进行浮点数的精确运算

 

总结

正则表达式

String中能使用正则表达式的方法

matches replaceAll split

包装类：

类型转换

基本数据类型  包装类型

String之间的转换

自动装箱 自动拆箱

Math:

取整

随机数