java集合

一、集合框架的概述

  1. 集合、数组都是对多个数据进行存储操作的结构,简称Java容器。

    • 说明:此时的存储,主要指的是内存层面的存储,不涉及到持久化的存储(.txt,.jpg,.avi,数据库中)
  2. 数组在存储多个数据方面的特点:

    • 一旦初始化以后,其长度就确定了。
    • 数组一旦定义好,其元素的类型也就确定了。我们也就只能操作指定类型的数据了。
      • 比如:String[] arr;int[] arr1;Object[] arr2;
  3. 数组在存储多个数据方面的缺点:

    • 一旦初始化以后,其长度就不可修改。
    • 数组中提供的方法非常有限,对于添加、删除、插入数据等操作,非常不便,同时效率不高。
    • 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用
    • 数组存储数据的特点:有序、可重复。对于无序、不可重复的需求,不能满足。

二、集合框架

  1. Collection接口:单列集合,用来存储一个一个的对象

    • List接口:存储有序的、可重复的数据。–>“动态”数组
      • ArrayList:作为List接口的主要实现类;线程不安全的,效率高 LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表存储
      • Vector:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData存储
    • **Set接口:**存储无序的、不可重复的数据 -->高中讲的“集合”
      • HashSet:作为Set接口的主要实现类;线程不安全的;可以存储null值
        • LinkedHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历,对于频繁的遍历操作,LinkedHashSet效率高于HashSet.
      • TreeSet:可以按照添加对象的指定属性,进行排序。
  2. **Map接口:**双列集合,用来存储一对(key - value)一对的数据 -->高中函数:y = f(x)

    • HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

三、Collection接口中的方法的使用

添加

  • add(Object obj)
  • addAll(Collection coll)

获取有效元素的个数

  • int size()

清空集合

  • void clear()

是否是空集合

  • boolean isEmpty()

    代码演示

import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;

public class CollectionTest {
    @Test
    public void test1(){
        //add(Object e);  将元素e添加到集合coll中
        Collection coll = new ArrayList();
        coll.add("AA");
        coll.add("BB");
        coll.add(123);//自动装箱
        coll.add(new Date());
        //size()  获取添加的元素的个数
        System.out.println(coll.size());//4
        //addAll(Collection coll1):将coll1集合中的元素添加到当前的集合中
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add("CC");
        coll.addAll(coll1);
        System.out.println(coll.size());//6
        System.out.println(coll);
        //clear():清空集合元素
        coll.clear();
        //isEmpty():判断当前集合是否为空
        System.out.println(coll.isEmpty());//false

    }
}

是否包含某个元素

  • boolean contains(Object obj):是通过元素的equals方法来判断是否 是同一个对象
    • 向Collection接口的实现类的对象中添加数据obj时,要求obj所在类要重写equals().
  • boolean containsAll(Collection c):也是调用元素的equals方法来比 较的。拿两个集合的元素挨个比较。
@Test
public void test2(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new String("Tom"));
    coll.add(false);
    coll.add(new Person("Jerry",20));
    Person p = new Person("Jerry",20);
    coll.add(p);
    //contains(Object obj):判断当前集合中是否包含obj
    boolean contains = coll.contains(123);
    System.out.println(contains);
    System.out.println(coll.contains(new String("Tom")));//掉的String重写的equals  就是比内容
    System.out.println(coll.contains(p));
    System.out.println(coll.contains(new Person("Jerry",20)));//调的Object中的equals  就是==  就是false 重写之后就是true
    //containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。
    Collection coll1 = Arrays.asList(123,4567);
    System.out.println(coll.containsAll(coll1));//false
}

删除

  • boolean remove(Object obj) :通过元素的equals方法判断是否是 要删除的那个元素。只会删除找到的第一个元素
  • boolean removeAll(Collection coll):取当前集合的差集
@Test
public void test3(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);
    //remove(Object obj):从当前集合中移除obj元素。
    coll.remove(123);//也会先执行equals  123 是一个Integer已经重写过了equals
    System.out.println(coll);//[456, Person{name='Jerry', age=20}, Tom, false]
    //removeAll(Collection coll1):差集:从当前集合中移除coll1中有的元素。
    Collection coll1 = Arrays.asList(123,456);
    coll.removeAll(coll1);
    System.out.println(coll);//[Person{name='Jerry', age=20}, Tom, false]
}

取两个集合的交集

  • boolean retainAll(Collection c):把交集的结果存在当前集合中,不 影响c
@Test
public void test4(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);
    //retainAll(Collection coll1):交集:获取当前集合和coll1集合的交集,并返回给当前集合
    Collection coll1 = Arrays.asList(123,456,789);
    coll.retainAll(coll1);
    System.out.println(coll);//[123, 456]
}

集合是否相等

  • boolean equals(Object obj)
 @Test
    public void test4(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);
        //  equals(Object obj):要想返回true,需要当前集合和形参集合的元素都相同。
        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(456);
        coll1.add(new Person("Jerry",20));
        coll1.add(new String("Tom"));
        coll1.add(false);
        System.out.println(coll.equals(coll1));//true
    }

获取集合对象的哈希值

  • hashCode()
@Test
public void test5(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);
    //hashCode():返回当前对象的哈希值
    System.out.println(coll.hashCode());//-783340298  随机数
}

转成对象数组

  • Object[] toArray()
@Test
public void test5(){
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry",20));
    coll.add(new String("Tom"));
    coll.add(false);
    //集合 --->数组:toArray()
    Object[] arr = coll.toArray();
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
/*123
456
Person{name='Jerry', age=20}
Tom
false
*/
     //数组 --->集合:调用Arrays类的静态方法asList()
     List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
     System.out.println(list);//[AA, BB, CC]
    
     List arr1 = Arrays.asList(new int[]{123, 456});
        System.out.println(arr1);//[[I@78e03bb5]  把{123, 456}整体当成一个元素了
        System.out.println(arr1.size());//1

        List arr2 = Arrays.asList(123, 456);
        System.out.println(arr2);//[123, 456]

        List arr3 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(arr3.size());//2
}
数组 --->集合:调用Arrays类的静态方法asList()

遍历

  • iterator():返回迭代器对象,用于集合遍历

四、Iterator迭代器接口

1、集合元素的遍历操作

  • 使用迭代器Iterator接口
    • 内部的方法:hasNext() 和 next()
      • 在调用it.next()方法之前必须要调用it.hasNext()进行检测。若不调用,且 下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
    • 集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合 的第一个元素之前。
import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorTest {
    //iterator():返回Iterator接口的实例,用于遍历集合元素。放在IteratorTest.java中测试
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);
        Iterator iterator = coll.iterator();
/*

        //方式一
        System.out.println(iterator.next());//123
        System.out.println(iterator.next());//456
        System.out.println(iterator.next());//Person{name='Jerry', age=20}
        System.out.println(iterator.next());//Tom
        System.out.println(iterator.next());//false
        //报异常  NoSuchElementException
//        System.out.println(iterator.next());//NoSuchElementException
*/

        /*
        //方式二  不推荐
        for(int i = 0 ; i < coll.size() ; i++){
            System.out.println(iterator.next());
        }*/

        //方式三 推荐
        //hasNext():判断是否还有下一个元素
        while(iterator.hasNext()){
        //next():①指针下移 ②将下移以后集合位置上的元素返回
            System.out.println(iterator.next());
        }
        /*
        /*
        //错误方式
        Iterator iterator = coll.iterator();
        while(iterator.next() != null){
            System.out.println(iterator.next());//打印456 Tom然后越界异常
        }
        */
        
        //错误方式二:
        //集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。
        while (coll.iterator().hasNext()){
            System.out.println(coll.iterator().next());//123死循环
        }
        */
    }
}

注意:Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象,则必须有一个被迭代的集合。

Iterator迭代器接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zp8XwndB-1638200694132)(C:\Users\吴金融\AppData\Roaming\Typora\typora-user-images\image-20211104160906714.png)]

2、集合元素的删除操作

  • 内部定义了remove(),可以在遍历的时候,删除集合中的元素。此方法不同于集合直接调用remove()
@Test
public void test3() {
    Collection coll = new ArrayList();
    coll.add(123);
    coll.add(456);
    coll.add(new Person("Jerry", 20));
    coll.add(new String("Tom"));
    coll.add(false);
    Iterator iterator = coll.iterator();
    while (iterator.hasNext()) {
        Object obj = iterator.next();
        if("Tom".equals(obj)){
            iterator.remove();
        }
    }//删除集合中的Tom
    iterator = coll.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }// 123 456 Person{name='Jerry', age=20} false
}

3、使用 foreach 循环遍历集合元素

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0rKwLuCX-1638200694137)(C:\Users\吴金融\AppData\Roaming\Typora\typora-user-images\image-20211104170926303.png)]


import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;

public class ForTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);
        //for( 集合中元素的类型  局部变量 : 集合对象)
        for(Object obj : coll){
            System.out.println(obj);//123 456 Person{name='Jerry', age=20} Tom false
        }
    }

    @Test
    public void test2(){
        int arr[] = new int[]{1,2,3,4,5,6};
        for(int i :arr){
            System.out.println(i);//1 2 3 4 5 6
        }
    }
    
    @Test
    public void test3(){
        String[] arr = new String[]{"MM","MM","MM"};
        //方式一:普通for赋值 
        for(int i = 0;i < arr.length;i++){
            arr[i] = "GG";//这个可以使输出为GG
        }

        //方式二:增强for循环
        for(String s : arr){
            s = "GG";//这个不可以使输出为GG  因为这是新建String s 把arr赋值给s
        }

        for(int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

五、Collection子接口

1、 List接口

鉴于Java中数组用来存储数据的局限性,我们通常使用List替代数组

List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。

List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据 序号存取容器中的元素。

JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector。

1、List实现类之一:ArrayList

ArrayList源码分析
1、jdk 7情况下的ArrayList

ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData

这是空参开辟的源码

public ArrayList() {//空构造器 刚开始开辟10空间的数组
    this(10);
}

public ArrayList(int initialCapacity) {//进来一个10
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

这是增添元素的源码

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

list.add(123);//elementData[0] = new Integer(123);

list.add(11);//如果此次的添加导致底层elementData数组容量不够,则扩容。

这是增添元素尺寸计算的代码

private void ensureCapacityInternal(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);//扩容代码
}

默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中。

这是扩容的源码

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);//右移  如10是1010  右移1位就是去掉右边一位  变成101 就是5
    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);
}
2、jdk 8中ArrayList的变化

ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组

这是空参开辟的源码

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//刚开始空间为空
}
//下面是DEFAULTCAPACITY_EMPTY_ELEMENTDATA的源码定义
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

list.add(123);//第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]

这是增添元素的源码

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
//这是ensureCapacityInternal的源码
private void ensureCapacityInternal(int minCapacity) {//size + 1是下面的 minCapacity  应该是0 + 1   二  1+1
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {// DEFAULTCAPACITY_EMPTY_ELEMENTDATA刚开始是空
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//DEFAULT_CAPACITY 是static final = 10	
        }//所以这里会把10赋值给minCapacity

        ensureExplicitCapacity(minCapacity);
    }
//这是ensureExplicitCapacity的源码
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;//刚开始是0 二 1

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)//刚开始添加第一个元素时 elementData.length == 0
            grow(minCapacity);//刚开始扩容10的空间
    }
//这是grow的源码
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//刚开始还是0   10
        int newCapacity = oldCapacity + (oldCapacity >> 1);  10 + 10 >> 1 == 15
        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);//造了一个10的数组
    }

后续的添加和扩容操作与jdk 7 无异

jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象

的创建类似于单例的懒汉式,延迟了数组的创建,节省内存。

2、List实现类之二:LinkList

双向链表,内部没有声明数组,而是定义了Node类型的first和last, 用于记录首末元素。同时,定义内部类Node,作为LinkedList中保存数据的基 本结构。Node除了保存数据,还定义了两个变量:

  • prev变量记录前一个元素的位置
  • next变量记录下一个元素的位置
LinkList源码分析

LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性,默认值为null

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
transient Node<E> first;
transient Node<E> last;
private static class Node<E> {
    E item;//这就是存的元素
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {//内部的Node内部类
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

list.add(123);//将123封装到Node中,创建了Node对象。

public boolean add(E e) {
    linkLast(e);
    return true;
}
void linkLast(E e) {
    final Node<E> l = last;//首次就是null
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

3、List 实现类之三:Vector

Vector的源码分析

jdk7和jdk8中通过Vector()构造器创建对象时,底层都创建了长度为10的数组。

x在扩容方面,默认扩容为原来的数组长度的2倍。

4、List中操作集合元素的方法、

  • void add(int index, Object ele):在index位置插入ele元素
  • boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
  • Object get(int index):获取指定index位置的元素、
 @Test
    public void test1(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);
        System.out.println(list);//[123, 456, AA, Person{name='Tom', age=12}, 456]
//      void add(int index, Object ele):在index位置插入ele元素
        list.add(1 , "BB");
        System.out.println(list);//[123, BB, 456, AA, Person{name='Tom', age=12}, 456]
//      boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list);//[123, BB, 456, AA, Person{name='Tom', age=12}, 456, 1, 2, 3]
//      Object get(int index):获取指定index位置的元素
        System.out.println(list.get(2));//456
    }
  • int indexOf(Object obj):返回obj在集合中首次出现的位置
  • int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
  • Object remove(int index):移除指定index位置的元素,并返回此元素
  • Object set(int index, Object ele):设置指定index位置的元素为ele
  • List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
  @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new Person("Tom",12));
        list.add(456);
//      int indexOf(Object obj):返回obj在集合中首次出现的位置
        int index = list.indexOf(456);
        System.out.println(index);//1
        int index2 = list.indexOf(4562);
        System.out.println(index2);//-1
//      int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
        System.out.println(list.lastIndexOf(456));//4
//      Object remove(int index):移除指定index位置的元素,并返回此元素
        Object obj = list.remove(0);
        System.out.println(obj);//123
        System.out.println(list);//[456, AA, Person{name='Tom', age=12}, 456]
//      Object set(int index, Object ele):设置指定index位置的元素为ele
        list.set(1,"CC");
        System.out.println(list);//[456, CC, Person{name='Tom', age=12}, 456]
//      List subList(int fromIndex, int toInd*//*ex):返回从fromIndex到toIndex位置的左闭右开的子集合,对本身集合不造成影响
        List sublist = list.subList(2, 4);
        System.out.println(sublist);//[Person{name='Tom', age=12}, 456]
    }

总结:常用方法

  • 增:add(Object obj)
  • 删:remove(int index) / remove(Object obj)
  • 改:set(int index, Object ele)
  • 查:get(int index)
  • 插:add(int index, Object ele)
  • 长度:size()
  • 遍历:① Iterator迭代器方式
    ② 增强for循环
    ③ 普通的循环

2、Set接口

1、Set实现类之一:HashSet

  1. 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值决定的。
  2. 不可重复性:保证添加的元素按照equals()判断时,不能返回true.即:相同的元素只能添加一个
  3. HashSet 不是线程安全
  4. 集合元素可以是 null
  5. 对于存放在Set容器中的对象,对应的类一定要重写equals()和hashCode(Object obj)方法,以实现对象相等规则。即:“相等的对象必须具有相等的散列码”。
  6. HashSet底层:数组+链表的结构。
  7. 底层也是数组,初始容量为16,当如果使用率超过0.75,(16*0.75=12) 就会扩大容量为原来的2倍。(16扩容为32,依次为64,128…等)
添加元素的过程

向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值,此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为:索引位置),判断数组此位置上是否已经有元素:

  • 如果此位置上没有其他元素,则元素a添加成功 —>情况1
  • 如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素a与元素b的hash值
    • 如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素a与元素b的hash值
    • 如果hash值不相同,则元素a添加成功 —>情况2
    • 如果hash值相同,进而需要调用元素a所在类的equals()方法
      • equals()返回true,元素a添加失败
      • equals()返回false,则元素a添加成功 —>情况2

对于添加成功的情况2和情况3而言:元素a 与已经存在指定索引位置上数据以链表的方式存储。

  • jdk 7 :元素a放到数组中,指向原来的元素。
  • jdk 8 :原来的元素在数组中,指向元素a
    总结:七上八下
关于hashcode()方法

如果对于存放在Set容器中的对象,该对象没有重写hashcode()方法,则调用Object中的该方法,这个就是完全等于随机数

重写 hashCode() 方法的基本原则

  1. 在程序运行时,同一个对象多次调用 hashCode() 方法应该返回相同的值。(哈希值就是散列码
  2. 当两个对象的 equals() 方法比较返回 true 时,这两个对象的 hashCode() 方法的返回值也应相等。
  3. 对象中用作 equals() 方法比较的 Field,都应该用来计算 hashCode 值。

2、Set实现类之二:LinkedHashSet

LinkedHashSet 是 HashSet 的子类

LinkedHashSet作为HashSet的子类,在添加数据的同时,每个数据还维护了两个引用,记录此数据前一个数据和后一个数据。

优点:对于频繁的遍历操作,LinkedHashSet效率高于HashSet

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a94rZdrd-1638200694142)(C:\Users\吴金融\AppData\Roaming\Typora\typora-user-images\image-20211105232118731.png)]

LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置, 但它同时使用双向链表维护元素的次序,这使得元素看起来是以插入 顺序保存的。

import org.junit.Test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
public class SetTest {
    @Test
    public void test1(){//HashSet
        Set set = new HashSet();
        set.add(456);
        set.add(123);

        set.add("AA");
        set.add("CC");
        set.add(new User("Tom",12));
        set.add(new User("Tom",12));
        set.add(129);
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }

    @Test
    public void test2(){//LinkedHashSet
        Set set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("CC");
        set.add(new User("Tom",12));
        set.add(new User("Tom",12));
        set.add(129);
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }

}

3、Set实现类之三:TreeSet

TreeSet 是 SortedSet 接口的实现类,TreeSet 可以确保集合元素处于排序状态。

TreeSet底层使用红黑树结构存储数据

向TreeSet中添加的数据,要求是相同类的对象

两种排序方式:自然排序(实现Comparable接口) 和 定制排序(Comparator)

  • 自然排序中,比较两个对象是否相同的标准为:compareTo()返回0.不再是equals().

    1. TreeSet类的add()方法中会把存入的对象提升为Comparable类型
    2. 调用对象的comparaTo方法和集合中的对象比较
    3. 根据comparaTo方法返回的结果进行存储
  • 定制排序中,比较两个对象是否相同的标准为:compare()返回0.不再是equals().

    1. 创建TreeSet的时候可以制定一个Comparator
    2. 如果传入了Comparator的子类对象,那么TreeSet就会按照比较器的顺序排序
    3. add()方法内部会自动调用Comparator接口中的compare方法的第二个参数
    4. 利用int compare(T o1,T o2)方法,比较o1和o2的大小:如果方法返回正整数,则表 示o1大于o2;如果返回0,表示相等;返回负整数,表示o1小于o2。

两种排序方式区别:

  1. TreeSet构造函数什么都不传,默认按照类中Comparable的顺序(没有就报错ClassCastException)
  2. TreeSet如果传入Comparator,默认按照Comparator

import org.junit.Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetTest {
    @Test
    public void test1(){//自然排序
        TreeSet set = new TreeSet();
        //失败:不能添加不同类的对象
//        set.add(123);
//        set.add(456);
//        set.add("AA");
//        set.add(new User("Tom",12));
        //举例一:
//        set.add(34);
//        set.add(-34);
//        set.add(43);
//        set.add(11);
//        set.add(8);
        //举例二:
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",2));
        set.add(new User("Mike",65));
        set.add(new User("Jack",33));
        set.add(new User("Jack",56));
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        /*
User{name='Jack', age=33}
User{name='Jack', age=56}
User{name='Jerry', age=32}
User{name='Jim', age=2}
User{name='Mike', age=65}
User{name='Tom', age=12}
 */
    }

    @Test
    public void test2(){//定制排序
        Comparator com = new Comparator() {
            //按照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1 = (User)o1;
                    User u2 = (User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else{
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };
        TreeSet set = new TreeSet(com);
        set.add(new User("Tom",12));
        set.add(new User("Jerry",32));
        set.add(new User("Jim",2));
        set.add(new User("Mike",65));
        set.add(new User("Mary",33));
        set.add(new User("Jack",33));
        set.add(new User("Jack",56));
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
public class User implements Comparable {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    //按照姓名、年龄从小到大排
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
//            return this.name.compareTo(user.name);
            int compara = this.name.compareTo(user.name);
            if(compara != 0){
                return compara;
            }else{
                return Integer.compare(this.age , user.age);
            }
        }else{
            throw new RuntimeException("输入类型不匹配");
        }
    }
}

4、Set的两个练习

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;

/**
 * @author shkstart
 * @create 2019 上午 9:36
 */
public class CollectionTest {
    @Test
    public void test1(){
        Collection coll = new ArrayList();

        coll.add(123);
        coll.add(456);
        coll.add(343);
        coll.add(343);

        coll.forEach(System.out::println);
    }
    //练习:在List内去除重复数字值,要求尽量简单
    public static List duplicateList(List list) {
        HashSet set = new HashSet();
        set.addAll(list);
        return new ArrayList(set);
    }
    @Test
    public void test2(){
        List list = new ArrayList();
        list.add(new Integer(1));
        list.add(new Integer(2));
        list.add(new Integer(2));
        list.add(new Integer(4));
        list.add(new Integer(4));
        List list2 = duplicateList(list);
        for (Object integer : list2) {
            System.out.println(integer);
        }
    }
    @Test
    public void test3(){
        HashSet set = new HashSet();
        Person p1 = new Person(1001,"AA");
        Person p2 = new Person(1002,"BB");
        set.add(p1);
        set.add(p2);
        System.out.println(set);
        p1.name = "CC";
        set.remove(p1);//这个删除找的hash值是cc时候的  和aa时候不一样所以删不掉
        System.out.println(set);//两个 一个1002 bb 一个1001 cc
        set.add(new Person(1001,"CC"));//这个是拿cc算的hash值 所以能加进来
        System.out.println(set);//三个 一个1002 bb 两个1001 cc
        set.add(new Person(1001,"AA"));//hash相同但是equals时候还是可以存
        System.out.println(set);//链表吧aacc存了  4个
    }
}

六、Map接口

1、Map的实现类的结构

  • Map:双列数据,存储key-value对的数据 —类似于高中的函数:y = f(x)

    • HashMap:作为Map的主要实现类;线程不安全的,效率高;存储null的key和value

      • LinkedHashMap:保证在遍历map元素时,可以按照添加的顺序实现遍历。

        原因:在原有的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素。对于频繁的遍历操作,此类执行效率高于HashMap。

    • TreeMap:保证按照添加的key-value对进行排序,实现排序遍历。此时考虑key的自然排序或定制排序底层使用红黑树

    • Hashtable:作为古老的实现类;线程安全的,效率低;不能存储null的key和value

      • Properties:常用来处理配置文件。key和value都是String类型

Map结构理解

Map中的key:无序的、不可重复的,使用Set存储所有的key —> key所在的类要重写equals()和hashCode() (以HashMap为例)
Map中的value:无序的、可重复的,使用Collection存储所有的value —>value所在的类要重写equals()
一个键值对:key-value构成了一个Entry对象。
Map中的entry:无序的、不可重复的,使用Set存储所有的entry

2、HashMap的底层实现原理

jdk7中

  1. HashMap map = new HashMap():
    在实例化以后,底层创建了长度是16的一维数组Entry[] table。、

    public HashMap() {
        this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);//16 0.75
    }
    
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
    
        // Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;//2 4  8 16
    
        this.loadFactor = loadFactor;//loadFactor就是加载因子
        threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//扩容时候的临界值
        table = new Entry[capacity];//造了一个长度16的数组
        useAltHashing = sun.misc.VM.isBooted() &&
                (capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
        init();
    }
    

    …可能已经执行过多次put…

  2. map.put(key1,value1);//添加元素

    • 首先,调用key1所在类的hashCode()计算key1哈希值,此哈希值经过某种算法计算以后,得到在Entry数组中的存放位置。
      如果此位置上的数据为空,此时的key1-value1添加成功。 ----情况1

    • 如果此位置上的数据不为空,(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据
      的哈希值:

      • 如果key1的哈希值与已经存在的数据的哈希值都不相同,此时key1-value1添加成功。----情况2

      • 如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同,继续比较:调用key1所在类的equals(key2)方法,比较:

        • 如果equals()返回false:此时key1-value1添加成功。----情况3

        • 如果equals()返回true:使用value1替换value2。

补充:关于情况2和情况3:此时key1-value1和原来的数据以链表的方式存储。
在不断的添加过程中,会涉及到扩容问题,当超出临界值(且要存放的位置非空)时,扩容。默认的扩容方式:扩容为原来容量的2倍,并将原有的数据复制过来。

public V put(K key, V value) {
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    int i = indexFor(hash, table.length);//通过这个获取到hash值在数组对应的位置
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    addEntry(hash, key, value, i);//添加元素
    return null;
}
void addEntry(int hash, K key, V value, int bucketIndex) {
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);//扩容之前的2倍
        hash = (null != key) ? hash(key) : 0; 
        bucketIndex = indexFor(hash, table.length);//计算对应哈希值在数组的位置
    }

    createEntry(hash, key, value, bucketIndex);
}
final int hash(Object k) {
    int h = 0;
    if (useAltHashing) {
        if (k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
        h = hashSeed;
    }

    h ^= k.hashCode();

    // This function ensures that hashCodes that differ only by
    // constant multiples at each bit position have a bounded
    // number of collisions (approximately 8 at default load factor).
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e);
    size++;
}
Entry(int h, K k, V v, Entry<K,V> n) {
    value = v;
    next = n;
    key = k;
    hash = h;
}

jdk8相比较jdk7在底层实现方面的不同

  1. new HashMap():底层没有创建一个长度为16的数组
  2. jdk 8底层的数组是:Node[],而非Entry[]
  3. 首次调用put()方法时,底层创建长度为16的数组
  4. jdk7底层结构只有:数组+链表。jdk8中底层结构:数组+链表+红黑树
    4.1 形成链表时,七上八下(jdk7:新的元素指向旧的元素。jdk8:旧的元素指向新的元素)
    4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时,此时此索引位置上的所数据改为使用红黑树存储。

3、Map中定义的方法

  1. Object put(Object key,Object value):将指定key-value添加到(或修改)当前map对象中
  2. void putAll(Map m):将m中的所有key-value对存放到当前map中
  3. Object remove(Object key):移除指定key的key-value对,并返回value
  4. void clear():清空当前map中的所有数据
@Test
    public void test3(){
        Map map = new HashMap();
        //添加
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);
        //修改
        map.put("AA",87);  // 因为可以、是aa时候已经有值了  所以找到key修改他的数据
        System.out.println(map);//{AA=87, BB=56, 45=123}
        Map map1 = new HashMap();
        map1.put("CC",123);
        map1.put("DD",123);
        map.putAll(map1);
        System.out.println(map);//{AA=87, BB=56, CC=123, DD=123, 45=123}
        //remove(Object key)
        Object value = map.remove("CC");
        System.out.println(value);//123
        System.out.println(map);//{AA=87, BB=56, DD=123, 45=123}
        //clear()
        map.clear();//与map = null操作不同
        System.out.println(map.size());//0
        System.out.println(map);//{}
    }
  1. Set keySet():返回所有key构成的Set集合
  2. Collection values():返回所有value构成的Collection集合
  3. Set entrySet():返回所有key-value对构成的Set集合
    @Test
    public void test5(){
        Map map = new HashMap();
        map.put("AA",123);
        map.put(45,1234);
        map.put("BB",56);
        //遍历所有的key集:keySet()
        Set set = map.keySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println();
        //遍历所有的value集:values()
        Collection values = map.values();
        for(Object obj : values){
            System.out.println(obj);
        }
        System.out.println();
        //遍历所有的key-value
        //方式一:entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator1 = entrySet.iterator();
        while (iterator1.hasNext()){
            Object obj = iterator1.next();
            //entrySet集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "---->" + entry.getValue());
        }
        /*
AA---->123
BB---->56
45---->1234*/
        System.out.println();
        //方式二:
        Set keySet = map.keySet();
        Iterator iterator2 = keySet.iterator();
        while(iterator2.hasNext()){
        Object key = iterator2.next();
        Object value = map.get(key);
        System.out.println(key + "=====" + value);
    }
}
  1. Object get(Object key):获取指定key对应的value
  2. boolean containsKey(Object key):是否包含指定的key
  3. boolean containsValue(Object value):是否包含指定的value
  4. int size():返回map中key-value对的个数
  5. boolean isEmpty():判断当前map是否为空
  6. boolean equals(Object obj):判断当前map和参数对象obj是否相等

七、Collection工具类常用方法

reverse(List):反转 List 中元素的顺序
shuffle(List):对 List 集合元素进行随机排序
sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List,Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List,int, int):将指定 list 集合中的 i 处元素和 j 处元素进行交换

Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
Object max(Collection,Comparator):根据 Comparator 指定的顺序,返回给定集合中的最大元素
Object min(Collection)
Object min(Collection,Comparator)
int frequency(Collection,Object):返回指定集合中指定元素的出现次数
void copy(List dest,List src):将src中的内容复制到dest中
boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换 List 对象的所有旧值

@Test
public void test3(){
    List list = new ArrayList();
    list.add(123);
    list.add(43);
    list.add(765);
    list.add(765);
    list.add(765);
    list.add(-97);
    list.add(0);
    System.out.println(list);
    Collections.reverse(list);
    Collections.shuffle(list);
    Collections.sort(list);
    Collections.swap(list,1,2);
    int frequency = Collections.frequency(list, 123);
    System.out.println(list);
    System.out.println(frequency);
}
 @Test
    public void test2(){
        List list = new ArrayList();
        list.add(123);
        list.add(43);
        list.add(765);
        list.add(-97);
        list.add(0);
        //报异常:IndexOutOfBoundsException("Source does not fit in dest")
//        List dest = new ArrayList();
//        Collections.copy(dest,list);
        //正确的:
        List dest = Arrays.asList(new Object[list.size()]);
        System.out.println(dest.size());//list.size();
        Collections.copy(dest,list);
        System.out.println(dest);
        /*
        Collections 类中提供了多个 synchronizedXxx() 方法,
        该方法可使将指定集合包装成线程同步的集合,从而可以解决
        多线程并发访问集合时的线程安全问题
         */
        //返回的list1即为线程安全的List
        List list1 = Collections.synchronizedList(list);
    }
  • 2
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值