Java 刷题必须了解的 API
时间：2021-10-18 16:12:04
[导读]作者：蓝笔头链接：https://www.jianshu.com/p/f3e64e70eb1b1.排序1.1数组排序（`java.util.Arrays`）1.1.1基本数据类型排序对整个数组排序public static void sort(int[] a);对部分数组[fro...
作者：蓝笔头
链接：https://www.jianshu.com/p/f3e64e70eb1b
1. 排序
1.1 数组排序（`java.util.Arrays`）
1.1.1 基本数据类型排序
- 对整个数组排序
public static void sort(int[] a);
- 对部分数组
[fromIndex, toIndex)排序
public static void sort(int[] a, int fromIndex, int toIndex);
七种基本类型int、long、short、char、byte、float、double（除了boolean），都支持上述格式的排序 API。
1.1.2 对象排序
- 实现了
java.lang.Comparable接口的对象。
// 对整个数组排序
public static void sort(Object[] a);
// 对部分数组 [fromIndex, toIndex) 排序
public static void sort(Object[] a, int fromIndex, int toIndex);
- 通过
java.util.Comparator排序：
// 对整个数组排序
public static void sort(T[] a, Comparatorsuper T> c);
// 对部分数组 [fromIndex, toIndex) 排序
public static void sort(T[] a, int fromIndex, int toIndex,
Comparatorsuper T> c);
public interface Comparator<T> {
// result < 0：o1 排在 o2 前面
// result == 0：o1 和 o2 的值一样
// result > 0：o1 排在 o2 后面
int compare(T o1, T o2);
}
案例：() { @Override public int compare(Person o1, Person o2) { return o1.id - o2.id; } }); // 输出： // Solution.Person(id=1) // Solution.Person(id=2) Arrays.stream(persons).forEach(System.out::println); } @AllArgsConstructor @ToString public static class Person { private int id; } } " data-snippet-id="ext.9f53044395f3063f1ff57b840ee3a007" data-snippet-saved="false" data-codota-status="done" style="font-size: inherit; color: inherit; line-height: inherit;">public class Solution {
public static void main(String[] args) {
Person[] persons = new Person[2];
persons[0] = new Person(2);
persons[1] = new Person(1);
Arrays.sort(persons, new Comparator() {
@Override
public int compare(Person o1, Person o2) {
return o1.id - o2.id;
}
});
// 输出：
// Solution.Person(id=1)
// Solution.Person(id=2)
Arrays.stream(persons).forEach(System.out::println);
}
@AllArgsConstructor
@ToString
public static class Person {
private int id;
}
}
或者使用 lambda 表达式替换 Comparator 匿名类。 { return o1.id - o2.id; }); " data-snippet-id="ext.4973bc6f1d0213eb013aab093375a4f4" data-snippet-saved="false" data-codota-status="done" style="font-size: inherit; color: inherit; line-height: inherit;"> Arrays.sort(persons, (o1, o2) -> {
return o1.id - o2.id;
});
1.2 列表排序（`java.util.Collections`）
- 排序
public static super T>> void sort(List list) ;
public static void sort(List list, Comparatorsuper T> c);
public interface Comparator<T> {
// result < 0：o1 排在 o2 前面
// result == 0：o1 和 o2 的值一样
// result > 0：o1 排在 o2 后面
int compare(T o1, T o2);
}
- 反转列表元素
public static void reverse(List list);
1.3 二维数组排序（`java.util.Arrays`）
提示：Java 数组也是一种对象void sort(T[] a, Comparator c); // 案例 Arrays.sort(nums, (int[]a, int[]b) -> a[0] - b[0]); " data-snippet-id="ext.d85d29980807199ad798d55caa97768a" data-snippet-saved="false" data-codota-status="done" style="font-size: inherit; color: inherit; line-height: inherit;">
// api
public static void sort(T[] a, Comparatorsuper T> c);
// 案例
Arrays.sort(nums, (int[]a, int[]b) -> a[0] - b[0]);
2. 二分查找
- 数组（
java.util.Arrays）
public static int binarySearch(int[] a, int key);
public static int binarySearch(int[] a, int fromIndex, int toIndex, int key);
public static int binarySearch(Object[] a, Object key);
public static int binarySearch(Object[] a, int fromIndex, int toIndex, Object key);
public static int binarySearch(T[] a, T key, Comparatorsuper T> c);
public static int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparatorsuper T> c);
- 列表（
java.util.Collections）
public static int binarySearch(List extends Comparable super T>> list, T key);
public static int binarySearch(List extends T> list, T key, Comparator super T> c);
3. 栈（`java.util.Stack`）
- 创建
Stack stack = new Stack<>();
- 数据操作
// 往【栈】里面添加一个元素
public E push(E item)
// 往【栈】里面弹出一个元素
public synchronized E pop();
- 条件判断
public synchronized boolean isEmpty();
4. 队列（`java.util.Queue`）
- 创建（
java.util.LinkedList）
Queue queue = new LinkedList<>();
- 数据操作
// 往【队列】里面添加一个元素
boolean add(E e);
// 往【队列】里面弹出一个元素
E poll();
- 条件判断
boolean isEmpty();
5. 堆（`java.util.PriorityQueue`）
提示：Java 里面的优先队列
- 创建
// 创建一个最小堆
PriorityQueue minHeap = new PriorityQueue<>();
// 创建一个最大堆
PriorityQueue maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
- 数据操作
// 往【堆】里面添加一个元素
public boolean add(E e);
// 从【堆】里面弹出一个元素
public E poll();
其他工具
- 降序排序（
java.util.Comparator）
// 反转一个 Comparator 的排序规则
// 比如从【升序】反转为【降序】
default Comparator reversed() ;
// 反转一个 Comparable 的排序规则
// 比如从【升序】反转为【降序】
public static super T>> Comparator reverseOrder() ;
- 大数（
java.math.BigInteger）
// 创建一个大数
public static BigInteger valueOf(long val);
// 数据操作
public BigInteger add(BigInteger val);
public BigInteger subtract(BigInteger val);
public BigInteger multiply(BigInteger val);
public BigInteger divide(BigInteger val);
- 集合（
java.util.Collections）
// 初始化一个具有 n 个相同元素 o 的 list
public static List nCopies(int n, T o);
// 反转一个 list 的顺序
public static void reverse(List list); 
下载文档
