蓝桥杯JAVA-9.集合（容器）在竞赛中的快速入门使用

墨水记忆

4510人浏览 · 2021-12-17 15:49:46

墨水记忆 · 2021-12-17 15:49:46 发布

Modifier and Type	Method and Description
`boolean`	`add(E e)`将指定的元素追加到此列表的末尾（可选操作）。
`void`	`add(int index, E element)`将指定的元素插入此列表中的指定位置（可选操作）。
`boolean`	`addAll(Collection<? extends E> c)`按指定集合的迭代器（可选操作）返回的顺序将指定集合中的所有元素附加到此列表的末尾。
`boolean`	`addAll(int index, Collection<? extends E> c)`将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。
`void`	`clear()`从此列表中删除所有元素（可选操作）。
`boolean`	`contains(Object o)`如果此列表包含指定的元素，则返回 `true` 。
`boolean`	`containsAll(Collection<?> c)`如果此列表包含指定 `集合的`所有元素，则返回true。
`boolean`	`equals(Object o)`将指定的对象与此列表进行比较以获得相等性。
`E`	`get(int index)`返回此列表中指定位置的元素。
`int`	`hashCode()`返回此列表的哈希码值。
`int`	`indexOf(Object o)`返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
`boolean`	`isEmpty()`如果此列表不包含元素，则返回 `true` 。
`Iterator<E>`	`iterator()`以正确的顺序返回该列表中的元素的迭代器。
`int`	`lastIndexOf(Object o)`返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
`ListIterator<E>`	`listIterator()`返回列表中的列表迭代器（按适当的顺序）。
`ListIterator<E>`	`listIterator(int index)`从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
`E`	`remove(int index)`删除该列表中指定位置的元素（可选操作）。
`boolean`	`remove(Object o)`从列表中删除指定元素的第一个出现（如果存在）（可选操作）。
`boolean`	`removeAll(Collection<?> c)`从此列表中删除包含在指定集合中的所有元素（可选操作）。
`default void`	`replaceAll(UnaryOperator<E> operator)`将该列表的每个元素替换为将该运算符应用于该元素的结果。
`boolean`	`retainAll(Collection<?> c)`仅保留此列表中包含在指定集合中的元素（可选操作）。
`E`	`set(int index, E element)`用指定的元素（可选操作）替换此列表中指定位置的元素。
`int`	`size()`返回此列表中的元素数。
`default void`	`sort(Comparator<? super E> c)`使用随附的 `Comparator`排序此列表来比较元素。
`default Spliterator<E>`	`spliterator()`在此列表中的元素上创建一个`Spliterator` 。
`List<E>`	`subList(int fromIndex, int toIndex)`返回此列表中指定的 `fromIndex` （含）和 `toIndex`之间的视图。
`Object[]`	`toArray()`以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
`<T> T[]`	`toArray(T[] a)`以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。

public static void main(String[] args) throws Exception {
  List<Integer> list = new ArrayList<>();
  List<Integer> two = new ArrayList<>();
  //增加
  list.add(5); //单个增加
  list.add(2,9); //在指定位置2插入元素9
  list.addAll(two); //将集合two中的元素全部添加到list中
  list.addAll(3,two); //在指定位置将集合two中的元素全部添加到list中
  //删除
  list.clear(); //删除所有元素
  list.remove(2); //删除指定索引下标元素
  list.removeAll(two); //删除list中存在于指定集合two中的元素

  //查找
  list.lastIndexOf(5); //返回指定元素在 arraylist 中最后一次出现的位置
  list.contains(2); //判断元素是否存在
  list.retainAll(two); //保留list中在指定集合two中也存在的那些元素
  list.containsAll(two);  //查看list是否包含指定集合two中的所有元素
  list.indexOf(6); //返回list中元素的索引值
  list.get(6); //通过索引获取元素

  //替换
  list.set(2,5); //替换list中指定索引为2的元素为5

  //其他操作
  list.isEmpty(); //判断list是否为空
  list.size(); //返回list里元素数量
  list.subList(2,6); //通过索引截取部分list中的元素
  list.equals(two); //将指定的对象与此列表进行比较以获得相等性,当大小、内容全部相同返回true，否则返回false
  list.toArray(); //以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组,也可以指定返回数组的类型
}

1.2 Set

Modifier and Type	Method and Description
`boolean`	`add(E e)`如果指定的元素不存在，则将其指定的元素添加（可选操作）。
`boolean`	`addAll(Collection<? extends E> c)`将指定集合中的所有元素添加到此集合（如果尚未存在）（可选操作）。
`void`	`clear()`从此集合中删除所有元素（可选操作）。
`boolean`	`contains(Object o)`如果此集合包含指定的元素，则返回 `true` 。
`boolean`	`containsAll(Collection<?> c)`返回 `true`如果此集合包含所有指定集合的元素。
`boolean`	`equals(Object o)`将指定的对象与此集合进行比较以实现相等。
`int`	`hashCode()`返回此集合的哈希码值。
`boolean`	`isEmpty()`如果此集合不包含元素，则返回 `true` 。
`Iterator<E>`	`iterator()`返回此集合中元素的迭代器。
`boolean`	`remove(Object o)`如果存在，则从该集合中删除指定的元素（可选操作）。
`boolean`	`removeAll(Collection<?> c)`从此集合中删除指定集合中包含的所有元素（可选操作）。
`boolean`	`retainAll(Collection<?> c)`仅保留该集合中包含在指定集合中的元素（可选操作）。
`int`	`size()`返回此集合中的元素数（其基数）。
`default Spliterator<E>`	`spliterator()`在此集合中的元素上创建一个 `Spliterator` 。
`Object[]`	`toArray()`返回一个包含此集合中所有元素的数组。
`<T> T[]`	`toArray(T[] a)`返回一个包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

public static void main(String[] args) throws Exception {
  Set<Integer> ttf = new TreeSet<>();
  Set<Integer> two = new TreeSet<>();
  //增加
  ttf.add(5); //单个增加
  ttf.addAll(two); //将集合two中的元素全部添加到ttf中
  //删除
  ttf.clear(); //删除所有元素
  ttf.remove(2); //删除指定元素
  ttf.removeAll(two); //删除ttf中存在于指定集合two中的元素

  //查找
  ttf.contains(2); //判断元素是否存在
  ttf.retainAll(two); //保留ttf中在指定集合two中也存在的那些元素
  ttf.containsAll(two);  //查看ttf是否包含指定集合two中的所有元素

  //其他操作
  ttf.isEmpty(); //判断ttf是否为空
  ttf.size(); //返回ttf里元素数量
  ttf.equals(two); //将指定的对象与此列表进行比较以获得相等性,当大小、内容全部相同返回true，否则返回false
  ttf.toArray(); //以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组,也可以指定返回数组的类型
}

2.Map

Modifier and Type	Method and Description
`void`	`clear()`从该地图中删除所有的映射（可选操作）。
`default V`	`compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`尝试计算指定键的映射及其当前映射的值（如果没有当前映射， `null` ）。
`default V`	`computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)`如果指定的键尚未与值相关联（或映射到 `null` ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非 `null` 。
`default V`	`computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。
`boolean`	`containsKey(Object key)`如果此映射包含指定键的映射，则返回 `true` 。
`boolean`	`containsValue(Object value)`如果此地图将一个或多个键映射到指定的值，则返回 `true` 。
`Set<Map.Entry<K,V>>`	`entrySet()`返回此地图中包含的映射的`Set`视图。
`boolean`	`equals(Object o)`将指定的对象与此映射进行比较以获得相等性。
`default void`	`forEach(BiConsumer<? super K,? super V> action)`对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。
`V`	`get(Object key)`返回到指定键所映射的值，或 `null`如果此映射包含该键的映射。
`default V`	`getOrDefault(Object key, V defaultValue)`返回到指定键所映射的值，或 `defaultValue`如果此映射包含该键的映射。
`int`	`hashCode()`返回此地图的哈希码值。
`boolean`	`isEmpty()`如果此地图不包含键值映射，则返回 `true` 。
`Set<K>`	`keySet()`返回此地图中包含的键的`Set`视图。
`default V`	`merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)`如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。
`V`	`put(K key, V value)`将指定的值与该映射中的指定键相关联（可选操作）。
`void`	`putAll(Map<? extends K,? extends V> m)`将指定地图的所有映射复制到此映射（可选操作）。
`default V`	`putIfAbsent(K key, V value)`如果指定的键尚未与某个值相关联（或映射到 `null` ）将其与给定值相关联并返回 `null` ，否则返回当前值。
`V`	`remove(Object key)`如果存在（从可选的操作），从该地图中删除一个键的映射。
`default boolean`	`remove(Object key, Object value)`仅当指定的密钥当前映射到指定的值时删除该条目。
`default V`	`replace(K key, V value)`只有当目标映射到某个值时，才能替换指定键的条目。
`default boolean`	`replace(K key, V oldValue, V newValue)`仅当当前映射到指定的值时，才能替换指定键的条目。
`default void`	`replaceAll(BiFunction<? super K,? super V,? extends V> function)`将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。
`int`	`size()`返回此地图中键值映射的数量。
`Collection<V>`	`values()`返回此地图中包含的值的`Collection`视图。

public static void main(String[] args) throws Exception {
  Map<String,Integer> map = new HashMap<>();
  Map<String,Integer> two = new HashMap<>();
  //增加
  map.put("key",123);
  map.putAll(two); //将指定map复制到此map（可选操作）。
  //删除
  map.clear(); //删除所有的映射（可选操作）。
  map.remove("key"); //如果存在，从该地图中删除一个键的映射。
  map.remove("key",159); //删除符合的键值对
  //查找
  map.containsKey("key"); //如果此映射包含指定键的映射，则返回 true 。
  map.containsValue("value"); //如果此地图将一个或多个键映射到指定的值，则返回 true 。
  map.entrySet(); //返回包含映射的Set集合,返回类型 Set<Map.Entry<K,V>>
  map.get("key"); //返回指定键所映射的值，如果没有此键则返回null
  map.getOrDefault("key",456); ////返回指定键所映射的值，如果没有则返回设置的默认值。
  map.keySet(); //返回包含的键的Set集合。Set<K>
  map.values(); //返回包含的值的Collection集合。 Collection<V>
  //替换
  map.replace("key", 456); //找到指定的键，修改并返回原来的值。
  map.replace("key", 123, 789); //找到key为key，值为123的，才将123修改为789。否则不修改。
  //其他
  map.isEmpty(); //如果不包含键值映射，则返回 true 。
  map.equals("156"); //将指定的对象与此映射进行比较
  map.putIfAbsent("key",789); //如果指定的键尚未与某个值相关联（或映射到 null ）,则将其与给定值相关联并返回 null ，如果已经有关联的值，则返回。
  map.size(); //键值对的数量
}

3.其他

3.1 Map.Entry

一个Java中类似于C++中的Pair的容器。Map.Entry是Map的一个内部接口。配合Map使用。

主要的三个方法。

K getKey()：
V getValue()：
V setValue(V value)

public static void main(String[] args) throws Exception {
  Scanner sc = new Scanner(System.in);
  LinkedHashMap<String,Integer> lm = new LinkedHashMap<>();
  lm.put("C",3);
  lm.put("A",1);
  lm.put("B",2);
  lm.put("D",4);
  Set<Map.Entry<String, Integer>> ent = lm.entrySet();
  Iterator<Map.Entry<String, Integer>> it = ent.iterator();
  while(it.hasNext()){
    Map.Entry<String,Integer> mid = it.next();
    System.out.println(mid.getKey());
    System.out.println(mid.getValue());
  }
}

//输出
C
3
A
1
B
2
D
4

public static void main(String[] args) throws Exception {
  Scanner sc = new Scanner(System.in);
  LinkedHashMap<String,Integer> lm = new LinkedHashMap<>();
  lm.put("C",3);
  lm.put("A",1);
  lm.put("B",2);
  lm.put("D",4);
  Set<Map.Entry<String, Integer>> ent = lm.entrySet();
  Iterator<Map.Entry<String, Integer>> it = ent.iterator();
  while(it.hasNext()){
    Map.Entry<String,Integer> mid = it.next();
    System.out.println(mid.getKey());
    System.out.println(mid.getValue());
    mid.setValue(23);
  }
  System.out.println("修改后：");
  Iterator<Map.Entry<String, Integer>> it2 = ent.iterator();
  while(it2.hasNext()){
    Map.Entry<String,Integer> mid = it2.next();
    System.out.println(mid.getKey());
    System.out.println(mid.getValue());
  }
}

//输出
C
3
A
1
B
2
D
4
修改后：
C
23
A
23
B
23
D
23

3.2 Stack（栈）

返回值	方法描述
`boolean`	`empty()`测试此堆栈是否为空。
`E`	`peek()`查看栈顶元素。
`E`	`pop()`删除栈顶元素，并将该元素作为返回值返回。
`E`	`push(E item)添加元素到堆栈的顶部。与addElement(item)效果完全相同。
`int`	`search(Object o)`返回一个对象在此堆栈上的基于1的位置。

    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        Stack<Integer> s = new Stack<Integer>();
        System.out.println(s.empty()? "是空的":"不是空的");
        System.out.println("现在Stack的大小为："+s.size());
        System.out.println("输入第一个元素：");
        int a = sc.nextInt();
        s.push(a);
        System.out.println(s.empty()? "是空的":"不是空的");
        System.out.println("现在Stack的大小为："+s.size());
        System.out.println("输入第二个元素：");
        int b = sc.nextInt();
        s.push(b);
        System.out.println(s.empty()? "是空的":"不是空的");
        System.out.println("现在Stack的大小为："+s.size());
        System.out.println("输入第三个元素：");
        int c = sc.nextInt();
        s.push(c);
        System.out.println(s.empty()? "是空的":"不是空的");
        System.out.println("现在Stack的大小为："+s.size());

        System.out.println("Stack中的元素有：");
        while (!s.empty()){
            System.out.println(s.peek());
            System.out.println("删除了："+s.pop()); //删除
        }

    }

//依次输入
7 
13 
23
//输出
是空的
现在Stack的大小为：0
输入第一个元素：
7
不是空的
现在Stack的大小为：1
输入第二个元素：
13
不是空的
现在Stack的大小为：2
输入第三个元素：
23
不是空的
现在Stack的大小为：3
Stack中的元素有：
23
删除了：23
13
删除了：13
7
删除了：7

3.3 Queue（队列）

Queue的6个方法分类：

压入元素(添加)：add()、offer()
相同：未超出容量，从队尾压入元素，并返回压入的元素。
区别：在超出容量时，add()方法会对抛出异常，offer()返回false
弹出元素(删除)：remove()、poll()
相同：容量大于0的时候，删除并返回队头元素。
区别：在容量为0的时候，remove()会抛出异常，poll()返回false
获取队头元素(不删除)：element()、peek()
相同：容量大于0的时候，都返回队头元素。但是不删除。
区别：容量为0的时候，element()会抛出异常，peek()返回null。

LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。

import java.util.LinkedList;
import java.util.Queue;
 
public class Main {
    public static void main(String[] args) {
        //add()和remove()方法在失败的时候会抛出异常(不推荐)
        Queue<String> queue = new LinkedList<String>();
        //添加元素
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        queue.offer("e");
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("poll="+queue.poll()); //返回第一个元素，并在队列中删除
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("element="+queue.element()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
        System.out.println("===");
        System.out.println("peek="+queue.peek()); //返回第一个元素 
        for(String q : queue){
            System.out.println(q);
        }
    }
}

3.4 Deque（双端队列）

Deque是一个双端队列接口，继承自Queue接口，Deque的实现类是LinkedList、ArrayDeque、LinkedBlockingDeque，其中LinkedList是最常用的。

注意：Java堆栈Stack类已经过时，Java官方推荐使用Deque替代Stack使用。Deque堆栈操作方法：push()、pop()、peek()。

Deque有三种用途：

普通队列(一端进另一端出):
Queue queue = new LinkedList()或Deque deque = new LinkedList()
双端队列(两端都可进出)
Deque deque = new LinkedList()
堆栈
Deque deque = new LinkedList()

在将双端队列用作队列时，将得到 FIFO（先进先出）行为。将元素添加到双端队列的末尾，从双端队列的开头移除元素。

Queue方法	等效Deque方法
add(e)	addLast(e)
offer(e)	offerLast(e)
remove()	removeFirst()
poll()	pollFirst()
element()	getFirst()
peek()	peekFirst()

双端队列也可用作 LIFO（后进先出）堆栈。应优先使用此接口而不是遗留 Stack 类。在将双端队列用作堆栈时，元素被推入双端队列的开头并从双端队列开头弹出。

堆栈方法	等效Deque方法
push(e)	addFirst(e)
pop()	removeFirst()
peek()	peekFirst()

当作普通队列，就用普通队列的方法，当作双端队列就用双端队列的方法，当作堆栈就用堆栈的方法。

3.5 PriorityQueue（优先队列）

返回值	方法描述
`boolean`	`add(E e)`将指定的元素插入到此优先级队列中。
`void`	`clear()`从此优先级队列中删除所有元素。
`Comparator<? super E>`	`comparator()`返回用于为了在这个队列中的元素，或比较`null`如果此队列根据所述排序natural ordering的元素。
`boolean`	`contains(Object o)`如果此队列包含指定的元素，则返回 `true` 。
`Iterator<E>`	`iterator()`返回此队列中的元素的迭代器。
`boolean`	`offer(E e)`将指定的元素插入到此优先级队列中。
`E`	`peek()`检索但不删除此队列的头，如果此队列为空，则返回 `null` 。
`E`	`poll()`检索并删除此队列的头，如果此队列为空，则返回 `null` 。
`boolean`	`remove(Object o)`从该队列中删除指定元素的单个实例（如果存在）。
`int`	`size()`返回此集合中的元素数。
`Spliterator<E>`	`spliterator()`在此队列中的元素上创建late-binding和失败快速 `Spliterator` 。
`Object[]`	`toArray()`返回一个包含此队列中所有元素的数组。
`<T> T[]`	`toArray(T[] a)`返回一个包含此队列中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

常用方法：

peek()//返回队首元素
poll()//返回队首元素，队首元素出队列
add()//添加元素
offer()//添加元素
size()//返回队列元素个数
isEmpty()//判断队列是否为空，为空返回true,不空返回false

//自定义比较器，降序排列
static Comparator<Integer> cmp = new Comparator<Integer>() {
      public int compare(Integer e1, Integer e2) {
        return e2 - e1;
      }
    };
public static void main(String[] args) {
        //不用比较器，默认升序排列
        Queue<Integer> q = new PriorityQueue<>();
        q.add(3);
        q.add(2);
        q.add(4);
        while(!q.isEmpty())
        {
            System.out.print(q.poll()+" ");
        }
        /**
         * 输出结果
         * 2 3 4 
         */
        //使用自定义比较器，降序排列
        Queue<Integer> qq = new PriorityQueue<>(cmp);
        qq.add(3);
        qq.add(2);
        qq.add(4);
        while(!qq.isEmpty())
        {
            System.out.print(qq.poll()+" ");
        }
        /**
         * 输出结果
         * 4 3 2 
         */
}

自定义类：

//矩形类
class Node{
    public Node(int chang,int kuan)
    {
        this.chang=chang;
        this.kuan=kuan;
    }
    int chang;
    int kuan;
}

public class Test {
　　　　//自定义比较类，先比较长，长升序排列，若长相等再比较宽，宽降序
    static Comparator<Node> cNode=new Comparator<Node>() {
        public int compare(Node o1, Node o2) {
            if(o1.chang!=o2.chang)
                return o1.chang-o2.chang;
            else
                return o2.kuan-o1.kuan;
        }
        
    };
    public static void main(String[] args) {
        Queue<Node> q=new PriorityQueue<>(cNode);
        Node n1=new Node(1, 2);
        Node n2=new Node(2, 5);
        Node n3=new Node(2, 3);
        Node n4=new Node(1, 2);
        q.add(n1);
        q.add(n2);
        q.add(n3);
        Node n;
        while(!q.isEmpty())
        {
            n=q.poll();
            System.out.println("长: "+n.chang+" 宽：" +n.kuan);
        }
　　　　　/**
　　　　　　* 输出结果
　　　　　　* 长: 1 宽：2
　　　　　　* 长: 2 宽：5
　　　　　　* 长: 2 宽：3
　　　　　　*/
    }
}

优先队列遍历。PriorityQueue的iterator（）不保证以任何特定顺序遍历队列元素。若想按特定顺序遍历，先将队列转成数组，然后排序遍历

Queue<Integer> q = new PriorityQueue<>(cmp);
        int[] nums= {2,5,3,4,1,6};
        for(int i:nums)
        {
            q.add(i);
        }
        Object[] nn=q.toArray();
        Arrays.sort(nn);
        for(int i=nn.length-1;i>=0;i--)
            System.out.print((int)nn[i]+" ");
        /**
         * 输出结果
         * 6 5 4 3 2 1 
         */

比较器生降序说明

Comparator<Object> cmp = new Comparator<Object>() {
        public int compare(Object o1, Object o2) {
            //升序
            return o1-o2;
            //降序
            return o2-o1;
        }
    };

详细自定义比较器的返回值如何理解，可见《蓝桥杯JAVA-3.自定义排序、进制转换、保留小数位数》

3.6 Pair

获取Key值：getKey()。
获取Value值：getValue()。

public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        //单个
        Pair<String,Integer> test = new Pair<>("qwer",234);
        System.out.println(test.getKey());
        System.out.println(test.getValue());

        //数组
        Pair<String,Integer>[] pair = new Pair[52];
        pair[0] = new Pair<>("23",23);
        pair[1] = new Pair<>("2323",2323);
        pair[2] = new Pair<>("223343",2343);
        for (int i = 0; i < 3; i++) {
            String s = pair[i].getKey();
            System.out.println(s);
            int t  = pair[i].getValue();
            System.out.println(t);
        }

    }