JAVASE02-Unit02： 正则表达式 、 Object 、 包装类

　　　　正则表达式 、 Object 、 包装类　　　　

字符串支持正则表达式的方法一:

package day02;
/**
 * 字符串支持正则表达式的方法一:
 * boolean matches(String regex)
 * 该方法会使用给定的正则表达式验证当前字符串是否
 * 满足格式要求，满足则返回true
 * 需要注意，给定的正则表达式就算不指定边界符(^,$)，
 * 也是全匹配验证。
 * @author adminitartor
 *
 */
public class String_Matches {
    public static void main(String[] args) {
        String email = "fancq@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]+)+";
        System.out.println(regex);
        
        boolean match = email.matches(regex);
        if(match){
            System.out.println("是邮箱");
        }else{
            System.out.println("不是邮箱");
        }
        
    }
}

字符串支持正则表达式方法二:

package day02;
/**
 * 字符串支持正则表达式方法二:
 * String[] split(String regex)
 * 将当前字符串中满足正则表达式的部分进行拆分
 * 返回所有被拆分的部分
 * @author adminitartor
 *
 */
public class String_Split {
    public static void main(String[] args) {
        String str = "abc123def456ghi789jkl";
        /*
         * 按照数字部分进行拆分，保留所有英文
         * 部分
         * 
         * 若在拆分字符串的过程中连续匹配了两次
         * 要拆分的内容，那么它们中间会拆分出一
         * 个空字符串，但是在字符串末尾若连续匹配
         * 那么所有拆分出的空字符串会被忽略。
         */
//        String regex = "[0-9]+";
        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的split方法实现图片重命名

package day02;
/**
 * 使用String的split方法实现图片重命名
 * @author adminitartor
 *
 */
public class Demo1 {
    public static void main(String[] args) {
        String imgName = "1.jpg";
        
        String[] names = imgName.split("\.");
        //获取当前系统时间毫秒值作为图片名
        long time = System.currentTimeMillis();
        
        imgName = time+"."+names[1];
        System.out.println(imgName);
        
        
    }
}

将当前字符串满足正则表达式的部分替换为给定内容

package day02;
/**
 * String replaceAll(String regex,String str)
 * 将当前字符串满足正则表达式的部分替换为给定内容
 * @author adminitartor
 *
 */
public class String_ReplaceAll {
    public static void main(String[] args) {
        String str = "abc123def456ghi789jkl";
        /*
         * 将字符串中的数字部分替换为"#NUMBER#"
         */
        str = str.replaceAll("[0-9]+", "#NUMBER#");
        System.out.println(str);
    }
}

和谐用语

package day02;
/**
 * 和谐用语
 * @author adminitartor
 *
 */
public class Demo2 {
    public static void main(String[] args) {
        String regex = "(wqnmlgdsb|cnm|mdzz|tmd|djb|nc|nnd|yyd)";
        
        String message = "wqnmlgdsb!你怎么这么nc!cnm!你就是个djb!";
        
        message = message.replaceAll(regex, "****");
        System.out.println(message);

    }
}

使用Point测试Object方法的重写

package day02;
/**
 * 使用Point测试Object方法的重写
 * @author adminitartor
 *
 */
public class Point {
    private int x;
    private int y;
    
    public Point(){
        
    }

    public Point(int x, int y) {
        super();
        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;
    }
    /**
     * API文档中有所说明，当我们需要使用到一个
     * 类的toString方法，通常就需要重写该方法。
     * 否则Object中该方法返回的是对象的句柄信息。
     * 
     * 返回的字符串原则上应当包含需要了解当前对象
     * 的属性信息，具体根据需求而定，没有统一的格式
     * 要求。
     */
    public String toString(){
        return "("+x+","+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;
            //x,y都一样才认为内容一致
            return this.x==p.x&&this.y==p.y;
        }
        
        return false;
    }
    
    
}

测试Point重写Object的方法

package day02;
/**
 * 测试Point重写Object的方法
 * @author adminitartor
 *
 */
public class TestPoint{
    public static void main(String[] args) {
        Point p = new Point(1,2);
        /*
         * Object提供的toString方法返回的字符串
         * 为该对象的引用，格式为:
         * 类名@地址
         * 通常这个格式也成为:对象的句柄
         * 没有什么实际价值
         */
        String str = p.toString();
        System.out.println(str);
        /*
         * System.out.println(Object o)
         * 该方法会将给定的对象的toString方法返回
         * 的字符串输出到控制台。
         */
        System.out.println(p);
        
        
        Point p1 = new Point(1,2);
        
        System.out.println(p==p1);//false
        System.out.println(p.equals(p1));//true
    }
}

package day02;

public class TestInteger {
    public static void main(String[] args) {
        dosome("hello");
        dosome(new Point(1,2));
        int d = 1;
        Integer ii = new Integer(d);
        dosome(ii);
        
        d = ii.intValue();
    }
    
    public static void dosome(Object obj){
        
    }
}

包装类

package day02;
/**
 * 包装类
 * 包装类是为了解决基本类型不能直接参与面向对象开发
 * 的问题。因为基本类型没有面向对象特性。
 * 
 * 其中6个数字类型对应的包装类继承自Number
 * Number是一个抽象类，定义了6个数字类型之间互转
 * 的相关方法。
 * @author adminitartor
 *
 */
public class Integer_Number {
    public static void main(String[] args) {
        /*
         * 基本类型转换为包装类的方式:
         * 1:使用构造方法
         * 2:使用静态方法valueOf(推荐)
         */
//        Integer i1 = new Integer(1);
//        Integer i2 = new Integer(1);
        
        //valueOf对于整数可以重用1字节内的整数对象
        Integer i1 = Integer.valueOf(128);
        Integer i2 = Integer.valueOf(128);
        
        System.out.println(i1==i2);
        System.out.println(i1.equals(i2));
        
        /*
         * 包装类转换为基本类型
         */
        int d = i1.intValue();
        double dd = i1.doubleValue();
        System.out.println(dd);
        
        short sh = i1.shortValue();
        System.out.println(sh);
        
        byte b = i1.byteValue();
        System.out.println(b);
        
        
        Double dou = Double.valueOf(123.123);
        
        d = dou.intValue();
        System.out.println(d);
        
        
    }
}

数字类型包装类有两个常量:

package day02;
/**
 * 数字类型包装类有两个常量:
 * MAX_VALUE,MIN_VALUE 分别保存的值为该包装类
 * 对应的基本类型数据的取值范围
 * @author adminitartor
 *
 */
public class Integer_MAX_VALUE {
    public static void main(String[] args) {
        int imax = Integer.MAX_VALUE;
        System.out.println("imax:"+imax);
        
        int imin = Integer.MIN_VALUE;
        System.out.println("imin:"+imin);
        
        long lmax = Long.MAX_VALUE;
        System.out.println("lmax:"+lmax);
    }
}

该方法可以将字符串解析为对应的基本类型

package day02;
/**
 * 包装类支持一个静态方法 parseXXX(String str)
 * 该方法可以将字符串解析为对应的基本类型，前提是
 * 该字符串能正确描述该基本类型可以保存的值
 * @author adminitartor
 *
 */
public class Integer_ParseInt {
    public static void main(String[] args) {
        String str = "123";
        int i =    Integer.parseInt(str);
        System.out.println(i+1);//124
        
        double d = Double.parseDouble(str);
        System.out.println(d+1);//124.123
    }
}

自动拆装箱

package day02;
/**
 * java自1.5发布后，推出了一个新特性:
 * 自动拆装箱
 * 所谓自动拆装箱是指编译器在编译源程序时会自动
 * 补充代码将基本类型与包装类之间做转换。
 * 这样的好处是我们可以省去互相转换的代码编写。
 * @author adminitartor
 *
 */
public class Integer_AutoBoxing {
    public static void main(String[] args) {
        
        /*
         * 编译器会自动补全代码，将引用类型转换为
         * 基本类型:自动拆箱
         * 下面的代码在编译后的class文件中为:
         * int i = new Integer(1).intValue();
         */
        int i = new Integer(1);
        
        /*
         * 编译器会自动补全代码，将基本类型转换为
         * 引用类型:自动装箱
         * 下面的代码在编译后的class文件中为:
         * Integer ii = Integer.valueOf(i);
         */
        Integer ii = i;
    }
}

equals和“==”：
euqals 比较内容是否一样，长得像不像；
==  比较的是地址；

把字符串，转基本类型，掉包装类，包装类（8个），为了解决基本类型不能直接参加到面向对象开发；

引用类型   =   基本类型
基本类型  =  引用类型  

1.5版本后可以相互赋值，自动不.intvalue;    intvaluof;  编译器补充代码了，叫自动拆装箱

Eclipse自动生成，set，get方法

package day01;

public class Test {
    private int x;
    private int y;
    
    public Test(){
        
    }


========选择：Source -- Gnerrate **** using fiels==========

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

===========选择：an setters==================
    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;
    }

}