Java常用类

Java常用类

Object类

toString方法

源码分析：

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
1
2
3

toString 用于返回该对象的字符串表示，它的值等于：getClass()+’@’+Interger.toHexString(hashCode()) 。

由于 toString 方法返回的是内存的地址，实际开发中没太大意义，所以我们需要重写 toString 方法。

我们可以使用快捷键 alt + shift + s 自动生成 toString 重写方法：

@Override
	public String toString() {
		return "Student [age=" + age + ", name=" + name + "]";
	}
1
2
3
4

也可以按照这个格式自己写。

注意事项：
(1) 重写 Object 类中的 toString 方法，让其返回成员信息
(2) 在输出语句中，直接写入一个对象，会默认调用 toString 方法

System.out.println(stu.toString());
System.out.println(stu);				//二者结果相同
1
2

eauals方法

1.关于 “==” ：

• 如果是基本数据类型，比较的是值是否相等。

• 如果是引用数据类型，比较的是地址值是否相等。

2.equals 方法默认比较的是地址值！

Student stu = new Student();
Student stu2 = new Student();
System.out.println(stu.equals(stu2));		//打印结果：false
1
2
3

3.由于比较地址值意义不大，所以我们需要重写该方法

我们依旧可以通过快捷键 alt + shift + s 重写 equals 方法。

@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;		//obj参数进行向下转型
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return 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
25
26

4.String类型的 equals 方法已经被重写，默认比较的是字符串的值。

Object 类没有 length() 方法！，若想使用 length() 方法，必须向下转型成 String 类型，即：

String s = (String) obj;
1

String类

String 类代表字符串，Java程序中所有字符串字面值都作为此类的实例实现。字符串是常量，一旦创建就不能改变，字符串本身是不能改变的，但存放字符串的地址可以改变，引用变量指向的内存可以改变。

String str1 = "qwer";
String str2 = new String("qwer");
System.out.println(str1 == str2);    //false
System.out.println(str1.equals(str2));    //true
1
2
3
4

• String str1 = "qwer"; ===>在内存中只有一个对象，这个对象在字符串常量池中
• String str2 = new String("qwer"); ===>在内存中有两个对象，一个对象是在堆中的new String()，另一个对象是字符串 “qwer”本身对象，在字符串常量池中
• str1 == str2; 为 false 是因为引用类型比较的是地址，肯定不同
• str1.equals(str2); 为 true 是因为String类将equals方法进行了重写，建立了字符串自己的判断依据，通过字符串对象中的字符来判断

String 类的字符串的长度

• str.length()：返回str字符串长度
• str.substring(int beginIndex)：返回一个新字符串，内容为指定位置开始到字符串末尾的所有字符
• str.substring(int beginIndex,int endIndex)：返回一个新字符串，内容为指定位置开始到指定位置结束所有字符
• String.valueOf()：将括号中的类型转化为字符串类型

如：

String str = "abcdef";
int len = str.length();    //返回字符串长度
String s1 = str.substring(1); //返回一个新字符串，内容为指定位置开始到字符串末尾的所有字符
String s2 = str.substring(2, 4);//返回一个新字符串，内容为指定位置开始到指定位置结束所有字符
1
2
3
4

StringBuffer类

StringBuffer 又称为可变字符序列，它是类似于 String 的字符串缓冲区，通过某些方法调用可以改变的该序列的长度和内容。其实StringBuffer是一个字符串的缓冲区，就是个容器，容器中可以装很多个字符串，并且能够对其中的字符串进行各种操作。

StringBuffer 常用方法使用

• append(String str)：将制定字符串追加到此字符序列
• delete（int star，int end）：移除指定字符串
• insert(int offset，String str)：在指定位置插入
• replace(int star，int end，String str)：替换指定范围的内容
• reverse()：将字符序列反转
• toString()：返回此序列中数据的字符串表示形式
• substring(int star，int end)：从指定位置开始到指定位置结束，截取该字符串缓冲区，返回新字符串

逻辑实例：

//创建一个字符串缓冲区对象，用于存储数据
StringBuffer sb = new StringBuffer();
sb.append("qwert");    //添加字符串
sb.insert(2,"as");    //在指定位置插入
sb.delete(1,4);    //删除
sb.replace(1,4,"dfs");    //替换指定范围内的内容
String str = sb.toString();    //返回此序列中数据的字符串表示形式
1
2
3
4
5
6
7

注：append、delete、insert、replace、reverse方法调用后，返回值都是当前对象自己

String 和 StringBuffer 的相互转换

String ----> StringBuffer

方法一：构造方法：

String str = "test";
StringBuffer sb = new StringBuffer(sb);
System.out.println(sb);
1
2
3

方法二：通过append方法：

String str = "test";
StringBuffer sb = new StringBuffer();
sb.append(sb);
System.out.println(sb);
1
2
3
4

StringBuffer ----> String

方法一：构造方法：

StringBuffer sb = new StringBuffer();
sb.append("test");
String str = new String(sb);
System.out.println(str);
1
2
3
4

方法二：通过toString方法

StringBuffer sb = new StringBuffer();
sb.append("test");
String str = sb.toString();
System.out.println(str);
1
2
3
4

StringBuilder类

StringBuilder 类是字符串缓冲区，是一个可变的字符序列，该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类，因为大多数实现中，它比 StringBuffer 要快。

String、StringBuffer、StringBuilder的区别

1.String 是内容不可变的，而 StringBuffer、StringBuilder 都是内容可变的。

2.StringBuffer 是同步的，数据安全但效率低；StringBuilder 是不同步的，数据不安全，效率高。（相对于多线程来说）

StringBuffer和数组的区别

二者都可以看成一个容器装其他的数据。

StringBuffer 的数据最终是一个字符串数据，，而数组可以放置多种数据，但必须是同一种数据类型的。

包装类

着重讲解 Integer ，其他的类似。

String 转为 int

Integer 的 parseInt 方法：

String name = "1111";
int x = Integer.parseInt(name);
System.out.println(x);
1
2
3

其他引用类型也可使用 parseXxx 方法将字符串类型转为对应的数据类型。

进制转换

十进制到其他进制：Integer.toString();

实例：

System.out.println(Integer.toString(100,2));		//将100转换为二进制
System.out.println(Integer.toString(100,8));		//将100转换为八进制
System.out.println(Integer.toString(100,10));		//将100转换为十进制
System.out.println(Integer.toString(100,16));		//将100转换为十六进制
1
2
3
4

其他进制到十进制：Integer.parseInt;

实例：

System.out.println(Integer.parseInt("100", 2));				//二进制的100转换成十进制
System.out.println(Integer.parseInt("100", 8));				//八进制的100转换成十进制
System.out.println(Integer.parseInt("100", 10));			//十进制的100转换成十进制
System.out.println(Integer.parseInt("100", 16));			//十六进制的100转换成十进制
1
2
3
4

自动装箱和自动拆箱

JDK5 的新特性：自动装箱和自动拆箱

自动装箱：把基本类型转换为包装类类型

自动拆箱：把包装类类型转换为基本类型

Integer i = 10;		//原来的程序：Integer i = new Integer(10);		自动装箱
int x = i;			//自动拆箱
System.out.println(i);
1
2
3

在使用上述方法时应注意：加上一个条件：

if(i != NULL){
    xxxx
}
1
2
3

面试题

Integer i = num;

针对-128到127之间的数据有一个数据缓冲池，如果这个 num 的值的范围是-128到127之间，每次并不创建新的空间，而在i >= 128 || i < -128是会创建不同的对象。

public class Main {
	public static void main(String[] args) {
    	Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;
        System.out.println(i1==i2);  //true
        System.out.println(i3==i4);  //false
     }
 }
1
2
3
4
5
6
7
8
9
10

其他类型见表：

Character包装类

Character 包装类主要用于判断大写字符、小写字符以及数字的个数。

判断大写字符：Character.isUpperCase(ch)

判断小写字符：Character.isLowerCase(ch)

判断数字：Character.isDight(ch)

实例：

public class demo1 {
	public static void main(String[] args) {
		int BigCount = 0;
		int SmallCount = 0;
		int NumberCount = 0;
		Scanner scan = new Scanner(System.in);
		String str = scan.nextLine();
		char[] ch = str.toCharArray();
		for(int i = 0;i < ch.length;++i) {
			if(Character.isUpperCase(ch[i])) {
				BigCount++;
			}else if(Character.isLowerCase(ch[i])) {
				SmallCount++;
			}else if(Character.isDight(ch[i]))
				NumberCount++;
		}
		System.out.println("大写字符个数：" + BigCount);
		System.out.println("小写字符个数：" + SmallCount);
		System.out.println("数字个数：" + NumberCount);
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

正则表达式

正则表达式：符合一定规则的字符串。

校验功能

String.matches(regex)，返回值是 boolean 类型。

1.字符：

​ x 字符x。举例：‘a’ 表示字符 a 。

​ // 反斜线字符。

​ \n 换行符（’\u000A’）

​ \r 回车符（’\u000D’）

2.字符类

​ [abc] a、b 或 c

​ [a - zA - Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）

​ [0 - 9] 0 到 9 的字符都包括

3.预定义字符类

​ . 任何字符（若原字符就是 . 则为\.）

​ \d 数字：[0 - 9]

​ \w 单词字符：[a - zA-Z_0 - 9]

4.边界匹配器

​ ^ 行的开头

​ $ 行的结尾

​ \b 单词边界：就是不是单词字符的地方，如空格、?、; 等等。

5.数量词

​ X? X 一次或一次也没有

​ X* X 零次或多次

​ X+ X 一次或多次

​ X{n} X 恰好 n 次

​ X{n, } X 至少 n 次

​ X{n, m} X 至少 n 次，但不超过 m 次

若没有给定次数，默认为一次。

public class demo2 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		String str = scan.nextLine();
		String regex = "1[38]\\d{9}";
		boolean flag = str.matches(regex);
		System.out.println(flag);
	}
}
1
2
3
4
5
6
7
8
9

分割功能

根据给定正则表达式的匹配拆分此字符串。

String类的public String[] split(String regex)

public class demo2 {
	public static void main(String[] args) {
		String str = "19-24";
		String regex = "-";
		String[] str1 = str.split(regex);
		Scanner scan = new Scanner(System.in);
		String s = scan.nextLine();
		int age = Integer.parseInt(s);
		int ageStart = Integer.parseInt(str1[0]);
		int ageEnd = Integer.parseInt(str1[1]);
		if(age >= 19 && age <=24) {
			System.out.println("Yes!");
		}else
			System.out.println("No!");
		
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

替换功能

使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

String 类的 public String replaceAll(String regex, String replacement)

public class demo3 {
	public static void main(String[] args) {
		String str = "hellojavaqq724520362ip17766666world!";
		String regex = "\\d";
		String replacement = "*";
		System.out.println(str.replaceAll(regex, replacement));
	}
}
1
2
3
4
5
6
7
8

获取功能

Pattern 和 Matcher

public class demo4 {
	public static void main(String[] args) {
		String str = "ab cd efg ahcd auot ahut zy 123 qwer 666";
		String regex = "\\b\\w{3}\\b";
		//把规则编译成模式对象
		Pattern p = Pattern.compile(regex);
		//通过模式对象得到匹配器对象
		Matcher m = p.matcher(str);
		//通过 find 方法查找有没有符合条件的子串		public boolean find();
		//调用 group 之前必须先调用 find ！ 
		while(m.find()) {
			System.out.println(m.group());
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15