Java集合框架概述

Java集合框架

集合

• 概念：集合是java中提供的一种容器，可以用来存储多个数据。

• 集合和数组的区别：

  • 数组长度固定，集合长度是可变的

  • 数组可以存储基本类型和引用类型，集合只能存储引用类型。

测试

 /*
             1.添加 2.删除 3.遍历 4.判断
          */
         Collection col = new ArrayList();
         col.add("张三");
         col.add("李四");
         col.add("王五");
 //        col.add("张三");
         System.out.println(col);
 //        col.remove("张三");
 //        System.out.println(col);
         for (Object o : col) {
             System.out.println(o);
         }
         System.out.println("------------------");
         Iterator it = col.iterator();
         while (it.hasNext()){
             String next = (String) it.next();
             System.out.println(next);
         }
         System.out.println(col.isEmpty());
         System.out.println(col.contains("张三"));

 

1、Collection常用功能

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合（List和Set）通用的⼀些方法，这些方法可用于操作所有的单列集合

• public boolean add(E e) ： 把给定的对象添加到当前集合中

• public void clear() ：清空集合中所有的元素。

• public boolean remove(E e) ：把给定的对象在当前集合中删除。

• public boolean remove(int index) ：根据下标删除知道对象

• public boolean contains(E e) ：判断当前集合中是否包含给定的对象。

• public boolean isEmpty() ：判断当前集合是否为空。

• public int size() ：返回集合中元素的个数。

• public Object[] toArray() ：把集合中的元素，存储到数组中。

 

2、Iterator迭代器

Iterator接口：在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专们提供了⼀个接口java.util.Iterator 。 Iterator 接口也是Java集合中的⼀员，但它与 Collection 、 Map 接口有所不同， Collection 接口与 Map 接口主要用于存储元素，而 Iterator 主要用于迭代访问（即遍历） Collection 中的元素，因此 Iterator 对象也被称为迭代器

• 想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作

• public Iterator iterator()：获取集合对应的迭代器，用来遍历集合中的元素

迭代：在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。⼀直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

Iterator接口的常用方法：

• public E next() ：返回迭代的下⼀个元素

• public boolean hasNext() ：如果仍有元素可以迭代，则返回 true。

 

3、增强for

• 也称for each循环，JDK1.5后出来的一个高级for循环，专门用来遍历数组和集合得。

• 它的内部原理其实是一个Iterator迭代器，在遍历得过程中，不能对集合中的元素进行增删改查。

• 必须有被遍历的目标，只能是collection或者是数组

 

4、泛型：

• 是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递；

• ⼀般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

• 常见形式有泛型类、泛型接口、泛型方法；

• 好处：

  • 提高代码的重用性

  • 将运行时期的ClassCastException，转移到了编译时期变成了编译失败

  • 防止类型转换异常，提高代码的安全性

泛型集合：参数化类型、类型安全的集合，强制集合元素的类型必须一致。

特点：

• 编译时即可检查，而非运行时抛出异常。

• 访问时，不必类型转换。

• 不同泛型之间引用不能相互赋值，泛型不存在多态。

通配符高级使用 -- 受限泛型

• 之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定⼀个泛型的上限和下限。

• 上限：

  • 格式：类型名称 <? extends 类> 对象名称

  • 使用：只能接收该类型及其子类型

• 下限

  • 格式：类型名称 <? super 类> 对象名称

  • 使用：只能接收该类型及其父类型

 

5、常见的数据结构

数据存储的常用结构有：栈、队列、数组、链表、红黑树。

5.1、栈

• stack，又称堆栈，它是运算受限的线性表，其限制是仅允许在栈顶的⼀端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。

• 先进后出，例如：子弹压弹夹

• 压栈：存元素；弹栈：取元素

5.2、队列

• queue，简称队，同栈一样，也是一种受限制的线性表，其限制时仅允许在一端进行插入，另一端进行删除

• 先进先出

5.3、数组

• Array，是有序的元素序列，是在内存中开辟一段连续的空间，并在此空间存放元素。

• 查找快：通过下标索引可以快速访问指定位置的元素

• 增删慢：指定索引位置增加元素，需要创建一个新数组进行操作

5.4、链表

• linked list，由一系列节点node组成，节点可以在运行时动态生成。每个节点包括两部分：一个存储数据元素的数据域，另一个是存储下一个节点地址的指针域。

• 多个节点之间通过地址进行连接，例如，多个人的手拉手

• 查找元素慢：查找某个元素是，需要通过连接的节点，依次向后查找指定元素

• 增删元素快：只需要修改连接下一个元素的地址即可

5.5、红黑树

• 二叉树：binary tree，每个节点不超过2的有序树。即每个节点上都最多只能有两个子节点

• 红黑树是一种自平衡的二叉树，就是在每次插入新的数据的时候，红黑树会进行变色和旋转来使生成的树不会出现偏的情况，来让高度保持在log2（N）这个合理高度内

• 特点：

  • （1）每个节点或者是黑色，或者是红色。

  • （2）根节点是黑色。

  • （3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！

  • （4）如果一个节点是红色的，则它的子节点必须是黑色的，也就是说不可能出现两个连续的红色节点，不过两个连续的黑色节点是可能出现的

  • （5）从任意一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

• java中的TreeMap底层就是实现红黑树

 

 

6、List接口

特点：有序、有下标、元素可以重复。

可以通过角标在指定位置添加查询元素。

  List list = new ArrayList();
         list.add("java");
         list.add("c++");
         list.add(1,"python");
         list.add(".net");
         System.out.println(list.size());
         System.out.println(list.toString());
         //1.for each遍历
         System.out.println("---------------");
         for (Object o : list) {
             System.out.println(o);
         }
         //2.迭代器遍历
         System.out.println("---------------");
         Iterator iterator = list.iterator();
         while (iterator.hasNext()){
             System.out.println(iterator.next());
         }
         //3.list迭代器遍历
         System.out.println("--------正序-------");
         ListIterator listIterator = list.listIterator();
         while (listIterator.hasNext()){
             System.out.println(listIterator.next());
         }
         //逆序前必须先进行正序遍历，让指针指向列表最后一个元素，才能开始遍历
         System.out.println("--------逆序-------");
         while (listIterator.hasPrevious()){
             System.out.println(listIterator.previousIndex() + ":" +listIterator.previous());
         }

添加数字等基本类型数据时，会进行自动装箱的操作。

删除数字元素需要通过下标来删除，或者将需要删除的数字转成object类或者该类型对应的包装类。

subList:返回一个子集合，含头不含尾。

 

6.1、ArrayList

• 数组存储结构，查询快、增删慢；

• JDK1.2版本出现，运行效率快，线程不安全。

• 源码分析：

  • DEFAULT_CAPACITY = 10 默认容量 。注意：如果没有向集合中添加任何元素时，容量为0，添加一个元素之后，容量为10。每次扩容大小都是原来的1.5倍，如添加第11个元素时，容量由10变为了15。

  • add（）方法源码：为什么添加一个元素之后，容量为10。

   public boolean add(E e) {
           ensureCapacityInternal(size + 1);  // Increments modCount!!增长修改个数
           elementData[size++] = e;
           return true;
       }
   ​
   private void ensureCapacityInternal(int minCapacity) {
           if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
               minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
           }
   ​
           ensureExplicitCapacity(minCapacity);
       }
   ​
   private void ensureExplicitCapacity(int minCapacity) {
           modCount++;
   ​
           // overflow-conscious code
           if (minCapacity - elementData.length > 0)
               grow(minCapacity);
       }
   ​
    private void grow(int minCapacity) {
           // overflow-conscious code
           int oldCapacity = elementData.length;
           int newCapacity = oldCapacity + (oldCapacity >> 1);
           if (newCapacity - minCapacity < 0)
               newCapacity = minCapacity;
           if (newCapacity - MAX_ARRAY_SIZE > 0)
               newCapacity = hugeCapacity(minCapacity);
           // minCapacity is usually close to size, so this is a win:
           elementData = Arrays.copyOf(elementData, newCapacity);
       }

   

  • elemetnData 存放元素的数组

  • size 实际元素个数

• 测试代码：

  ArrayList arrayList = new ArrayList();
         Student s1 = new Student("张三",18);
         Student s2 = new Student("李四",18);
         Student s3 = new Student("王五",18);
         arrayList.add(s1);
         arrayList.add(s2);
         arrayList.add(s3);
         System.out.println(arrayList.toString());
         //删除元素（需要重写equals方法）
         arrayList.remove(new Student("李四",18));
         System.out.println(arrayList.size());
  public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         Student student = (Student) o;
         return age == student.age && Objects.equals(name, student.name);
     }

6.2、Vector

• 数组存储结构，查询快，增删慢；

• JDK1.0版本出现，运行效率慢、线程安全；

• 枚举器遍历

 Vector vector = new Vector();
         vector.add("java");
         vector.add("python");
         vector.add(".net");
         System.out.println(vector.toString());
         //枚举器遍历
         Enumeration elements = vector.elements();
         while (elements.hasMoreElements()){
             System.out.println(elements.nextElement());
         }

 

6.3、LinkedList：

• 双向链表存储结构，增删快，查询慢。

• 在开发中，LinkedList集合也可以作为堆栈，队列的结构使用

 

7、Set接口

特点：无序、无下标、元素不可重复

方法：全部继承自Collection中的方法。

 

7.1、HashSet

什么是哈希表？

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用链表处理冲突，同⼀hash值的元素都存储在⼀个链表里。但是当位于⼀个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大的减少了查找时间。

• 存储结构：哈希表（数组+链表+红黑树）

• 基于HashCode实现元素不重复

  • 根据hashcode计算保存的位置，如果此位置为空，则直接保存。如果不为空，执行下一步。

• 当存入元素的哈希码相同时，会调用equals进行确认，如果为true，则拒绝后者存入。否则，则生成链表。

• LinkedHashSet:

  作用：HashSet可以保证元素唯一，但是其中的元素是无序的，如果我们要保证有序，那么就需要使用LinkedHashSet。

•  public HashSet(){
     map = new HashMap<>();
   }

测试代码：

  HashSet<Student> set = new HashSet<>();
         Student s1 = new Student("张三",18);
         Student s2 = new Student("李四",18);
         Student s3 = new Student("王五",18);
         set.add(s1);
         set.add(s2);
         set.add(s3);
 //        set.add(new Student("李四",18));
         System.out.println(set.size());
         System.out.println(set.toString());
 //        set.remove(new Student("李四",18));
 //        System.out.println(set.size());
 //        System.out.println(set.toString());
         for (Student student : set) {
             System.out.println(student);
         }
         System.out.println("====================");
         Iterator<Student> iterator = set.iterator();
         while (iterator.hasNext()){
             System.out.println(iterator.next());
         }
  
 public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         Student student = (Student) o;
         return age == student.age && Objects.equals(name, student.name);
     }
 ​
 public int hashCode() {
         return Objects.hash(name, age);
     }

 

hashcode重写方法中加入31的原因

1. 31是一个质数，减少散列冲突

2. 31提高执行效率

 

7.2、TreeSet

• 存储结构：红黑树

• 基于排列顺序实现元素不重复

• 实现了SortedSet接口，对集合元素自动排序

• 元素对象的类型必须实现Comparable接口，指定排列规则

• 通过CompareTo方法确定是否为重复元素

测试代码：使用TreeSet集合实现字符串按照长度进行排序

 public class Demo01 {
     public static void main(String[] args) {
         TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
             @Override
             public int compare(String o1, String o2) {
                 int n1 = o1.length() - o2.length();
                 int n2 = o1.compareTo(o2);
                 return n1==0 ? n2 :n1;
             }
         });
         treeSet.add("zhangSan");
         treeSet.add("wkf");
         treeSet.add("abc");
         treeSet.add("abc");
         treeSet.add("ljCv");
         treeSet.add("liSi");
         treeSet.add("wanG");
 ​
         System.out.println(treeSet.toString());
         System.out.println(treeSet.size());
     }
 }

 

8、可变参数

在JDK1.5之后，如果我们定义⼀个方法需要接受多个参数，并且多个参数类型⼀致，我们可以对其简化成如下格式：

 修饰符 返回值类型 ⽅法名(参数类型... 形参名) { }

其实这个书写完全等价于

 修饰符 返回值类型 ⽅法名(参数类型[] 形参名) { }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。JDK1.5以后。出现了简化操作。... 用在参数上，称之为可变参数。同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组（这就是简单之处），直接将数组中的元素作为实际参数进行传递，其实编译成的.class文件，将这些元素先封装到⼀个数组中，在进行传递。这些动作都在编译.class⽂件时，自动完成了。

 

9、Map接口

特点：

1. 用于储存任意键值对（Key，Value）

2. 键：无序、无下标、不允许重复

3. 值：无序、无下标、允许重复

遍历：

• keySet（）方法遍历：拿到key的set集合。

• entrySet（）方法遍历：将map封装成entry键值对集合。

测试代码：

 Map<String, String> map = new HashMap<>();
         map.put("wkf","666");
         map.put("qwe","678");
         map.put("kfc","999");
         map.put("asd","694");
         Set<String> keySet = map.keySet();
         for (String s : keySet) {
             System.out.println(s + "=" + map.get(s));
         }
         System.out.println("===================");
         Set<Map.Entry<String, String>> entries = map.entrySet();
         for (Map.Entry<String, String> entry : entries) {
             System.out.println(entry.getKey() +"=" + entry.getValue() );
         }

 

HashMap

• JDK1.2版本，线程不安全，运行效率快；允许用null作为key或是value。

• 构造一个具有默认初始容量16和默认加载因子0.75的空HashMap。

  • 加载因子：比如当前集合容量为100，那么当数据存储到第75个位置是进行扩容操作。

• 源码分析

•  static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // hashMap初始容量大小16
   static final int MAXIMUM_CAPACITY = 1 << 30;//hashMap的数组最大容量
   static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认加载因子
   static final int TREEIFY_THRESHOLD = 8;//jdk1.8开始，当链表长度大于8时，调整成红黑树
   static final int UNTREEIFY_THRESHOLD = 6;//jdk1.8开始，当链表长度小于6时，调整成链表
   static final int MIN_TREEIFY_CAPACITY = 64;//jdk1.8开始，当链表长度大于8时，并且集合元素个数大于等于64时调整成红黑树
   transient Node<K,V>[] table;//哈希表中的数组

• 总结：

  1. HashMap刚创建时，table是null，为了节省空间，当添加第一个元素时，table容量调整为16

  2. 当元素个数大于阈值（16*0.75=12）时，会进行扩容，扩容后大小为原来的两倍。目的是减少调整元素的个数

  3. jdk1.8开始，当链表长度大于8时，并且集合元素个数大于等于64时调整成红黑树，目的是提高执行效率

  4. jdk1.8开始，当链表长度小于6时，调整成链表

  5. jdk1.8以前，链表时头插入，jdk1.8以后是尾插入

Hashtable

• JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value

• Properties：

  • Hashtable的子类，要求key和value都是String，通常用于配置文件的读取。

TreeMap

• 实现了SortedMap接口（是Map的子接口），可以对key自动排序。

10、Collections工具类

java.utils.Collections是集合工具类，用来对集合进行操作

• sort（）：升序排列

• copy（）：复制

• binarySearch（）：二分查找

  • Collections.binarySearch(list,需要查找的值);

• reverse（）：反转

• shuffle（）：打乱集合中的元素

• list转成数组：

  • list.toArray(new Integer[0]);

• 数组转成集合

  • Arrays.asList(names);

  • 集合是一个受限集合，不能添加和修改

 

10.1、Comparator和Comparable

Comparator：强行对某个对象进行整体排序。可以将 Comparator 传递给 sort 方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator 来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。只能在类中实现 compareTo() ⼀次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，⽆需指定比较器。

 

 

线程安全性

线程安全

1. Vector

2. HashTable

3. StringBuffer

4. ConcurrentHashMap

线程不安全

1. ArrayList

2. LinkedList

3. HashMap

4. TreeMap

5. HashSet

6. TreeSet

7. StringBuilder

HashMap的比较

三者效率的比较： 由于安全机制的原因，HashMap的效率比HashTable，CurrentHashMap的效率高；但是由于CurrentHashMap加锁的高效性,HashTable是整个加锁，他的效率比HashTable高； 总的来说 HashMap>CurrentHashMap>HashTable;