Java刷题问题笔记

本文档主要记录刷题过程中遇到的 Java 语言中的种种问题，比较杂乱。

1. Array.sort 如何根据字符串长度排序？

这里的知识点包括：

  1. Arrays.sort() 函数。其第一个参数是要排序的数组，第二个参数是比较方法。
  2. lambda 表达式。其形式为 (参数) -> 逻辑表达式。
  3. Integer.compare() 函数。
  4. String 类的长度是用的 String,length() 方法。
Arrays.sort(words, (a, b) -> Integer.compare(a.length(), b.length()));

2. 如何判断 stringA 是不是 stringB 的子串？

这里的知识点包括：

  1. String.contains() 方法可以直接用于判断 String 对象是否为子串。
StringA.contains(stringB) == true;

3. 如何判断 intA 在不在 listB 数组内？

这里的知识点包括：

  1. List.indexOf() 方法可以用于判断数是不是在 List 对象内。
listB.indexOf(intA) != -1;

4. 如何求 listA 内的最小值？

这里的知识点包括：

  1. List 没有直接对应的 min，需要先转换为 ArrayList。
  2. Collections.min() 可以获取最小值。
  3. List 转换为 ArrayList，需要先 new 一个新的 ArrayList。
  4. Arrays.asList() 可以配合 ArrayList() 方法，将 List 转换为 ArrayList。
ArrayList<Integer> arrayListB = new ArrayList<>(Arrays.asList(listA));
int minValue = Collections.min(arrayListB);

5. 如何格式化输出？

这里的知识点包括：

  1. 不能直接使用 println 进行输出，需要使用 printf 才能格式化输出。
System.out.printf("%s, %s %n", a, b);

6. 如何遍历 hashMapA？

这里的知识点包括：

  1. HashMap.Entry<A, B> entryB 可以构建迭代器元素 entryB。
  2. HashMap.entrySet() 方法可以提供迭代遍历。
  3. entry.getKey()，entry.getValue() 方法可以获取键和值。
for (HashMap.Entry<Integer, String> entryB : hashMapA.entrySet()) {
    if (entryB.getKey() == C && entryB.getValue() == D) {
        ...
    }
}

7. 如何正序、逆序排序？

这里的知识点包括：

  1. Collections.sort() 方法提供集合类正序排序。
  2. Collections.reverse() 方法可以将排序好的集合类进行逆序。
  3. 如果嫌两句话麻烦，也可以在 Collections.sort() 方法的第二个参数写上 Collections.reverseOrder()。
  4. Arrays.sort() 方法提供数组正序排序。
  5. 如果要对 Arrays 进行逆序排序，可以用流式操作：int[] nums = {1,2,3}; nums = IntStream.of(nums).boxed().sorted(Comparator.reverseOrder.mapToInt(Integer::intValue).toArray();
Collections.sort(arrayListA);
Collections.reverse(arrayListA);
Collections.sort(arrayListA, Collections.reverseOrder());
Arrays.sort(arrayB);
arrayB = IntStream.of(arrayB).boxed().sorted(Comparator.reverseOrder()).mapToInt(Integer::intValue).toArray();

8. 如何获取 stringA 中位置 intB 的 charC？

这里的知识点包括：

  1. String.charAt() 方法可以获取指定位置的 char 值。
char charC = stringA.charAt(intB);

9. 如何方便处理字符串 stringA 内字符？

这里的知识点包括：

  1. 可以上来就将 stringA 转换为字符数组。
  2. String.toCharArray() 方法可以将字符串转换为字符数组。
  3. Character.isLetter() 方法可以判断指定字符是否为字母。
  4. 类似的，Character.isDigit() 方法可以判断指定字符是否为数字。
char[] charListB = stringA.toCharArray();
char charC = stringA.charAt(0);
boolean flag1 = Character.isLetter(charC);
boolean flag2 = Character.isDigit(charC);

10. 如何区分 length, length() 和 size()?

这里的知识点包括：

  1. length 是 Array 类的属性。
  2. length() 是 String 类的方法。
  3. size() 是 Collections 类的方法。
int lengthA = listA.length;
int lengthB = stringB.length();
int lengthC = arrayListC.size();

11. 如何判断 hashSetA 是否含有 stringB 对应 intC 位置的字符？

这里的知识点包括：

  1. HashSet.contains() 可以判断是否有指定内容。
  2. String.charAt() 可以获取指定位置的字符。
if (hashSetA.contains(stirngB.charAt(intC)));

12. 如何根据 listA 快速构建 listB？

这里的知识点包括：

  1. Arrays.copyOf() 方法可以从现有数组中选择一部分，构建新数组。
  2. 第二个参数为数组长度。
int[] listB = Arrays.copyOf(listA, k);

13. 如何用 PriorityQueue 实现大根堆 queueA？

这里的知识点包括：

  1. PriorityQueue 默认是小根堆，大根堆需要重写比较器。
  2. 可以在 new PriorityQueue<>() 中的参数部分加入比较器。
  3. 具体写法是：(v1, v2) -> v2 - v1。
  4. Queue 类的输入是 offer() 方法，弹出是 poll() 方法。
Queue<Integer> queueA = new PriorityQueue<>((v1, v2) -> v2 - v1);
queueA.offer(1);
queueA.poll();
queueA.size();

14. 如何用 TreeMap 实现二叉搜索树 treeA？

这里的知识点包括：

  1. TreeMap 和 TreeSet 都可以实现二叉搜索树。
  2. TreeMap 适合有重复数字的二叉搜索树。
  3. TreeMap 类的输入和修改 value 是 put() 方法，弹出是 pollLastEntry() 方法。
  4. TreeMap.getOrDefault() 方法很有趣，包括两个参数，尝试获取对应 key 的 value，如果没有，则填上默认 value。
  5. TreeMap.lastEntry() 方法可以获取最大元素键值对。
  6. TreeMap.Entry<> 对应的是键值对元素。
TreeMap<Integer, Integer> treeA = new TreeMap<>();
treeA.put(1, map.getOrDefault(1, 0) + 1);
treeA.Entry<Integer, Integer> entry = treeA.lastEntry();
if (entry.getKey() > 10) {
    map.pollLastEntry();
} else {
    map.put(entry.getKey(), entry.getValue() - 1);
}

15. 如何通过函数交换数组 listA 元素 intB 和 intC？

这里的知识点包括：

  1. 交换函数必须传入数组引用。
  2. 没有数组引用，就不能完成数组元素交换。
public static void swap(int[] listA, int intB, int intC) {
    int intD = intB;
    intB = intC;
    int C = intD;
}
swap(listA, intB, intC);

16. 如何通过 StringBuilder 构建字符串 stringA？

这里的知识点包括：

  1. Java 的 String 无法直接修改，必须通过 StringBuilder之类才能修改。
  2. StringBuilder.append() 方法可以加入要添加的字符串。
  3. StringBuilder.toString() 方法可以获取最终需要的字符串。
StringBuilder stringA = new StringBuilder();
stirngA.append("Hello");
stringA.append("world");
return stringA.toString();

17. 如何将 arrayListA 转换为 listB？

这里的知识点包括：

  1. Java8 提供的流可以实现转换。
  2. ArrayList.stream().mapToInt(Integer::intValue).toArray() 可以实现类型转换。
int[] listB = arrayListA.stream().mapToInt(Integer::intValue).toArray();

18. 如何将二维数组 matrixA 按照内部一维数组排序？

这里的知识点包括：

  1. 可以通过重写 Arrays.sort() 的第二个参数 new Comparator<int[]>() {} 实现排序规则。
  2. 内部写法：@Override public int compare(int[] o1, int[] o2) {}。
Arrays.sort(matrixA, new Comparator<int[]>() {
    @Override
    public int compare(int[] o1, int[]o2) {
        if (o1[0] != o2[0]) {
            return o1[0] - o2[0];
        } else {
            return o1[1] - o2[1];
        }
    }
});

另一种更简洁的写法：

Arrays.sort(matrixA, (o1, o2) -> {
    if (o1[0] != o2[0]) {
        return o1[0] - o2[0];
    } else {
        return o1[1] - o2[1];
    }
});

19. 如何实现返回值类型为 List<List\> 的数组 listA?

这里的知识点包括：

  1. 可以将外部的 List 转换为 ArrayList，但内部的必须要实现时才能转换为 ArrayList。
  2. 外部写法：List<List\> listA = new ArrayList\<List\>。
  3. 也可以简写成：List<List\> listA = new ArrayList\<>。
List<List<String>> listA = new ArrayList<>();
List<String> listB = new ArrayList<>();

20. 如何获取 charA 的 ASCII 码？

这里的知识点包括：

  1. Integer.valueOf(charA) 可以获取 charA 的 ASCII 码。
  2. 将字符转换为数字，还可以用这样的表达方式：charA - 'A'，将大写字母转换为 0-26 的数字。
  3. 获取 charA 和 charB ASCII 码的差值，还可以直接 Math.abs(charA - charB)。

21. 如何正确使用 Collections.toArray() 和 Arrays.asList()？

这里的知识点包括：

  1. Collections.toArray() 用于将集合转换为数组。包括三种用法。
  2. Arrays.asList() 用于将数组转换为集合。包括两种用法。
  3. 注意：Arrays.asList() 仅适用于包装类！
// Collections.toArray() 用法：
Integer[] array = new Integer[list.size()];
list.toArray(array); // 用法1：list.toArray(目标数组)
array = list.toArray(new Integer[0]); // 用法2：a = list.toArray(new Type[0]) 利用 new Type[0] 转换 Object 类型
array = list.toArray((Integer[]) new Object(list.size)) // 用法3：a = list.toArray((Type[]) new Object(list.size())) 利用 (Type[]) 强制类型转换
//Arrays.asList() 用法：
Integer array = {1, 2, 3}; // 源数组必须为包装类数组
List<Integer> list = Arrays.asList(array); // 用法1：直接调用 Arrays.asList()
List<Integer> list = new ArrayList<>(Arrays.asList(array)); // 用法2：利用 new Type<>() 修改 Arrays.asList 的类型

22. 如何逆序排序 arrayListA 和 arrayB?

这里的知识点包括：

  1. Collections 元素可以用 Collections.sort(arrayListA, Collections.reverseOrder());
  2. Collections 元素也可以排序后，使用 Collections.reverse(arrayListA);
  3. Arrays 元素可以用 Arrays.sort(arrayB, Collections.reverseOrder());
  4. 注意：想使用逆序排序的 Arrays 元素必须是包装类型的才能调用 Collections.reverseOrder()。可以建两个数组，一个逆序用，一个赋值用。

23. 如何将 queueA 转换为 arrayListB？

这里的知识点包括：

  1. 由于 queueA 和 arrayListB 都是 List 下的对象数组，所以可以直接转换。
arrayListB = new ArrayList<>(queueA);

24. 如何从字符串 stringA 中截取 stringB?

这里的知识点包括：

  1. 可以通过 new String(string, left, right) 的初始化方法获取子串。

  2. 也可以通过 String.substring(left, right) 方法获取子串。

stringB = new String(stringA, left, right);
stringC = stringA.substring(left, right);

25. 如何将字符类型 charA 转换为整数类型 intB？

这里的知识点包括：

  1. 应该明确，强制类型转换是 (int) 而不是 int()。不要用错了

  2. 如果直接用 (int) 进行强制类型转换的话，获取到的是 ASCII 码，而不是字符代表的数字。

  3. 因此，可以用 intB = charA - '0' 这种方式，获取整型代表的数字。

26. 如何区分 >> 和 >>> 运算符？

这里的知识点包括：

  1. >> 算数右移：舍弃最低位，最高位用符号填补。

  2. >>> 逻辑右移：舍弃最低位，最高位用 0 填补。

  3. 在部分移除最低位 1 的运算中，不能用 >>，而应该用 >>>。否则会出现死循环。

27. 如何实现 Collections 的内部转换，如 setA 转换为 arrayListB？

这里的知识点包括：

  1. Collections 内部转换，可以直接用相应的 new 方法进行转换。
List arrayListB = new ArrayList<>(setA);

28. 如何获取 arrayA 的最大值和总和？

这里的知识点包括：

  1. 可以利用 Java8 的新方法：Arrays.stream。

  2. 获取最大值：max().getAsInt()。

  3. 获取总和：sum()。

max = Arrays.stream(arrayA).max().getAsInt();
sum = Arrays.stream(arrayA).sum();

29. 如何取整？

这里的知识点包括：

  1. 可以利用 (int) 进行强制类型转换。Java 的强制类型转换就是舍去小数点后面的内容，也就是保留整数。

  2. 也可以用 Math 对应函数。包括 Math.floor(), Math.ceil 和 Math.round()。

a = Math.floor(f)
b = Math.ceil(f)
c = Math.round(f)

30. 如何获取输入？

这里的知识点包括：

  • 有三种方法：in/out 方法、替换系统流方法、Scanner 方法。

  • in/out 方法：只能获取一个 char 类型的。

  • System.out.print("Enter a Character");
char charA = (char)System.in.read();

  • 替换系统流方法：需要 InputStreamReader 和 BufferedReader 配合使用。

  • import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
  • InputStreamReader inputStreamReaderA = new InputStreamReader(System.in);
BufferedReader bufferedReaderA = new BufferedReader(inputStreamReaderA);
try {
  String stringA = bufferedReaderA.readLine();
} catch (IOException e) {
  e.printStackTrace();
}

  • Scanner 方法：使用简便，特别是构造起来简便，可以用字符串、输入流、文件等来构建 Scanner 对象。常用 next 和 nextLine 等方法。

  • import java.util.Scanner;
  • Scanner scannerA = new Scanner(System.in);
String stringA = scannerA.nextLine();
int integerB = scannerA.nextInt();
float floatC = scannerA.nextFloat();

31. 如何初始化获取 hashMapA？

这里的知识点包括：

  • 可以通过 new HashMap<>() {{ put() }} ，实现 hashMapA 的初始化。

  • Map hashMapA = new HashMap<>() {{
      put('I', 1);
      put('V', 5);
      put('X', 10);
      put('L', 50);
      put('C', 100);
      put('D', 500);
      put('M', 1000);
  }};

32. 如何对两个数 num1 和 num2 的每一位进行比较？

这里的知识点包括：

  • 可以首先异或操作，然后通过位移和与操作判断对应位是否相等。

  • int res = 0, val = num1 ^ num2;
while (val != 0) {
  res += val & 1;
  val >>= 1;
}
return res;

33. 如何将普通数组 arraysA 转换为包装类数组 arraysB？

这里的知识点包括：

  • 许多操作是只适用于包装类的，例如逆序排序，转换为集合类等等。

  • 因此，普通数组 arraysA 转换为包装类数组 arraysB 是十分重要的。

  • 可以用如下操作进行转换：

  • int[] arraysA = new int[]{1, 2, 3};
Integer[] arraysB = Arrays.stream(arraysA).boxed().toArray(Integer[]::new);

34. 如何进行位操作？

这里的知识点包括：

  • 这里总结了各种位操作。

  • int a, b;
int c = (a >> b) & 1; // 获取第 b 位是否为1。
a |= 1 << 5; // 在第五位增加一个1。

35. 如何替换字符串 stringA 中指定位置的字符 charA？

这里的知识点包括：

  • 采用 StringBuffer.replace(i, i + length, String) 可以完成替换。

  • 另一种非常简单的方法：首先字符串转数组，然后替换数组中指定位置的字符，最后返回字符数组生成的新字符串即可。

  • String stringA = "defdef", stringB = "abc";
StringBuffer stringBufferA = new StringBuffer(stringA);
stringBufferA.replace(0, 3, stringB);
stringA = stringBufferA.toString();

char c = "a";
char[] charArrayA = stringA.toCharArray();
charArrayA[0] = c;
stringA = new String(charArrayA);

36. Collections.sort 和 Arrays.sort 的区别在哪？

这里的知识点包括：

  • Collections.sort() 适用于内部采用 Collections 对象的排序。如果比较中使用了 Collections 对象，那也要用 Collections.sort()。比如比较时用了 HashMap.get() 方法，那如果使用 Arrays.sort() 就会报错。

  • 相对的，Arrays.sort() 就适用于内部采用普通数组的排序。

  • char[] array = s.toCharArray();
map = new HashMap<>();
for (char c : array) {
  map.put(c, map.getOrDefault(c, 0) + 1);
}
List list = new ArrayList<>(map.keySet());
// 这里就不能采用 Arrays.sort(array, (a, b) -> map.get(b) - map.get(a))
// 因为 map 是 Collections 对象
Collections.sort(list, (a, b) -> map.get(b) - map.get(a));

37. 字符串如何按照字典序排序？

这里的知识点包括：

  • 可以通过重写 Arrays.sort(array, new Comparator() {}) 的方法解决。

  • 也可以通过 lambda 表达式解决。

  • // lambda 表达式方法
Arrays.sort(array, (s1, s2) -> (s1 + s2).compareTo(s2 + s1));

38. 如何返回 List<List<xxx>> 类型？

这里的知识点包括：

  • 左侧保持原类型不变。右侧可以对最外侧的类型进行实例化。

  • List> res = new ArrayList>();
// 也可以简写
List> res = new ArrayList<>();

39. 如何实现 int 和 String 的互相转换？

这里的知识点包括：

  • String 转 int 有两种方式，都是 Integer 的方法。一个是 parseInt(String)，另一个是 valueOf(String).intValue()。

  • int 转 String 有三种方式。一种字符串加 int，一种是 String 的 valueOf(int) 方法，还有一种是 Integer 的 toString(int) 方法。

  • int intA = 99;
String stringB = "100";

// String 转 int
Integer.parseInt(stringB);
Integer.valueOf(stringB).intValue();

// int 转 String
stringB = "" + intA;
String.valueOf(intA);
Integer.toString(intA);

40. 子数组和子序列有什么区别？

这里的知识点包括：

  • 这一点是经常容易弄混的。
  • 子数组要求是连续的。
  • 子序列不要求连续。
  • 这个和并行和并发一样，很容易弄混。
  • img
  • 并发是两个队列交替使用一台咖啡机，并行是两个队列同时使用两台咖啡机。

41. 如何比较对应位？

这里的知识点包括：

  • 可以首先异或操作，然后通过位移和与操作判断对应位是否相等。

  • int res = 0, val = x ^ y;
while (val != 0) {
  res += val & 1;
  val >>= 1;
}
return res;

42. 如何二进制转十进制、十进制转二进制？

这里的知识点包括：

  • 二进制转十进制可以用 Integer.toBinaryString(int) 方法。

  • 十进制转二进制可以用 Integer.valueOf(s, radix) 方法。

  • Integer.toBinaryString(100);

Integer.valueOf("11010", 2);

43. 如何选择合适的类型表示数字？

这里的知识点包括：

  • byte 类型范围是 -128 到 127。是 8 位。
  • short 类型范围是 -32768 到 32767。是 16 位。
  • int 类型范围是 -2 ^ 31 到 2 ^ 31 - 1。是 32 位。
  • long 类型范围是 -2 ^ 63 到 2 ^ 63 - 1。是 64 位。

44. 如何快速判断是否包含指定字母？

这里的知识点包括：

  • 一种技巧是设置一个字符串包含所有的目标字母，然后使用 indexOf(c) >= 0 方法进行判断。

  • String s = "aeiouAEIOU";
return s.indexOf(ch) >= 0;

45. 如何拆分字符串？

这里的知识点包括：

  • Java 中拆分字符串其实也是十分好用的，也是 s.split() 方法，但不同的是 split 方法的参数是字符串。
  • 这也就导致了里面需要有转移符号。
  • \ 需要写成 \\\\
  • .*| 之类需要写成 \\ 加上符号。
  • || 需要写成 \\|\\|

46. 如何将字符串变成整数？

这里的知识点包括：

  • 可以采用 Integer.parseInt(s) 方法，是比较直接的。
  • 除此之外，还可以用 Integer.valueOf(s).intValue() 方法。
int intA = Integer.parseInt(s);
int intB = Integer.valueOf(s).intValue();

47. 栈应该用什么实现类？

这里的知识点包括：

  • 推荐用 Deque 的 LinkedList 实现类，这样比较简单。
  • 方法还是 push 和 pop。
Deque<Integer> stack = new LinkedList<Integer>();
stack.push(1);
stack.pop();

48. 如何比较字符串字典序？

这里的知识点包括：

  • 可以用 stringObject.compareTo 方法进行比较。
String s1 = "abc", s2 = "def";
System.out.println(s1.compareTo(s2));

49. 如何实现 Array, List 和 Set 的互转？

这里的知识点包括：

  • Array 转 List：如果用 Arrays.asList 方法，之后修改 Array，会直接改变 List。而且这种方法不能增删（没有 add remove 方法），只能查改（set get contains）。
  • List 转 Array：如果用 List.toArray 方法，之后修改 List，不会改变 Array。注意参数是提供一个类型即可，如 new String[0]。
  • 方法名是 Arrays.asList() 和 List.toArray()。
List<String> listA = Arrays.asList(stringA);
String[] stringB = List.toArray(new String[0]);
// 转整数 array：
int[] intA = listA.stream().mapToInt(Integer::intValue).toArray();
// 转整数 list
List<Integer> listB = Arrays.stream(intB).boxed().collect(Collectors.toList());
  • 更好的 Array 转 List：将 Arrays.asList() 的返回值由 java.util.Arrays.ArrayList 转换为 java.util.ArrayList，也就是用构造器方法创建返回对象类型。
List<String> listA = new ArrayList<String>(Arrays.asList(stringA));
  • 最高效的 Array 转 List：首先构造对应数组大小的 List 对象，然后用 Collections.addAll() 方法将 Array 的内容添加到 List 对象中。这种方法运算速度最快，适合处理大量数据。
List<String> listA = new ArrayList<>(stringA.length);
Collections.addAll(listA, stringA);
  • Stream 方法的 Array 转 List：针对数类型和 String 类型，Stream 方法也是不一样的。
  • 对于数类型 Array，首先用 Arrays.stream() 方法将 Array 的内容转换为流类型，随后用 boxed() 方法进行封装，最后再用 collect() 方法进行转换，参数是 Collectors.toList() 方法。
  • 注意这里是 Arrays.stream() 方法，随后还需要用一下 boxed() 方法。比字符串类型麻烦。
List<Integer> listA = Arrays.stream(intA).boxed().collect(Collectors.toList());
  • 对于 String Array，首先用 Stream.of() 方法将 Array 的内容转换为流类型，随后调用 collect() 方法进行转换，参数是 Collectors.toList() 方法。
  • 注意这里是 Collectors，方法名是 toList()，类似的有 toSet()，但是没有 toQueue()。也可以不用那么麻烦，直接 toCollection()，里面可以写 需要的类型::new。
List<String> listA = Stream.of(stringA).collect(Collectors.toList());
List<String> listB = Stream.of(stringA).collect(Collectors.toCollection(ArrayList::new));
  • List 和 Set 互转：由于 List 和 Set 都实现了 Collection 接口，因此可以直接将对方作为构造函数的参数进行互转，也可以用 Collections.AddAll()。
List<String> listA = new ArrayList<>(setA);
Set<String> setA = new HashSet<>(listA);
List<String> listA = new ArrayList<>(setA.size());
Collections.addAll(listA, setA);
  • Array 和 Set 互转：参考 Array 和 List 互转即可。

50. Collection, Collections, Collector, Collectors 有什么区别？

这里的知识点包括：

  • Collection 是集合类接口，也就是 java.util.Collection，提供了对集合对象的基本操作方法。我们之前整理的那篇 集合类总结 也就是介绍的这部分内容。

  • image-20210916163719136

  • Collections 则是一个包装类或者说工具类，包含了许多集合操作的静态方法，同时这个类不能实例化。Collections 提供的常用方法有：

    • sort 排序
    • Shuffling 混排
    • Reverse 反转
    • Fill 全部替换
    • copy 拷贝
    • addAll 深层拷贝
    • min max 返回最小最大
    • Rotate 循环移位

  • Collector 也是个集合类接口，定义了对流元素的基本操作。

  • Collectors 也是一个收集器工具类，常用于流操作。

  • Collector 和 Collectors 的关系和 Collection 和 Collections 的关系类似。流中的 collect() 方法传入的都是 Collector 接口，Collectors 工具类中的方法返回的也是 Collector 接口。

51. 如何对数组初始化同时赋值

这里的知识点包括：

  • 初始化同时赋值，就可以省略 new int [] 这些字样，直接用花括号括起来赋值就行。

  • 一维数组初始化同时赋值：

  • int[] arrayA = {1,2,3};
int[] arrayB = new int[]{1,2,3};

  • 二维数组初始化同时赋值：

  • int[][] arrayA = {{1,2,3}, {4,5,6}};
int[][] arrayB = new int[][]{{1,2,3}, {4,5,6}};

  • 注意，二维数组的每一维度都可以长度不同。所以可以动态申请。

  • int[][] arrayA = new int[3][];
for (int i = 0; i < 3; ++i) {
  arrayA[i] = new int[i + 1];
}

52. 如何将其他类型转换为 String 类型？

这里的知识点包括：

  • 可以用 String.valueOf() 方法。

  • String stringA = String.valueOf(5/3);

53. strip, trim, replace 和 replaceAll 有什么区别和联系？

这里的知识点包括：

  1. replace 和 replaceAll 都是把源字符串替换为指定字符串。但是 replaceAll 更强大，支持正则表达式。

  2. strip 和 trip 都是删除头尾空白符。但是现在推荐用 strip，因为可以删除 trim 删不掉的 unicode 空白符。

54. TreeSet 和 HashSet 有什么区别？

这里的知识点包括：

  1. TreeSet 是二叉树实现的，HashSet 是哈希表实现的。
  2. TreeSet 数据是有序的，HashSet 数据是无序的。
  3. TreeSet 不能放 null 值，HashSet 可以但只能放一个 null 值。
  4. TreeSet 是基于 HashSet 实现的，内部封装了 HashSet。
  5. TreeMap 和 HashMap 同理。
  6. TreeSet 是基于 TreeMap 实现的。HashSet 是基于 HashMap 实现的。

55. char 如何转为 String

这里的知识点包括：

  • 首先，没有 String s = new String('c'); 这种方法！但是可以这样写：String s = new String(new char[]{'c'});
  • 可以用 String.valueOf() 方法，也可以用 Character.toString() 方法。
String s = String.valueOf('c');

String s = String.valueOf(new char[]{'c'});

String s = Character.toString('c') // 这种方法其实调用的是 String.valueOf

String s = new Character('c').toString();

String s = "" + 'c'; // 这种方法简单，但是效率最低。因为相当于 new StringBuilder().append("").append('c').toString();

String s = new String(new char[]{'c'});

56. 如何输出整数的二进制形式？

这里的知识点包括：

  • 可以用 Integer 的 toBinaryString 方法。
String res = Integer.toBinaryString(123);