不多说，直接上干货！

　　集合框架中包含了大量集合接口、这些接口的实现类和操作它们的算法。

　　 集合容器因为内部的数据结构不同，有多种具体容器。
　　 不断的向上抽取，就形成了集合框架。

　　Map是一次添加一对元素。Collection是一次添加一个元素。

　　 iterator是迭代获取元素

第一大类：Iterator

　　迭代器是一个对象，它是遍历并选择序列中的对象。

　　说比了，就是给后面的Collection接口里的实现类使用搭配的，为了取值罢了。

　    Iterator 只能正向遍历集合，适用于获取移除元素。

　　ListIterator 继承自Iterator，专门针对List，可以从两个方向来遍历List，同时还支持元素的修改。

第二大类：Collection

　　包括List（ArrayList、LinkedList）和Set（HashSet、TreeSet、LinkedHashSet）

　　ArrayList： 基于数组，不同步，查询较快

　　LinkedList：基于链表，不同步，查询较慢，增删较快

　　

　　HashSet: 内部数据结构是哈希表 ，是无序不能排序，是不同步的。
　　　　　　如何保证该集合的元素唯一性呢？
　　　　　　是通过对象的hashCode和equals方法来完成对象唯一性的。
　　　　　　如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。 
　　　　　　如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
　　　　　　如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

　　　　　　记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
　　　　　　一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
　　　　　　建立对象判断是否相同的依据。

　　hash是一种算法，很多存储起来，就是hash表。

　　TreeSet排序方式有两种。
　　1， 让元素自身具备比较性。
　　　　其实是让元素实现Comparable接口， 覆盖compareTo方法。这称为元素的自然排序。
　　2， 当元素自身不具备比较性， 或者元素具备的比较性不是所需要的，可以让集合自身具备比较性。
　　定义一个比较器： 其实就是定义一个类， 实现Comparator接口。 覆盖compare方法。
　　　　将Comparator接口的子类对象作为参数传递给TreeSet的构造函数。

　　LinkedHashSet
　　　　元素存入和取出的顺序一致。 是一个有序的集合， 不需要我们自己实现排序功能 。

第三大类：Map

　　包括（HashMap、TreeMap、LinkedHashMap）

Map与Collection在集合框架中属并列存在。Map是一次添加一对元素（存储的是夫妻，哈哈）。Collection是一次添加一个元素（存储的是光棍，哈哈）。
　　Map存储的是键值对。
　　Map存储元素使用put方法， Collection使用add方法。
　　Map集合没有直接取出元素的方法， 而是先转成Set集合， 再通过迭代获取元素。
　　Map集合中键要保证唯一性。

Map的两种取值方式keySet、entrySet
　　keySet
　　　　先获取所有键的集合， 再根据键获取对应的值。（即先找到丈夫，去找妻子）
　　entrySet
　　　　先获取map中的键值关系封装成一个个的entry对象， 存储到一个Set集合中，再迭代这个Set集合， 根据entry获取对应的key和value。
　　向集合中存储自定义对象 （entry类似于是结婚证）

　　 HashMap : 内部结构是哈希表，不是同步的。允许null作为键，null作为值。
　　TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。

　　更多，见

牛客网Java刷题知识点之Map的两种取值方式keySet和entrySet、HashMap 、Hashtable、TreeMap、LinkedHashMap、ConcurrentHashMap 、WeakHashMap

　

java中集合、集合类和集合框架是什么意思？

  1. 集合类，是这些集合框架里的集合接口的一些实现类。
  1.  
  1.  

为什么出现集合类？
　　面向对象语言对事物的体现都是以对象的形式， 所以为了方便对多个对象的操作， 就对对象进行存储， 集合就是存储对象最常用的一种方式。 　

　　对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定，就使用集合容器进行存储。

　　数值有很多，用数组存。

　　数组有很多，用二维数组存。

　　数据有很多，用对象存。

　　对象有很多，用集合存。

　　数组和集合类同是容器， 有何不同？
　　　　数组虽然也可以存储对象， 但长度是固定的； 集合长度是可变的。 数组中可以存储基本数据类型。 集合只能存储对象， 不可以存储基本数据类型值。

　　集合类的特点：
　　　　集合只用于存储对象， 集合长度是可变的， 集合可以存储不同类型的对象。

　　好比水杯是容器，有的带有茶隔，有的不带茶隔。同样，集合容器里也有不同的。每一个容器里的数据结构不一样。

  Collections和Collection有什么区别

　　Collection是一个集合接口，它提供了对集合对象进行基本操作的通用接口方法。

　　集合接口Collection的实现类有： List 和 Set 。

　　集合框架Collections是针对集合类的一个包装类，它提供一系列静态方法以实现对各种Collection集合的搜索、排序、线程安全化等操作。

　   集合框架Collections不能被实例化。

CollectionDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5.  
  6. public class CollectionDemo {
  7.  
  8.     /**
  9.      * @param args
  10.      */
  11.     public static void main(String[] args) {
  12.         Collection coll = new ArrayList();
  13.         show(coll);
  14.         Collection c1 = new ArrayList();
  15.         Collection c2 = new ArrayList();
  16.         show(c1,c2);
  17.  
  18.     }
  19.  
  20.     public static void show(Collection c1,Collection c2){
  21.  
  22.         //给c1添加元素。
  23.         c1.add("abc1");
  24.         c1.add("abc2");
  25.         c1.add("abc3");
  26.         c1.add("abc4");
  27.  
  28.         //给c2添加元素。
  29.         c2.add("abc1");
  30.         c2.add("abc2");
  31.         c2.add("abc3");
  32.         c2.add("abc4");
  33.         c2.add("abc5");
  34.  
  35.         System.out.println("c1:"+c1);//c1:[abc1, abc2, abc3,abc4]
  36.         System.out.println("c2:"+c2);//c2:[abc1, abc2, abc3,abc4,abc5]
  37.  
  38.         //演示addAll
  39. //        c1.addAll(c2);//将c2中的元素添加到c1中。
  40. //        System.out.println("c1:"+c1);//c1:[abc1, abc2, abc3,abc4,abc1, abc2, abc3,abc4,abc5]
  41.  
  42.         //演示removeAll，跟retainAll相反
  43. //        boolean b = c1.removeAll(c2);//将两个集合中的相同元素,从调用removeAll的集合中删除。
  44. //        System.out.println("removeAll:"+b);//removeAll:true
  45. //        System.out.println("c1:"+c1);//c1:[abc1,abc3,abc4]
  46.  
  47.         //演示containsAll
  48. //        boolean b = c1.containsAll(c2);
  49. //        System.out.println("containsAll:"+b);//containsAll:false
  50.  
  51.         //演示retainAll，跟removeAll相反
  52.         boolean b = c1.retainAll(c2);//取交集，保留和指定的集合相同的元素，而删除不同的元素。
  53.         System.out.println("retainAll:"+b);//retainAll:false
  54.         System.out.println("c1:"+c1);//c1:[abc1, abc2, abc3,abc4]
  55.     }
  56.  
  57.     public static void show(Collection coll){
  58.         //1,添加元素。add.
  59.         coll.add("abc1");
  60.         coll.add("abc2");
  61.         coll.add("abc3");
  62.         System.out.println(coll);//[abc1, abc2, abc3]
  63.  
  64.         //2，删除元素。remove
  65. //        coll.remove("abc2");//会改变集合的长度 
  66.  
  67.         //清空集合.
  68. //        coll.clear();
  69.         System.out.println(coll.contains("abc3"));//true
  70.         System.out.println(coll);
  71.     }
  72. }

一、集合框架中的迭代器Iterator
　　其实可以把迭代理解为顺序读取。 即取出元素的方式。它的返回值比较特殊， 是Iterator。

　　迭代器是一个对象，它是遍历并选择序列中的对象。
　　使用迭代器可以获取集合中的元素。
注意： 在集合中， 取出元素的格式是固定的。 只要是Collection集合体系， 迭代器就是通用取出方式。
注意： 其实list中存储的都是对象地址。 集合中存储的都是对象引用， 获取迭代器后， 迭代器中持有的也是元素的引用。
注意： 在进行迭代器使用时， next方法在循环中， 建议只定义一个， 定义多个会导致数据错误。 当next方法没有获取到元素时， 会发生NosuchElementException

列表迭代器ListIterator 

　　在对集合中元素迭代的同时进行添加操作， 会发生并发修改异常。
　　concurrentModifycationException(当方法检测到对象的并发修改， 但不允许这种修改时， 抛出此异常)， 属于runtime里面的一个异常。
　　原因： 使用迭代器进行迭代的同时又使用了集合中的方法。
　　分析： 这两个不能同时使用。
　　但是需求就是在迭代的时候要添加元素
　　解决： 对于List集合。 有一个新的迭代方式。 就是ListIterator 列表迭代器。 ListIterator本身也是Iterator的子接口。 并提供了更多的迭代过程中的操作。 在迭代过程中， 如果需要增删改查元素的操作， 需要使用列表迭代器中的方法。
　　注意： 该迭代器， 只能用于List集合。

Iterator与ListIterator有什么区别？

　　Iterator只能正向遍历集合，适用于获取移除元素。

　　ListIterator继承自Iterator，专门针对List，可以从两个方向来遍历List，同时还支持元素的修改。

  1. //使用for循环进行遍历，开发时优先考虑使用for循环的方式进行遍历
  2.         for(Iterator it = c1.iterator();it.hasNext();){ //集合框架中的迭代器Iterator
  3.             System.out.println(it.next());
  4.         }

IteratorDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.Iterator;
  6.  
  7. public class IteratorDemo {
  8.  
  9.     /**
  10.      * @param args
  11.      */
  12.     public static void main(String[] args) {
  13.  
  14.         Collection coll = new ArrayList();
  15.         coll.add("abc1");
  16.         coll.add("abc2");
  17.         coll.add("abc3");
  18.         coll.add("abc4");
  19.  
  20. //        System.out.println(coll);
  21.  
  22.         //使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
  23. //        Iterator it = coll.iterator();
  24. //        while(it.hasNext()){
  25. //            System.out.println(it.next());
  26. //        }
  27.         
    　　　　　　//开发中，用下面的这种，因为循环后，对象it还可以再用
  28.         for(Iterator it = coll.iterator(); it.hasNext(); ){
  29.             System.out.println(it.next());
  30.         }
  32. //        System.out.println(it.next());
  33. //        System.out.println(it.next());
  34. //        System.out.println(it.next());
  35. //        System.out.println(it.next());
  36. //        System.out.println(it.next());//java.util.NoSuchElementException
  37.  
  38.     }
  39.  
  40. }

　　Iterator iterator()：取出元素的方式，迭代器。
　　该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
　　所以该迭代器对象是在容器中进行内部实现的。
　　对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
　　也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

　　List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。

 ListDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. public class ListDemo {
  7.  
  8.     /**
  9.      * @param args
  10.      */
  11.     public static void main(String[] args) {
  12.         List list = new ArrayList();
  13.         show(list);
  14.     }
  15.  
  16.     public static void show(List list) {
  17.         //添加元素
  18.         list.add("abc1");
  19.         list.add("abc2");
  20.         list.add("abc3");
  21.         System.out.println(list);
  22.  
  23.         //插入元素。
  24.         list.add(,"abc9");
  25.         System.out.println(list);//得到[abc1, abc9, abc2, abc3]
  26.  
  27.         //删除元素。
  28.         System.out.println("remove:"+list.remove());//remove:abc2
  29.         System.out.println(list);//得到[abc1, abc9, abc3]
  30.  
  31.         //修改元素。
  32.         System.out.println("set:"+list.set(, "abc8"));//set:abc9
  33.         System.out.println(list);//[abc1, abc8, abc3] 
  34.  
  35.         //获取元素。
  36.         System.out.println("get:"+list.get());//get:abc1
  37.         System.out.println(list);//[abc1, abc8, abc3]
  38.  
  39.         //获取子列表。
  40.         System.out.println("sublist:"+list.subList(, ));//sublist:[abc8]
  41.         System.out.println(list);//[abc1, abc8, abc3]
  42.     }
  43. }

　　

　　ListIterator 在对集合中元素迭代的同时进行添加操作， 会发生并发修改异常。

ListDemo2.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  6. import java.util.ListIterator;
  7.  
  8. public class ListDemo2 {
  9.     /**
  10.      * @param args
  11.      */
  12.     public static void main(String[] args) {
  13.         List list = new ArrayList();
  14.         show(list);
  15.  
  16.         list.add("abc1");
  17.         list.add("abc2");
  18.         list.add("abc3");
  19.  
  20.         System.out.println("list:"+list);//list:[abc1, abc2, abc3, abc4, abc1, abc2, abc3]
  21.      ListIterator it = list.listIterator();//获取列表迭代器对象
  22.         //它可以实现在迭代过程中完成对元素的增删改查。
  23.         //注意：只有list集合具备该迭代功能。 
  24.  
  25.         while(it.hasNext()){
  26.             Object obj = it.next();
  27.             if(obj.equals("abc2")){
  28.                 it.set("abc9");
  29.             }
  30.         }
  31.         System.out.println("hasNext:"+it.hasNext());//hasNext:false
  32.             //it.hasNext()分为两个：    it 和  .hasNext();
  33.             //it:这里应该是上文定义了一个可迭代对象
  34.             //.hasNext()是检查序列中是否还有元素，即hasnext（）是检测下一个元素是否存在，多用于遍历输出。
  35.  
  36.         System.out.println("hasPrevious:"+it.hasPrevious());//hasPrevious:true
  37.             //it.hasNext()这句是正序.这句意思就是从第一个开始,有下一个的话继续遍历。hasNext()由前向next后输出。
  38.             //it.hasPrevious()这句是倒序遍历，这句就是从最后一个开始,有上一个的话继续遍历。
  39.  
  40.         while(it.hasPrevious()){
  41.             System.out.println("previous:"+it.previous());//previous跟next不觉得很熟悉么,这俩就是上一个跟下一个的意思。由后向前输出previous()
  42.                 /*得到
  43.                 previous:abc3
  44.                 previous:abc9
  45.                 previous:abc1
  46.                 previous:abc4
  47.                 previous:abc3
  48.                 previous:abc9
  49.                 previous:abc1
  50.                  */
  51.         }
  52.         System.out.println("list:"+list);
  53.  
  54.         /*Iterator it = list.iterator();
  55.         while(it.hasNext()){
  56.             Object obj = it.next();//java.util.ConcurrentModificationException
  57.                             //在迭代器过程中，不要使用集合操作元素，容易出现异常。
  58.                         //可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。 
  59.  
  60.             if(obj.equals("abc2")){
  61.                 list.add("abc9");
  62.             }
  63.             else
  64.                 System.out.println("next:"+obj);
  65.         }
  66.         System.out.println(list);
  67.         */
  68.     }
  69.  
  70.     public static void show(List list) {
  71.         list.add("abc1");
  72.         list.add("abc2");
  73.         list.add("abc3");
  74.         list.add("abc4");
  75.  
  76.      Iterator it = list.iterator();
  77.         while(it.hasNext()){
  78.             System.out.println("next:"+it.next());
  79.         }
  80.         //list特有的取出元素的方式之一。
  81.         for(int x=; x<list.size(); x++){
  82.             System.out.println("get:"+list.get(x));
  83.         }
  84.     }
  85. }

二、集合框架中的Collection接口

　　Collection接口有两个子接口：List（列表） ， Set（集合）
　　List： 可存放重复元素(因为元素有索引角标)， 元素存取是有序的。
　　Set： 不可以存放重复元素， 元素存取是无序的。

List集合中子类 Vector、ArrayList、LinkedList

　　List：有序， 可重复， 有索引。三者均为可伸缩数组。
　　Vector：底层数据结构是数组结构。 jdk1.0版本。 线程安全的。 无论增删还是查询都非常慢。默认扩充为原来的2倍。
　　ArrayList：底层数据结构是数组结构。 线程不安全的。 所以ArrayList的出现替代了Vector， 但是查询的速度很快。默认扩充为原来的1.5倍。
　　LinkedList：底层是链表数据结构。 线程不安全的， 同时对元素的增删操作效率很高。但查询慢。
　　注意： 链表结构是这样的： 让后一个元素记住前一个元素的地址。

　　 Vector 和  ArrayList都是基于存储元素的Object[ ] array来实现的。

　　 LinkedList是采用双向列表来实现的。

　　LinkdedList，增删改查很快：

　　LinkedList的查询速率比较慢：

　　List集合子类Vector这个类已经不常用了， 我就说里面的一个方法， Elements方法， 这个方法的返回值是枚举接口， 里面有两个方法， 判断和获取。此接口Enumeration的功能与 Iterator 接口的功能是重复的。Enumeration的名称和方法的名称过程， 书写很麻烦。 所以被Iterator所取代。

　　更多，见

牛客网Java刷题知识点之ArrayList 、LinkedList 、Vector 的底层实现和区别

  1.     Collection c1 = new ArrayList();//Collection中的ArrayList
  2.         c1.add("Hadoop");
  3.         c1.add("Spark");
  4.         c1.add("Storm");

  1. //删除元素
  2. coll.remove("Spark");
  3. //清空集合
  4. coll.clear();

 VectorDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.Enumeration;
  4. import java.util.Iterator;
  5. import java.util.Vector;
  6.  
  7. public class VectorDemo {
  8.     public static void main(String[] args) {
  9.         Vector v = new Vector();
  10.         v.addElement("abc1");
  11.         v.addElement("abc2");
  12.         v.addElement("abc3");
  13.         v.addElement("abc4");
  14.  
  15.         Enumeration en = v.elements();//Enumeration是枚举类型
  16.         while(en.hasMoreElements()){
  17.             System.out.println("nextelment:"+en.nextElement());
  18.             /*
  19.             nextelment:abc1
  20.             nextelment:abc2
  21.             nextelment:abc3
  22.             nextelment:abc4
  23.              */
  24.         }
  25.  
  26.         Iterator it = v.iterator();
  27.         while(it.hasNext()){
  28.             System.out.println("next:"+it.next());
  29.             /*
  30.             next:abc1
  31.             next:abc2
  32.             next:abc3
  33.             next:abc4
  34.              */
  35.         }
  36.     }
  37. }

 LinkedListDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;  
  2.  
  3. import java.util.Iterator;
  4. import java.util.LinkedList;       
  5.  
  6. public class LinkedListDemo{                  
  7.  
  8.     /**
  9.      * @param args
  10.      */
  11.     public static void main(String[] args){
  12.         LinkedList link = new LinkedList();
  13.         link.addFirst("abc1");
  14.         link.addFirst("abc2");
  15.         link.addFirst("abc3");
  16.         link.addFirst("abc4");
  17.         System.out.println(link);//[abc4, abc3, abc2, abc1]
  18.         System.out.println(link.getFirst());//获取第一个但不删除。abc4
  19.         System.out.println(link.getFirst());//abc4
  20.  
  21.         System.out.println(link.removeFirst());//获取元素但是会删除。是abc4
  22.         System.out.println(link.removeFirst());//abc3
  23.  
  24.         while(!link.isEmpty()){
  25.             System.out.println(link.removeLast());//abc1
  26.         }
  27.  
  28.         System.out.println(link);//abc2
  29.         Iterator it = link.iterator();
  30.         while(it.hasNext()){
  31.             System.out.println(it.next());//[]
  32.         }
  33.     }
  34.  
  35. }

 Person.java

  1. package cn.itcast.p.bean;
  2.  
  3. public class Person /*extends Object*/ implements Comparable {
  4.  
  5.     private String name;
  6.     private int age;
  7.  
  8.     public Person() {
  9.         super();
  10.  
  11.     }
  12.     public Person(String name, int age) {
  13.         super();
  14.         this.name = name;
  15.         this.age = age;
  16.     }
  17.  
  18.     @Override
  19.     public int hashCode() {
  20. //        System.out.println(this+".......hashCode");
  21.  
  22.         return name.hashCode()+age*;
  23. //        return 100;
  24.     }
  25.     @Override
  26.     public boolean equals(Object obj) {
  27.  
  28.         if(this == obj)
  29.             return true;
  30.         if(!(obj instanceof Person))
  31.             throw new ClassCastException("类型错误");
  32.  
  33. //        System.out.println(this+"....equals....."+obj);
  34.         Person p = (Person)obj;
  35.  
  36.         return this.name.equals(p.name) && this.age == p.age;
  37.     }
  38.     public String getName() {
  39.         return name;
  40.     }
  41.     public void setName(String name) {
  42.         this.name = name;
  43.     }
  44.     public int getAge() {
  45.         return age;
  46.     }
  47.     public void setAge(int age) {
  48.         this.age = age;
  49.     }
  50.     public String toString(){
  51.         return name+":"+age;
  52.     }
  53.     @Override
  54.     public int compareTo(Object o) {
  55.  
  56.         Person p = (Person)o;
  57.  
  58.         int  temp = this.age-p.age;
  59.         return temp==?this.name.compareTo(p.name):temp;
  60.  
  61. //        int  temp = this.name.compareTo(p.name);
  62. //        return temp==0?this.age-p.age:temp;
  63.  
  64.         /*
  65.         if(this.age>p.age)
  66.             return 1;
  67.         if(this.age<p.age)
  68.             return -1;    
  69.  
  70.         else{
  71.  
  72.             return this.name.compareTo(p.name);
  73.         }
  74.         */
  75.  
  76.     }
  77.  
  78. }

ArrayListTest.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5.  
  6. import zhouls.bigdata.DataFeatureSelection.Person;
  7.  
  8. public class ArrayListTest {
  9.     /**
  10.      * @param args
  11.      */
  12.     public static void main(String[] args) {
  13.         Person p1 = new Person("lisi1",);
  14.         ArrayList al = new ArrayList();
  15.         al.add(p1);
  16.         al.add(new Person("lisi2",));
  17.         al.add(new Person("lisi3",));
  18.         al.add(new Person("lisi4",));
  19.  
  20.         Iterator it = al.iterator();
  21.         while(it.hasNext()){
  22. //            System.out.println(((Person) it.next()).getName()+"::"+((Person) it.next()).getAge());
  23.             Person p = (Person) it.next();
  24.             System.out.println(p.getName()+"--"+p.getAge());
  25.         }
  26. //        al.add(5);//al.add(new Integer(5));//因为集合里存储的是对象，同时集合里不能存储基本数据类型。这是自动装箱。
  27.     }
  28.  
  29. }

ArrayListTest2.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5.  
  6. import zhouls.bigdata.DataFeatureSelection.Person;
  7. /*
  8.  * 定义功能去除ArrayList中的重复元素。
  9.  */
  10. public class ArrayListTest2 {
  11.     /**
  12.      * @param args
  13.      */
  14.     public static void main(String[] args) {
  15. //        demo();
  16. //        singleDemo();
  17.         ArrayList al = new ArrayList();
  18.         al.add(new Person("lisi1",));
  19.         al.add(new Person("lisi2",));
  20.         al.add(new Person("lisi3",));
  21.         al.add(new Person("lisi4",));
  22.         al.add(new Person("lisi2",));
  23.         al.add(new Person("lisi3",));
  24.         System.out.println(al);
  25.         al = getSingleElement(al);
  26.         System.out.println(al.remove(new Person("lisi2",)));
  27.         System.out.println(al);
  28.     }
  29.  
  30.     /**
  31.      *
  32.      */
  33.     public static void singleDemo() {
  34.         ArrayList al = new ArrayList();
  35.         al.add("abc1");
  36.         al.add("abc2");
  37.         al.add("abc2");
  38.         al.add("abc1");
  39.         al.add("abc");
  40.         System.out.println(al);
  41.         al = getSingleElement(al);
  42.         System.out.println(al);
  43.     }
  44.  
  45.     public static ArrayList getSingleElement(ArrayList al) {
  46.         //1,定义一个临时容器。
  47.         ArrayList temp = new ArrayList();
  48.         //2,迭代al集合。
  49.         Iterator it = al.iterator();
  50.         while(it.hasNext()){
  51.             Object obj = it.next();
  52.             //3,判断被迭代到的元素是否在临时容器存在。
  53.             if(!temp.contains(obj)){
  54.                 temp.add(obj);
  55.             }
  56.         }
  57.         return temp;
  58.     }
  59.  
  60.     /**
  61.      *
  62.      */
  63.     public static void demo() {
  64. //        al.add(5);//al.add(new Integer(5));
  65.     }
  66. }

Set集合概述

　　Set集合中的元素是无序， 不可以重复的， Set接口的方法和Collection中的方法一致
　　注意： Set集合取出元素的方法只有迭代器。
　　常用的实现类有是HashSet和TreeSet
　　应用场景： 假设要存储的元素必须是唯一的， 这个时候就可以使用Set集合

Set：元素不可以重复，是无序。
Set接口中的方法和Collection一致。
　　|--HashSet: 内部数据结构是哈希表 ，是无序不能排序，是不同步的。
　　　　　　如何保证该集合的元素唯一性呢？
　　　　　　是通过对象的hashCode和equals方法来完成对象唯一性的。
　　　　　　如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
　　　　　　如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
　　　　　　如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

　　　　　　记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
　　　　　　一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
　　　　　　建立对象判断是否相同的依据。

　　hash是一种算法，很多存储起来，就是hash表。

　　|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。
　　　　　　判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。

　　　　　　TreeSet对元素进行排序的方式一：
　　　　　　　　让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。
　　　　　　　　如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？

　　　　　　可以使用TreeSet集合第二种排序方式二：
　　　　　　　　让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
　　　　　　　　将该类对象作为参数传递给TreeSet集合的构造函数。

　　比如，ab的hash值是5.

Set接口中常用的类HashSet、TreeSet
　　HashSet： 底层数据结构是哈希表。 哈希表这种结构， 其实就是对哈希值的存储。 线程不安全， 存取速度快。 它是如何保证元素唯一性的呢？
　　TreeSet： 可以对Set集合中的元素进行排序。 底层数据结构是二叉树结构，
　　这种结构， 可以提高排序性能。 线程不安全的。 它的排序是如何进行的呢？

 HashSetDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.HashSet;
  4. import java.util.Iterator;
  5.  
  6. public class HashSetDemo {
  7.  
  8.     /**
  9.      * @param args
  10.      */
  11.     public static void main(String[] args) {
  12.  
  13.         HashSet hs = new HashSet();
  14.  
  15.         hs.add("hehe");
  16. //        hs.add("heihei");
  17.         hs.add("hahah");
  18.         hs.add("xixii");
  19.         hs.add("hehe");
  20.  
  21.         Iterator it = hs.iterator();
  22.  
  23.         while(it.hasNext()){
  24.             System.out.println(it.next());
  25.         }
  26.     }
  27.  
  28. }

　　同时，也看出来，set的确是保证唯一性，保证里面的元素不能重复。  hehe没进去。

　　HashSet集合数据结构是哈希表，所以存储元素的时候，使用的元素的hashCode方法来确定位置，如果位置相同，再通过元素的equals来确定是否相同。

Set集合元素唯一性原因
　　HashSet： 通过equals方法和hashCode 方法来保证元素的唯一性。
　　TreeSet： 通过compareTo或者compare 方法中的来保证元素的唯一性。 元素是以二叉树的形式存放的。 
　　

ArrayList和HashSet判断重复总结
　　ArrayList： 判断包含， 以及删除， 都是依据元素的equals方法
　　HashSet， 判断包含， 以及删除， 都是依据元素的hashCode方法， 当hashCode相同时， 再判断一次equals方法

Treeset添加排序功能
　　在向里面添加自定义对象的时候， 需要指定这个对象的排序方式。 让这个对象具有可比较性， 否则会报错。 ClassCastException。
　　第一种： 自定义类， 要想要被treeset排序， 就需要实现Comparable接口， 实现里面的compareTo方法
　　第二种： 将一个实现了comparetor接口的子类对象作为参数传递给treeset集合中的构造函数， 这时该集合就具备了比较功能。

Person.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. public class Person /*extends Object*/ implements Comparable {
  4.  
  5.     private String name;
  6.     private int age;
  7.  
  8.     public Person() {
  9.         super();
  10.  
  11.     }
  12.     public Person(String name, int age) {
  13.         super();
  14.         this.name = name;
  15.         this.age = age;
  16.     }
  17.  
  18.     public int hashCode() {
  19. //        System.out.println(this+".......hashCode");
  20.  
  21.         return name.hashCode()+age*;
  22. //        return 100;
  23.     }
  24.  
  25.     public boolean equals(Object obj) {
  26.  
  27.         if(this == obj)
  28.             return true;
  29.         if(!(obj instanceof Person))
  30.             throw new ClassCastException("类型错误");
  31.  
  32. //        System.out.println(this+"....equals....."+obj);
  33.         Person p = (Person)obj;
  34.  
  35.         return this.name.equals(p.name) && this.age == p.age;
  36.     }
  37.     public String getName() {
  38.         return name;
  39.     }
  40.     public void setName(String name) {
  41.         this.name = name;
  42.     }
  43.     public int getAge() {
  44.         return age;
  45.     }
  46.     public void setAge(int age) {
  47.         this.age = age;
  48.     }
  49.     public String toString(){
  50.         return name+":"+age;
  51.     }
  52.     public int compareTo(Object o) {
  53.  
  54.         Person p = (Person)o;
  55.  
  56.         int  temp = this.age-p.age;
  57.         return temp==?this.name.compareTo(p.name):temp;
  58.  
  59. //        int  temp = this.name.compareTo(p.name);
  60. //        return temp==0?this.age-p.age:temp;
  61.  
  62.         /*
  63.         if(this.age>p.age)
  64.             return 1;
  65.         if(this.age<p.age)
  66.             return -1;    
  67.  
  68.         else{
  69.  
  70.             return this.name.compareTo(p.name);
  71.         }
  72.         */
  73.     }
  74. }

 ComparatorByLength.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.Comparator;
  4.  
  5. public class ComparatorByLength implements Comparator {
  6.     public int compare(Object o1, Object o2) {
  7.         String s1 = (String)o1;
  8.         String s2 = (String)o2;
  9.         int temp = s1.length()-s2.length();
  10.         return temp==  ?  s1.compareTo(s2)  :  temp;
  11.     }
  12. }

ComparatorByName.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.Comparator;
  4.  
  5. /**
  6.  * 创建了一个根据Person类的name进行排序的比较器。
  7.  */
  8. public class ComparatorByName implements Comparator {
  9.     public int compare(Object o1, Object o2) {
  10.         Person p1 = (Person)o1;
  11.         Person p2 = (Person)o2;
  12.         int temp = p1.getName().compareTo(p2.getName());
  13.         return temp== ?   p1.getAge()-p2.getAge()  : temp;
  14. //        return 1;//有序。
  15.     }
  16. }

 TreeSetDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.Iterator;
  4. import java.util.TreeSet;
  5.  
  6. public class TreeSetDemo {
  7.     /**
  8.      * @param args
  9.      */
  10.     public static void main(String[] args) {
  11.         TreeSet ts = new TreeSet(new ComparatorByName());
  12.         /*
  13.          * 以Person对象年龄进行从小到大的排序。
  14.          *
  15.          */
  16.         ts.add(new Person("zhangsan",));
  17.         ts.add(new Person("lisi",));
  18.         ts.add(new Person("zhouqi",));
  19.         ts.add(new Person("zhaoliu",));
  20.         ts.add(new Person("wangu",));
  21.  
  22.         Iterator it = ts.iterator();
  23.         while(it.hasNext()){
  24.             Person p = (Person)it.next();
  25.             System.out.println(p.getName()+":"+p.getAge());
  26.         }
  27.     }
  28.  
  29.     /**
  30.      *
  31.      */
  32.     public static void demo1() {
  33.         TreeSet ts = new TreeSet();
  34.  
  35.         ts.add("abc");
  36.         ts.add("zaa");
  37.         ts.add("aa");
  38.         ts.add("nba");
  39.         ts.add("cba");
  40.  
  41.         Iterator it = ts.iterator();
  42.  
  43.         while(it.hasNext()){
  44.             System.out.println(it.next());
  45.         }
  46.     }
  47. }

总结
　　TreeSet排序方式有两种。
　　1， 让元素自身具备比较性。
　　其实是让元素实现Comparable接口， 覆盖compareTo方法。这称为元素的自然排序。
　　2， 当元素自身不具备比较性， 或者元素具备的比较性不是所需要的，可以让集合自身具备比较性。
　　定义一个比较器： 其实就是定义一个类， 实现Comparator接口。 覆盖compare方法。
　　将Comparator接口的子类对象作为参数传递给TreeSet的构造函数。

　　LinkedHashSet
　　元素存入和取出的顺序一致。 是一个有序的集合， 不需要我们自己实现排序功能

集合框架中的Collection集合总结
　　ArrayList： 基于数组，不同步，查询较快
　　LinkedList：基于链表，不同步，查询较慢，增删较快
　　HashSet： 哈希表 
　　TreeSet： 二叉树
　　看到array就要想到数组， 就要想到角标， 想到查询很快。
　　看到link就要想到链表， 就要想到增删很快， 最高再想到addFirst
　　看到hash就要想到哈希表， 就要想到元素的hashcode方法和equals方法
　　看到tree， 就要想到二叉树， 就要想到排序， 就要想到两个接口， comparable和comparator
　　什么时候用List， 什么时候用Set
　　保证元素唯一， 就用Set集合。不需要就使用List集合。
　　实在搞不清楚， 就用ArrayList

三、集合框架中的Map

　　Map与Collection在集合框架中属并列存在。Map是一次添加一对元素（存储的是夫妻，哈哈）。Collection是一次添加一个元素（存储的是光棍，哈哈）。
　　Map存储的是键值对。
　　Map存储元素使用put方法， Collection使用add方法。
　　Map集合没有直接取出元素的方法， 而是先转成Set集合， 再通过迭代获取元素。
　　Map集合中键要保证唯一性。

　　以下，就是Map集合没有直接取出元素的方法， 而是先转成Set集合， 再通过迭代获取元素。

　　MapDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.Map;
  7. import java.util.Set;
  8.  
  9. public class MapDemo {
  10.  
  11.     public static void main(String[] args) {
  12.         Map<Integer,String> map = new HashMap<Integer,String>();
  13.         method(map);
  14.     }
  15.  
  16.     public static void method(Map<Integer,String> map){
  17.         System.out.println(map.put(,"wangcai"));//null 把8看作丈夫，wangcai看作妻子。这里返回的是前妻，对于丈夫8来说，是新婚，所以返回null
  18.         System.out.println(map.put(,"xiaoqiang"));//wangcai  把8看作丈夫，xiaoqiang看作妻子。这里返回的是前妻，对于丈夫8来说，是wangcai
  19.         System.out.println(map);//{8=xiaoqiang}
  20.     }
  21. }

　　即，存相同键，则值会覆盖。

　　继续修改，MapDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.Map;
  7. import java.util.Set;
  8.  
  9. public class MapDemo {
  10.  
  11.     public static void main(String[] args) {
  12.         Map<Integer,String> map = new HashMap<Integer,String>();
  13.         method(map);
  14.     }
  15.  
  16.     public static void method(Map<Integer,String> map){
  17.         System.out.println(map.put(,"wangcai"));//null 把8看作丈夫，wangcai看作妻子。这里返回的是前妻，对于丈夫8来说，是新婚，所以返回null
  18.         System.out.println(map.put(,"xiaoqiang"));//wangcai  把8看作丈夫，xiaoqiang看作妻子。这里返回的是前妻 ，对于丈夫8来说，是wangcai
  19.         map.put(, "zhangshan");
  20.         map.put(, "zhaoliu");
  21.         System.out.println(map);//{2=zhangshan, 7=zhaoliu, 8=xiaoqiang}
  22.     }
  23. }

　　再修修，MapDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.Map;
  7. import java.util.Set;
  8.  
  9. public class MapDemo {
  10.  
  11.     public static void main(String[] args) {
  12.         Map<Integer,String> map = new HashMap<Integer,String>();
  13.         method(map);
  14.     }
  15.  
  16.     public static void method(Map<Integer,String> map){
  17.         System.out.println(map.put(,"wangcai"));//null 把8看作丈夫，wangcai看作妻子。这里返回的是前妻，对于丈夫8来说，是新婚，所以返回null
  18.         System.out.println(map.put(,"xiaoqiang"));//wangcai  把8看作丈夫，xiaoqiang看作妻子。这里返回的是前妻 ，对于丈夫8来说，是wangcai
  19.         map.put(, "zhangshan");
  20.         map.put(, "zhaoliu");            
  21.  
  22.         //删除。
  23.         System.out.println("remove:"+map.remove());//remove:zhangshan
  24.  
  25.         //判断。
  26.         System.out.println("containskey:"+map.containsKey());//containskey:true
  27.  
  28.         System.out.println(map);//{7=zhaoliu, 8=xiaoqiang}
  29.  
  30.         //获取。
  31.         System.out.println("get:"+map.get());//get:xiaoqiang
  32.         System.out.println("get:"+map.get());//get:null,即key为6的不存在
  33.  
  34.         System.out.println(map);
  35.     }
  36. }

　　再修改,MapDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.Map;
  7. import java.util.Set;
  8.  
  9. public class MapDemo{
  10.     public static void main(String[] args) {
  11.         Map<Integer,String> map = new HashMap<Integer,String>();
  12.         method_2(map);
  13.     }
  14.  
  15.     public static void method_2(Map<Integer,String> map){
  16.         map.put(,"zhaoliu");
  17.         map.put(,"zhaoliu");
  18.         map.put(,"xiaoqiang");
  19.         map.put(,"wangcai");
  20.  
  21.         /*
  22.          * 取出map中的所有元素。
  23.          * 原理，通过keySet方法获map中所有的键所在的Set集合，再通过set的迭代器获取到每一个键
  24.          * 再对每一个键通过map集合的get方法获取其对应的值即可
  25.          */
  26.  
  27.         Set<Integer> keySet = map.keySet();//Map集合没有直接取出元素的方法， 而是先转成Set集合，
  28.         Iterator<Integer> it = keySet.iterator();//再通过迭代获取元素。
  29.  
  30.         while(it.hasNext()){
  31.             Integer key = it.next();
  32.             System.out.println(key);
  33.         }
  34.     }
  35. }

　　再修改，MapDemo.java（非常重要，必须要理解）（里面有keySet）

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.Map;
  7. import java.util.Set;
  8.  
  9. public class MapDemo{
  10.     public static void main(String[] args) {
  11.         Map<Integer,String> map = new HashMap<Integer,String>();
  12.         method_2(map);
  13.     }
  14.  
  15.     public static void method_2(Map<Integer,String> map){
  16.         map.put(,"zhaoliu");
  17.         map.put(,"zhaoliu");
  18.         map.put(,"xiaoqiang");
  19.         map.put(,"wangcai");
  20.  
  21.         /*
  22.          * 取出map中的所有元素。
  23.          * 原理，通过keySet方法获map中所有的键所在的Set集合，再通过set的迭代器获取到每一个键
  24.          * 再对每一个键通过map集合的get方法获取其对应的值即可
  25.          */
  27.      Set<Integer> keySet = map.keySet();//Map集合没有直接取出元素的方法， 而是先转成Set集合，
  28.         Iterator<Integer> it = keySet.iterator();//再通过迭代获取元素。
  29.  
  30.         while(it.hasNext()){
  31.             Integer key = it.next();
  32.             String value = map.get(key);
  33.             System.out.println(key+":"+value);
  34.         }
  35.     }
  36. }

　　keySet是所有键的集合

　　

MapDemo.java（里面有entrySet）

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.Map;
  7. import java.util.Set;
  8.  
  9. public class MapDemo {
  10.  
  11.     public static void main(String[] args) {
  12.  
  13.         Map<Integer,String> map = new HashMap<Integer,String>();
  14.         method_2(map);
  15.     }
  16.  
  17.     public static void method_2(Map<Integer,String> map){
  18.  
  19.         map.put(,"zhaoliu");
  20.         map.put(,"zhaoliu");
  21.         map.put(,"xiaoqiang");
  22.         map.put(,"wangcai");
  23.  
  24.         Collection<String> values = map.values();
  25.  
  26.         Iterator<String> it2 = values.iterator();
  27.         while(it2.hasNext()){
  28.             System.out.println(it2.next());
  29.         }
  30.  
  31.         /*
  32.          * 通过Map转成set就可以迭代。
  33.          * 找到了另一个方法。entrySet。
  34.          * 该方法将键和值的映射关系作为对象存储到了Set集合中，而这个映射关系的类型就是Map.Entry类型(结婚证)
  35.          */
  36.         Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
  37.  
  38.       Iterator<Map.Entry<Integer, String>> it = entrySet.iterator();
  40.         while(it.hasNext()){
  41.             Map.Entry<Integer, String> me = it.next();
  42.             Integer key = me.getKey();
  43.             String value = me.getValue();
  44.             System.out.println(key+"::::"+value);
  45.  
  46.         }
  47.  
  48.         //取出map中的所有元素。
  49.         //原理，通过keySet方法获取map中所有的键所在的Set集合，在通过Set的迭代器获取到每一个键，
  50.         //在对每一个键通过map集合的get方法获取其对应的值即可。
  51.         /*
  52.         Set<Integer> keySet = map.keySet();
  53.         Iterator<Integer> it = keySet.iterator();
  54.  
  55.         while(it.hasNext()){
  56.             Integer key = it.next();
  57.             String value = map.get(key);
  58.             System.out.println(key+":"+value);
  59.         }
  60.         */
  61.     }
  62.  
  63.     public static void method(Map<Integer,String> map){//学号和姓名
  64.  
  65.         // 添加元素。
  66.         System.out.println(map.put(, "wangcai"));//null
  67.         System.out.println(map.put(, "xiaoqiang"));//wangcai 存相同键，值会覆盖。
  68.         map.put(,"zhangsan");
  69.         map.put(,"zhaoliu");
  70.  
  71.         //删除。
  72. //        System.out.println("remove:"+map.remove(2));
  73.  
  74.         //判断。
  75. //        System.out.println("containskey:"+map.containsKey(7));
  76.  
  77.         //获取。
  78.         System.out.println("get:"+map.get());
  79.  
  80.         System.out.println(map);
  81.  
  82.         Outer.Inner.show();
  83.     }
  84.  
  85. }
  86.  
  87. interface MyMap{
  88.     public static interface MyEntry{//内部接口
  89.         void get();
  90.     }
  91. }
  92.  
  93. class MyDemo implements MyMap.MyEntry{
  94.     public void get(){}
  95. }
  96.  
  97. class Outer{
  98.     static class Inner{
  99.         static void show(){}
  100.     }
  101. }

Map集合常用类Hashtable、HashMap、TreeMap
　　Hashtable： 线程安全， 速度慢， 不允许存放null键， null值， 已被HashMap替代。
　　HashMap： 线程不安全， 速度快， 允许存放null键， null值。
　　TreeMap： 对键进行排序， 排序原理与TreeSet相同。

　　Hashtable :内部结构是哈希表，是同步的。不允许null作为键，null作为值。
　　　　　　Properties：用来存储键值对型的配置文件的信息，可以和IO技术相结合。
　　HashMap : 内部结构是哈希表，不是同步的。允许null作为键，null作为值。
　　TreeMap : 内部结构是二叉树，不是同步的。可以对Map集合中的键进行排序。

　　HashMap根据键的HashCode值存放数据。

　　HashMap与Hashtable都采用了hash法进行索引。

　　HashMap是Hashtable的轻量级实现，HashMap允许空（null）键值（key）（但需要注意，最多只运行一条记录的键为null，不允许多条记录的值为null），而Hashtable不允许。

　　HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。Hashtable继承自Dictionary类 ，而HashMap是Map接口的一个实现

　　Hashtable的方法是线程安全的，而HashMap不支持线程的同步，所以它不是线程安全的。

　　Hashtable使用Enumeration，HashMap使用Iterator。

　　Hashtable和HashMap采用的hash/rehash算法都几乎一样。

　　HashMap里面存入的键值对在取出时没有固定的顺序，是随机的。

　　TreeMap实现了SortMap接口，键是排序的。

　　

 HashMapDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Iterator;
  5. import java.util.Set;
  6.  
  7. public class HashMapDemo {
  8.     /**
  9.      * @param args
  10.      */
  11.     public static void main(String[] args) {
  12.         /*
  13.          * 将学生对象和学生的归属地通过键与值存储到map集合中。
  14.          */
  15.      HashMap<Student,String> hm = new HashMap<Student,String>();

  17.         hm.put(new Student("lisi",),"北京");
  18.         hm.put(new Student("zhaoliu",),"上海");
  19.         hm.put(new Student("xiaoqiang",),"沈阳");
  20.         hm.put(new Student("wangcai",),"大连");
  21.         hm.put(new Student("zhaoliu",),"铁岭");
  22.  
  23.        Set<Student> keySet = hm.keySet();
  24.      Iterator<Student> it = keySet.iterator();  
  26.         while(it.hasNext()){
  27.             Student key = it.next();
  28.             String value = hm.get(key);
  29.             System.out.println(key.getName()+":"+key.getAge()+"---"+value);
  30.         }
  31.  
  32.     }
  33.  
  34.     }

Student.java

  1. package zhouls.bigdata.DataFeatureSelection; 
  2.  
  3. public class Student extends Person {
  4.  
  5.     public Student() {
  6.         super();
  7.  
  8.     }
  9.  
  10.     public Student(String name, int age) {
  11.         super(name, age);
  12.  
  13.     }
  14.  
  15.     @Override
  16.     public String toString() {
  17.  
  18.         return "Student:"+getName()+":"+getAge();
  19.     }
  20.  
  21.     public int getAge() {
  22.         // TODO Auto-generated method stub
  23.         return ;
  24.     }
  25.  
  26. }

 Person.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. public class Person implements Comparable<Person> {
  4.  
  5.     private String name;
  6.     private int age;
  7.  
  8.     public Person() {
  9.         super();
  10.     }
  11.  
  12.     public Person(String name, int age) {
  13.         super();
  14.         this.name = name;
  15.         this.age = age;
  16.     }
  17.  
  18.     public int compareTo(Person p){
  19.  
  20. //        Person p = (Person)obj;
  21.         int temp = this.age - p.age;
  22.         return temp==?this.name.compareTo(p.name):temp;
  23.     }
  24.  
  25.     @Override
  26.     public int hashCode() {
  27.         final int prime = ;
  28.         int result = ;
  29.         result = prime * result + age;
  30.         result = prime * result + ((name == null) ?  : name.hashCode());
  31.         return result;
  32.     }
  33.  
  34.     @Override
  35.     public boolean equals(Object obj) {
  36.         if (this == obj)
  37.             return true;
  38.         if (obj == null)
  39.             return false;
  40.         if (getClass() != obj.getClass())
  41.             return false;
  42.         Person other = (Person) obj;
  43.         if (age != other.age)
  44.             return false;
  45.         if (name == null) {
  46.             if (other.name != null)
  47.                 return false;
  48.         } else if (!name.equals(other.name))
  49.             return false;
  50.         return true;
  51.     }
  52.  
  53.     public String getName() {
  54.         return name;
  55.     }
  56.     public void setName(String name) {
  57.         this.name = name;
  58.     }
  59.     public int getAge() {
  60.         return age;
  61.     }
  62.     public void setAge(int age) {
  63.         this.age = age;
  64.     }
  65.  
  66.     @Override
  67.     public String toString() {
  68.  
  69.         return "Person:"+getName()+":"+getAge();
  70.     }
  71. }

　　HashMapDemo.java，再次修改。

　　继续。。。。

Map的两种取值方式keySet、entrySet
　　keySet
　　　　先获取所有键的集合， 再根据键获取对应的值。（即先找到丈夫，去找妻子）
　　entrySet
　　　　先获取map中的键值关系封装成一个个的entry对象， 存储到一个Set集合中，再迭代这个Set集合， 根据entry获取对应的key和value。
　　向集合中存储自定义对象 （entry类似于是结婚证）

　　keySet的演示图解：

　　

　　entrySet的演示图解：

LinkedHashMap
　　这个是HashMap的子类
　　可以实现存入顺序和取出顺序一致 。

 LinkedHashMapDemo.java

  1. package zhouls.bigdata.DataFeatureSelection;
  2.  
  3. import java.io.File;
  4. import java.util.HashMap;
  5. import java.util.Iterator;
  6. import java.util.LinkedHashMap;
  7. import java.util.Map;
  8.  
  9. public class LinkedHashMapDemo {
  10.     /**
  11.      * @param args
  12.      */
  13.     public static void main(String[] args) {
  14.         File f= null;
  15.      HashMap<Integer,String> hm = new LinkedHashMap<Integer,String>();
  16.         hm.put(, "zhouqi");
  17.         hm.put(, "zhangsan");
  18.         hm.put(, "qianyi");
  19.         hm.put(, "wangwu");
  20.  
  21.      Iterator<Map.Entry<Integer,String>> it = hm.entrySet().iterator();
  22.         while(it.hasNext()){
  23.             Map.Entry<Integer,String> me = it.next();
  24.             Integer key = me.getKey();
  25.             String value = me.getValue();
  26.             System.out.println(key+":"+value);
  27.         }
  28.     }
  29. }

　　map-values方法
　　　　可以获取map中的所有value的一个集合。

集合的一些技巧：

需要唯一吗？
　　需要：Set
需要制定顺序： 
　　需要： TreeSet
　　不需要：HashSet
　　　　但是想要一个和存储一致的顺序(有序):LinkedHashSet
　　不需要：List
需要频繁增删吗？
　　需要：LinkedList
　　不需要：ArrayList

如何记录每一个容器的结构和所属体系呢？

看名字！

List
　　|--ArrayList
　　|--LinkedList

Set
　　|--HashSet
　　|--TreeSet

　　后缀名就是该集合所属的体系。

　　前缀名就是该集合的数据结构。

看到array：就要想到数组，就要想到查询快，有角标.
看到link：就要想到链表，就要想到增删快，就要想要 add get remove+frist last的方法 
看到hash:就要想到哈希表，就要想到唯一性，就要想到元素需要覆盖hashcode方法和equals方法。 
看到tree：就要想到二叉树，就要想要排序，就要想到两个接口Comparable，Comparator 。

　　而且通常这些常用的集合容器都是不同步的。

  1. :Set集合(理解)
  2.     ()Set集合的特点
  3.         无序,唯一
  4.     ()HashSet集合(掌握)
  5.         A:底层数据结构是哈希表(是一个元素为链表的数组)
  6.         B:哈希表底层依赖两个方法：hashCode()和equals()
  7.           执行顺序：
  8.             首先比较哈希值是否相同
  9.                 相同：继续执行equals()方法
  10.                     返回true：元素重复了，不添加
  11.                     返回false：直接把元素添加到集合
  12.                 不同：就直接把元素添加到集合
  13.         C:如何保证元素唯一性的呢?
  14.             由hashCode()和equals()保证的
  15.         D:开发的时候，代码非常的简单，自动生成即可。
  16.         E:HashSet存储字符串并遍历
  17.         F:HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)
  18.     ()TreeSet集合
  19.         A:底层数据结构是红黑树(是一个自平衡的二叉树)
  20.         B:保证元素的排序方式
  21.             a:自然排序(这种排序方式可以理解成元素本身具备比较性)
  22.                 让元素所属的类实现Comparable接口
  23.             b:比较器排序(这种排序可以理解成集合类具备比较性)
  24.                 让集合构造方法接收Comparator的实现类对象，实现方式可以用匿名类来实现。
  25.         C:把我们讲过的代码看一遍即可
  26.     ()案例：
  27.         A:获取无重复的随机数
  28.         B:键盘录入学生按照总分从高到底输出
  29.  
  30. :Collection集合总结(掌握)
  31.     Collection
  32.         |--List 有序,可重复
  33.             |--ArrayList
  34.                 底层数据结构是数组，查询快，增删慢。
  35.                 线程不安全，效率高
  36.             |--Vector
  37.                 底层数据结构是数组，查询快，增删慢。
  38.                 线程安全，效率低
  39.             |--LinkedList
  40.                 底层数据结构是链表，查询慢，增删快。
  41.                 线程不安全，效率高
  42.         |--Set  无序,唯一
  43.             |--HashSet
  44.                 底层数据结构是哈希表。
  45.                 如何保证元素唯一性的呢?
  46.                     依赖两个方法：hashCode()和equals()
  47.                     开发中自动生成这两个方法即可
  48.                 |--LinkedHashSet
  49.                     底层数据结构是链表和哈希表
  50.                     由链表保证元素有序
  51.                     由哈希表保证元素唯一
  52.             |--TreeSet
  53.                 底层数据结构是红黑树。
  54.                 如何保证元素排序的呢?
  55.                     自然排序
  56.                     比较器排序
  57.                 如何保证元素唯一性的呢?
  58.                     根据比较的返回值是否是0来决定
  59.  
  60. :针对Collection集合我们到底使用谁呢?(掌握)
  61.     唯一吗?
  62.         是：Set
  63.             排序吗?
  64.                 是：TreeSet
  65.                 否：HashSet
  66.         如果你知道是Set，但是不知道是哪个Set，就用HashSet。
  67.  
  68.         否：List
  69.             要安全吗?
  70.                 是：Vector
  71.                 否：ArrayList或者LinkedList
  72.                     查询多：ArrayList
  73.                     增删多：LinkedList
  74.         如果你知道是List，但是不知道是哪个List，就用ArrayList。
  75.  
  76.     如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。
  77.  
  78.     如果你知道用集合，就用ArrayList。
  79.  
  80. :在集合中常见的数据结构(掌握)
  81.     ArrayXxx:底层数据结构是数组，查询快，增删慢
  82.     LinkedXxx:底层数据结构是链表，查询慢，增删快
  83.     HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()
  84.     TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

牛客网Java刷题知识点之Java 集合框架的构成、集合框架中的迭代器Iterator、集合框架中的集合接口Collection（List和Set）、集合框架中的Map集合的更多相关文章

  1. 牛客网Java刷题知识点之Java集合类里面最基本的接口有哪些

    不多说,直接上干货! https://www.nowcoder.com/ta/review-java/review?tpId=31&tqId=21086&query=&asc= ...

  2. 牛客网Java刷题知识点之Java为什么不能支持多继承，但可以用接口来间接实现多继承

    不多说,直接上干货! java只支持单继承,这是由于安全性的考虑,如果子类继承的多个父类里面有相同的方法或者属性,子类将不知道具体要继承哪个,而接口可以多实现,是因为接口只定义方法,而没有具体的逻辑实 ...

  3. 牛客网sql刷题解析-完结

    查找最晚入职员工的所有信息 解题步骤: 题目:查询最晚入职员工的所有信息        目标:查询员工的所有信息 筛选条件:最晚入职           答案: SELECT *--查询所有信息就用* ...

  4. 牛客网Java刷题知识点之为什么HashMap和HashSet区别

    不多说,直接上干货! HashMap  和  HashSet的区别是Java面试中最常被问到的问题.如果没有涉及到Collection框架以及多线程的面试,可以说是不完整.而Collection框架的 ...

  5. 牛客网Java刷题知识点之为什么HashMap不支持线程的同步，不是线程安全的？如何实现HashMap的同步？

    不多说,直接上干货! 这篇我是从整体出发去写的. 牛客网Java刷题知识点之Java 集合框架的构成.集合框架中的迭代器Iterator.集合框架中的集合接口Collection(List和Set). ...

  6. 牛客网Java刷题知识点之Map的两种取值方式keySet和entrySet、HashMap 、Hashtable、TreeMap、LinkedHashMap、ConcurrentHashMap 、WeakHashMap

    不多说,直接上干货! 这篇我是从整体出发去写的. 牛客网Java刷题知识点之Java 集合框架的构成.集合框架中的迭代器Iterator.集合框架中的集合接口Collection(List和Set). ...

  7. 牛客网Java刷题知识点之ArrayList 、LinkedList 、Vector 的底层实现和区别

    不多说,直接上干货! 这篇我是从整体出发去写的. 牛客网Java刷题知识点之Java 集合框架的构成.集合框架中的迭代器Iterator.集合框架中的集合接口Collection(List和Set). ...

  8. 牛客网Java刷题知识点之HashMap的实现原理、HashMap的存储结构、HashMap在JDK1.6、JDK1.7、JDK1.8之间的差异以及带来的性能影响

    不多说,直接上干货! 福利 => 每天都推送 欢迎大家,关注微信扫码并加入我的4个微信公众号:   大数据躺过的坑      Java从入门到架构师      人工智能躺过的坑          ...

  9. 牛客网Java刷题知识点之泛型概念的提出、什么是泛型、泛型在集合中的应用、泛型类、泛型方法、泛型接口、泛型限定上限、泛型限定下限、 什么时候使用上限？泛型限定通配符的体现

    不多说,直接上干货! 先来看个泛型概念提出的背景的例子. GenericDemo.java package zhouls.bigdata.DataFeatureSelection; import ja ...

随机推荐

  1. MacBook Pro (13 英寸, 2012 年中)安装win7系统

    准备: windows7 ISO镜像 16G或更大U盘(提前备份,需要格式化) Apple 官方提供的 windows7驱动程序 详细步骤: 1.打开Bootcamp,选择前两个选择点击继续,选择下载 ...

  2. Gazebo学习随记2 SDF和XML

    Model 模型 一个模型数据库会拥有的文件 database.config:有关数据库的元数据,从CMakeList自动填充『本地不需要』 model文件夹 一个模型[奏是辣个文件夹]会有的文件 m ...

  3. Struct结构体

    1.结构体的定义与调用 // 定义结构体类型 // 结构体类型名为 MyDate1 struct MyDate1 { int year; int month; int day; }; // 定义结构体 ...

  4. 解决RegexKitLite导入报错问题

    1.RegexKitLite是什么? RegexKitLite是一个非常方便的处理正则表达式的第三方类库. 本身只有一个RegexKitLite.h和RegexKitLite.m 2.导入RegexK ...

  5. 分数规划-poj3111

    题意:给定n个珠宝,每个珠宝有重量 w 和价值v ,要求你从中选出k个,使∑v/∑w 尽可能大,输出选出的珠宝的编号 数据范围: 1 ⩽ k ⩽ n ⩽ 10 , 1 ⩽ w , v ⩽ 10. 这道 ...

  6. c++运算符重载-如何决定作为成员函数还是非成员函数

    The Decision between Member and Non-member The binary operators = (assignment), [] (array subscripti ...

  7. SP263 PERIOD - Period KMP技巧

    \(\color{#0066ff}{题目描述}\) 如果一个字符串S是由一个字符串T重复K次形成的,则称T是S的循环元.使K最大的字符串T称为S的最小循环元,此时的K称为最大循环次数. 现给一个给定长 ...

  8. mac 卸载 node

    sudo rm -rf /usr/local/{bin/{node,npm},lib/node_modules/npm,lib/node,share/man/*/node.*} 除此之外,还需要检查一 ...

  9. CodeForces - 359C-Prime Number

    Simon has a prime number x and an array of non-negative integers a1, a2, ..., an. Simon loves fracti ...

  10. Linux 文件系统的目录结构

    http://www.jb51.net/LINUXjishu/151820.htmlLinux下的文件系统为树形结构,入口为/ 树形结构下的文件目录: 无论哪个版本的Linux系统,都有这些目录,这些 ...