正则表达式、包装类

正则表达式

验证邮箱

/**
 * String支持正则表达式的方法之一:
 *
 * boolean matches(String regex)
 * 使用给定的正则表达式验证当前字符串是否符合格式要求，符合则返回true
 */
public class MatchesDemo {
    public static void main(String[] args) {
        String email = "wangcb@tedu.cn";
        /*
           邮箱的正则:[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\.[a-zA-Z]+)+
         */
        String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";
        boolean match = email.matches(regex);
        if(match){
            System.out.println("是邮箱");
        }else {
            System.out.println("不是邮箱");
        }
    }
}

/**
 * String支持正则表达式方法之二:
 *
 * String[] spilt(String regex)
 * 将当前字符串按照满足正则表达式的部分进行拆分，将拆分后的所有部分以
 * 一个String数组形式返回
 */
public class SplitDemo {
    public static void main(String[] args) {
        String str = "abc123def456ghi789jkl";
        //按照数字部分拆分
        String[] arr = str.split("[0-9]+");
        System.out.println(arr.length);
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }

        str = "123.456.789";
        //按照"."拆分
        arr = str.split("\\.");
        System.out.println(arr.length);
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }

        /**
         * 当遇到连续出现可拆分项时，中间会拆分出一个空字符串
         * 如果字符串最开始就是可拆分项，则拆分后的第一项是空字符串
         *
         * 注意:如果字符串末尾连续出现可拆分项，所有拆分出来的空字符串会被忽略!
         */
        str = ",123,,,456,789,,,,,,,,,,";
        //按照"."拆分
        arr = str.split(",");
        System.out.println(arr.length);
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }
    }
}

/**
 * String支持正则表达式的方法之三:
 *
 * String replaceAll(String regex,String str)
 * 将当前字符串中满足正则表达式的部分替换为给定内容
 */
public class replaceAllDemo {
    public static void main(String[] args) {
        String str = "abc123def456ghi789jkl";
        //将字符串中的数字部分替换为"#NUMBER#"
        str = str.replaceAll("[0-9]+","#NUMBER#");
        System.out.println(str);

        //和谐用语
        String regex = "(wqnmd|sb|cnm|ngnt|nc|nmsl|mdzz)";
        String message = "mdzz,你是sb吗，你全家nc";
        message = message.replaceAll(regex,"***");
        System.out.println(message);
    }
}

/**
 * 使用当前类测试常被重写的Object相关方法
 */
public class Point {
    private int x;
    private int y;

    //自动生成代码快捷键:alt+insert

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x &&
                y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

/**
 * 测试Object中常用的方法
 */
public class Test {
    public static void main(String[] args) {
        Point p = new Point(1,2);
        /*
           Object中定义了方法:
           String toString()
           作用是将当前对象转换为String
           Objcet中该方法的实现返回的字符串格式为:类名@地址
         */
        String str= p.toString();
        System.out.println(str);

        /*
           向控制台输出是很常用的操作，当我们输出一个对象时，
           实际上该方法会调用该对象的toString方法，
           将返回的字符串输出到控制台
         */
        System.out.println(p);
        /*
           字符串与其他类型连接时，会将其他类型转换为String。
           而转换也是依靠该对象的toString
           下面的代码实际上将p.toString()返回的字符串连接的。
         */
        String line = "这个对象是:" + p;
        System.out.println(line);

        Point p2 = new Point(1,2);
        System.out.println(p==p2);//false
        /*
           Object提供的另一种常用方法:
           boolean equals(Object o)
           该方法的作用是比较当前对象与参数给定的对象内容是否相同
           但是如果子类不重写这个方法，则该方法毫无价值。因为Object
           实现该方法时使用的是"=="比较的
         */
        System.out.println(p.equals(p2));//true

        /*
           JAVA提供的类基本都妥善的重写了toString和equals
           比如String，只有我们自己定义的类在使用时需要去重写
         */
    }
}

# 包装类

```java
/**
 * 包装类
 * 包装类是为了解决基本类型不能直接参与面向对象开发的问题，使得
 * 基本类型可以以"对象"的形式存在。
 * 包装类都定义在java.lang包中作为基础类使用。
 * 六个数字类型的包装类继承自Number，其余两个直接继承自Object
 */
public class IntegerDemo {
    public static void main(String[] args) {
        //基本类型转化为包装类
        int d = 123;
        //Integer i1 = new Integer(d);
        //Integer i2 = new Integer(d);

        /*
           基本类型转换为包装类建议使用包装类的静态方法valueOf
           对于Integer而言，该方法会重用1字节之内正数的包装类对象
         */
        Integer i1 = Integer.valueOf(d);
        Integer i2 = Integer.valueOf(d);
        System.out.println(i1==i2);//valueOf创建则为true
        //包装类都重写过equals方法
        System.out.println(i1.equals(i2));//true

        //包装类转换为基本类型
        int i = i1.intValue();//以int类型返回
        System.out.println(i);
    }
}

/**
 * 包装类常见功能
 */
public class IntegerDemo2 {
    public static void main(String[] args) {
        //获取int最大值
        int imax = Integer.MAX_VALUE;
        System.out.println("imax:"+imax);
        //获取int最小值
        int imin = Integer.MIN_VALUE;
        System.out.println("imin:"+imin);

        /*
           包装类提供了一个静态方法parseXXX(String line)
           可以将字符串解析为对应的基本类型数据。但是前提是该字符串
           正确描述了基本类型可以保存的值。否则会抛出异常:
           java.lang.NumberFormatException
         */
        String line = "123";
        //String line = "123.123";这个字符串就不能转为int值
        int in = Integer.parseInt(line);
        System.out.println(in);//123
        double dou = Double.parseDouble(line);
        System.out.println(dou);//123.123
    }
}

/**
 * JDK5推出时推出了一个特性:自动拆装箱
 * 该特性是编译器认可的，当我们在基本类型与引用类型赋值时，编译器会
 * 在编译期间自动添加转换代码，将基本类型转换为包装类，或反之。
 * 使得我们在编写源代码时不在关注基本类型与包装类之间的转换工作。
 */
public class IntegerDemo3 {
    public static void main(String[] args) {
        int d = 123;
        /*
           下面的代码触发了编译器的自动装箱特性:
           编译器会补充代码将基本类型转换为包装类，代码会变为:
           Integer i = Integer.valueOf(d);
         */
        Integer i = d;
        /*
           下面的代码触发了编译器的自动拆箱特性:
           编译器会补充代码将包装类型转换为基本类型，代码会变为:
           d = i.intValue();
         */
        d = i;
    }
}