关于正则表达式和包装类（Java）

在Java中用到正则表达式的三个方法
String[] split(String regex)
String replaceAll(String regex,String str)
boolean matches(String regex)
实例代码：

/**
 * 字符串支持正则表达式的方法一：
 * boolean matches(String regex)
 * 根据给定的正则表达式验证当前字符串是否满足格式、
 *要求，满足则返回true，负责返回false 
 *
 *regex:正则表达式
 *matches：动词。匹配的单三形式
 * @author Analyze
 *
 */
public class Matches {
    public static void main(String[] args) {


        /*
         * 用正则表达式来表达邮箱
         * [a-zA-Z0-9_]+@\w+(\.[a-zA-Z0-9_]+)+
         * 因为.在正则表达式中有特殊含义，所以需要将.加上转义字符\
         * String regex=" [a-zA-Z0-9_]+@\w+(\.[a-zA-Z0-9_]+)+";
         * 编译报错
         * 但是在Java中\也是转移字符，他会先将正则表达式中的\w和\.转义，
         * 但是Java中没有\w和\.转义的含义，所以报错
         * 需要将/再次转义
         * 这样就变成了\\w和\\.
         */
         String regex="[a-zA-Z0-9_]+@\\w+(\\.[a-zA-Z0-9_]+)+";
         System.out.println(regex);

         String email="fancq@tedu.cn";
         boolean flag=email.matches(regex);
         if(flag){
            System.out.println("是邮箱"); 
         }else{
             System.out.println("不是邮箱");
         }
    }
}

/**
 * 字符串支持正则表达方法二：
 * String[] split(String regex)
 * 将当前字符串按照满足正则表达式的部分进行拆分
 * 返回拆分后的每段内容
 * 如果能连续满足正则表达式，就会拆分出空字符串
 * 例如：
 * 将下面的字符串按照regex="[0-9]"拆分
 * 那么结果为：
 * 拆分长度：10
    abc


    def


    ghi


    jkl

    但是！！注意如果拆分结果最后为空字符串那么不会显示
    例如：
    将字符串改为：String str="abc123def456ghi789jkl1111"
    按照regex="[0-9]"拆分，结果为：
    拆分长度：10
    abc


    def


    ghi


    jkl
 * @author Analyze
 *
 */
public class Split {

    public static void main(String[] args) {
        String str="abc123def456ghi789jk";
        /*
         * 按照数字拆分，保留所有的英文字母部分
         */
        String regex="[0-9]+";
        String [] array=str.split(regex);

        System.out.println("拆分长度："+array.length);
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }
    }

}

/**
 * String replaceAll(String regex,String str)
 * 将当前字符串中满足正则表达式的部分替换为给定字符
 * @author Analyze
 *
 */
public class ReplaceAll {

    public static void main(String[] args) {
        String str="abc123def456ghi789jk";
        /*
         * 将数字部分替换为#NUMBER#
         */
        String regex="\\d+";
        //正则表达式\d表示数子，需要在Java中再次转义
        str=str.replaceAll(regex, "#NUMBER#");
        System.out.println(str);
    }

}

包装类：为了使八个基本类型具有能像面向对象开发的特性
Java提出了包装类。每个基本类型都有一个包装类与之对应

实例代码：

/**
 * 包装类
 * Java对于8个基本类型分别定义了对应的包装类
 * 特殊记忆的：
 * int     Integer
 * char    Character
 * 其他只需要首字母大写
 * 例如
 * boolean  Boolean
 * 而包装类出现的原因是为了解决基本类型不能参与面向对象开发的问题
 * @author Analyze
 *
 */
public class IntegerDemo1 {

    public static void main(String[] args) {
        dosome("abc");
        dosome(new Point(1,2));
        dosome(1);
        /**
         * !!这里注意，!!在jdk1.4版本前这么写是会报错的
         * ！!在jdk1.4版本前认为8个基本类型：
         * byte,short,int,long,float.double,char
         * boolean
         * 是以值的形式直接存在的，所以他们没有面向对象的特征
         * 自然也不继承Object，所以不能使用多态，用Object的
         * 角度去接受基本类型
         */
        /**
         * 为了方便Java在JDK1.4之后提供的包装类的说法
         * dosome(1)
         * q其实变为dosome(new Integer(1));
         */
        dosome(new Integer(1));
        /*
         *Java不仅帮助你完成了包装类，还有脱包装的方法
         *例如：
         *public class Integer{
         *  private i;
         *  public Integer(int i){
         *      this.i=i;
         *  }
         *  public int intValue(){
         *      return this.i; 
         *  }
         *}
         *
         */

    }
    public static void dosome(Object obj){
        System.out.println(obj.equals(1));
    }

}

/**
 * 数字类型的包装类继承自Number
 * 其提供了如：intValue,doubleValue这样的方法
 * 作用是可以将当前包装类表示的数字以其他数字类型形式返回
 * @author Analyze
 *
 */
public class IntegerDemo2 {

    public static void main(String[] args) {
        /*
         * 将基本类型转换为包装类有两种方式：
         * 1.调用构造方法
         * 2.调用静态方法ValueOf()
         * 
         * 两者会有一定的区别
         * 用valueOf方法时，在字面量小于一个字节（-128-127）时
         * 会和String一样重用
         * 所以推荐用valueOf()方法包装
         */

        //代码示例
        Integer i1=new Integer(123);
        Integer i2=new Integer(123);

        System.out.println("用构造方法创建==判断结果:"+(i1==i2));
        System.out.println("用构造方法创建equal判断结果:"+i1.equals(i2));

        Integer i3=Integer.valueOf("123");
        Integer i4=Integer.valueOf(123);

        System.out.println("用valueOf方法创建，==判断结果:"+(i3==i4));
        System.out.println("用valueOf方法创建，equal判断结果:"+i3.equals(i4));

        System.out.println("||||||||||||||||||||||||||");

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

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

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


    }

}

/**
 * 数字类型包装类都支持两个常量：
 * MAX_VALUE,MIN_VALUE
 * 分别保存了对应基本类型的最大值与最小值
 * @author Analyze
 *
 */
public class IntegerDemo3 {

    public static void main(String[] args) {
        //获取int最大值和最小值
        int imax=Integer.MAX_VALUE;
        int imin=Integer.MIN_VALUE;
        System.out.println(imax);
        System.out.println(imin);

        //获取double最大值和最小值
        double dmax=Double.MAX_VALUE;
        double dmin=Double.MIN_VALUE;
        System.out.println(dmax);
        System.out.println(dmin);


    }

}

/**
 * 包装类提供了一个静态方法parseXXX(String str)
 * 可以将给定的字符串转换为对应的基本类型
 * 提前是该字符串必须正确的描述基本类型可以保存的值
 * @author Analyze
 * 
 * parse的英文意思为对XXX进行语法分析
 *
 */
public class IntegerDemo4 {

    public static void main(String[] args) {
         String str="123";
         int i=Integer.parseInt(str);
         System.out.println(i);

         double d=Double.parseDouble(str);
         System.out.println(d+1.5);

    }

}

public class IntegerDemo5 {
/**
 * JDK1.5之后推出了一个新特性
 * 自动拆装箱
 * @param args
 */
    public static void main(String[] args) {
        /*
         * 自动拆装箱是编译器认可，而不是虚拟机认可
         * 编译器在原程序编译时自动补充代码来完成
         * 基本类型与包装类之间的转换
         * 
         * 下面代码自动触发了自动拆箱：
         * 在class文件中，下面的代码被编译器改为：
         * int i=new Integer(1).intValue();
         */
        int i=new Integer(1);
        System.out.println(i);
        /*
         * 下面的代码触发了自动装箱：
         * 在class文件中，下面代码被编译器改为
         * Integer ii=Integer.valueOf(123);
         */
        Integer ii=123;
        System.out.println(ii);
    }

}