java刷题必备api【常用】_java刷题常用api

整理java刷题过程中常用api，加强记忆，好记性不如烂笔头嘛！Online notebook！

刷题过程，了解各种数据结构(组织数据的方式)是非常重要的，如数组，字符串及集合等。数学相关的工具类java.lang.Math中的一些常用方法，如绝对值，取整(向上、向下)、四舍五入及次幂等。数组工具类java.util.Arrays和集合工具类java.util.Collections中的常用方法，如排序。基本数据类型的最大值最小值，也是也是需要知道的哦！

（数据结构包括 ：线性结构和非线性结构。线性结构常见的有：数组、队列、链表和栈。）

目录

1、数组

2、字符串

3、集合

4、工具类

5、基本类型的最大值与最小值

---

1、数组

常用数组为：一维数组和二维数组。
（1）定义

定义数组的语法有两种。

type arrayName[]; //第一种
type[] arrayName; //第二种
 
//eg
int arrayName[] = new int[5];
int[] arrayName = new int[5];

type 为Java中的任意数据类型，包括基本类型和引用类型，arrayName为数组名，必须是一个合法的标识符，[ ] 指明该变量是一个数组类型变量，[ ]的数量表示数组的维度，可以有多个，表示多维度数组。Java实际上没有多维数组，只有一维数组。多维数组可以理解为“数组的数组” ，比如二维数组其实是一个一维数组，数组中每个元素是一个一维数组。。

（2）初始化

可以在声明数组的同时进行初始化（静态初始化），也可以在声明以后进行初始化（动态初始化）。

//静态初始化
int[] arr=new int[]{1,2,3};
 
//动态初始化
String[] strArr=new String[3];
strArr[0]="Hello";
strArr[1]="World";
strArr[2]="Hello World";

（3）使用

根据对应索引进行访问（赋值，修改）即可。

2、字符串

字符串分为两类：不可变字符串（String）和可变字符串（StringBuilder）。

String类用来表示那些创建后就不会再改变的字符串，而StringBuffer类用来表示内容可变的字符串，并提供了修改字符串的方法。

表面上拼接字符串时，String类使用str1+str2这种形式拼接字符串，实际上是JVM帮助创建StringBuilder对象来拼接，StringBuffer类却要调用一个append()方法来拼接，看起来调用一个方法比一个简单的“+”麻烦一些，但是拼接字符串最好用StringBuilder类，效率更高，更高，更高~

（1）java.lang.String

• 初始化        

java中创建并初始化一个String对象，最常见的方式有两种。

String str = new String("XXX"); //参数可以是字符串常量，也可为字符数组
String str = "XXX"; //参数可为字符串常量，可为String.valueOf()系列的返回值

二者看似相同，其实有很大的差别。
前者是java中标准的对象创建方式，其创建的对象将直接放置到堆中，每调用一次就会创建一个新的对象；后者则会在栈中创建一个对象引用变量str，然后查看字符串池中是否存在"XXX"，如果没有，则将"XXX"存放字符串池，并令引用变量str指向它；如果已经有"XXX"，则直接令str指向它。

• 常用方法

charAt(int index); //返回index位置的字符char --- O(1)
 
length(); //返回字符串长度 --- O(1)
 
substring(int beginIndex, int endIndex); //返回字符片段[beginIndex, endIndex) --- O(n)
substring(int beginIndex); //返回字符片段[beginIndex, end_of_String) 就是从beginIndex开始后面的 ---- O(n)
 
 
indexOf(String str); //返回str第一个出现的位置(int)，没找到则返回-1。 --- O(m * n) m为原串长度， n为str长度
s.indexOf(String str, int fromIndex); //同上，但从fromIndex开始找 --- O(m * n)
 
lastIndexOf(String str); //返回str最后出现的位置(int)，没找到则返回-1。 --- O(m * n) m为原串长度， n为str长度
lastIndexOf(String str, int fromIndex); //同上，但从fromIndex开始从后往前找 [0 <- fromIndex] --- O(m * n)
 
replace(char oldChar, char newChar); //返回一个新字符串String，其oldChar全部变成newChar --- O(n)
 
toCharArray(); //返回char[]数组。把String变成字符数组 --- O(n)
 
trim(); //去除前后空格的新字符串 --- O(n)
 
split(String regex); //返回String[]，以regex(正则表达式)分隔好的字符换数组。 ---- O(n)
//eg："nanjing" -> [, a, ji, g] (一定要注意，参数可以适合正则表达式的)
String str = "nanjing";System.out.println(Arrays.toString(str.split("n")));
 
toLowerCase(); //返回一个新的字符串全部转成小写 --- O(n)
toUpperCase(); //返回一个新的字符串全部转成大写 --- O(n)

（2）java.lang.StringBuilder

• 创建对象

StringBuilder sb = new StringBuilder();

• 常用方法

charAt(int index); //返回index位置的char --- O(1)
 
length(); //返回缓冲字符串长度 --- O(1)
 
append(String str); //拼接字符串 --- O(n)
 
toString(); //返回一个与构建起或缓冲器内容相同的字符串 --- O(n)

3、集合

 LIFO：Last In First Out，FIFO： First Input First Output。[first() last()]：TreeSet类中的方法。

关于集合（接口）的特性，使用时候要看接口的具体实现类。

1、List的两个实现类（ArrayList，LinkedList）：其中，ArrayList底层是通过数组（动态扩容的数组）实现的，查询快；LinkedList底层是通过双向链表实现的，插入和删除快。

2、Set的三个实现类（HashSet，LinkedHashSet，TreeSet），关于存储元素顺序的区别：HashSet元素乱序， LinkedHashSet保证元素添加顺序，TreeSet元素按自然顺序排序。

3、Map的两个实现类（HashMap，TreeMap），关于存储键值对顺序的区别：HashMap键值对乱序、TreeMap键值对以“键”排序。

TreeSet中的元素和TreeMap中键如果是基本数据类型（的包装类型）或者是字符串，那么就按照数值大小以及字典序排序即可，但是如果是自定义的实体类对象，就需要程序员自己自定义排序方式。自定义排序时，需要用到Comparable接口或者是Comparator接口。

自然排序--使用Comparable接口

定制排序--使用Comparator接口

自定义实体类对象作为集合中元素的自定义排序，见：https://blog.csdn.net/King_wq_2020/article/details/118911582?spm=1001.2014.3001.5501

1、List列表（ArrayList、LinkedList）

（1）实例化以及传参

List<Integer> array = new ArrayList<>();    // 顺序表
// Set<Integer> a = new HashSet<Integer>();
List<Integer> b = new ArrayList<>(a);     //接受一个集合容器

（2）get

get(int index)    // 返回元素位置在index的元素e --- 数组 O(1), 链表 O(n)

（3）size

size()    // 返回动态数组所存元素个数/链表长度 --- O(1)

 （4）add

add(E e)    // 在尾部添加一个元素e --- O(1)
add(int index, E e)    // 在index位置插一个元素e --- O(n)

 （5）remove

remove(int index)    // 删除位于index的元素，并返回删除元素e --- 删除最后元素为O(1)， 其余为O(n)
//删除最后元素 list.remove(list.size() - 1);

（6）subList

subList(int from, int to)    // 相当于返回原数组的一个片段,但不要对其进行改动，改动会影响原数组 --- O(1)
// List<Integer> list, 对原来的list和返回的list做的“非结构性修改”(non-structural changes)，
//都会影响到彼此对方. 如果你在调用了sublist返回了子list之后，如果修改了原list的大小，那么之前产生的子list将会失效，变得不可使用

2、Set集合

Set是一种没有重复元素的集合，常用的实现是HashSet。

（1）实例化及传参

Set<Integer> set = new HashSet<>();
List<Integer> list = new ArrayList<>();
Set<Integer> set = new HashSet<>(list);

（2）add

add(E e);    // 在集合中添加元素E e， 若成功添加则返回true，若集合中有元素e则返回false --- O(1)

 （3）remove

remove(E e);    // 在集合中删除元素e，若删除成功返回true；若集合中没有元素e，返回false --- O(1)

（4）contains

contains(E e);    // 若存在元素e，则返回true，否则返回false --- O(1)

（6）isEmpty

isEmpty()    // 若集合为空返回true， 否则返回false --- O(1)

（7）first()、last()

也就是TreeSet类中有这个两个方法。

//first()、last(),返回有序集合中第一个元素，最后一个元素
// Creating an empty TreeSet
TreeSet<Integer> tree = new TreeSet<Integer>();
 
// Use add() method to add elements into the Set
tree.add(14);
tree.add(8);
tree.add(200);
tree.add(48);
tree.add(7);
tree.add(124);
 
// Displaying the TreeSet
System.out.println("TreeSet: " + tree);
 
// Displaying the highest element of the set
System.out.println("The last element is: " + tree.last());

3、Map映射

（1）实例化

Map<Characters, Integer> map = new HashMap<>();

（3）put

put(K key, V value);    // 在Map中加入键值对<key, value>。返回value值。如果Map中有key，则replace旧的value --- O(1)

 （4）get

get(K key);    // 返回Map中key对应的value。若Map中没有该key，则返回null --- O(1)

 （5）getOrDefault

getOrDefault(K key, V defaultValue);    // 返回Map中key对应的value。若Map中没有该key，则返回defaultValue --- O(1)
 
// For example:
// Map<Character, Integer> map = new HashMap<>();
// if (...)    // 如果发现k，则k在Map中的值加1。没一开始没有k，则从0开始加1。（相当于给了key在Map中的一个初试值）
    map.put('k', map.getOrDefault('k', 0) + 1);

 （6）containsKey

containsKey(Key key);    // 在Map中若存在key，则返回true，否则返回false --- O(1)
 
get(x) == null // 可以代替改用法

（7）keySet

keySet();    // 返回一个Set,这个Set中包含Map中所有的Key --- O(1)
 
// For example:
// We want to get all keys in Map
// Map<Character, Integer> map = new HashMap<>();
for (Character key : map.keySet()) {
    // Operate with each key
}

（8）values

values();    // 返回一个Collection<v>,里面全是对应的每一个value --- O(1)
 
// For example:
// We want to get all values in Map
// Map<Character, Integer> map = new HashMap<>();
for (Integer value : map.values()) {
    // Operate with each values
}

（9）isEmpty

isEmpty()    // 若Map为空返回true， 否则返回false --- O(1)

（10）size

size()    // 返回Map中中键值对<K, V>的个数 --- O(1)

4、栈（Stack、Deque）

java中定义了Stack类，仅仅实现有栈的操作。另外，Deque不仅有队列（双向队列，普通队列）的特性，也可以作为栈，用法同Stack类，方法也相同。

Stack<Integer> stack = new Stack<>(); //Stack类
Deque<Integer> stack = new LinkedList<>(); //Deque接口，LinkedList是Deque的一个实现类
 
 
push(E e);    // 入栈元素e， 返回值为元素e --- O(1)
 
pop();    // 出栈一个元素，返回出栈元素e --- O(1)
 
peek();    // 查看栈顶元素， 返回值为栈顶元素e --- O(1)
 
isEmpty()    // 若栈空返回true， 否则返回false --- O(1)
 
size()    // 返回栈中元素个数 --- O(1)
 

5、单向队列（Queue）

Queue为接口，实现类是LinkedList，特性是先进先出。

Queue<Integer> q = new LinkedList<>(); //实例化
 
offer(E e);    // 队尾加入元素e。 若成功入队返回值true，否则返回false --- O(1)
 
poll();    // 出队头，返回出队元素e --- O(1)
 
peek();    // 查看队头元素， 返回值队首元素e --- O(1)
 
isEmpty()    // 若队空返回true， 否则返回false --- O(1)
 
size()    // 返回队中元素个数 --- O(1)

6、双向队列（Duque）

Queue有一个子接口Dueue，即双向队列，和单向队列不同，它的出队入队可以从两个方向。

Dueue<Integer> q = new LinkedList<>(); //实例化
 
offFirst(Object e)   // 将指定元素添加到双端队列的头部 --- O(1)
 
offLast(Object e)   //将指定元素添加到双端队列的尾部 --- O(1)
 
pollFirst()   //获取并删除双端队列的第一个元素 --- O(1)
 
pollLast()   //获取并删除双端队列的最后一个元素 --- O(1)
 
peekFirst()   //获取但不删除双端队列的第一个元素 --- O(1)
 
peekLast()   //获取但不删除双端队列的最后一个元素 --- O(1)
 
isEmpty() //非空返回true，否则返回false
 
size() //队列中元素个数

7、优先队列（PriorityQueue）

优先队列是一种比较特殊的队列，保存队列元素的顺序不是按照元素添加的顺序来保存的，而是在添加元素的时候对元素的大小排序后再保存。PriorityQueue对元素采用的是堆排序，头是按指定排序方式的最小元素。堆排序只能保证根是最大（最小），整个堆并不是有序的。

所以在队头的元素不是按照先后顺序，而是按照大小顺序。

在Java中的实现是PriorityQueue，底层是一棵树， 以小根堆为例。对于任意结点来说，该节点的值比其左右子节点的值都要小。 （就是最上面的结点最小）。 大根堆类似，最上面结点最大

//小根堆
Queue<Integer> minH = new PriorityQueue<>();    // 小根堆，默认大小为11 相当于  new PriorityQueue<>(11)
Queue<Integer> minH = new PriorityQueue<>(100);  // 定义一个默认容量有100的小根堆。在当中增加元素会扩容，只是开始指定大小。不是size，是capacity
 
//大根堆Queue<Integer> maxH = new PriorityQueue<>((i1, i2) -> i2 - i1);    // 大根堆，默认大小为11 相当于  new PriorityQueue<>(11, (i1, i2) -> i2 - i1)
Queue<Integer> maxH = new PriorityQueue<>(100, (i1, i2) -> i2 - i1);    // 定义一个默认容量有100的大根堆。在当中增加元素会扩容，只是开始指定大小
 
 
//for example
// 默认实现了一个最小堆。
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(); 
//最大堆
PriorityQueue<Integer> maxheap = new PriorityQueue<>(Collections.reverseOrder());
 
// 自定义实现最小/最大（o1-o2，升序）（o2-o1,降序）
PriorityQueue<ListNode> priorityQueue = new PriorityQueue<ListNode>(100,new Comparator<ListNode>(){
 
     @Override
     public int compare(ListNode o1, ListNode o2) {
          return o2.val-o1.val;
      }
});
 
 
offer(E e);    // 在堆中加入元素e，并调整堆。若成功入堆返回值true，否则返回false --- O(logN)
 
poll();    // 弹出堆顶元素，并重新调整堆，返回出队元素e --- O(logN)
 
peek();    // 查看堆顶元素， 返回值堆顶元素e --- O(1)
 
isEmpty(); //判断队列是否为空
 
size(); //队列中元素数量
 
 
//for example
PriorityQueue<Integer> pq = new PriorityQueue();
pq.offer(50);
pq.offer(2);
pq.offer(1);
pq.offer(10);
pq.offer(18);
for(Integer temp:pq){
    System.out.println(temp);
}
//输出：默认最下堆，能够保证根元素最小
1
10
2
50
18
 
PriorityQueue<Integer> pq = new PriorityQueue(Collections.reverseOrder());
pq.offer(50);
pq.offer(2);
pq.offer(1);
pq.offer(10);
pq.offer(18);
for(Integer temp:pq){
     System.out.println(temp);
}
//输出：改成了最大堆，保证根元素为最大
50
18
1
2
10

如果搞不清楚，自然排序和定制排序过程中，（o1-o2，o2-o1）升序及降序问题，可以参考：

https://blog.csdn.net/ljrsunshine/article/details/107362206

4、工具类

1、java.util.Math：主要包含数学内的应用方法

（1）Math.abs(参数)

作用：返回参数的绝对值

参数可以是 int，float，long，double等类型，返回值类型同参数类型。（参数也可以是short，byte，但是返回类型会转成int）

Math.abs(double a);   

（2）Math.max(参数1，参数2)，Math.min(参数1，参数2)

作用：返回两个参数的最大值，最小值。

参数可以是 int，float，long，double等类型，返回值类型同参数类型。（参数也可以是short，byte，但是返回类型会转成int）

Math.max(long a, long b);    //返回两个参数中较大的值
Math.min(long a, long b);    //返回两个参数中较小的值

（3）Math.sqrt(参数)、Math.cbrt(参数)

作用：开平方，开立方

参数可以是 int，float，long，double，short，byte等类型，返回值类型为double。

Math.sqrt(long a) //开平方
Math.cbrt(long b) //开立方

（4）Math.pow(参数1，参数2）

作用：返回参数1的参数2次方。

参数可以是 int，float，long，double，short，byte等类型，返回值类型为double。

Math.pow(double a, double b)

（5）Math.ceil(参数)

作用：对浮点数向上取整。

参数可以是 int，float，long，double，short，byte等类型，返回值类型为double。

Math.ceil(double a)

（6）Math.floor(参数)

作用：对浮点数向下取整。

参数可以是 int，float，long，double，short，byte等类型，返回值类型为double。

Math.floor(double a)

 （7）Math.round(参数)

作用：对浮点数四舍五入。

参数可以是 int，float，long，double，short，byte等类型，返回值类型为int或者long。

Math.round(double a)

（8）Math.log(参数），Math.log10(参数)

作用：取对数。

参数可以是 int，float，long，double，short，byte等类型，返回值类型为double。

Math.log(double a) //以e为底取对数
Math.log10(double b) //以10为底取对数

 那么，以m为底取N的对数该如何求呢？

//注意：logmN：以m为底取N的对数。
Math.log(8)/Math.log(2); //该代码意为：以2为底取8的对数为：3。

（9）Math.random()

作用：返回一个随机数，随机数范围为[0，1)，左闭右开。返回值类型为double。

2、java.util.Arrays：主要包含了操作数组的各种方法。

（1）Arrays.toString(arr)

作用：返回字符串，便于打印数组内容

String str = Arrays.toString(arr); // Arrays类的toString()方法能将数组中的内容全部打印出来
System.out.print(str);

（2）Arrays.sort(arr，fromIndex，toIndex)

作用：数组升序

int[] a = new int[]{1,4,2,3,5};
Arrays.sort(a,0,5);//默认对全部元素升序，对下标0到下标为5-1的5个元素进行排序。

（3）Arrays.sort(arr，fromIndex，toIndex，Collections.reverseOrder())

作用：数组降序

Arrays.sort(a,1,3,Collections.reverseOrder());

 （4）Arrays.equals()

作用：比较数组元素

int[] arr1 = {1,2,3};
int[] arr2 = {1,2,3};
System.out.println(Arrays.equals(arr1,arr2)); //输出：true
//如果是arr1.equals(arr2),则返回false，因为equals比较的是两个对象的地址，不是里面的数，而Arrays.equals重写了equals，所以，这里能比较元素是否相等。

（5）Arrays.copeOf() 和Arrays.copeOfRange() 

作用：截取数组，传回的数组是新的数组对象，改变传回数组中的元素值，不会影响原来的数组。

int[] arr = {10,20,30,40,50};
int[] arr1 = Arrays.copyOf(arr, 3);
String str = Arrays.toString(arr1); // Arrays类的toString()方法能将数组中的内容全部打印出来
System.out.print(str);
//输出：[10, 20, 30] （截取arr数组的3个元素赋值给新数组arr1）
 
 
int []arr = {10,20,30,40,50};
int []arr1 = Arrays.copyOfRange(arr,1,3);
String str = Arrays.toString(arr1); // Arrays类的toString()方法能将数组中的内容全部打印出来
System.out.print(str);
//输出：[20, 30] （从第1位（index=0开始）截取到第3位（不包括）

3、java.util.Collections：主要对集合进行操作

（1）Collections.sort()

作用：升序/降序

Arrays.sort()、Collections.sort()有关升序降序的应用，见链接：https://blog.csdn.net/King_wq_2020/article/details/118911582

5、基本类型的最大值与最小值

数字类型包装类都支持两个常量：MAX_VALUE，MIN_VALUE 分别保存了对应基本类型的最大值与最小值。

fmax = Float.MAX_VALUE;
 
fmin = Float.MIN_VALUE;
 
dmax = Double.MAX_VALUE;
 
dmin = Double.MIN_VALUE;
 
bmax = Byte.MAX_VALUE;
 
bmin = Byte.MIN_VALUE;
 
cmax = Character.MAX_VALUE;
 
cmin = Character.MIN_VALUE;
 
shmax = Short.MAX_VALUE;
 
shmin = Short.MIN_VALUE;
 
imax = Integer.MAX_VALUE;
 
imin = Integer.MIN_VALUE;
 
lmax = Long.MAX_VALUE;
 
lmin = Long.MIN_VALUE;

参考链接1：https://blog.csdn.net/sinat_40770656/article/details/118772581

参考链接2：https://www.cnblogs.com/HOI-Yzy/p/14407021.html