需要注意的点

ArrayList.toArray()
数组的复制
二分搜索
字符串转整数，并判断是否溢出
int 与字符串互转
字符串的比较 compareTo()
字符串的方法
Comparator 比较器的升序问题
二进制判断奇偶数

ArrayList.toArray()

ArrayList 有两个方法生成数组

Object toArray();
// 需要传入一个指定类型的数组
T[] toArray(T[]);

以 String[] 为例

List<String> res = new ArrayList<>();
list.toArray(new String[res.size()]);

注意：一定要以 res.size() 去指定返回的数组的长度。这样才不会多于

ArrayList.toArray() 底层

public <T> T[] toArray(T[] a) {
        if (a.length < this.size) {
            return Arrays.copyOf(this.elementData, this.size, a.getClass());
        } else {
            System.arraycopy(this.elementData, 0, a, 0, this.size);
            if (a.length > this.size) {
                a[this.size] = null;
            }
            return a;
        }
    }

数组的复制

有两种方法
Arrays 工具类
复制原数组的指定长度，整个复制或者截取

static int[]    copyOf(int[] original, int newLength)
static <T> T[]    copyOf(T[] original, int newLength)

二分搜索

Arrays 工具类

static int    binarySearch(int[] a, int fromIndex, int toIndex, int key)

字符串转整数，并判断是否溢出

以 -123456 为，依次进行整数拼接

String str = "123456";
int res = 0;
for(int i = 0; i < str.length(); i ++){
    res = res * 10 + (str.charAt(i) - '0');
}

溢出处理：
整数的最大值：Integer.MAX_VALUE = 2^32 -1 = 2147483648 - 1 = 2147483647 十六进制（0x7fffffff）
最小值：Integer.MIN_VALUE = - 2^32 = 2147483648 十六进制（0x8ffffffff）

String str = "123456789123";
int res = 0;
for(int i = 0; i < str.length(); i ++){
    int max = Integer.MAX_VALUE / 10;
    if(res > max || (res == max && str.charAt(i) > '7'))
        即说明越界了
    res = res * 10 + (str.charAt(i) - '0');
}

在每轮整数拼接的时候，判断在这轮 res 拼接后的值是否会超过 Integer.MAX_VALUE。
设置一个 res 即将要超过 Integer.MAX_VALUE 的边界，boundary = Integer.MAX_VALUE / 10，下面两中情况会越界：

res > Integer.MAX_VALUE / 10 ，也就是 2147483647 / 10 = 214748364。res 超过这个值，那么下面进行拼接的是 res = res * 10 + (str.charAt(i) - ‘0’) 一定会超过最大值。
res = Integer.MAX_VALUE / 10 && str.charAt(i) > ‘7’ ，当 res = 214748364 并且待拼接的数字超过了 7，那么在下一轮 res = res*10 + (str.charAt(i) - ‘0’) 一定超过了 214748364。
int 与字符串互转
int 转 String
```
String str = String.valueOf(2);
```
String 转 int
```
int num = Integer.parseInt(str);
```
不能使用 new String(2)
String 的构造函数只接受 byte[]、char[]、char

字符串的比较 compareTo()

int    compareTo(String anotherString)

按照字典的顺序来比较字符串

str1.compareTo(str2)
// str1 大于 str2，返回的值大于 0
// str1 等于 str2，返回的值等于 0
// str1 小于 str2，返回的值小于 0

字符串的方法

char    charAt(int index)

int    compareTo(String anotherString) // 按字典顺序比较两个字符串。

boolean    contains(CharSequence s)  // 当且仅当此字符串包含指定的char值序列时才返回true。

boolean    equals(Object anObject)   // 将此字符串与指定对象进行比较。

byte[]    getBytes()  //使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中
byte[]    getBytes(Charset charset)  // 指定字符集

int    indexOf(int ch)   // 返回指定字符第一次出现的字符串内的索引。

int    lastIndexOf(int ch)  // 返回指定字符的最后一次出现的字符串中的索引。

static String    join(CharSequence delimiter, CharSequence... elements)  // 连接字符集

String[]    split(String regex)  // 分割

char[]    toCharArray()  // 将此字符串转换为新的字符数组。

Comparator 比较器的升序问题

在使用 Java 内置的排序函数时，如果要自定义排序规则，则需要传入一个比较器 Comparator，并实现 compareTo 函数

public int compareTo(Comparable c1, Comparable c2){
    return c1 - c2;
}

c1 在数组中的位置排在 c2 前面

如果按上述的排序规则，则是升序的asc。
当 c1 - c2 返回 -1，则表示 c1 小于 c2，不需要交换位置。
当 c1 - c2 返回 1，则表示 c1 大于 c2，需要交换位置。
所以上面的排序规则是升序的

而如果改为下面的，则为降序desc：

public int compareTo(Comparable c1, Comparable c2){
    return c2 - c1;
}

c1 在数组中的位置排在 c2 前面。

当 c2 - c1 返回 -1，则表示 c2 小于 c1，不需要交换位置。
当 c2 - c1 返回 1，则表示 c2 大于 c1，需要交换位置。
所以上述的排序规则是降序

结果返回 -1，则不需要交换位置。
结果返回 1，则需要交换位置。

二进制判断奇偶数

num & 1 == 1   // 则该数是奇数
num & 1 == 0   // 则该数是偶数

原因是：二进制位：最低为1，即 0001，而其余位数表示的都是 2 的倍数，即 0010，当该数奇数时，该二进制最低为一定为 1 ，所以判断是否是奇数，拿该数与 1 进行 & 运算，来判断最低位是否为 1。