VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > 编程开发 > Java教程 >

  • 十一(一)、集合之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) 

测试方法代码如下：

复制代码
  1 @Test
  2     public void test1() {
  3         Collection coll = new ArrayList();
  4         //1.add(Object e):将元素e添加到集合coll中；
  5         coll.add("AA");
  6         coll.add("BB");
  7         coll.add(123);
  8         coll.add(new Date());
  9         System.out.println("Collection中的add()方法："+coll);
 10         //size():获取添加元素的个数
 11         System.out.println("Collection中的size()方法："+coll.size());
 12         //addAll(Collection c),将coll1集合中的元素添加到当前集合中
 13         Collection coll1 = new ArrayList();
 14         coll1.add(1234);
 15         coll1.add("abc");
 16         coll.addAll(coll1);
 17         System.out.println(coll.size());//6
 18         System.out.println("Collection中的addAll()方法："+coll.toString()+",此时 coll元素个数："+coll.size());
 19         
 20         //isEmpty():判断当前元素是否为空；
 21         System.out.println("Collection中的isEmpty()方法："+coll.isEmpty());//false,就是看size()是否为0；
 22         
 23         //clear():清空集合元素
 24         coll.clear();
 25         System.out.println("Collection中的clear()方法，此时coll:"+coll.isEmpty());//true
 26         
 27         coll.add(123);
 28         coll.add(456);
 29         coll.add(123);
 30         coll.add(new String("tom"));
 31         coll.add(false);
 32         coll.add(new Person("joy",1));
 33         //contains(Object obj):判断当前集合中是否包含obj
 34         boolean contain = coll.contains(123);
 35         System.out.println("Collection中的contains()方法，此时返回boolean:"+contain);
 36         System.out.println(coll.add(new String("tom")));//判断的是内容，调用的是equals方法；
 37         System.out.println(coll.contains(new Person("joy",1)));//判断的是内容
 38         //2.containsAll(collection coll1)
 39         //判断新城coll1中所有元素是否都存在于当前集合中；
 40         coll1.clear();
 41         coll1.add(123);
 42         coll1.add(456);
 43         boolean flag = coll.containsAll(coll1);
 44         System.out.println(flag);
 45         System.out.println("Collection中的containsAll()方法，此时返回boolean:"+flag);
 46         
 47         //remove(Object obj)移除对象（从当前集合中）,只移除一个对象；
 48         boolean removeFlag = coll.remove(123);
 49         System.out.println("Collection中的remove()方法，此时返回boolean:"+removeFlag);
 50         System.out.println("Collection中的remove()方法，此时返回coll:"+coll.toString());
 51         //removeAll(Collection coll1),从当前集合中移除所有的coll1中存在的元素；
 52         System.out.println(coll.removeAll(coll1));
 53         System.out.println("Collection中的removeAll()方法，此时返回coll:"+coll.toString());
 54         
 55         //retainAll(coll1) 取当前集合和coll1 的交集 ,交集给了当前集合；
 56         //[123, 456, 123, tom, false, Person [name=joy, age=1], tom]
 57         //[123, 456]
 58         //交集就是[123, 456]
 59         /
 60           coll.retainAll(coll1); System.out.println(coll);
 61          /
 62         
 63         
 64         //equals(Object obj) obj也是集合，比较两个集合是否一样；集合中的各个元素顺序必须一样才可以；
 65         Collection coll6 = new ArrayList();
 66         Collection coll7 = new ArrayList();
 67         Collection coll8 = new ArrayList();
 68         coll6.add(123);
 69         coll6.add(456);
 70         coll6.add(789);
 71         coll7.add(123);
 72         coll7.add(456);
 73         coll7.add(789);
 74         coll8.add(789);
 75         coll8.add(456);
 76         coll8.add(123);
 77         System.out.println("Collection中的equals()方法，equeal结果:"+coll6.equals(coll7));
 78         System.out.println("Collection中的equals()方法,equeal结果:"+coll6.equals(coll8));
 79         
 80         //hashCode();返回当前对象的哈希值
 81         System.out.println("Collection中的hashCode()方法,当前hashcode值:"+coll8.hashCode());
 82         
 83         //toArray()集合转数组
 84         Object[] arr = coll.toArray();
 85         for(int i = 0;i<arr.length;i++) {
 86             System.out.println("第"+(i+1)+"个元素："+arr[i]);
 87         }
 88         //拓展：数组转集合
 89         List<String> asList = Arrays.asList(new String[] {"aa","bb","cc"});
 90         System.out.println(asList);
 91         
 92         //iterator():返回接口的实例，拥有遍历集合元素。
 93         //内部方法： hasNext()和next()方法
 94         //原理图
 95         Iterator iterator = coll.iterator();
 96         while(iterator.hasNext()) {
 97             System.out.println("iterator遍历："+iterator.next());
 98         }
 99         
100         //iterator():移除当前集合中的某条数据数据
101         //内部的方法：hasNext()和next();
102         //集合对象每次调用iterator()方法都得到一个全新的迭代器对象
103         //默认游标都在集合的第一个元素之前
104         //内部定义了remove()方法，可以在遍历的时候，删除集合中的元素，此方法不同于集合直接调用remove()；
105         //如果还未调用next()或上一次调用next方法之后已经调用了remove方法，再调用remove都会报错；
106         iterator = coll.iterator();
107         while(iterator.hasNext()) {
108             Object obj = iterator.next();
109             if(obj.equals("tom")) {
110                 iterator.remove();//移除
111             }
112         }
113         iterator = coll.iterator();
114         while(iterator.hasNext()) {
115             Object obj = iterator.next();
116             System.out.println("iterator删除后"+iterator.next());
117         }
118         System.out.println("coll.toString()=>"+coll.toString());
119         
120         //补充：foreach循环，用于遍历集合、数组（jdk1.5新增）
121         //for(集合元素的类型 局部遍历：集合对象)
122         //此种方式不能更改值
123         for(Object obj:coll){
124             System.out.println("foreach=》"+obj);
125         }
126     }
复制代码
回到顶部

四、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情况下：

1 ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}，并没有创建长度为10的数组；
2 
3  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的双向链表的说法；

 

复制代码
1 private static class Node<E> { 
2     E item;
3  Node<E> next; Node<E> prev;
4   
5   Node(Node<E> prev, E element, Node<E> next) {
6       this.item = element; 
7      this.next= next; this.prev = prev;
8     } 
9 }
复制代码

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.  
  2. 　　Object类中的hashCode方法计算的哈希值是随机的，所以，需要重写hashCode方法；
  3. 　　同理 Object类中的equals方法，默认是==运算符，所以类需要判断equals，则需要重写equals方法
  4. HashSet的使用：输出就是无序的；
复制代码
 1     @Test
 2     public void test1() {
 3         Set set = new HashSet();
 4         set.add(456);
 5         set.add(123);
 6         set.add("AA");
 7         set.add("AA");
 8         set.add("CC");
 9         set.add(new Person("Tom",12));
10         set.add(new Person("Tom",12));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
11         set.add(129);
12         Iterator iterator = set.iterator();
13         while(iterator.hasNext()) {
14             System.out.println(iterator.next());
15         }
16     }
复制代码

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

作为hashset的子类，在添加数据的同时，还维护了每个数据的 两个引用，记录了前一个数据和后一个数据
优点：遍历频繁的操作，效率较高
复制代码
 1     /**
 2      *linkedHashSet的使用：
 3      *作为hashset的子类，在添加数据的同时，还维护了每个数据的 两个引用，记录了前一个数据和后一个数据
 4      *优点：遍历频繁的操作，效率较高； 
 5      * 
 6      */
 7     @Test
 8     public void test2() {
 9         LinkedHashSet set = new LinkedHashSet();
10         set.add(456);
11         set.add(123);
12         set.add("AA");
13         set.add("AA");
14         set.add("CC");
15         set.add(new Person("Tom",12));
16         set.add(new Person("Tom",12));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
17         set.add(129);
18         Iterator iterator = set.iterator();
19         while(iterator.hasNext()) {
20             System.out.println(iterator.next());
21         }
22     }
复制代码

TreeSet的使用：

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

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

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

复制代码
 1 @Test
 2     public void test3() {
 3         TreeSet set = new TreeSet();
 4         set.add(new Person("Tom",12));
 5         set.add(new Person("Joy",14));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
 6         set.add(new Person("Jay",14));//
 7         Iterator iterator = set.iterator();
 8         while(iterator.hasNext()) {
 9             System.out.println(iterator.next());
10         }
11     }
12     //TreeSet Comparator接口实现方法
13     @Test
14     public void test4() {
15         Comparator com = new Comparator<Person>() {
16             @Override
17             public int compare(Person o1, Person o2) {
18                 // TODO Auto-generated method stub
19                 return o1.getName().compareTo(o2.getName());
20             }
21             
22             
23             
24         };
25         TreeSet set = new TreeSet(com);
26         set.add(new Person("Tom",12));
27         set.add(new Person("Joy",14));//如果Person类没有重写 equals和hashCode，则还是会出现两个Tom，
28         set.add(new Person("Jay",14));//
29         Iterator iterator = set.iterator();
30         while(iterator.hasNext()) {
31             System.out.println(iterator.next());
32         }
33     }
复制代码

 

Person类：

复制代码
 1 package collection;
 2 
 3 public class Person implements Comparable {
 4 
 5     private String name;
 6     private int age;
 7     public String getName() {
 8         return name;
 9     }
10     public void setName(String name) {
11         this.name = name;
12     }
13     public int getAge() {
14         return age;
15     }
16     public void setAge(int age) {
17         this.age = age;
18     }
19     public Person(String name, int age) {
20         super();
21         this.name = name;
22         this.age = age;
23     }
24     public Person() {
25         super();
26     }
27     @Override
28     public String toString() {
29         return "Person [name=" + name + ", age=" + age + "]";
30     }
31     @Override
32     public int hashCode() {
33         final int prime = 31;//这里使用31为了减少冲突、提高算法效率
34         int result = 1;
35         result = prime * result + age;
36         result = prime * result + ((name == null) ? 0 : name.hashCode());
37         return result;
38     }
39     @Override
40     public boolean equals(Object obj) {
41         if (this == obj)
42             return true;
43         if (obj == null)
44             return false;
45         if (getClass() != obj.getClass())
46             return false;
47         Person other = (Person) obj;
48         if (age != other.age)
49             return false;
50         if (name == null) {
51             if (other.name != null)
52                 return false;
53         } else if (!name.equals(other.name))
54             return false;
55         return true;
56     }
57     @Override
58     public int compareTo(Object o) {
59         Person person = (Person)o;
60         if(this.age>person.age) {
61             return -1;
62         }else {
63             return 1;
64         }
65         
66     }
67     
68     
69 }
复制代码

 

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

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

4、其他

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

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

 

我从来不相信什么懒洋洋的自由。我向往的自由是通过勤奋和努力实现的更广阔的人生。 我要做一个自由又自律的人，靠势必实现的决心认真地活着。
 
来源：https://www.cnblogs.com/lixiuming521125/p/14626817.html

相关教程