Java比赛常用API总结
1.栈和队列
1.1 栈的常用方法
//1.栈顶插入元素
push(element)
//2.返回栈顶元素并弹出栈顶元素
pop()
//3.返回栈顶元素但不弹出
peek()
//4.清空栈
clear()
//5.返回栈中元素个数
size()
//6.判断栈是否为空
isEmpty()
//7.获得指定索引元素
get(index)
//8.更改指定索引处的元素
set(index,element)
代码演示
package pk1;
import java.util.*;
public class Main {
public static void main(String[] args) {
Stack<Integer>stk=new Stack<Integer>();
stk.push(1);//往栈顶插入元素1
stk.push(2);//往栈顶插入元素2
stk.push(3);//往栈顶插入元素3
System.out.println(stk.size());//查看栈中元素个数------输出3
System.out.println(stk.isEmpty());//查看栈是否为空-----输出false
System.out.println(stk.get(0));//获取索引为0的元素-----输出1
System.out.println(stk.get(1));//获取索引为1的元素-----输出2
System.out.println(stk.get(2));//获取索引为2的元素-----输出3
stk.set(0,10);//更改索引0的元素
System.out.println(stk.peek());//查看栈顶元素但不弹出栈-----输出3
System.out.println(stk.pop());//查看栈顶元素并弹出栈-----输出3
System.out.println(stk.pop());//查看栈顶元素并弹出栈-----输出2
System.out.println(stk.pop());//查看栈顶元素并弹出栈-----输出10
}
}
1.2 队列的常用方法
1.2.1 LinkedList的常见用法
//1.队尾插入元素，如果没有空间则抛出异常
add(element)
//2.删除并返回队首元素
remove()
//3.判断队列是否非空
isEmpty()
//4.返回队列中元素个数
size()
//5.返回队首元素但不弹出
peek()
//6.清空队列
clear()
代码演示
package pk1;
import java.util.*;
public class Main {
public static void main(String[] args) {
Queue<Integer>q=new LinkedList<>();
q.add(1);//往队尾插入元素1
q.add(2);//往队尾插入元素2
q.add(3);//往队尾插入元素3
System.out.println(q.size());//查看队列中元素个数------输出3
System.out.println(q.isEmpty());//查看队列是否为空------输出false
System.out.println(q.peek());//查看队头元素但不弹出队列------输出1
System.out.println(q.remove());//查看队头元素并弹出队列------输出1
System.out.println(q.remove());//查看队头元素并弹出队列------输出2
System.out.println(q.remove());//查看队头元素并弹出队列------输出3
}
}
1.2.2 Deque的常见用法
//1.将指定的元素插入此双端队列的队首
addFirst(element)
//2.将指定的元素插入此双端队列的队首
push(element)
//3.将指定的元素插入此双端队列的队尾
addLast(element)
//4.将指定的元素插入此双端队列的队尾
add(element)
//5.检索并删除队首元素
removeFirst()
//6.检索并删除队尾元素
removeLast()
//7.检索队首元素
getFirst()
//8.检索队尾元素
getLast()
//9.判断队列中是否包含某个元素
contains(element)
//10.返回队列中元素个数
size()
//11.判断队列是否非空
isEmpty()
//12.清空队列
clear()
代码演示
package pk1;
import java.util.*;
public class Main {
public static void main(String[] args) {
Deque<Integer>deque = new LinkedList<>();
deque.addFirst(3);//往队首插入元素3
deque.addFirst(2);//往队首插入元素2
deque.addFirst(1);//往队首插入元素1
deque.addLast(4);//往队尾插入元素4
deque.addLast(5);//往队尾插入元素5
deque.addLast(6);//往队尾插入元素6
System.out.println(deque.size());//查看队列中元素个数------输出6
System.out.println(deque.isEmpty());//查看队列是否为空------输出false
System.out.println(deque.contains(3));//查看队列是否包含3------输出true
System.out.println(deque.getFirst());//查看队首元素------输出1
System.out.println(deque.getLast());//查看队尾元素------输出6
System.out.println(deque.removeFirst());//查看队首元素并弹出队列------输出1
System.out.println(deque.removeFirst());//查看队首元素并弹出队列------输出2
System.out.println(deque.removeFirst());//查看队首元素并弹出队列------输出3
System.out.println(deque.removeLast());//查看队尾元素并弹出队列------输出6
System.out.println(deque.removeLast());//查看队尾元素并弹出队列------输出5
System.out.println(deque.removeLast());//查看队尾元素并弹出队列------输出4
}
}
1.2.3 PriorityQueue的常见用法
- PriorityQueue默认是小根堆，大根堆写法为：
Queue<Integer>q=new PriorityQueue<>(Collections.reverseOrder());
//1.将指定元素插入优先队列
add(element)
//2.删除指定元素（如果存在）
remove(element)
//3.检索并删除队首元素
poll()
//4.检索但不删除队首元素
peek()
//5.判断队列中是否包含某个元素
contains(element)
//6.返回队列中元素个数
size()
//7.判断队列是否非空
isEmpty()
//8.清空队列
clear()
代码演示
//小根堆
package pk1;
import java.util.*;
public class Main {
public static void main(String[] args) {
Queue<Integer>q=new PriorityQueue<>();
q.add(3);//将元素3插入优先队列
q.add(6);//将元素6插入优先队列
q.add(1);//将元素1插入优先队列
q.add(4);//将元素4插入优先队列
q.add(5);//将元素5插入优先队列
q.add(2);//将元素2插入优先队列
System.out.println(q.size());//查看优先队列中元素个数------输出6
System.out.println(q.isEmpty());//查看优先队列是否为空------输出false
System.out.println(q.contains(3));//查看优先队列是否包含3------输出true
System.out.println(q.peek());//查看队首元素------输出1
System.out.println(q.remove(6));//删除元素6------输出true
System.out.println(q.poll());//查看队首元素并弹出队列------输出1
System.out.println(q.poll());//查看队首元素并弹出队列------输出2
System.out.println(q.poll());//查看队首元素并弹出队列------输出3
System.out.println(q.poll());//查看队首元素并弹出队列------输出4
System.out.println(q.poll());//查看队首元素并弹出队列------输出5
}
}
//大根堆
package pk1;
import java.util.*;
public class Main {
public static void main(String[] args) {
Queue<Integer>q=new PriorityQueue<>(Collections.reverseOrder());
q.add(3);//将元素3插入优先队列
q.add(6);//将元素6插入优先队列
q.add(1);//将元素1插入优先队列
q.add(4);//将元素4插入优先队列
q.add(5);//将元素5插入优先队列
q.add(2);//将元素2插入优先队列
System.out.println(q.size());//查看优先队列中元素个数------输出6
System.out.println(q.isEmpty());//查看优先队列是否为空------输出false
System.out.println(q.contains(3));//查看优先队列是否包含3------输出true
System.out.println(q.peek());//查看队首元素------输出6
System.out.println(q.remove(6));//删除元素6------输出true
System.out.println(q.poll());//查看队首元素并弹出队列------输出5
System.out.println(q.poll());//查看队首元素并弹出队列------输出4
System.out.println(q.poll());//查看队首元素并弹出队列------输出3
System.out.println(q.poll());//查看队首元素并弹出队列------输出2
System.out.println(q.poll());//查看队首元素并弹出队列------输出1
}
}
2.集合Set
HashSet和TreeSet的区别：
-
内部数据结构：
HashSet：使用哈希表（HashMap）作为其内部数据结构来存储元素。HashSet通过将元素的哈希码映射到数组索引来快速访问元素。因此，HashSet的元素是无序的，并且不允许重复。TreeSet：使用红黑树（Red-Black Tree）作为其内部数据结构来存储元素。红黑树是一种自平衡排序二叉树，它可以保持元素的有序性。因此，TreeSet的元素是有序的，按照自然顺序或者通过提供的比较器进行排序。同时，TreeSet也不允许重复元素。
-
元素排序：
HashSet：由于使用哈希表存储元素，HashSet不维护元素的任何特定顺序。元素在哈希表中的存储位置是根据其哈希码决定的，因此元素的顺序可能是随机的。TreeSet：通过红黑树的特性，TreeSet会对元素进行排序并保持有序状态。元素默认按照自然顺序进行排序，或者如果提供了比较器（Comparator），则根据比较器进行排序。
-
性能：
HashSet：由于内部使用哈希表，HashSet提供了O(1)的平均时间复杂度来执行添加、删除和查找操作。但是，由于哈希冲突的存在，最坏情况下的插入和查找操作可能需要O(n)的时间复杂度。TreeSet：红黑树作为内部数据结构，TreeSet提供了O(log n)的时间复杂度来执行添加、删除和查找操作。由于元素的有序性，TreeSet还提供了一些特殊的方法，例如获取子集或范围查询。
-
元素唯一性：
HashSet：HashSet不允许重复元素，如果尝试添加一个已经存在的元素，操作将被忽略。TreeSet：TreeSet也不允许重复元素，如果尝试添加一个已经存在的元素，操作将被忽略。
选择使用HashSet还是TreeSet要根据具体的需求来决定。如果需要无序且元素唯一的集合，可以选择HashSet。如果需要有序且元素唯一的集合，并且希望执行范围查询或按照特定顺序访问元素，可以选择TreeSet。
2.1 TreeSet的常用方法
//1.将元素添加到集合中
add(element)
//2.删除集合中指定元素
remove(element)
//3.判断集合中是否包含某个元素
contains(element)
//4.返回集合中元素个数
size()
//5.判断集合是否非空
isEmpty()
//6.返回集合第一个元素
first()
//7.返回集合最后一个元素
last()
//8.返回集合中大于等于from小于to的元素
subSet(from,to)
//9.返回集合中小于指定值的元素
headSet(element)
//10.返回集合中大于等于指定值的元素
tailSet(element)
//11.清空集合
clear()
代码演示
package pk1;
import java.util.*;
public class Main2 {
public static void main(String[] args) {
TreeSet<Integer>s=new TreeSet<Integer>();
s.add(6);//将元素6添加到集合中
s.add(3);//将元素3添加到集合中
s.add(4);//将元素4添加到集合中
s.add(2);//将元素2添加到集合中
s.add(5);//将元素5添加到集合中
System.out.println(s.size());//查看集合中元素个数------输出5
System.out.println(s.isEmpty());//查看集合是否为空------输出false
System.out.println(s.first());//查看集合中的第一个元素------输出2
System.out.println(s.last());//查看集合中的最后一个元素------输出6
System.out.println(s.contains(3));//查看集合是否包含3------输出true
System.out.println(s.subSet(3,6));//返回集合中大于等于3小于6的元素的子集合------输出[3,4,5]
System.out.println(s.headSet(3));//返回集合中小于3的元素的子集合------输出[2]
System.out.println(s.tailSet(3));//返回集合中大于等于3的元素的子集合------输出[3,4,5,6]
System.out.println(s.remove(3));//删除元素3------输出true
}
}
2.2 HashSet的常见方法
//1.将元素添加到集合中
add(element)
//2.删除集合中指定元素
remove(element)
//3.判断集合中是否包含某个元素
contains(element)
//4.返回集合中元素个数
size()
//5.判断集合是否非空
isEmpty()
//6.清空集合
clear()
代码演示
package pk1;
import java.util.*;
public class Main {
public static void main(String[] args) {
HashSet<Integer>s=new HashSet<Integer>();
s.add(6);//将元素6添加到集合中
s.add(3);//将元素3添加到集合中
s.add(4);//将元素4添加到集合中
s.add(2);//将元素2添加到集合中
s.add(5);//将元素5添加到集合中
System.out.println(s.size());//查看集合中元素个数------输出5
System.out.println(s.isEmpty());//查看集合是否为空------输出false
System.out.println(s.contains(3));//查看集合是否包含3------输出true
System.out.println(s.remove(3));//删除元素3------输出true
}
}
3.映射Map
HashMap和TreeMap的区别：
-
内部数据结构：
HashMap：使用哈希表（Hash Table）作为其内部数据结构来存储键值对。HashMap通过将键的哈希码映射到数组索引来快速访问值。因此，HashMap的键是无序的，并且不允许重复。值可以重复。TreeMap：使用红黑树（Red-Black Tree）作为其内部数据结构来存储键值对。红黑树是一种自平衡排序二叉树，它可以保持键的有序性。因此，TreeMap的键是有序的，按照自然顺序或者通过提供的比较器进行排序。键不允许重复，但值可以重复。
-
键的排序：
HashMap：由于使用哈希表存储键值对，HashMap不维护键的任何特定顺序。键的存储位置是根据其哈希码决定的，因此键的顺序可能是随机的。TreeMap：通过红黑树的特性，TreeMap会根据键的顺序对键值对进行排序并保持有序状态。键默认按照自然顺序进行排序，或者如果提供了比较器（Comparator），则根据比较器进行排序。
-
性能：
HashMap：由于内部使用哈希表，HashMap提供了O(1)的平均时间复杂度来执行添加、删除和查找操作。但是，由于哈希冲突的存在，最坏情况下的插入和查找操作可能需要O(n)的时间复杂度。TreeMap：红黑树作为内部数据结构，TreeMap提供了O(log n)的时间复杂度来执行添加、删除和查找操作。由于键的有序性，TreeMap还提供了一些特殊的方法，例如获取子映射或范围查询。
-
迭代顺序：
HashMap：由于键的无序性，HashMap的迭代顺序是不确定的，并且可能随着时间的推移而改变。TreeMap：由于键的有序性，TreeMap的迭代顺序将按照键的顺序进行。因此，对TreeMap进行迭代将按照键的升序（或提供的比较器的顺序）进行。
-
空间消耗：
HashMap：由于使用哈希表存储键值对，HashMap通常在空间上比TreeMap更高效，因为它不需要额外的空间来维护树结构。TreeMap：由于使用红黑树存储键值对，TreeMap通常在空间上比HashMap更消耗内存，因为它需要额外的空间来存储树的结构信息。
选择使用HashMap还是TreeMap要取决于具体的需求。如果需要无序且键唯一的映射，可以选择HashMap。如果需要有序且键唯一的映射，并且希望按照键的顺序访问映射条目，可以选择TreeMap。同时，对于大量的数据和范围查询需求，TreeMap可能会更适合，而对于频繁的插入和查找操作，HashMap可能更高效。
3.1 TreeMap的常见方法
//1.将指定的键/值映射（条目）插入到映射中
put(key,value)
//2.返回与指定键关联的值
get(key)
//3.返回并从TreeMap中删除与指定键关联的条目
remove(key)
//4.用key新的值value替换原映射的值
replace(key, value)
//5.判断TreeMap是否包含指定key
containsKey(key)
//6.判断TreeMap是否包含指定value
containsValue(value)
//7.返回treeMap中的第一个元素
firstEntry()
//8.返回treeMap中的最后一个元素
lastEntry()
//9.返回key大于等于参数key的元素的最小的key
ceilingKey(key)
//10.返回key小于等于参数key的元素的最大的key
floorKey(key)
//11.返回key大于参数key的元素的最小的key
higherKey(key)
//12.返回小于指定key的元素的最大的key。
lowerKey(key)
//13.返回TreeMap中映射的对数
size()
//14.判断TreeMap是否为空
isEmpty()
//15.清空TreeMap中的所有元素
clear()
代码演示
package pk1;
import java.util.*;
public class Main {
public static void main(String[] args) {
TreeMap<Integer,String>mp=new TreeMap<>();
mp.put(1, "aaa");//将键值对(1, "aaa")插入映射
mp.put(2, "bbb");//将键值对(2, "bbb")插入映射
mp.put(3, "ccc");//将键值对(3, "ccc")插入映射
mp.put(4, "ddd");//将键值对(4, "ddd")插入映射
System.out.println(mp.size());//查看TreeMap中映射的对数------输出4
System.out.println(mp.isEmpty());//查看TreeMap是否非空------输出false
System.out.println(mp.get(2));//查看键2对应的值------输出bbb
System.out.println(mp.replace(2, "BBB"));//将键2对应的值替换为BBB，返回原键2对应的值bbb
System.out.println(mp.containsKey(2));//查看TreeMap是否包含键2------输出true
System.out.println(mp.containsValue("BBB"));//查看TreeMap是否包含值"BBB"------输出true
System.out.println(mp.ceilingKey(2));//返回key大于等于参数key的元素的最小的key------输出2
System.out.println(mp.floorKey(2));//返回key小于等于参数key的元素的最大的key------输出2
System.out.println(mp.higherKey(2));//返回key大于参数key的元素的最小的key------输出3
System.out.println(mp.lowerKey(2));//返回小于指定key的元素的最大的key------输出1
System.out.println(mp.remove(2));//返回并从TreeMap中删除与键2关联的条目-----输出BBB
System.out.println(mp.containsKey(2));//查看TreeMap是否包含键2------输出false
}
}
3.2 HashMap的常见方法
//1.将指定的键/值映射（条目）插入到映射中
put(key,value)
//2.返回与指定键关联的值
get(key)
//3.返回并从HashMap中删除与指定键关联的条目
remove(key)
//4.用key新的值value替换原映射的值
replace(key, value)
//5.判断HashMap是否包含指定key
containsKey(key)
//6.判断HashMap是否包含指定value
containsValue(value)
//7.返回HashMap中映射的对数
size()
//8.判断HashMap是否为空
isEmpty()
//9.清空HashMap中的所有元素
clear()
代码演示
package pk1;
import java.util.*;
public class Main {
public static void main(String[] args) {
HashMap<Integer,String>mp=new HashMap<>();
mp.put(1, "aaa");//将键值对(1, "aaa")插入映射
mp.put(2, "bbb");//将键值对(2, "bbb")插入映射
mp.put(3, "ccc");//将键值对(3, "ccc")插入映射
mp.put(4, "ddd");//将键值对(4, "ddd")插入映射
System.out.println(mp.size());//查看TreeMap中映射的对数------输出4
System.out.println(mp.isEmpty());//查看TreeMap是否非空------输出false
System.out.println(mp.get(2));//查看键2对应的值------输出bbb
System.out.println(mp.replace(2, "BBB"));//将键2对应的值替换为BBB，返回原键2对应的值bbb
System.out.println(mp.containsKey(2));//查看TreeMap是否包含键2------输出true
System.out.println(mp.containsValue("BBB"));//查看TreeMap是否包含值"BBB"------输出true
System.out.println(mp.remove(2));//返回并从TreeMap中删除与键2关联的条目-----输出BBB
System.out.println(mp.containsKey(2));//查看TreeMap是否包含键2------输出false
}
}
4.List的常见方法
//1.向list中添加元素
add(element)
//2.获取下标为idx的元素
get(idx)
//3.删除下标为idx的元素
remove(idx)
//4.删除值为val的元素，其中val为Object类型
remove(val)
//5.判断list中是否包含某个元素
contains(item)
//6.修改下标为idx的元素的值
set(idx,element)
//7.返回指定元素的索引
indexOf(element)
//8.判断list是否非空
isEmpty()
//9.将集合转换为字符串
toString()
//10.将集合转换为数组
toArray()
//11.返回iterator迭代器对象
iterator()
代码演示
package pk1;
import java.util.*;
public class Main{
public static void main(String[] args){
List<Integer>list = new ArrayList<>();
list.add(10);//向list中添加元素10
list.add(20);//向list中添加元素20
list.add(30);//向list中添加元素30
list.add(40);//向list中添加元素40
for(int i=0;i<list.size();i++)System.out.print(list.get(i)+" ");//输出10 20 30 40
System.out.println();
list.remove(1);//按下标删除：删除下标为1的元素20
for(int i=0;i<list.size();i++)System.out.print(list.get(i)+" ");//输出10 30 40
System.out.println();
Integer x = 30;
list.remove(x);//按值删除：删除值为30的元素
for(int i=0;i<list.size();i++)System.out.print(list.get(i)+" ");//输出10 40
System.out.println();
System.out.println(list.get(0));//输出下标为0的元素，输出10
System.out.println(list.contains(40));//判断list中是否包含40，输出true
list.set(0,100);//将list中下标为0的元素改为100
for(int i=0;i<list.size();i++)System.out.print(list.get(i)+" ");//输出100 40
System.out.println();
System.out.println(list.indexOf(100));//返回list中100所对应的索引下标，输出0
System.out.println(list.isEmpty());//判断list是否非空，输出false
System.out.println(list.toString());//将list转换为字符串并输出，输出[100, 40]
//将list转换为数组并输出
Integer[] res = new Integer[2];
res = list.toArray(res);
for(int i=0;i<res.length;i++)System.out.print(res[i]+" ");//输出100 40
}
}
