java中集合介绍与运用

集合List

思维导图

1.概述

java中对于各种数据结构的实现,就是我们用到的集合

1. 集合与数组的区别:

   1. 长度区别:

      数组固定.

      集合可变.

   2. 内容区别:

      数组可以是基本类型,也可以是引用类型.

      集合只能是引用类型.

   3. 元素内容:

      数组只能存储同一种类型

      集合可以存储不同类型(其实集合一般存储的也是同一种类型).

2. 集合体系

   java的集合框架是由很多接口、抽象类、具体类组成的，都位于java.util包中

2.Collection接口

Collection接口-定义了存取一组对象的方法,其子接口Set和List分别定义了存储方法.

Set中的数据对象没有顺序且不可以重复.

List中的数据对象有顺序且可以重复.

在Collection中定义了一些集合中的共有方法:

boolean add(Object element);//确保此集合包含指定的元素.

boolean addAll(Collection c);//将指定集合中的元素添加到此集合.

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

boolean removeAll(Collection c)//删除指定集合中包含的所有此集合的元素.

void clear();//从此集合中删除所有的元素.

int size();//返回此集合中的元素数.

boolean isEmpty();//如果此集合不包含元素,则返回true.

boolean contains(object element);//如果此集合包含指定的元素,则返回true.

boolean containAll(Collection c);//如果此集合包含指定集合中的所有元素,则返回true.

boolean retainAll(Collection c);//仅保留此集合中包含在指定集合中的元素.

Object[] toArray;//以正确的顺序返回一个包含此列表中所有元素的数组.

1. List接口及实现类

   List继承了Collection接口,有三个实现的类

   ArrayList

   优点: 底层数据结构是数组,长度可变的，查询快，增删慢。
   缺点: 线程不安全，效率高

   常用方法:

   void add(int index, E element)//将指定的元素插入此列表中的指定位置.
   E get(int index) //返回此列表中指定位置的元素.
   int indexOf(Object o) lastIndexOf(Object o) //返回此列表中指定元素的第一次出现的索引,如果此列表不包含元素,则返回-1
   E remove(int index) 删除并返回指定位置元素
   void removeRange(int fromIndex, int toIndex) 删除指定区间的元素(子类继承使用)
   E set(int index, E element) //用指定的元素替换此列表中指定位置的元素.

   void sort(Comparator<? super E> c);//使用提供的Comparator对此列表进行排序以比较元素.需要继承Comparator,重写compare方法.

   LinkedList

   优点: 底层数据结构是链表(双向链表)，查询慢，增删快。
   缺点: 线程不安全，效率高

   常用方法:

   void add(int index,Object element)//在此列表中的指定位置插入指定的元素.它会先使用valueof自动装箱
   void addFirist(Object element)//在该列表开头插入指定的元素.
   void addLast(Object element)//将指定的元素追加到此列表的末尾
   E removeFirst()//从此列表中删除并返回第一个元素
   E removeLast()//从此列表中删除并返回最后一个元素
   E remove(int index)//删除该列表中指定位置的元素
   E getFirst()//返回此列表中的第一个元素
   E getLast()//返回此列表中的最后一个元素

   Vector

   优点: 底层数据结构是数组，查询快，增删慢。
   缺点: 添加同步锁, 线程安全，效率低

   Stack是Vector类的实现类

2. List接口集合迭代

   1. for循环遍历:通过索引值获取所对应的数据信息

   2. 增强for循环的遍历:通过迭代器的方法获取信息

   3. 迭代器遍历:通过集合返回迭代器

      例如:

      Iterator iter = list.iterator();
      while(iter.hasNext()){
      iter.next();
      }

   注意:进行删除操作时最好使用迭代器

3. Set接口及实现类

   Set接口继承了Collection接口

   Set中所存储的元素是不重复的,但是是无序的,Set中的元素是没有索引的

   • HashSet
     底层数据结构是哈希表。(无序,唯一)
     如何来保证元素唯一性?
     1.依赖两个方法：hashCode()和equals()

   • LinkedHashSet
     底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
     1.由链表保证元素有序
     2.由哈希表保证元素唯一

   • TreeSet
     底层数据结构是红黑树。(唯一，有序)

     可以给Set集合中的元素进行指定方式的排序.存储的对象必须实现Comparable接口.

     \1. 如何保证元素排序的呢?
     自然排序
     比较器排序
     2.如何保证元素唯一性的呢?
     根据比较的返回值是否是0来决定

4. Set接口集合迭代

   增强for循环

   迭代器遍历

3.Map接口

将键映射到值的对象.

一个映射不能包含重复的键.

每个键最多只能映射到一个值.

常用方法:

V put(K key,V value)//将指定的值与该映射中的指定键相关联.

V remove(Object key)//如果存在,从该图中删除一个键的映射.

void clear()//从该地图中删除所有的映射
boolean containsKey(Object key)//如果此映射包含指定键的映射,则返回true.
boolean containsValue(Object value)//如果此地图将一个或多个键映射到指定的值,则返回true.
boolean isEmpty()//如果此地图不包含键值映射,则返回true.
int size()//返回此地图中间值映射的数量
V get(Object key)//返回到指定键所映射的值,或null如果此映射包含该键的映射.
Set keySet()//返回此地图中包含的键的Set视图
Collection values()//返回此地图包含的值的Collection视图
Set<Map.Entry<K,V>> entrySet()//返回此地图中包含的映射的Set视图.

1. Map实现类

   Map接口有三个比较重要的实现类，分别是HashMap、TreeMap和HashTable。

   TreeMap是有序的，HashMap和HashTable是无序的。

   Hashtable的方法是同步的，HashMap的方法不是同步的。这是两者最主要的区别。

   这就意味着:

   Hashtable是线程安全的，HashMap不是线程安全的。

   HashMap效率较高，Hashtable效率较低。
   如果对同步性或与遗留代码的兼容性没有任何要求，建议使用HashMap。 查看Hashtable的源代码就可以发现，除构造函数外，Hashtable的所有 public 方法声明中都有 synchronized关键字，而HashMap的源码中则没有。

   Hashtable不允许null值，HashMap允许null值（key和value都允许）

   父类不同：Hashtable的父类是Dictionary，HashMap的父类是AbstractMap.

2. Map集合遍历

   方式1：根据键找值
   获取所有键的集合
   遍历键的集合，获取到每一个键
   根据键找值
   方式2：根据键值对对象找键和值
   获取所有键值对对象的集合
   遍历键值对对象的集合，获取到每一个键值对对象
   根据键值对对象找键和值

4.Collections

Collections对集合体系进行常规操作的类
常用方法:
例如:

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("s");
        list.add("a");
        list.add("d");
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("s1");
        list1.add("a1");
        list1.add("d1");

        Collections.sort(list);//[a, d, s]
        System.out.println(Collections.binarySearch(list,"a"));//二分搜索,0
        Collections.addAll(list,"x","y");//[a, d, s, x, y]
        Collections.copy(list,list1);//将后者源内容覆盖到前者目标内容中,结果[s1, a1, d1, x, y]
        //Collections.fill(list,"A");//全部变为A
        Collections.reverse(list);//回文,[y, x, d1, a1, s1]
        Collections.swap(list,0,1);//结果[x, y, d1, a1, s1]
        System.out.println(list);

    }