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 ==和equals()的区别:

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

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值.

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值的正平方根.

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);    }}

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):获取指定键指示的系统属性.

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();    }}

2.3 Random类

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

2.3.1 Random类构造方法

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

2.3.2 Random类成员方法

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

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());    }}

2.4 Date

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

2.4.1 Date类构造方法

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

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毫秒的时间点.

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    }}

2.5 DateFormat抽象类

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

2.5.1 日期和字符串间的转换

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

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创建对象时使用的格式匹配.

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}

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...]

2.6.1 Calendar类的成员方法

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

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月)

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));    }}

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

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

byte short int long float double char boolean Byte Short Integer Long Float Double Character Boolean

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

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

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);        }

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文件的大小写映射信息将字符参数转换为大写.

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    }}

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():返回由以前匹配操作所匹配的输入子序列.

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());        }    }}