Java中的集合略述-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_69331283/article/details/140901622

一、什么是集合？

集合可以用于存储多个元素，并且可以动态改变大小。并且提供了一系列方法来操作集合中的数据。集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

二、Java集合体系结构

主要分为单列结合和双列集合

三、 Collection集合

（一） Collection集合概述

是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素，JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现。

（二）常用方法

`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()` 返回此集合中的元素的迭代器。
`default Stream<E>`	`parallelStream()` 返回一个可能并行 `Stream`与集合的来源。
`boolean`	`remove(Object o)` 从这个集合中移除指定元素的一个实例，如果它是存在的（可选操作）。
`boolean`	`removeAll(Collection<?> c)` 删除此集合中包含的所有元素（可选操作）的所有元素（可选操作）。
`default boolean`	`removeIf(Predicate<? super E> filter)` 删除满足给定谓词的这个集合的所有元素。
`boolean`	`retainAll(Collection<?> c)` 仅保留包含在指定集合中的这个集合中的元素（可选操作）。
`int`	`size()` 返回此集合中的元素的数目。
`default Spliterator<E>`	`spliterator()` 创建此集合中的元素的 `Spliterator`。
`default Stream<E>`	`stream()` 返回一个序列 `Stream`与集合的来源。
`Object[]`	`toArray()` 返回包含此集合中所有元素的数组。
`<T> T[]`	`toArray(T[] a)` 返回包含此集合中所有元素的数组；返回数组的运行时类型是指定的数组的运行时类型。

（三）Collection集合的遍历

方式一：迭代器,集合的专用遍历方式

Iterator<E> iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

Iterator中的常用方法

boolean	hasNext(): 判断当前位置是否有元素可以被取出
E	next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

代码示例

 //创建集合对象
        Collection<String> c = new ArrayList<>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("javaee");

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

        //用while循环改进元素的判断和获取
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }

方式二：增强for循环遍历

它是JDK5之后出现的,其内部原理是一个Iterator迭代器实现Iterable接口的类才可以使用迭代器和增强for，简化数组和Collection集合的遍历，格式如下：

for(集合/数组中元素的数据类型变量名 : 集合/数组名) {

// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可

}

代码示例

 ArrayList<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        //1,数据类型一定是集合或者数组中元素的类型
        //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
        //3,list就是要遍历的集合或者数组
        for(String str : list){
            System.out.println(str);
        }

四、List集合

特点：有序、可重复、有索引

（一）常用方法

`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)` 返回一个数组，包含在这个列表中的所有元素在适当的顺序（从第一到最后一个元素）；返回数组的运行时类型是指定的数组的运行时类型。

（二）List集合的实现类

- ArrayList集合

底层是数组结构实现，查询快、增删慢，线程不安全

- LinkedList集合

底层是链表结构实现，查询慢、增删快，线程不安全

-Vector集合

底层是数组结构实现，查询快、增删慢,线程安全

-Stack集合

继承自Vector类实现的一个后进先出的数据结构

（三） LinkedList集合的特有方

public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

五、Set集合

特点：不可以存储重复元素；没有索引,不能使用普通for循环遍历

使用：

public class MySet1 {
    public static void main(String[] args) {
      	//创建集合对象
        Set<String> set = new TreeSet<>();
      	//添加元素
        set.add("ccc");
        set.add("aaa");
        set.add("aaa");
        set.add("bbb");

//        for (int i = 0; i < set.size(); i++) {
//            //Set集合是没有索引的，所以不能使用通过索引获取元素的方法
//        }
      
      	//遍历集合
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------------------");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

（一）TreeSet集合

不可以存储重复元素；没有索引；可以将元素按照规则进行排序

TreeSet()：	根据其元素的自然排序进行排序
TreeSet(Comparator comparator) ：	根据指定的比较器进行排序

使用：

public class TreeSetDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<Integer>();

        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);

        ts.add(30);

        //遍历集合
        for(Integer i : ts) {
            System.out.println(i);
        }
    }
}

（二）HashSet集合

底层数据结构是哈希表；存取无序；不可以存储重复元素；没有索引,不能使用普通for循环遍历

使用：

public class HashSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> set = new HashSet<String>();

        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素的集合
        set.add("world");

        //遍历
        for(String s : set) {
            System.out.println(s);
        }
    }
}

HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法

六、Map集合

特点：

双列集合,一个键对应一个值
键不可以重复,值可以重复

public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //V put(K key, V value) 将指定的值与该映射中的指定键相关联
        map.put("wedu001","林青霞");
        map.put("wedu002","张曼玉");
        map.put("wedu003","王祖贤");
        map.put("wedu003","柳岩");

        //输出集合对象
        System.out.println(map);
    }
}

（一）常用方法

`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`），尝试使用给定的映射功能，进入到这个Map除非 `null`计算其价值。
`default V`	`computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)` 如果指定键的值是存在和非空的，尝试计算一个新的映射，给出了键和它当前的映射值。
`boolean`	`containsKey(Object key)` 返回 true如果这Map包含一个指定的键映射。
`boolean`	`containsValue(Object value)` 返回 true如果映射到指定的值的一个或多个键。
`Set<Map.Entry<K,V>>`	`entrySet()` 返回一个 `Set`视图的映射包含在这个Map。
`boolean`	`equals(Object o)` 将指定的对象与此映射的相等性进行比较。
`default void`	`forEach(BiConsumer<? super K,? super V> action)` 在该映射中的每个条目执行给定的操作，直到所有的条目被处理或操作抛出异常。
`V`	`get(Object key)` 返回指定的键映射的值，或 `null`如果这个Map不包含的键映射。
`default V`	`getOrDefault(Object key, V defaultValue)` 返回指定的键映射的值，或 `defaultValue`如果这个Map不包含的键映射。
`int`	`hashCode()` 返回此映射的哈希代码值。
`boolean`	`isEmpty()` 返回 true如果这个Map不包含键值的映射。
`Set<K>`	`keySet()` 返回一个 `Set`的关键视图包含在这个Map。
`default V`	`merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)` 如果指定的键已与值相关联的值或与空值相关联的，则将其与给定的非空值关联。
`V`	`put(K key, V value)` 将指定的值与此映射中的指定键关联（可选操作）。
`void`	`putAll(Map<? extends K,? extends V> m)` 从指定的映射到这个Map（可选操作）复制所有的映射。
`default V`	`putIfAbsent(K key, V value)` 如果指定的键是不是已经与价值相关的（或映射到 `null`）将其与给定的值并返回 `null`，否则返回当前值。
`V`	`remove(Object key)` 如果存在（可选操作），则从该Map中移除一个键的映射。
`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`视图的值包含在这个Map。