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的区别：

1. 内部数据结构：
   
   HashSet：使用哈希表（HashMap）作为其内部数据结构来存储元素。HashSet通过将元素的哈希码映射到数组索引来快速访问元素。因此，HashSet的元素是无序的，并且不允许重复。

   TreeSet：使用红黑树（Red-Black Tree）作为其内部数据结构来存储元素。红黑树是一种自平衡排序二叉树，它可以保持元素的有序性。因此，TreeSet的元素是有序的，按照自然顺序或者通过提供的比较器进行排序。同时，TreeSet也不允许重复元素。

2. 元素排序：
   
   HashSet：由于使用哈希表存储元素，HashSet不维护元素的任何特定顺序。元素在哈希表中的存储位置是根据其哈希码决定的，因此元素的顺序可能是随机的。

   TreeSet：通过红黑树的特性，TreeSet会对元素进行排序并保持有序状态。元素默认按照自然顺序进行排序，或者如果提供了比较器（Comparator），则根据比较器进行排序。

3. 性能：
   
   HashSet：由于内部使用哈希表，HashSet提供了O(1)的平均时间复杂度来执行添加、删除和查找操作。但是，由于哈希冲突的存在，最坏情况下的插入和查找操作可能需要O(n)的时间复杂度。

   TreeSet：红黑树作为内部数据结构，TreeSet提供了O(log n)的时间复杂度来执行添加、删除和查找操作。由于元素的有序性，TreeSet还提供了一些特殊的方法，例如获取子集或范围查询。

4. 元素唯一性：
   
   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的区别：

1. 内部数据结构：
   
   HashMap：使用哈希表（Hash Table）作为其内部数据结构来存储键值对。HashMap通过将键的哈希码映射到数组索引来快速访问值。因此，HashMap的键是无序的，并且不允许重复。值可以重复。

   TreeMap：使用红黑树（Red-Black Tree）作为其内部数据结构来存储键值对。红黑树是一种自平衡排序二叉树，它可以保持键的有序性。因此，TreeMap的键是有序的，按照自然顺序或者通过提供的比较器进行排序。键不允许重复，但值可以重复。

2. 键的排序：
   
   HashMap：由于使用哈希表存储键值对，HashMap不维护键的任何特定顺序。键的存储位置是根据其哈希码决定的，因此键的顺序可能是随机的。

   TreeMap：通过红黑树的特性，TreeMap会根据键的顺序对键值对进行排序并保持有序状态。键默认按照自然顺序进行排序，或者如果提供了比较器（Comparator），则根据比较器进行排序。

3. 性能：
   
   HashMap：由于内部使用哈希表，HashMap提供了O(1)的平均时间复杂度来执行添加、删除和查找操作。但是，由于哈希冲突的存在，最坏情况下的插入和查找操作可能需要O(n)的时间复杂度。

   TreeMap：红黑树作为内部数据结构，TreeMap提供了O(log n)的时间复杂度来执行添加、删除和查找操作。由于键的有序性，TreeMap还提供了一些特殊的方法，例如获取子映射或范围查询。

4. 迭代顺序：
   
   HashMap：由于键的无序性，HashMap的迭代顺序是不确定的，并且可能随着时间的推移而改变。

   TreeMap：由于键的有序性，TreeMap的迭代顺序将按照键的顺序进行。因此，对TreeMap进行迭代将按照键的升序（或提供的比较器的顺序）进行。

5. 空间消耗：
   
   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
    }
}