Java基础之浅谈集合

前言

  • 兄弟们，终于更到Java集合了😭。
  • 学完集合我们就可以刷算法题了😄。
  • 但是目前博主还没有这个实力😎。

一、Java集合框架接口

  • Java集合其实就是别人写好的数据结构，分别为栈、队列、链表、动态扩容数组、哈希表、二叉树等等
  • 数据结构呢，在这篇文章中不作为重点，我们主要介绍实现了此数据结构的集合。
  • 现在我们开始吧👇(Φ皿Φ)

1.1Collection接口

  • 我想大家也看到上面的图了，在Java类库中，集合类的基本接口是Collection接口。

  • Collection接口有三个子接口分别为List、Set

  • Collection接口中有很多的方法，其中有一种利与集合遍历的方法，就是使用迭代器iterator遍历。

  • boolean add(E e)确保此集合包含指定的元素

  • boolean addAll(Collection<? extends E> c)将指定集合中所有元素添加到此集合

  • void clear()从此集合中删除所有元素

  • boolean contains(Object o)如果此集合包含指定集合中的所有元素，则返回true

  • boolean equals(Object o)将指定的对象与此集合进行比较以获得相等性

  • int hashCode() 返回此集合的哈希码值

  • boolean isEmpty()如果此集合不包含元素，则返回true

  • Iterator iterator()返回此集合中的元素的迭代器

  • boolean remove(Object o)从该集合中删除指定元素的单个实例

  • boolean removeAll(Collection<?> c)删除指定集合中包含的所有此集合的元素

  • boolean retainAll(Collection<?> c)仅保留此集合中包含在指定集合中的元素

  • int size() 返回此集合中的元素数

  • Object[] toArray()返回一个包含此集合中所有元素的数组

  • T[] toArray(T[] a)返回包含此集合中所有元素的数组，返回的数组的运行时类型时指定数组的运行时类型

1.2Iterator迭代器

  • Collection也继承了Iterable接口，具体操作看如下或者上图。
  • 我给大家写一段对于集合使用迭代器遍历的基本操作。
public class Test1 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();//首先我们创建一个ArrayList集合
        list.add(1);//向集合中添加元素
        list.add(2);
        list.add(3);
        Iterator<Integer> iter = list.iterator();//调用集合中的迭代器方法
        while(iter.hasNext()) {//判断集合中是否还有元素
            int it = iter.next();//把集合中的元素取出来，然后跳过当前元素，指向下一个元素
            System.out.println(it);//输出🤔
        //这就是迭代器使用的基本操作啦！前面讲过，在迭代器操作过程中，我们不能在循环里对元素进行操作的o😊
        }
    }
}
  • 我给大家画一个迭代器移动的图🎇
  • 这就是我们迭代器移动的原理，其实它使指在了两个元素中间进行移动的。
for(Integer value:list) {
    System.out.println(value);//当然使用增强for循环，可谓是对我们集合非常的方便简洁。
}
    Iterator<Integer> iter = list.iterator();
    //我们可以利用lambda表达式。
    //直接调用forEachRemaining方法。(但是并不推荐使用此方法)
    iter.forEachRemaining(value-> System.out.println(list));
  • 对于Iterator接口还有一个remove()方法，见名知意删除，用法也没什么大区别。
  • 具体的Collection方法可以查看API文档进行学习，在这里我不一一介绍了。
  • boolean hasNext()如果集合中还有元素，则返回true
  • E next()返回迭代中的下一个元素
  • default void remove()删除此迭代器返回的当前元素
  • default void forEachRemaining(Consumer<? super E> action)对每个剩余元素执行给定的操作。

二、List接口✍

2.1List接口的特点

  1. 对于前面的学习我们已经知道了，集合的两个基本接口为：Collection和Map。
  2. List是一个有序集合，当我们使用List接口的实现类时，元素都是按顺序添加进来的，就跟我们的数组一样。
  3. 同时List集合中可以添加重复的元素，每个元素有自己的下标。
  4. 所以我们可以采用两种访问方式：①使用迭代器访问 ②使用整数索引(数组下标)来访问----->也称之为随机访问。
  5. ListIterator接口时Iterator的一个子接口，这个接口可以让我们在使用迭代器遍历时，对元素进行操作，我们可以对元素进行增删改查操作。
  6. List接口下面有三个实现类分别为：ArrayList、LinkedList、Vector。

2.2ArrayList

  • ArrayList是用数组实现的，它支持动态扩容机制。当前数组是由默认构造方法生成的空数组并且第一次添加数据。此时minCapacity等于默认的容量（10）那么根据下面逻辑可以看到最后数组的容量会从0扩容成10。而后的数组扩容才是按照当前容量的1.5倍进行扩容。
    优点：
  1. 根据下标遍历元素效率高
  2. 根据下标查询元素效率高
  3. 可以自动扩容
    缺点：
  4. 插入、删除元素效率低。数组所谓的删除元素其实都是覆盖，没有真正的删除
  • Collection接口所拥有的方法，ArrayList都有
  • void add(int index , E element)在此列表中的指定位置插入指定的元素
  • Object clone()返回此ArrayList实例的浅拷贝
  • boolean contains(Object o)如果此列表包含指定的元素，则返回true
  • void ensureCapacity(int minCapacity)如果需要，增加此ArrayList实例的容量，以确保它可以至少保存最小容量参数指定的元素
  • void forEach(Consumer<? super E> action)对Iterable的每个元素执行给定的操作，直到所有元素都被处理或者动作引发异常。
  • E get(int index)返回此列表中指定位置的元素
  • int indexOf(Object o)返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
  • boolean isEmpty()如果此列表不包含元素，则返回true
  • int lastIndexOf(Object o)返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1
  • ListIterator listIterator()返回列表中的列表迭代器
  • E set(int index , E element)用指定的元素替换此列表中指定位置的元素
  • void sort(Comparator<? super E> c)使用提供的Comparator对此列表进行排序比较元素
  • void trimToSize()修改这个ArrayList实例的容量是列表当前的大小

2.3LinkedList

  • LinkedList是用链表来实现的，是一个有序集合。
    优点：插入、删除效率高
    缺点：查找、修改效率低
  • LinkedList的add()方法是链表的尾插法。
  • LinkedList类实现了ListIterator接口，可以在迭代的时候对元素进行操作
public class Test1 {
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        ListIterator<Integer> iterator = list.listIterator();
        Integer next = iterator.next();
        iterator.add(10);//会在迭代器位置前添加元素
        System.out.println(list);
      //输出结果[1, 10, 2, 3, 4, 5]
    }
}
  • LinkedList常用的方法如下：仍然是Collection有的它也有
  • void addFirst(E e)在该列表开头插入指定的元素
  • void addLast(E e)将指定的元素追加到此列表的末尾
  • void clear()从列表中删除所有元素
  • Object clone()返回此LinkedList的浅版本
  • Iterator descendingIterator以相反的顺序返回此deque中的元素的迭代器
  • E element()检索但不删除此列表的头(第一个元素)
  • E get(int index)返回此列表中指定位置的元素
  • E getFirst()返回此列表中的第一个元素
  • E getLast()返回此列表中的最后一个元素
  • boolean offer(E e)将指定的元素添加到为此列表的尾部(最后一个元素)
  • boolean offerFirst(E e)在此列表的前面插入指定的元素
  • boolean offerLast(E e)在该列表的末尾插入指定的元素
  • E peek()检索但不删除此列表的头
  • E peekLast()检索但不删除此列表的第一个元素
  • E peekLast()检索但不删除此列表的最后一个元素
  • E poll()检索并删除此列表的头
  • E pollFirst()检索并删除此列表的第一个元素
  • E pollLast()检索并删除此列表的最后一个元素
  • E pop()从此列表表示的堆栈中弹出一个元素
  • void push(E e)将元素推送到由此列表表示的堆栈上
  • E set(int index, E element)用指定的元素替换此列表中指定位置的元素

三、Set接口✍

3.1Set接口的特点

  • 首先我们要来了解一下什么是散列表
  • 可以用来快速查找对象，每个对象都拥有一个自己的散列码。散列码是由String类的hashCode方法产生的。如果a.equals(b)为true，则a与b的hashCode必须相等。
  • Java集合中提供的HashSet类的实现就基于散列表的集。
  • 它是无序的插入。
  • 元素不可以重复
  • 无法根据下标进行操作
  • Set接口中的方法和Collection中方法一致的。Set接口取出方式只有一种，迭代器。

3.2HashSet

　　　　|——HashSet：底层数据结构是哈希表，线程是不同步的。无序，高效；

　　　　　　　　HashSet集合保证元素唯一性：通过元素的hashCode方法，和equals方法完成的。

　　　　　　　　当元素的hashCode值相同时，才继续判断元素的equals是否为true。

　　　　　　　　如果为true，那么视为相同元素，不存。如果为false，那么存储。

　　　　　　　　如果hashCode值不同，那么不判断equals，从而提高对象比较的速度。

　　　　　　|——LinkedHashSet：有序，hashset的子类。

　　　　|——TreeSet：对Set集合中的元素的进行指定顺序的排序。不同步。TreeSet底层的数据结构就是二叉树。
　　对于ArrayList集合，判断元素是否存在，或者删元素底层依据都是equals方法。

　　对于HashSet集合，判断元素是否存在，或者删除元素，底层依据的是hashCode方法和equals方法。

3.3TreeSet

  1. 用于对Set集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性。

  2. 如果元素不具备比较性，在运行时会发生ClassCastException异常。

  3. 所以需要元素实现Comparable接口，强制让元素具备比较性，复写compareTo方法。

  4. 依据compareTo方法的返回值，确定元素在TreeSet数据结构中的位置。

  5. TreeSet方法保证元素唯一性的方式：就是参考比较方法的结果是否为0，如果return 0，视为两个对象重复，不存。

四、Map接口✍

4.1映射

  • 映射用来存放键/值对，如果提供了键，就能查找到值。
  • Java类库为映射提供了两个通用的实现：HaspMap和TreeMap。
  • Map集合：

　　　　|——Hashtable：底层是哈希表数据结构，是线程同步的。不可以存储null键，null值。

　　　　|——HashMap：底层是哈希表数据结构，是线程不同步的。可以存储null键，null值。替代了Hashtable.

　　　　|——TreeMap：底层是二叉树结构，可以对map集合中的键进行指定顺序的排序。

  • Map集合存储和Collection有着很大不同：

　　　　Collection一次存一个元素；Map一次存一对元素。

　　　　Collection是单列集合；Map是双列集合。

　　　　Map中的存储的一对元素：一个是键，一个是值，键与值之间有对应(映射)关系。

　　　　特点：要保证map集合中键的唯一性。

  • 1，添加。

　　　　put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。

　　　　void putAll(Map);

  • 2，删除。

　　　　void clear()：清空

　　　　value remove(key) ：删除指定键。

  • 3，判断。

　　　　boolean isEmpty()：

　　　　boolean containsKey(key)：是否包含key

　　　　boolean containsValue(value) ：是否包含value

  • 4，取出。

　　　　int size()：返回长度

　　　　value get(key) ：通过指定键获取对应的值。如果返回null，可以判断该键不存在。当然有特殊情况，就是在hashmap集合中，是可以存储null键null值的。

　　　　Collection values()：获取map集合中的所有的值。

  • 5，想要获取map中的所有元素：

　　　　原理：map中是没有迭代器的，collection具备迭代器，只要将map集合转成Set集合，可以使用迭代器了。之所以转成set，是因为map集合具备着键的唯一性，其实set集合就来自于map，set集合底层其实用的就是map的方法。

★ 把map集合转成set的方法：

  • Set keySet();

  • Set entrySet();//取的是键和值的映射关系。

  • Entry就是Map接口中的内部接口；

  • 为什么要定义在map内部呢？entry是访问键值关系的入口，是map的入口，访问的是map中的键值对。

——————————————————————————————————————————————————————
★取出map集合中所有元素的方式一：keySet()方法。

  • 可以将map集合中的键都取出存放到set集合中。对set集合进行迭代。迭代完成，再通过get方法对获取到的键进行值的获取。
    　　　Set keySet = map.keySet();

　　　　　　Iterator it = keySet.iterator();

　　　　　　while(it.hasNext()) {

　　　　　　　　Object key = it.next();

　　　　　　　　Object value = map.get(key);

　　　　　　　　System.out.println(key+":"+value);

　　　　　　}
——————————————————————————————————————————————————————

★取出map集合中所有元素的方式二：entrySet()方法。

　　　　　　Set entrySet = map.entrySet();

　　　　　　Iterator it = entrySet.iterator();

　　　　　　while(it.hasNext()) {

　　　　　　　　Map.Entry me = (Map.Entry)it.next();

　　　　　　　　System.out.println(me.getKey()+"::::"+me.getValue());

　　　　　　}

——————————————————————————————————————————————————————

★使用集合的技巧：

  • 看到Array就是数组结构，有角标，查询速度很快。

  • 看到link就是链表结构：增删速度快，而且有特有方法。addFirst； addLast； removeFirst()； removeLast()； getFirst()；getLast()；

  • 看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到该结构的中的元素必须覆盖hashCode，equals方法。

  • 看到tree就是二叉树，就要想到排序，就想要用到比较。

★比较的两种方式：

  • 一个是Comparable：覆盖compareTo方法；

  • 一个是Comparator：覆盖compare方法。

  • LinkedHashSet，LinkedHashMap:这两个集合可以保证哈希表有存入顺序和取出顺序一致，保证哈希表有序。

★集合什么时候用？

  • 当存储的是一个元素时，就用Collection。当存储对象之间存在着映射关系时，就使用Map集合。

　　保证唯一，就用Set。不保证唯一，就用List。

五、排序与查找小补充

  • Collections类提供的用于排序和查找的类方法如下：👇
  • public static sort(List list):该方法可以将list的元素按升序排序
  • int binarySearch(List list,T key,CompareTo c):二分查找
  • String类实现了Comparable接口，规定字符串按字典序比较大小，如果链表中存放的对象不是String对象，那么创建对象的类必须实现Comparable接口，即用该接口中的int compareTo(T b)方法来规定对象的大小关系，(原因是sort()方法在排序时需要调用名字时compareTo的方法，来比较的对象大小)。
  • 就时如果对象不是String类型的，我们在用sort时需要自己编写compareTo()方法。

六、结尾

  • 对于Java集合内容就总结这么多(后面比较水了！)，若想深入学习等待后续更新，基础部分掌握这些足矣。如果有不足之处，希望大家多多包涵，多多支持。如果有不懂的地方可以直接私信问我，欢迎来访！
  • 我将会继续更新关于Java的学习知识，感兴趣的小伙伴可以关注一下。
  • 文章写得比较走心，用了很长时间，绝对不是copy过来的！
  • 尊重每一位学习知识的人，同时也尊重每一位分享知识的人。
  • 😎你的点赞与关注，是我努力前行的无限动力。🤩
posted @ 2022-04-07 19:03  lx-Meteor  阅读(398)  评论(0)  编辑  收藏  举报