第九章 工具类（20210805）

Object类

1.equals

比较两个对象的引用值

Object obj1 = new Object();
Object obj2 = new Object();
System.out.println(obj1.equals(obj2));
输出：false

2.hashCode

返回十进制整数，唯一标识一个对象

System.out.println(obj1.hashCode());
System.out.println(obj2.hashCode());
输出：604107971  123961122

3.toString

返回 类名@hashcode(16进制)
一般子类都会覆盖该方法，让它返回有意义的文本。

System.out.println(obj1.toString());
System.out.println(obj1);
输出：java.lang.Object@2401f4c3
注：println()方法默认调用toString()方法

4.equals 和 == 的区别

• “==” ： 可以比较基本数据类型，也可以比较引用数据类型；
  基本数据类型->值，引用数据类型->地址 。
• equals ：只能比较引用类型；
  重写前->地址，重写后->内容。

包装类

1.包装类常用属性

整型最大值、最小值

Byte.MIN_VALUE;
Byte.MAX_VALUE;
输出：-128 127 

（为方便阅读，部分代码中省略输出语句）

2.包装类常用方法

• 判断字符 c 是否为数字

Character.isDigit('c')
输出：false

• 判断字符 c 是否为字母

Character.isLetter('c')
输出：true

• 判断字符 c 是否为小写字母

Character.isLowerCase('c')
输出：true

包装类，基本数据类型，字符串之间转换

1.字符串–>基本数据类型

通过 包装类名.parseXXX(字符串) 方法

String s = "500";
int i = Integer.parseInt(s);
输出：500

2.字符串–>包装类

• 通过构造方法转换

String s = "500";
Integer i = new Integer(s);
输出：500
System.out.println(i + 1);
输出：501
注：整数类型包装类可以直接参与运算

• 通过包装类的 包装类名.ValueOf（字符串） 转换

String s = "500";
Integer i = Integer.valueOf(s);
输出：500

注意：字符串 不能 通过以上两种方式转换为Character,但可以转换为字符数组。

String s = "abcd";
char[] arr = s.toCharArray();
for(char c : arr) {
	System.out.println(c);
}

3. 包装类 --> 字符串

通过 toString() 方法

Integer i = new Integer(100);
String s = i.toString();
输出："100"

4. 包装类 --> 基本数据类型

• 包装类通过 包装类对象.xxxValue() 方法转换为基本类型

Integer i = new Integer(100);
int i2 = i.intValue();
输出：100

• 自动拆箱

Integer i = new Integer(100);
int i2 = i;
输出：100

5. 基本数据类型 --> 包装类

• 通过构造器转换

int i = 100;
Integer i2 = new Integer(i);
输出：100

• 自动装箱

int i = 100;
Integer i2 = i;
输出：100

6. 基本数据类型 --> 字符串

通过 “”-- 双引号

int i = 100;
String s = i + "";
输出："100" 

String类

面试题1：String StringBuffer StringBilder的区别？

• String 是内容不可变的字符串
• StringBuffer，StringBuilder内容可变的字符串

面试题2：String的创建对象的区别？

• 静态创建对象:String s = “abc”;
  使用静态方式创建的字符串，在方法区的常量池中只会产生唯一一个字符串对象，使用该方式产生同样一个字符串时，内存中不再开辟另外一块空间，而是两个引用变量指向同一个字符串对象。
• 动态创建对象:String s = new String(“abc”);
  使用动态方式创建的字符串，在堆内存中会产生出不同的对象。

1.String类构造方法

• 使用一个字符数组创建一个String对象

char[] arr = { 'a', 'b', 'c', 'd', 'e' };
String sarr = new String(arr);
输出：abcde

• 通过 字符数组 指定位置，指定个数的元素 去创建String对象
  第一个参数表示起始位置，第二个参数表示个数

char[] arr = { 'a', 'b', 'c', 'd', 'e' };
String sarr = new String(arr, 1, 3);
输出：bcd

• 将StringBuffer对象转换为String对象

StringBuffer sb = new StringBuffer("abc");
String s = new String(sb);
输出：abc

• 将字节数组按照指定的编码形式转换为字符串

byte[] barr = { 2, 3, 4, 5 }; 	
String s = new String(barr,"UTF-8");

2.String类常用方法

• equals()
  比较两个字符串的内容是否相等

String s = "abc";
String s2 = "Abc";
s.equals(s2);
输出：false

• equalsIgnoreCase()
  比较两个字符串的内容是否相等，忽略大小写

String s = "abc";
String s2 = "Abc";
s.equalsIgnoreCase(s2);
输出：true

• toUpperCase()
  将String对象中的所有字符都转换为大写

String s = "abc";
s.toUpperCase();
输出："ABC"

• charAt()
  回指定索引处的 char 值

String s = "abc";
s.charAt(1)
输出："b"

• substring(a)
  返回一个新字符串，该字符串是从begin开始的字符串的内容(截取)

String s = "abcdecfgh";
s.substring(2);
输出："cdecfgh"

• substring(a,b)
  返回一个新字符串，该字符串是从begin开始到end-1结束的字符串的内容

String s = "abcdecfgh";
s.substring(2,5);
输出："cde"
理解：5-2=3,所以字符串长度为3，不包含end位置字符

• indexOf()
  返回指定字符在此字符串中第一次出现处的索引

String s = "abcdecfgh";
s.indexOf('c');
输出：2

• lastIndexOf()
  返回指定字符在此字符串中最后一次出现处的索引

String s = "abcdecfgh";
s.lastIndexOf('c');
输出：5

• indexOf()
  从指定的索引开始搜索，返回在此字符串中第一次出现指定字符串处的索引

String s = "abcdecfgh";
s.indexOf('c',0);
输出：2

• lastIndexOf()
  从指定的索引开始搜索，返回在此字符串中最后一次出现指定字符串处的索引

String s = "abcdecfgh";
s.lastIndexOf('c',3);
输出：2

• trim()
  去除字符串两端空格

String s = " ab c "
s.trim();
输出："ab c"

• length()
  返回此字符串的长度

String s = " ab c ";
s.length();
输出：6

• concat()
  将指定字符串连接到此字符串的结尾(拼接)

String s1 = "abc";
String s2 = "haha";
String concat = s1.concat(s2);
输出："abchaha"

• split()
  根据给定正则表达式的匹配拆分此字符串(切割)

String s1 = "a,b,c,d";
String [] s2 = s1.split(",");
输出：{a,b,c,d}

• replace()
  字符替换

String s1 = "abcdefg";
String replace = s9.replace('d','@');
输出："abc@efg"

• replaceAll()
  字符串替换

String s1 = "13399995555";
String replace = s9.replaceAll("9999","****");
输出："133****5555"

• startsWith()
  测试此字符串是否以指定的前缀开始

String s1 = "abcdefg";
boolean b = s1.startsWith("abc");
输出：true

• endsWith()
  测试此字符串是否以指定的前缀开始

String s1 = "abcdefg";
boolean b = s1.endsWith("abc");
输出：false

String与字符数组的转换

byte[] bname = new byte[10];
String sname = "张三";
try {
	// 字节数组->字符
	String name2 = new String(bname, "utf-8");
	System.out.println(name2);

	// 字符->字节数组
	byte[] name3 = sname.getBytes("utf-8");

	for (byte b : name3) {
		System.out.print(b);
	}
} catch (Exception e) {

}

StringBuffer类

• 创建StringBuffer对象

StringBuffer sb = new StringBuffer();

• 指定初始容量创建StringBuffer对象

StringBuffer sb = new StringBuffer(10);

• 字符串转换为StringBuffer

StringBuffer sb = new StringBuffer("abc");

注意：StringBuffer没有重写equals方法

StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb1.equals(sb2));
输出： false

StringBuffer常用方法

• length();
  返回长度（字符数）

StringBuffer sb = new StringBuffer("abc");
sb.length();
输出: 3

• reverse();
  反转

StringBuffer sb = new StringBuffer("abc");
sb.reverse();
输出sb: "cba"

• setCharAt();
  将给定索引处的字符设置为’#’(替换，修改)

StringBuffer sb = new StringBuffer("abc");
sb.setCharAt(1,'#');
输出sb: "a#c"

• delete()
  移除此序列的子字符串中的字符(删除)

StringBuffer sb = new StringBuffer("abcdefg");
sb.delete(2, 4);//从2开始，到4-1结束
输出sb："abefg"

• charAt()
  返回此序列中指定索引处的 char 值

StringBuffer sb = new StringBuffer("abefg");
char charAt = sb.charAt(0);
输出charAt：'a'

• toString()
  将StringBuffer对象转换成相应的String

StringBuffer sb = new StringBuffer("abefg");
String string = sb.toString();
输出string："abefg"

• append()
  将指定的字符串追加到此字符序列

StringBuffer sb1 = new StringBuffer("abefg");
StringBuffer sb2 =  sb1.append(1);
输出sb2:"abefg1"

• insert()
  将字符串插入此字符序列中

StringBuffer sb1 = new StringBuffer("abefg");
StringBuffer sb2 =  sb1.insert(1, "@@@");
输出sb2:"a@@@befg"

StringBuilder类

StringBuilder类方法与StringBuffer 基本相同，区别在以下几点：
1.StringBuffer类是线程安全的
2.StringBuilder类是线程不安全的
3.StringBuffer在JDK1.0中就有，而StringBuilder是在JDK5.0后才出现的。
4.StringBuilder的一些方法实现要比StringBuffer 快 些。
问题：如何理解线程安全与线程不安全？
答：在StringBuffer和StringBulifer中都有添加（append（）），删除（delete（）），插入方法（insert（）），
当多线程同时操作添加和删除或插入方法时，StringBulider会出现错误，而StringBuffer不会。

Math类

/属性
Math.PI;

/math常用方法
/求绝对值
Math.abs(-1);

/返回大于所给参数的最小整数值(向上取整)
Math.ceil(3.12);

/返回不大于所给参数的最大的整数值(向下取整)
Math.floor(3.12);

/返回两个值中较大的一个
Math.max(1, 3);

/返回两个值中较小的一个
Math.min(1, 3);

/返回0.0-1.0之间的随机的double值
Math.random();
int n = (int) Math.ceil(Math.random()*10);

/四舍五入
Math.round(3.46);

/三角函数
Math.sin(Math.PI/2);

/求平方根
Math.sqrt(4);

Date类

• 获取当前日期

Date d = new Date();
输出d:Sat Aug 07 12:23:57 CST 2021

• 将日期转换为字符串：format（）

Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String format = sdf.format(d);
输出format:2021-08-07 12:23:57

• 将字符串转换为日期：parse()

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String s = "2021-08-07 12:32:10";
try{
	Date d = sdf.parse(s);
}catch(ParseException e){
	e.printSrackTrace();
}
输出d：Sat Aug 07 12:32:10 CST 2021

• 获取指定日期

Date d = new Date(121,5,6);
输出d：Sun Jun 06 00:00:00 CST 2021

注意：
第一个参数年：目标年数-1900
第二个参数月：目标月数-1

• 测试此日期是否在指定日期后：after（）

Data d1 = new Date();
Date d2 = new Date(121,5,6);
boolean b = d1.after(d2);
输出b ：true

• 测试此日期是否在指定日期前：before(）

Data d1 = new Date();
Date d2 = new Date(121,5,6);
boolean b = d1.before(d2);
输出b ：false

• 比较：compareTo（）

Data d1 = new Date();
Date d2 = new Date(121,5,6);

int i1 = d1.compareTo(d2);
输出i1:1   //d1>d2,i1>0

int i2 = d2.compareTo(d2);
输出i2:0   //d2=d2,i2=0

int i3 = d2.compareTo(d1);
输出i3:-1  //d2<d1,i3<0

Calendar类

• Calendar是抽象类

Calendar instance = Calendar.getInstance();

• 设置时间

instance.set(2021, 8, 6);

• 获取时间

instance.get(Calendar.YEAR);
instance.get(Calendar.MONTH);
instance.get(Calendar.DAY_OF_MONTH);