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

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

Java基础进阶_day06_Object常用类包装类正则表达式

Object类
1 Object类的方法

2 和equals的区别

常用类
1 Math类
11 Math类的成员属性

12 Math类中的成员方法

13 案例代码

2 System类
21 System类的成员方法

22 案例代码

3 Random类
31 Random类构造方法

32 Random类成员方法

33 案例代码

4 Date
41 Date类构造方法

42 Date类成员方法

43 案例代码

5 DateFormat抽象类
51 日期和字符串间的转换

52 SimpleDateFormat类

53 案例代码

6 Calendar抽象类
61 Calendar类的子类

61 Calendar类的成员方法

62 Calendar子类的方法

63 案例代码

基本数据类型的包装类
1 基本数据类型与字符串间的转换

2 注意事项

3 Character类特殊方法

4 代码案例

正则表达式
1 Pattern类

2 正则表达式的应用

3 案例代码

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