Java SE核心API（2） —— 正则表达式、Object、包装类

一、正则表达式

　　实际开发中，经常需要对字符串进行一些复杂的匹配、查找、替换等操作。而通过“正则表达式”，就可以方便的实现这些功能。
　　正则表达式是一串特定字符，组成一个“规则字符串”，这个“规则字符串”是描述文本规则的工具。

1.1、常用正则表达式

字符集合：
[abc] 　　a、b、c中任意一个字符
[^abc]　　除了a、b、c的任意字符
[a-z] 　　a到z中的任意一个字符
[a-zA-Z0-9]　　a~z、A~Z、0~9中任意一个字符
[a-z&&[^bc]]　　a~z中除了b和c以外的任意一个字符，其中&&表示“与”的关系

预定义字符集：
.　　任意一个字符
\d　　任意一个数字字符，相当于[0-9]
\w　　单词字符，相当于[a-zA-Z0-9]
\s　　空白字符，相当于[\t\n\x0B\f\r]
\D　　非数字字符
\W　　非单词字符
\S　　非空白字符

数量词：
X？　　表示0个或1个X
X*　　表示0个或任意多个X
X+　　表示1个到任意多个X（大于等于1个X）
X{n}　　表示n个X
X{n,}　　表示n个到任意多个X（大于等于n个X）
X{n,m}　　表示n个到m个X

边界匹配
^：代表字符串开始
$：代表字符串结束

检索邮政号码，最简单的正则表达式是\d{6}

1.2、分组“()”

　　()圆括号表示分组，可以将一系列正则表达式看做一个整体，分组时可以使用”|”表示“或”关系，列如匹配手机号：
　　　　(\+86)?\s*\d{11}
　　注:“\+”中“\”用于转义加号。在正则表达式中“\.”表示的是“.”字符，但是，在Java代码中需要对“\”字符做转义，即“\\”表示一个“\”。因此，在定义Java的正则表达式变量时，使用“\ \.”来表示一个“.”字符。

1.3、正则表达式方法

1.3.1、matches()

　　matches()方法，将一个字符串与正则表达式进行匹配，如果匹配成功就返回true，否则返回false。

package day02;
/**
 * 字符串的matches方法用于验证当前字符串
 * 是否满足给定的正则表达式的格式要求
 * @author Administrator
 *
 */
public class MatchesDemo {
    public static void main(String[] args){
        /*
         * 身份证号的验证
         * \d{17}[0-9xX]
         */
        String id = "110104198810102410";
        String regex = "^\\d{17}[0-9xX]$";
        /*
         * matches方法是完全匹配，无论我们是否
         * 在正则表达式中是否书写了"^","$"
         */
        boolean match = id.matches(regex);
        if(match){
            System.out.println("是一个身份证号");
        }else{
            System.out.println("不是一个身份证号");
        }
    }
}

1.3.2、split()

　　String[] split(String regex)该方法可以将字符串按照特定的分隔符拆分成字符串数组。

package day02;
/**
 * 为附件生成名字
 * @author Administrator
 *
 */
public class SplitDemo2 {
    public static void main(String[] args){
        String imgName = "1.jpg";
        /*
         * 1:先根据“.”拆分字符串
         * 2:获取当前系统时间的毫秒值
         * 3:用毫秒值拼上一个"."在拼上后缀
         */
        //1
        String[] names = imgName.split("\\.");
        //2
        String name 
            =""+System.currentTimeMillis();
        //3
        imgName = name+"."+names[1];
        System.out.println(imgName);
    }
}

1.3.3、replaceAll()

　　String replaceAll(String regex,String replacement)将字符串中匹配正则表达式regex的字符串替换成replacement。

package day02;
/**
 * 构建和谐社会做贡献的ReplaceAll
 * @author Administrator
 *
 */
public class ReplaceAllDemo2 {
    public static void main(String[] args){
            String regex 
                = "(SB|WQNMLGB|TMB|NND|WC|NC|CNM)";
            String message 
                = "WC!你个SB!怎么这么NC！WQNMLGB";
            message 
                = message.replaceAll(regex, "*****");
            System.out.println(message);
    }
}

---

二、Object

　　在Java类继承结构中，java.lang.Object类位于顶端。如果定义一个Java类时没有使用extends关键字声明其父类，则其父类默认为java.lang.Object类。Object类型的引用变量可以指向任何类型对象。

2.1、toString()方法

　　toString()方法是Object类中的重要方法，它返回的是类名@地址。所以，一般都需要重写，用于返回对象值的字符串表示。
　　Java语言中很多地方会默认调用对象的toString方法：
　　　　-字符串+对象，自动调用对象的toString方法。
　　　　-System.out.println(任意对象)，直接调用toString方法。
　　toString方法是非常有用的调试工具。
　　JDK的标准类库中，许多类都重写了toString方法，方便用户获得有关对象状态的必要信息。

2.2、equals()方法

2.2.1、equals()

　　在Object类中，这个方法判断两个对象是否具有相同的引用，即是否为相同的对象。在实际应用中，一般需要重写该方法，通过比较对象的成员属性，使该方法更有意义。

2.2.2、equals和==的区别

　　==用于比较变量的值，可以应用于任何类型，如果用于引用类型，比较的是两个引用变量中存储的值（地址信息），判断两个变量是否指向相同的对象。
　　equals是Object的方法，重写以后，可以用于比较两个对象的内容是否“相等”。
　　需要注意的是，Object默认的equals方法的比较规则同==。

package day02;
/**
 * 该类的每一个实例用于描述二维坐标系上的一个点
 * 使用该类测试Object相关方法
 * @author Administrator
 */
public class Point {
    private int x;
    private int y;
    public Point(int x,int y){
        this.x = x;
        this.y = y;
    }

    //重写toString方法
    public String toString(){
        return "x="+x+",y="+y;
    }

    //重写equals方法
    public boolean equals(Object o){
        if(o == null){
            return false;
        }
        if(o == this){
            return true;
        }
        if( o instanceof Point ){
            Point p = (Point)o;
            return this.x==p.x && this.y==p.y;
        }
        return false;
    }

    public static void main(String[] args){
        Point p = new Point(1,2);
        Point p2 = new Point(1,2);

        System.out.println(p==p2);//false
        System.out.println(p.equals(p2));//true

        //默认的toString获取的是对象的句柄
        /*
         * System.out.println输出的就是对象
         * 的toString方法的返回值
         */
        System.out.println(p);
    }
}

---

三、包装类

3.1、8种基本类型的包装类

　　在进行类型转换的范畴内，有一种特殊的转换，需要将int这样的基本数据类型转换为对象。其实，所有基本类型都有一个与之对应的类，即包装类（wrapper），这个类就可以实现该功能。
　　包装类是不可变类，在构造了包装类对象后，不允许更改包装在其中的值。同时包装类也是final的，不能定义他们的子类。

int —— java.lang.Integer —— java.lang.Number
long —— java.lang.Long —— java.lang.Number
double —— java.lang.Double —— java.lang.Number
short —— java.lang.Short —— java.lang.Number
float —— java.lang.Float —— java.lang.Number
byte —— java.lang.Byte —— java.lang.Number
char —— java.lang.Character —— java.lang.Object
boolean —— java.lang.Boolean —— java.lang.Object

3.2、xxxValue()

　　抽象类Number是Byte、Double、Float、Integer、Long和Short类的父类。Number的子类必须提供将表示数值的包装类转换为byte，double，float，int，long和short类型变量的方法：
　　-doubleValue()，以double形式返回指定的数值。
　　-intValue()，以int形式返回指定的数值。
　　-floatValue()，以float形式返回指定的数值。

package day02;

/**
*数字类型的包装类继承自Number
*其提供了如：intValue,doubleValue这样的方法，作用是可以将当前包装类
*表示的数字以其他数字类型的形式返回。
*@author Administrator
*
*/
public class IntegerDemo2{
    public static void main(String[] args){
        /*
        *将基本类型转换为包装类有两种方式：
        *1、调用构造方法
        *2、调用静态方法valueOf(推荐)
        */
        Integer i1 = Integer.valueOf(127);
        Integer i2 = Integer.valueOf(127);
        System.out.println(i1 == i2);
        System.out.println(i1.equals(i2));

        int i = i1.intValue();
        System.out.println(i);

        double d = i1.doubleValue();
        System.out.println(d);

        byte b = i1.byteValue();
        System.out.println(b);
    }
}

3.3、MAX_VALUE和MIN_VALUE

　　Integer中提供了两个常量，MAX_VALUE和MIN_VALUE，分别用于表示int类型能表示的最大值和最小值。

package day02;
/**
 * 包装类的两个常用的常量
 * MAX_VALUE  MIN_VALUE
 * 用于获取对应基本类型的最大与最小取值
 * @author Administrator
 */
public class IntegerDemo3 {
    public static void main(String[] args) {
        int max = Integer.MAX_VALUE;
        int min = Integer.MIN_VALUE;
        System.out.println(max);
        System.out.println(min);
    }
}

3.4、parseXxx()

　　Integer的静态方法parseInt可用于将字符串转换为int。Double类的parseDouble()方法也有该功能。

package day02;
/**
 * 包装类常用方法:将字符串转换为对应的基本类型 
 * @author Administrator
 *
 */
public class IntegerDemo2 {
    public static void main(String[] args){
        String str = "123";
        /*
         * 将字符串转换为基本类型的前提是，该
         * 字符串描述的必须是基本类型支持的。
         */
        int i = Integer.parseInt(str);
        i++;
        System.out.println(i);  
        double d = Double.parseDouble(str);
        d++;
        System.out.println(d);
    }
}

3.5、自动装箱和拆箱操作

　　从Java 5.0版本以后，加入了autoboxing功能。自动“拆箱”和“装箱”是依靠JDK5的编译器在编译期预处理的，编译器在生成类的字节码时自动插入必要的方法调用。

package day02;
/**
 * 包装类的自动拆装箱
 * @author Administrator
 */
public class IntegerDemo5 {
    public static void main(String[] args) {
        /*
        *自动拆装箱是编译器认可，而不是虚拟机认可。编译器在将源程序编
        *译时自动补充代码来完成基本类型和包装类之间的转换。
        *
        *下面代码触发了自动拆箱：
        *在class文件中，下面的代码被编译器改为：
        *int i = new Integer(1).intValue();
        */
        int i = new Integer(1);
        /*
        *下面代码触发了自动装箱：
        *在class文件中，下面代码被编译器改为：
        *Integer ii = Integer.valueOf(123);
        */
        Integer ii = 123;

    }
}