十一(一)、集合之Collection

一、Collection

Collection接口：单列数据，定义了存取-组对象的方法集合；

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

  说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储；

2.  数组在存储多个数据方特点

　2.1数组在存储多个数据方面的特点；

  a.数据一旦初始化后，长度就确定了，

  b.一旦定义好，其元素的类型也确定，只能操作指定类型的元素；

 2.2数组在存储多个数据方面的缺点

  a.数据一旦初始化后，长度就确定了，不方便；

  b.数组中提供的方法非常有限，对添加、删除、插入数据等操作，非常有限

  c.获取数组中实际元素的个数，数组没有现成的属性和方法

  d.存储数据的特点：有序、可重复。对于无线、不可重复的需要，不能满足；

  

二、Java集合可以分为Collection 和 Map体系；

•   Collection接口：单列数据，定义了存取-组对象的方法集合；

1. List:元素有序、可重复的集合（动态数组）：ArrayList/LinkedList/Vector
2. Set:无序、不可重复的集合；（高中的集合）：HashSet/LinkedHashSet/TreeSet

  　　 

•   Map接口:双列数据；保存具有映射关系 “key-value”的集合；（高中函数）

1. HashMap/LinkedHashMap/TreeMap/HashTable/Properties

思维导图地址：https://www.cnblogs.com/lixiuming521125/p/14626222.html

三、Collection中的方法；

  注意：向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals方法；

  Collection 15个方法；

1.  boolean add(E e) 向集合中添加元素  
2.  void clear()  清空集合    
3.  boolean contains(Object o) 如果此 collection 包含指定的元素，则返回 true。 
4.  boolean containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素，则返回 true。 
5.  boolean equals(Object o) ：比较此 collection 与指定对象是否相等。 
6.  int hashCode() ：返回此 collection 的哈希码值。 
7.  boolean isEmpty() ：如果此 collection 不包含元素，则返回 true（查看size()是否为0）。 
8.  Iterator<E> iterator() ：返回在此 collection 的元素上进行迭代的迭代器。 
9.  boolean remove(Object o) ：从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。 
10.  boolean removeAll(Collection<?> c) ：移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。 
11.  boolean retainAll(Collection<?> c) ：仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。 
12.  int size() ：返回此 collection 中的元素数。 
13.  Object[] toArray() ：返回包含此 collection 中所有元素的数组。 
14.  <T> T[] 
15.  toArray(T[] a) 

测试方法代码如下：

@Test
    public void test1() {
        Collection coll = new ArrayList();
        //1.add(Object e):将元素e添加到集合coll中；
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());
        System.out.println("Collection中的add()方法："+coll);
        //size():获取添加元素的个数
        System.out.println("Collection中的size()方法："+coll.size());
        //addAll(Collection c),将coll1集合中的元素添加到当前集合中
        Collection coll1 = new ArrayList();
        coll1.add(1234);
        coll1.add("abc");
        coll.addAll(coll1);
        System.out.println(coll.size());//6
        System.out.println("Collection中的addAll()方法："+coll.toString()+",此时 coll元素个数："+coll.size());
        
        //isEmpty():判断当前元素是否为空；
        System.out.println("Collection中的isEmpty()方法："+coll.isEmpty());//false,就是看size()是否为0；
        
        //clear():清空集合元素
        coll.clear();
        System.out.println("Collection中的clear()方法，此时coll:"+coll.isEmpty());//true
        
        coll.add(123);
        coll.add(456);
        coll.add(123);
        coll.add(new String("tom"));
        coll.add(false);
        coll.add(new Person("joy",1));
        //contains(Object obj):判断当前集合中是否包含obj
        boolean contain = coll.contains(123);
        System.out.println("Collection中的contains()方法，此时返回boolean:"+contain);
        System.out.println(coll.add(new String("tom")));//判断的是内容，调用的是equals方法；
        System.out.println(coll.contains(new Person("joy",1)));//判断的是内容
        //2.containsAll(collection coll1)
        //判断新城coll1中所有元素是否都存在于当前集合中；
        coll1.clear();
        coll1.add(123);
        coll1.add(456);
        boolean flag = coll.containsAll(coll1);
        System.out.println(flag);
        System.out.println("Collection中的containsAll()方法，此时返回boolean:"+flag);
        
        //remove(Object obj)移除对象（从当前集合中）,只移除一个对象；
        boolean removeFlag = coll.remove(123);
        System.out.println("Collection中的remove()方法，此时返回boolean:"+removeFlag);
        System.out.println("Collection中的remove()方法，此时返回coll:"+coll.toString());
        //removeAll(Collection coll1),从当前集合中移除所有的coll1中存在的元素；
        System.out.println(coll.removeAll(coll1));
        System.out.println("Collection中的removeAll()方法，此时返回coll:"+coll.toString());
        
        //retainAll(coll1) 取当前集合和coll1 的交集 ,交集给了当前集合；
        //[123, 456, 123, tom, false, Person [name=joy, age=1], tom]
        //[123, 456]
        //交集就是[123, 456]
        /
          coll.retainAll(coll1); System.out.println(coll);
         /
        
        
        //equals(Object obj) obj也是集合，比较两个集合是否一样；集合中的各个元素顺序必须一样才可以；
        Collection coll6 = new ArrayList();
        Collection coll7 = new ArrayList();
        Collection coll8 = new ArrayList();
        coll6.add(123);
        coll6.add(456);
        coll6.add(789);
        coll7.add(123);
        coll7.add(456);
        coll7.add(789);
        coll8.add(789);
        coll8.add(456);
        coll8.add(123);
        System.out.println("Collection中的equals()方法，equeal结果:"+coll6.equals(coll7));
        System.out.println("Collection中的equals()方法,equeal结果:"+coll6.equals(coll8));
        
        //hashCode();返回当前对象的哈希值
        System.out.println("Collection中的hashCode()方法,当前hashcode值:"+coll8.hashCode());
        
        //toArray()集合转数组
        Object[] arr = coll.toArray();
        for(int i = 0;i<arr.length;i++) {
            System.out.println("第"+(i+1)+"个元素："+arr[i]);
        }
        //拓展：数组转集合
        List<String> asList = Arrays.asList(new String[] {"aa","bb","cc"});
        System.out.println(asList);
        
        //iterator():返回接口的实例，拥有遍历集合元素。
        //内部方法： hasNext()和next()方法
        //原理图
        Iterator iterator = coll.iterator();
        while(iterator.hasNext()) {
            System.out.println("iterator遍历："+iterator.next());
        }
        
        //iterator():移除当前集合中的某条数据数据
        //内部的方法：hasNext()和next();
        //集合对象每次调用iterator()方法都得到一个全新的迭代器对象
        //默认游标都在集合的第一个元素之前
        //内部定义了remove()方法，可以在遍历的时候，删除集合中的元素，此方法不同于集合直接调用remove()；
        //如果还未调用next()或上一次调用next方法之后已经调用了remove方法，再调用remove都会报错；
        iterator = coll.iterator();
        while(iterator.hasNext()) {
            Object obj = iterator.next();
            if(obj.equals("tom")) {
                iterator.remove();//移除
            }
        }
        iterator = coll.iterator();
        while(iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("iterator删除后"+iterator.next());
        }
        System.out.println("coll.toString()=>"+coll.toString());
        
        //补充：foreach循环，用于遍历集合、数组（jdk1.5新增）
        //for(集合元素的类型 局部遍历：集合对象)
        //此种方式不能更改值
        for(Object obj:coll){
            System.out.println("foreach=》"+obj);
        }
    }

四、List

1、ArrayList源码分析：

jdk7情况下：

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

list.add(123); ...

list.add(111);//如果此次的添加导致底层elementData数组容量不够，则扩容，类似StringBuilder;

关于扩容：默认情况下，扩容为原来的1.5倍，同时需要将原有数组种的数据复制到新的数组中； 

 结论：建议开发中使用带参的构造器，ArrayList list = new ArrayList(int capacity);指定数组长度； 

 jdk8情况下：

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

 list.add(123);//第一次调用add(),底层才创建长度为10的数组，并把数据123添加到elementData; 后续与1.7一致；

 小结：jdk1.7中的ArrayList的对象的创建类似于单例的饿汉式，1.8的类似于懒汉式，1.8延迟创建数组，节省内存；

2、LinkedList的源码分析

 

LinkedList list = new LinkedList();//内部声明了Node类型的first 和last属性，默认值为null;
list.add(123);//将123封装到Node中，创建了Node对象；

 

其中,Node定义为：提现了LinkedList的双向链表的说法；

 

private static class Node<E> { 
    E item;
 Node<E> next; Node<E> prev;
  
  Node(Node<E> prev, E element, Node<E> next) {
      this.item = element; 
     this.next= next; this.prev = prev;
    } 
}

3、vector的源码分析

 

• jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组
• 在扩容方面，默认扩容为原来数组长度的2倍

4、List常用方法

1.    void add(int index,Object ele);在index位置插入ele元素
2.    boolean addAll(int index,Collection eles),在index位置插入eles中的所有元素添加进来
3.    Object get(int index)获取指定index位置的元素；
4.    int indexOf(Object obj);返回obj在集合中首次出现的位置
5.    int lastIndexOf(Object obj)回obj在集合中末次出现的位置
6.    Object remove(int index),移除指定index位置的元素,返回删除元素的对象
7.    Object set(int index,Object ele):设置指定index位置的元素为ele;
8.    List subList(int fromIndex,int toIndex);返回从fromIndex到toIndex位置的集合；

 总结：常用方法

1.   增：add(Object obj);
2.   删：remove(int index)
3.   改：set(int index,Object ele);
4.   查：get(int index)
5.   插；void add(int index,Object ele)
6.  长度：size()
7.  遍历：

•   Iteraror
•   for
•   增强for循环

测试常用方法：

@Test
    public void test1() {
        ArrayList arrayList = new ArrayList();
        arrayList.add(123);
        arrayList.add(456);
        arrayList.add("AA");
        arrayList.add(new Person("Tom",1));
        arrayList.add(456);
        System.out.println(arrayList.toString());

        //void add(int inde,Object elemnet),在index位置插入element元素
        arrayList.add(1, "BB");
        System.out.println(arrayList.toString());
        
        //void addAll(int inde,Collection elemnets),在index位置插入elements的所有功能元素元素
        
        ArrayList arrayList2 = new ArrayList();
        arrayList2.add("aa");
        arrayList2.add("bb");
        arrayList.addAll(1, arrayList2);
        System.out.println(arrayList.toString());
        
        //查看元素个数
        System.out.println(arrayList.size());
        
        //访问第一个元素
        System.out.println(arrayList.get(0));
        
        //int indexOf(Object obj);返回obj在集合中首次出现的位置,没有返回-1；
        System.out.println(arrayList.indexOf("AA"));
        
        //int lastIndexOf(Object obj)回obj在集合中末次出现的位置
        System.out.println(arrayList.lastIndexOf(456));
        
        //Object remove(int index),移除指定index位置的元素返回删除元素的对象
        System.out.println(arrayList.remove(7));
        
        //Object set(int index,Object ele):设置指定index位置的元素为ele;
        System.out.println(arrayList.set(0, "set"));//设置指定index位置的元素为ele;
        System.out.println(arrayList.toString());
        //List subList(int fromIndex,int toIndex);返回从fromIndex到toIndex位置的集合；
        System.out.println(arrayList.subList(0, 4));
        
        
        //遍历List
        Iterator iterator = arrayList.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        
        for(Object obj : arrayList) {
            System.out.println(obj);
        }
        
        for(int i=0;i<arrayList.size();i++) {
            System.out.println(arrayList.get(i));
        }
    }

五、Set

1、Set:无序、不可重复的集合；（高中的集合）

•   HashSet：作为Set接口的主要实现类，线程不安全，可以存储null值；
•   LinkedHashSet:是HashSet的子类；遍历内部数据，可以按照添加的顺序遍历；
•   TreeSet：使用红黑树存储数据；要求数据是同一个对象new的；可以按照添加对象的指定属性排序
•  关于无序的说明

　　　　1.无序性：但是不是随机性；无序性是指，元素插入的位置不是按顺序插入，而是随机插入

　　　　2.不可重复性：保证添加的元素 ，按照equals()方法判断时，不能返回true，即：相同的元素只能添加一个

• 添加元素的过程（以HashSet为例）：

　　　　我们想HashSet中，添加元素a：

　　　　1、首先调用元素a所在类的hasCode()方法，计算元素a的哈希值，

　　　　　　此哈希值接着通过某种计算出在HashSet底层数组中的存放位置（即:索引位置）；

　　　　2、判断数组此位置上是否已经有元素；

　　　　　　如果此数组此位置上没有其他元素，则元素a添加成功；-----》情况1

　　　　　　如果此位置上有其他元素b(或以链表形式存在多个元素)，则比较元素a与元素b的hash值，

　　　　　　如果hash值不相同，则元素a,添加成功；-----》情况2

　　　　　　如果has值相同，进而需要调用元素a所在类的equals方法，比较

　　　　　　equals返回true，元素a添加失败，否则元素a添加成功；---------》情况3

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

1. jdk7. 元素a放到数组中，指向原来的元素；
2. jdk8. 原来的元素放到数组中，指向a元素；
3. hashset底层：数组+链表结构存放；

 

　　补充：

1. 　　Object类中的hashCode方法计算的哈希值是随机的，所以，需要重写hashCode方法；
2. 　　同理 Object类中的equals方法，默认是==运算符，所以类需要判断equals，则需要重写equals方法
3. HashSet的使用：输出就是无序的；

    @Test
    public void test1() {
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("AA");
        set.add("CC");
        set.add(new Person("Tom",12));
        set.add(new Person("Tom",12));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
        set.add(129);
        Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

LinkedHashSet的使用：（按照插入顺序输出）

作为hashset的子类，在添加数据的同时，还维护了每个数据的 两个引用，记录了前一个数据和后一个数据

优点：遍历频繁的操作，效率较高

    /**
     *linkedHashSet的使用：
     *作为hashset的子类，在添加数据的同时，还维护了每个数据的 两个引用，记录了前一个数据和后一个数据
     *优点：遍历频繁的操作，效率较高； 
     * 
     */
    @Test
    public void test2() {
        LinkedHashSet set = new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add("AA");
        set.add("AA");
        set.add("CC");
        set.add(new Person("Tom",12));
        set.add(new Person("Tom",12));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
        set.add(129);
        Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

TreeSet的使用：

 1.向TreeSet中添加的数据，要求是相同类的对；

* TreeSet 的类的对象中，必须实现Compare接口orComparator接口（Compare接口orComparator接口的使用可点击查看）

* 自然排序中，比较两对象是否相同的标准为；CompareTo()返回0，不再是equals();

@Test
    public void test3() {
        TreeSet set = new TreeSet();
        set.add(new Person("Tom",12));
        set.add(new Person("Joy",14));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
        set.add(new Person("Jay",14));//
        Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
    //TreeSet Comparator接口实现方法
    @Test
    public void test4() {
        Comparator com = new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                // TODO Auto-generated method stub
                return o1.getName().compareTo(o2.getName());
            }
            
            
            
        };
        TreeSet set = new TreeSet(com);
        set.add(new Person("Tom",12));
        set.add(new Person("Joy",14));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
        set.add(new Person("Jay",14));//
        Iterator iterator = set.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

 

Person类：

package collection;

public class Person implements Comparable {

    private String name;
    private int 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;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int hashCode() {
        final int prime = 31;//这里使用31为了减少冲突、提高算法效率
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public int compareTo(Object o) {
        Person person = (Person)o;
        if(this.age>person.age) {
            return -1;
        }else {
            return 1;
        }
        
    }
    
    
}

 

3、Set接口中没有定义额外的方法；使用的都是Collectio中声明过的方法；

•     要求：向Set中添加的数据，其所在的类一定要重写hasCode()和equals()；
•     要求：重写的hashCode()和equals()尽可能保持一致，相等的对象必须具有相等的散列码；
•     一般重写的hashCode()就可以保证一致性；

4、其他

 Set集合不允许包含相同的元素；如果试把两个相同的元素加入同一个Set集合中，则添加操作失败

 Set判断两个对象是都相同不是使用 == 运算符，而是根据equals()方法；