Java基础进阶_day06_(Object,常用类,包装类,正则表达式)_包装类与正则表达式第六关头歌

Java基础进阶_day06_(Object,常用类,包装类,正则表达式)

1. Object类

Object 是类层次结构的根类.每个类都使用 Object作为超类.所有对象(包括数组)都实现这个类的方法.
所有的类都直接过间接继承Object类.

1.1 Object类的方法

public int hashCode():返回该对象的哈希码值.
    哈希值是根据哈希算法计算出来的值,这个值跟地址值有关,但是不是实际地址值.
public final Class<?> getClass():返回此Object的运行时类,返回的Class对象是由所表示类的static synchronized方法锁定的对象.
        Class类中的方法:
            public String getName():以 String的形式返回此Class对象所表示的实体(类,接口,数组类,基本类型或 void)名称.
public String toString():返回该对象的字符串表示.
    子类一般重写该方法(自动生成即可).
    直接输出一个对象名称,其实默认调用了该对象的toString()方法.
public boolean equals(Object obj):指示其他某个对象是否与此对象"相等".
    Object类中默认比较的是两个对象的地址值是否相等,子类如果想要比较成员属性是否相等需要将该方法重写(一般自动生成).
protected void finalize() throws Throwable:当垃圾回收器确定不存在对该对象的更多引用时,
    由对象的垃圾回收器调用此方法.子类重写finalize方法,以配置系统资源或执行其他清除.子类一般不进行重写.
protected Object clone() throws CloneNotSupportedException:创建并返回此对象的一个副本.
    Object类本身不实现接口Cloneable,所以在类为Object的对象上调用clone方法将会导致在运行时抛出异常;
    子类重写该方法需要实现Cloneable接口(Cloneable接口只是一个是否能被克隆的标识,其本身没有任何属性及方法).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1.2 ==和equals()的区别:

# A:==
 * 基本类型：比较的是值是否相同
 * 引用类型：比较的是地址值是否相同
# B:equals()
 * 只能比较引用类型。默认情况下，比较的是地址值是否相同。
 * 但可以根据需要重写该方法。
1
2
3
4
5
6

2. 常用类

2.1 Math类

Math类: Math类包含用于执行基本数学运算的方法,如初等指数,对数,平方根和三角函数.是一个工具类.

2.1.1 Math类的成员属性

// 成员属性: Math类中的属性均为静态常量.
public static final double E:比任何其他值都更接近 e(即自然对数的底数)的 double值.
public static final double PI:比任何其他值都更接近 pi(即圆的周长与直径之比)的 double值.
1
2
3

2.1.2 Math类中的成员方法

public static int abs(int a):返回 int 值的绝对值.
public static double ceil(double a):返回最小的(最接近负无穷大)double值,该值大于等于参数,并等于某个整数.
public static double floor(double a):返回最大的(最接近正无穷大)double值,该值小于等于参数,并等于某个整数.
public static double max(double a,double b):返回两个 double值中较大的一个.
public static int min(int a,int b):返回两个 int值中较小的一个.
public static double pow(double a,double b):返回第一个参数的第二个参数次幂的值.
public static double random():返回带正号的 double值,该值大于等于0.0且小于1.0.
public static int round(float a):返回最接近参数的int.
public static double sqrt(double a):返回正确舍入的double值的正平方根.
1
2
3
4
5
6
7
8
9

2.1.3 案例代码

public class MyMathDemo {
    public static void main(String[] args) {
        // E和PI的值
        System.out.println("E:"+Math.E+",PI:"+Math.PI);
        // 求绝对值
        System.out.println(Math.abs(-123));
        // 向上取整
        System.out.println(Math.ceil(1.999));
        // 向下取整
        System.out.println(Math.floor(1.999));
        // 求两个数的最大值
        System.out.println(Math.max(2, 5));
        // 求两个数的最小值
        System.out.println(Math.min(34, 34));
        // 求第一个数的第二个数的次幂
        System.out.println(Math.pow(2,63));
        // 随机数范围是[0,1)浮点数
        System.out.println(Math.random());
        // 四舍五入
        System.out.println(Math.round(3.6));
        // 求一个数的正的平方根
        System.out.println(Math.sqrt(4.5));
        // 生成指定范围内的整形数的随机数
        System.out.println(myRandom(1, 100));
    }
    /**
     * 生成指定范围内的整形数的随机数
     * @param start 包含
     * @param end 包含
     * @return
     */
    public static int myRandom(int start, int end) {
        return (int)(Math.random()*(end - start + 1) + start);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

2.2 System类

System类:包含一些有用的类字段和方法,它不能被实例化.

2.2.1 System类的成员方法

public static void gc():运行垃圾回收器. 调用此方法时,jvm默认的会调用类的finalize方法进行垃圾回收,Object类定义了这个方法,子类需要重写该方法.
public static void exit(int status):终止当前正在运行的Java虚拟机.参数用作状态码,非0的状态码表示异常终止.
public static long currentTimeMillis():返回以毫秒为单位的当前时间.
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length): 从指定源数组中复制一个数组,复制从指定的位置开始,到目标数组的指定位置结束.
public static Properties getProperties():获取当前的系统属性。
public static String getProperty(String key):获取指定键指示的系统属性.
1
2
3
4
5
6

2.2.2 案例代码

public class MySystemDemo {
    public static void main(String[] args) {
        // 调用系统的垃圾回收器
        Person p = new Person("somnus");
        System.out.println(p); // Person [name=somnus]
        p = null;
        System.gc(); // jvm回收垃圾:Person [name=somnus]
        // exit方法,退出jvm
        System.out.println("hello");
        // System.exit(0);
        // System.out.println("world"); // 不会执行
        // currentTimeMillis获取当前时间,以毫秒表示
        // 用于统计程序运行时间
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100; i++) {
            // System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("程序运行时间:"+ (end - start));
        // arraycopy方法
        int[] arr = {1,2,3,4,5,6};
        int[] arr1 = {7,8,9,10,11,12};
        System.arraycopy(arr, 1, arr1, 2, 3);
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));
        // 获取指定的系统属性,可以查询API
        System.out.println(System.getProperty("user.name"));
        System.out.println(System.getProperty("user.home"));
        System.out.println(System.getProperty("user.dir"));
        System.out.println(System.getProperty("os.name"));
    }
}
// 定义标准的类
class Person {
    private String name;
    public Person() {
        super();
    }
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    // 重写父类(Object)的toString方法
    @Override
    public String toString() {
        return "Person [name=" + name + "]";
    }
    // 重写父类的finalize方法,用于垃圾回收
    @Override
    protected void finalize() throws Throwable {
        System.out.println("jvm回收垃圾:" + this);
        super.finalize();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

2.3 Random类

Random类是用于生成伪随机数的流。

2.3.1 Random类构造方法

public Random():创建一个新的随机数生成器. 此构造方法将随机数生成器的种子设置为某个值(当前时间的毫秒).
public Random(long seed):使用单个long种子创建一个新的随机数生成器.
// 两个构造方法的区别: 给出种子seed后,每次(重新运行)生成的随机数相同.
1
2
3

2.3.2 Random类成员方法

public int nextInt():返回下一个随机数.
public int nextInt(int n)返回一个在 [0,n)范围内的随机数.
1
2

2.3.3 案例代码

public class MyRandomDemo {
    public static void main(String[] args) {
        Random r = new Random();
        System.out.println(r.nextInt());
        // 每次重新运行时的结果相同
        Random rr =new Random(1213);
        System.out.println(rr.nextInt());
        System.out.println(rr.nextInt());
        System.out.println(rr.nextInt());
    }
}
1
2
3
4
5
6
7
8
9
10
11

2.4 Date

Date类:表示时间,精确到毫秒.

2.4.1 Date类构造方法

public Date():分配Date对象并初始化此对象,以表示分配它的时间(精确到毫秒). 空参构造方法获取的是当前系统的时间.
public Date(long date):使用给定毫秒时间值构造一个 Date对象. 有参构造方法是在历元时间基础上进行日期推算.
1
2

2.4.2 Date类成员方法

public long getTime():返回自1970年1月1日00:00:00 GMT以来此Date对象表示的毫秒数.
// 获取毫秒的时间方法:
// System.currentTimeMillis()也可以获取毫秒数.
// Calendar类的getTime()方法和getTimeInMillis()方法获取毫秒数时间.
public void setTime(long time):设置此 Date对象,以表示1970年1月1日 00:00:00 GMT以后time毫秒的时间点.
1
2
3
4
5

2.4.3 案例代码

public class MyDateDemo {
    public static void main(String[] args) {
        /*
         * 构造方法
         */
        Date d = new Date();
        System.out.println(d); // Tue Mar 28 18:59:49 CST 2017
        long date = 3600*1000;
        Date d1 = new Date(System.currentTimeMillis()); 
        System.out.println(d1); // Tue Mar 28 18:59:49 CST 2017
        Date d2 = new Date(date); 
        System.out.println(d2); // Thu Jan 01 09:00:00 CST 1970
        // 当Date的构造参数为负数时,是在历元时间基础上向前推进
        Date d4 = new Date(-1000L);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        System.out.println("d4:"+sdf.format(d4)); // 1970年01月01日 07:59:59
        /*
         * 成员方法
         */
        Date d3 = new Date();
        System.out.println(d3.getTime()); // 1490699238339
        d3.setTime(date);
        System.out.println(d3); // Thu Jan 01 09:00:00 CST 1970
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

2.5 DateFormat抽象类

DateFormat抽象类:是日期/时间格式化子类的抽象类,它以与语言无关的方式格式化并解析日期或时间.

2.5.1 日期和字符串间的转换

# Date-->String  日期格式化
# String-->Date  解析文本
# DateFormat类是一个抽象类,其有一个子类SimpleDateFormat是具体类,使用时用的子类的对象.
1
2
3

2.5.2 SimpleDateFormat类

构造方法

// SimpleDateFormat类
public SimpleDateFormat():用默认的模式和默认语言环境的日期格式符号构造 SimpleDateFormat.
public SimpleDateFormat(String pattern):用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat.
// DateFormat类
public final String format(Date date):将一个Date格式化为日期/时间字符串.
public Date parse(String source) throws ParseException:从给定字符串的开始解析文本,以生成一个日期.此方法处理的字符串必须和SimpleDateFormat创建对象时使用的格式匹配.
1
2
3
4
5
6

2.5.3 案例代码

public class MyDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        // 将日期格式为默认的字符串格式
        SimpleDateFormat sdf = new SimpleDateFormat();
        Date d = new Date();
        System.out.println("格式化前的日期:"+d);
        String date = sdf.format(d);
        System.out.println("格式化后的日期:"+date); // 默认格式17-3-28 下午7:32
        // 将日期格式为指定的字符串格式
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日  HH:mm:ss E");
        Date d2 = new Date();
        System.out.println("格式化前的日期:"+d2);
        String date2 = sdf2.format(d);
        System.out.println("格式化后的日期:"+date2); // 输出的指定格式2017年03月28日  19:32:59

        // 将字符串解析为日期
        // date3格式必须和SimpleDateFormat构造的参数格式严格匹配(空格也不能多)
        String date3 = "2015-02-28 19:19:19";
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d4 = sdf3.parse(date3);
        System.out.println(d4); // Sat Feb 28 19:19:19 CST 2015
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.6 Calendar抽象类

Calendar抽象类:是一个抽象类,它为特定瞬间与一组诸如YEAR等日历字段之间的转换提供了一些方法,并为操作日历字段提供了一些方法.

2.6.1 Calendar类的子类

# Calendar是一个抽象类,通过创建其子类的对象进行日期的操作.
# Calendar的getInstance方法返回一个Calendar对象,其日历字段已由当前日期和时间初始化:
    Calendar rightNow = Calendar.getInstance();
    rightNow中存储了当前时间的所有与时间相关的字段值,直接输出结果如下:
    java.util.GregorianCalendar[time=1490768748872,YEAR=2017,MONTH=2,,DAY_OF_MONTH=29...]
1
2
3
4
5

2.6.1 Calendar类的成员方法

// 成员方法:日历类是将日历的所有字段都存储好了,需要什么字段的时间的信息,直接通过get方法获取.
public int get(int field):返回给定日历字段的值.日历类中的所有字段均为静态常量,需要哪个字段的信息,参数就是对应的字段值.
1
2

2.6.2 Calendar子类的方法

public abstract void add(int field,int amount):根据日历的规则,为给定的日历字段添加或减去指定的时间量。
public final void set(int year,int month,int date):设置日历字段 YEAR,MONTH和DAY_OF_MONTH的值.
public final Date getTime():返回一个表示此Calendar时间值(从历元至现在的毫秒偏移量)的Date对象.
public long getTimeInMillis():返回此 Calendar的时间值,以毫秒为单位.
// 注意事项:Calendar类的月是从0开始算起的.(0月代表1月)
1
2
3
4
5

2.6.3 案例代码

public class MyCalendarDemo {
    public static void main(String[] args) {
        // 其日历字段已由当前日期和时间初始化： 
        // 返回的是Calendar子类的对象
        Calendar rightNow = Calendar.getInstance();
        System.out.println(rightNow); // java.util.GregorianCalendar[YEAR=2017,MONTH=2,,DAY_OF_MONTH=29...]
        int year = rightNow.get(Calendar.YEAR);
        int month = rightNow.get(Calendar.MONTH);
        int day = rightNow.get(Calendar.DAY_OF_MONTH);
        System.out.println(year+"年"+month+"月"+day+"日"); // 2017年2月28日
        // add方法
        rightNow.add(Calendar.YEAR, -5); // 当前年份减去5年
        rightNow.add(Calendar.MONTH, -3); // 当前月份减去2个月
        rightNow.add(Calendar.DAY_OF_MONTH, -5); // 当前天数减去5天
        int year1 = rightNow.get(Calendar.YEAR);
        int month1 = rightNow.get(Calendar.MONTH);
        int day1 = rightNow.get(Calendar.DAY_OF_MONTH);
        System.out.println(year1+"年"+month1+"月"+day1+"日"); // 2012年0月23日
        // set方法
        rightNow.set(2018, 11, 28);
        int year2 = rightNow.get(Calendar.YEAR);
        int month2 = rightNow.get(Calendar.MONTH);
        int day2 = rightNow.get(Calendar.DAY_OF_MONTH);
        System.out.println(year2+"年"+month2+"月"+day2+"日"); // 2018年11月28日
        // getTime和getTimeInMillis方法
        System.out.println(rightNow.getTime()); // Fri Dec 28 20:38:56 CST 2018
        System.out.println(rightNow.getTimeInMillis()); // 1546000736997
        method(2016);
    }
    /**
     * 获取任意一年2月份有多少天
     */
    public static void method(int year) {
        Calendar c = Calendar.getInstance();
        // 方式1,获取该年份的2月第1天,和3月份的第1天,然后获取各自时间的毫秒,再计算
        // 设置时间为2月份的第1天
        c.set(year, 1, 1);
        System.out.println(c.get(Calendar.YEAR)+".."+c.get(Calendar.MONTH)+".."+c.get(Calendar.DATE));
        long forMonthDay = c.getTimeInMillis() / 1000 / 60 / 60 / 24;
        // 设置时间为3月份的第1天
        c.set(year, 2, 1);
        long bacMonthDay = c.getTimeInMillis() / 1000 / 60 / 60 / 24;
        System.out.println(bacMonthDay-forMonthDay);
        // 方式2,获取该年的3月份的第1天,然后将日期向前推1天,输出改天即可
        c.set(year, 2, 1);
        c.add(Calendar.DATE, -1);
        System.out.println(c.get(Calendar.DATE));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

3. 基本数据类型的包装类

基本数据类型的包装类型:一般用包装类进行基本数据类型与字符串间的转换.
基本数据类型与对应的包装类

3.1 基本数据类型与字符串间的转换

# 基本数据类型-->String
    public static String valueOf(int i)
# String-->基本数据类型
    public static int parseInt(String s)
1
2
3
4

3.2 注意事项

# 注意事项: 包装类都有自动封箱和自动拆箱
    例如:
    Integer i = 4; // 自动装箱,i是应用类型的变量
    i += 4; // 自动拆箱
# Integer类型变量赋值时需注意:
  * Integer中有个byte类型(-128~127)的缓冲池.直接使用赋值的方式时,如果数值在byte的取值范围内,是直接从byte缓冲池中返回该值,不会创建对象;
  * 如果不在byte的缓冲池中,则会通过new Integer(i)的方式创建一个对象并返回.
  * Integer i1 = 127;-->实际是调用Integer.valueOf(i):valueOf的源码如下:
        public static Integer valueOf(int i) {
            assert IntegerCache.high >= 127;
            if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.3 Character类特殊方法

public static boolean isUpperCase(char ch):确定指定字符是否为大写字母; 
public static boolean isLowerCase(char ch):确定指定字符是否为小写字母;
public static boolean isDigit(char ch):确定指定字符是否为数字;
public static char toLowerCase(char ch):使用取自UnicodeData文件的大小写映射信息将字符参数转换为小写;
public static char toUpperCase(char ch):使用取自UnicodeData文件的大小写映射信息将字符参数转换为大写.
1
2
3
4
5

3.4 代码案例

public class MyIntegerDemo {
    public static void main(String[] args) {
        /*
         * Integer中有个byte类型(-128~127)的缓冲池.直接使用赋值的方式时,如果数值在byte的取值范围内,是直接从byte缓冲池中返回该值,不会创建对象;
         * 如果不在byte的缓冲池中,则会通过new Integer(i)的方式创建一个对象并返回.
         * Integer i1 = 127;-->实际是调用Integer.valueOf(i):valueOf的源码如下:
         * public static Integer valueOf(int i) {
                assert IntegerCache.high >= 127;
                if (i >= IntegerCache.low && i <= IntegerCache.high)
                    return IntegerCache.cache[i + (-IntegerCache.low)];
                return new Integer(i);
            }
         */
        Integer i1 = 127;
        Integer i2 = 127;
        System.out.println(i1==i2); // true
        System.out.println(i1.equals(i2)); // true

        Integer i3 = 128;
        Integer i4 = 128;
        System.out.println(i3==i4); // false
        System.out.println(i3.equals(i4)); // true
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

4. 正则表达式

正则表达式:符合一定规则的表达式(字符串).

4.1 Pattern类

Pattern类:正则表达式的编译表示形式.

4.2 正则表达式的应用

// 判断功能:String类的方法
public boolean matches(String regex):告知此字符串是否匹配给定的正则表达式. 
// 分割功能:String类的方法
public String[] split(String regex):根据给定正则表达式的匹配拆分此字符串.按照指定分隔符进行分割字符串,得到的是字符串数组.
// 替换功能:String类的方法
public String replaceAll(String regex,String replacement):使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 
//  获取功能:Pattern和Matcher配合使用
// 1.将规则编译成Pattern对象
// 2.通过模式对象获取匹配器对象
// 3.通过匹配器对象的find方法查找是否有满足要求的子字符串
// Matcher类的方法:必须先调用find方法,group方法才能调用.
public boolean find(int start):重置此匹配器,然后尝试查找匹配该模式,从指定索引开始的输入序列的下一个子序列. 
public String group():返回由以前匹配操作所匹配的输入子序列.
1
2
3
4
5
6
7
8
9
10
11
12
13

4.3 案例代码

public class MyRegexDemo {
    public static void main(String[] args) {
        /*
         * 判断功能,校验邮箱
         */
         // 定义邮箱的规则
         String regex = "^[\\w-]+(\\.[\\w-]+)*@[\\w-]+(\\.[\\w-]+)+$";
         Scanner sc = new Scanner(System.in);
         String email = sc.nextLine();
         boolean flag = email.matches(regex);
         System.out.println(flag);
        /*
         * 分割功能
         */
        String s = "java,hello";
        String[] strings = s.split(",");
        System.out.println(Arrays.toString(strings));
        String s1 = "java.hello";
        String[] strings1 = s1.split("\\."); // .需要使用斜杠进行转义,java中两个斜杠代表一个斜杠
        System.out.println(Arrays.toString(strings1));
        String s2 = "java     hello     world";
        String[] strings2 = s2.split(" +"); // 多个空格需要使用+表示多个
        System.out.println(Arrays.toString(strings2));
        // windows中的路径分割符是单斜杠,需要使用进行转义
        String s3 = "E:\\develop\\JavaAdvanceWorkSpace\\day06\\src\\com\\itheimamyregex\\MyRegexDemo.java";
        String[] strings3 = s3.split("\\\\"); // Java中要匹配s3中的双斜杠,Java中斜杠要进行转义,需要使用4个斜杠表示路径中的2个斜杠
        System.out.println(Arrays.toString(strings3));
        /*
         * 替换功能,将字符串中指定的字符替换为指定的字符
         * 如将指定字符串中的数字替换为*号
         */
        String data = "Somnus0809";
        String regex3 = "\\d";
        String rdata = data.replaceAll(regex3, "*");
        System.out.println("rdata:"+rdata); // rdata:Somnus****
        /*
         * 获取功能: 获取字符串中:
         * "wo zai hei ma cheng xu yuan cheng du fen xiao qu xue xi java bian cheng"
         * 有4个字母的字符串
         */
        String ss = "wo zai hei ma cheng xu yuan cheng du fen xiao qu xue xi java bian cheng";
        // 定义规则
        String regex2 = "\\b\\w{4}\\b";
        // 将规则编译成Pattern对象
        Pattern p = Pattern.compile(regex2);
        // 通过模式对象获取匹配器对象
        Matcher m = p.matcher(ss);
        // 通过匹配器对象的find方法查找是否有满足要求的子字符串
        while (m.find()) {
            // group方法调用之前必须先调用find方法
            System.out.println(m.group());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54