1、String、StringBuffer与StringBuilder的区别

1.1、String类

分析源码可知,String对象的内容是存储在一个char数组中,且这个数组使用final修饰,这也是String对象不可变的原因。当进行字符串拼接时,虚拟机会新建一个字符串对象,然后将新的字符串对象赋值给原来的引用,而不是真的修改了原来字符串对象的值。

字符串重写了Object父类的equals方法。

1.2、StringBuffer类和StringBuilder类

这两个类均继承于AbstractStringBuilder类,但分析源码可知StringBuffer的方法都添加了synchronized关键词进行修饰,所以StringBuffer是线程安全的,而没有使用synchronized修饰方法的StringBuilder是线程不安全的,但StringBuilder的速度要远远高于StringBuffer,所以在能保证线程安全的情况下,StringBuilder的优先级要高于StringBuffer。

1.3、总结

  • String是一个final修饰的类,所有的属性也是final的,所以String具有不可变性,也就是对字符串的操作,如拼接、剪切都会产生新的String对象。
  • StringBuffer本质是一个线程安全的可修改字符串序列。因为保证线程安全,所以会带来额外的性能消耗。
  • StringBuilder本质上和StringBuffer没有区别,但是StringBuilder去掉了线程安全部分提高了操作效率,是绝大部分情况下字符串拼接的首选。
  • 如果确定拼接字符串会发生多次,并且长度可预计,那么可以在开始的时候指定合适的大小,避免数组扩容造成的开销。

2、找出字符串中出现最多次的字符和出现的次数

遍历字符串,并使用一个HashMap来存储出现字符及出现的次数,以字符为key,次数为value。解题思路如下

  • 假定字符串中出现最多的字符maxCode为当前字符串的第一个元素,出现次数maxCount初始化为0

  • 遍历字符串,判断当前字符是否在hashmap的key中,如果包含,令次数+1,否则将该字符为key,1为value放入hashmap中

  • 判断maxCount和当前字符出现次数的关系,如果maxCount小于当前字符出现次数,就令maxCode = 当前字符,然后更新maxCode,最后返回maxCode和maxCount即可。

代码实现

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
/***
* 找出字符串中出现最多次的字符和出现的次数
* @param str 目标字符串
* @return 以maxCode为键、maxCount为值的map
*/
public static Map<Character, Integer> findMostCodeAndCount(String str) {
char maxCode = str.charAt(0);
int maxCount = 0;
Map<Character, Integer> map = new HashMap<>();
for (int i = 0; i < str.length(); i++) {
Character currentCode = str.charAt(i);
Integer count = map.get(currentCode);
if(count == null) {
count = 1;
} else {
count++;
}
map.put(currentCode, count);
if(maxCount < count) {
maxCode = currentCode;
maxCount = count;
}
}
Map<Character, Integer> result = new HashMap<>();
result.put(maxCode,maxCount);
return result;
}

测试代码及结果

1
2
3
String str = "abcacba";
Map result = findMostCodeAndCount(str);
System.out.println(result);
  • 结果

image-20210129152842664

3、找出字符串中第一次重复出现的字符

使用一个HashSet来解决问题,由于Set有不允许元素重复的性质,Set的add方法在添加重复值是会返回false,所以我们可以用这个性质来判断元素是否重复。

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/***
* 找出字符串中第一次重复出现的字符
* @param str 目标字符串
* @return 返回第一次重复的字符
*/
public static Character getFirstRepeat(String str) {
Set<Character> set = new HashSet<>();
Character result = null;
for (int i = 0; i < str.length(); i++) {
Character currentCode = str.charAt(i);
if(!set.add(currentCode)) {
result = currentCode;
break;
}
}
return result;
}

测试代码和结果

1
2
3
String str = "abcacba";
Character result = getFirstRepeat(str);
System.out.println(result);
  • 结果

image-20210129152855053

4、两个大数之和

题目描述:现在有两个数,位数均超过1000位,例如

  • String a = “123343432…”

  • String b = “3974928374928…”

这两个大数无法转换为Integer计算,所以我们使用两个数组来存储这两个数,然后进行计算。

解题思路如下

  • 设这两个数中大的数的位数位m,则结果的最大位数位m+1
  • 用一个int数组来存储结果

代码实现

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
/***
* 编程两个大数之和
* @param num1
* @param num2
* @return
*/
public static String sumOfBigNum(String num1,String num2) {
char[] largeArray = null;
char[] smallArray = null;
if(num1.length() >= num2.length()) {
largeArray = num1.toCharArray();
smallArray = num2.toCharArray();
} else {
largeArray = num2.toCharArray();
smallArray = num1.toCharArray();
}
int[] res = new int[largeArray.length + 1];
for (int i = 0; i < largeArray.length; i++) {
res[i] = largeArray[largeArray.length - i - 1] - '0';
}
for (int i = 0; i < smallArray.length; i++) {
res[i] += smallArray[smallArray.length - i - 1] - '0';
}
for (int i = 0; i < res.length - 1; i++) {
if(res[i] > 9) {
res[i + 1] += res[i] / 10;
res[i] %= 10;
}
}
StringBuilder stringBuilder = new StringBuilder();
for (int i = res.length - 1; i >= 0; i--) {
stringBuilder.append(res[i]);
}

String result = stringBuilder.toString();
if(result.startsWith("0")) {
result = result.substring(1);
}
return result;
}

测试代码和结果

1
2
3
4
5
6
7
String num1 = "12345";
String num2 = "56756";
Integer n1 = Integer.valueOf(num1);
Integer n2 = Integer.valueOf(num2);
Integer sum = n1 + n2;
System.out.println("计算机计算结果为:" + sum);
System.out.println("函数计算结果位:" + sumOfBigNum(num1,num2));
  • 结果

image-20210129152910086