1. 数组

一般题目给到的类型（如基本类型的数组int[]，char[]，double[]等）常常需要排序，反转，查找等操作。

int[] a = {1,4,6,2};

// init
Arrays.fill(a, 0); //全部初始化为0

// sort
void Arrays.sort(T[] a);
void Arrays.stream(a).boxed().sorted(Comparator.reverseOrder()).mapToInt(Integer::intValue).toArray(); // 降序

// find index with **sorted** array
int Arrays.binarySearch(T[] a, @Option int fromIndex, @Option int toIndex, T key);

// reverse
// 基本类型数组只能使用自定义函数    
public static void reverse(int[] arr) {
    int left = 0, right = arr.length - 1;
    while (left < right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
}
// Stream 处理
// char[][] - > List<String>
List<String> list = Arrays.stream(char[][]).map(String::new).collect(Collectors.toList())、

int[] nums = {1, 2, 3, 4, 5};
// 过滤
int[] result = Arrays.stream(nums).filter(n -> n % 2 == 0) .toArray();
// 聚合
int sum = Arrays.stream(nums).sum(); 
int avg = Arrays.stream(nums).average(); 

// 数组转可操作集合（add/remove/clear）
Integer[] arr = {1, 2, 3};
List<Integer> list = new ArrayList<>(Arrays.asList(arr));
List<Integer> list = Arrays.stream(arr).collect(Collectors.toList());

int[] arr = {1, 2, 3};
List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList());

2. 进制转换

// 10(int) -> 任意(String)
String Integer.toString(int n, int radix);
// 任意(String) - > 10(int)
int Integer.parseInt(String str, int radix); 

3. List

常用函数

List<T> list = new ArrayList<>();
void Collections.sort(list);
T[] array = list.toArray(new T[0]);
int list.indexOf(T);

Set<T> set = new HashSet<>(list);//去重

void reverse(List list)//反转
void shuffle(List list)//随机排序
void sort(List list)//按自然排序的升序排序
void sort(List list, Comparator c)//定制排序，由Comparator控制排序逻辑
void swap(List list, int i , int j)//交换两个索引位置的元素
void rotate(List list, int distance)//旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面

int binarySearch(List list, Object key)//对List进行二分查找，返回索引，注意List必须是有序的
int max(Collection coll)//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)
int max(Collection coll, Comparator c)//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素
int frequency(Collection c, Object o)//统计元素出现次数
int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target)
boolean replaceAll(List list, Object oldVal, Object newVal)//用新元素替换旧元素

Stream

class Person {
    private String name;
    private String phoneNumber;
     // getters and setters
}

List<Person> bookList = new ArrayList<>();
bookList.add(new Person("jack","18163138123"));
bookList.add(new Person("martin",null));
// 空指针异常
bookList.stream().collect(Collectors.toMap(Person::getName, Person::getPhoneNumber));

4. 字符串

常用转换：

// String -> char[]
String str = "tim";
char[] charArray = str.toCharArray();
// String -> String[]
String str = "tim";
String[] strArray = str.split("");

// char[] -> String
char[] charArray = {'t', 'i', 'm'};
String str = new String(charArray);

// String[] -> String
String[] strArray = {"t", "i", "m"};
String str = String.join("", strArray);

常见操作：

// 预处理
String trim(); // 去除字符串首尾的空格或其他空白字符（如制表符、换行符等)
// 转换
char[] toCharArray();
String[] split(String regex);
static String valueOf(primitive data type x)
// 定位
char charAt(int index);
int indexOf(int ch | String str);
int lastIndexOf(int ch | String str);
// 大小写
String toLowerCase();
String toUpperCase();
// 替换
String replace(char oldChar, char newChar)
String replaceAll(String regex,String replacement);
// 改写
String concat(String s);
String substring(int beginIndex, @Option int endIndex)
// 查找
boolean contains(CharSequence s);
boolean startsWith(String prefix, @Option int toffset)

进阶操作：

// 反转
StringBuilder sb = new StringBuilder(str);
String reversedStr = sb.reverse().toString();

// 排序
// String -> char[]
char[] cs = str.toCharArray();
// sort
Arrays.sort(cs);
// char[] -> String
str = new String(cs);