List和Map集合详细分析

1.Java集合主要三种类型(两部分)：

第一部分：Collection（存单个数据，只能存取引用类型）

　　（1）.List ：是一个有序集合，可以放重复的数据；（存顺序和取顺序相同）

　　（2）.Set ：是一个无序集合，不允许放置重复的数据；（存顺序和取顺序不一定相同）

　　（3）.SortedSet：无序不可重复，存进去的元素可以按照元素的大小自动排序。

第二部分：Map（存成对数据）

　　（1）.Map: 是一个无序集合，集合中包含一个键对象，一个值对象，键对象不允许重复，值对象可以重复（身份证号-姓名）。

2.Java集合存取数据类型及结构

2.1  常见集合的继承结构-Collection

2.1.1、集合中常用实现类的数据结构分析:

（1）List集合

　　List集合继承了Collection接口，因此包含了collection中所有的方法，此外，List接口还定义了以下两个非常重要的方法：

　　（a）get（int index）：获得指定索引位置的元素

　　（b）set（int index，Object obj）：将集合中指定索引位置的对象修改为指定对象。

（2）ArrayList

　　采用数组存储元素，适合查询，不适合随机增删元素。（常用）。是可变数组，允许保存所有的元素，包括null,并可以根据索引位置对集合进行快速的随机访问：缺点是指定的索引位置插入对象或删除对象的速度较慢。

（3）LinkedList

　　底层采用双向链表数据结构存储数据，适合频繁的增删元素，不适合查询元素。

（4）Vector

　　底层和ArrayList集合相同，但是 Vector是线程安全的，效率较低。（不常用）

（5）Set集合

　　 Set集合中的元素不按特定的方式排序，只是简单地把对象加入集合，Set集合中不能包含重复对象。set集合有Set接口的实现类组成，set接口继承了Collection接口，因包含了Collction接口的所有方法。 Set的构造方法有一个约束条件，传入的Collection对象不能把有重复值，必须小心操作可变对象（Mutable Object）。如果一个Set中可变元素改变了自身状态导致Object。equals（Object） = true,则会出现一些问题。

（6）HashSet

　　哈希表/散列表，底层是一个HashMap。HashSet有以下特点：

　　a. 不能保证元素的排列顺序，顺序有可能发生变化
　　b.不是同步的
　　c. 集合元素可以是null,但只能放入一个null

　　当向HashSet结合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值来决定该对象在HashSet中存储位置。

简单的说，HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值相 等。
　　注意，如果要把一个对象放入HashSet中，重写该对象对应类的equals方法，也应该重写其hashCode()方法。

　　其规则是如果两个对 象通过equals方法比较返回true时，其hashCode也应该相同。另外，对象中用作equals比较标准的属性，都应该用来计算 hashCode的值。

（5）TreeSet:

　　TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式， 自然排序 和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。

　　自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。
　　Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。
　　 obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。  
　　如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0    
b.定制排序
　　定制排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法

2.1.2、Collection接口中的方法分析:

（1）.list集合

 package list;
 import java.util.*;
 import java.util.ArrayList;
 public class Gather { // 创建类Gather
     public static void main(String[] args) { // 主方法
       List<String> list = new ArrayList<>();//创建集合对象
       list.add("a");
       list.add("b");
       list.add("c");
       //获得0~2之间随机数
       int i = (int)(Math.random()*(list.size() - 1));
       System.out.println("随机数组中的元素: "+list.get(i));
       list.remove(2);//将指定索引位置的元素从集合中移除
       System.out.println("将索引是2的元素从数组中移除后数组中的元素是：");
       for(int j = 0;j < list.size();j++){//循环遍历结合
           System.out.println(list.get(j));
       }
    }

 }
 /*
 运行结果：

 随机数组中的元素: a
 将索引是2的元素从数组中移除后数组中的元素是：
 a
 b
 */

（2）set集合

 import java.util.*;
 /**
  * 在项目中创建类UpdateStu，实现Comparable接口，重写该接口中的compareTo（）方法。在主方法中
  * 创建UpdateStu对象，创建集合，并将UpdataStu对象添加到集合中，遍历该集合中的全部元素，以及通过
  * headSet（），subSet（）方法获得的全部的部分集合。
  * @author z
  *
  */
 public class UpdateStu implements Comparable<Object> {
     String name;
     long id;
     public UpdateStu(String name, long id) {
         this.id = id;
         this.name = name;
     }
     public int compareTo(Object o) {
         UpdateStu upstu = (UpdateStu) o;
         int result = id > upstu.id ? 1 : (id == upstu.id ? 0 : -1);
         return result;
     }
     public long getId() {
         return id;
     }
     public void setId(long id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public static void main(String[] args) {
         UpdateStu stu1 = new UpdateStu("李同学", 01011);
         UpdateStu stu2 = new UpdateStu("陈同学", 01021);
         UpdateStu stu3 = new UpdateStu("王同学", 01051);
         UpdateStu stu4 = new UpdateStu("马同学", 01012);
         TreeSet<UpdateStu> tree = new TreeSet<>();
         tree.add(stu1);
         tree.add(stu2);
         tree.add(stu3);
         tree.add(stu4);
         Iterator<UpdateStu> it = tree.iterator();
         System.out.println("Set集合中的所有元素：");
         while (it.hasNext()) {
             UpdateStu stu = (UpdateStu) it.next();
             System.out.println(stu.getId() + " " + stu.getName());
         }
         it = tree.headSet(stu2).iterator();
         System.out.println("截取前面部分的集合：");
         while (it.hasNext()) {
             UpdateStu stu = (UpdateStu) it.next();
             System.out.println(stu.getId() + " " + stu.getName());
         }
         it = tree.subSet(stu2, stu3).iterator();
         System.out.println("截取中间部分的集合");
         while (it.hasNext()) {
             UpdateStu stu = (UpdateStu) it.next();
             System.out.println(stu.getId() + " " + stu.getName());
         }
     }
 }
 /*
 运行结果：

 Set集合中的所有元素：
 521 李同学
 522 马同学
 529 陈同学
 553 王同学
 截取前面部分的集合：
 521 李同学
 522 马同学
 截取中间部分的集合
 529 陈同学

    分析：存入TreeSet类实现的Set集合必须实现Comparable接口，该接口中的compareTo(Object o)方法比较此对象与指定对象的顺序，如果该对象小于，等于，或大于指定对象，则分别返回负整数，0或正整数。
 */

（3）contains方法：boolean contains(object o);判断集合中是否包含某个元素

 import java.util.*;

 class  Collection01
 {
     //重写equals方法

     public static void main(String[] args)
     {
         //创建集合
         Collection c = new ArrayList();
         //创建Integer类型对象
         Integer i1 = new Integer(10);
         //添加元素
         c.add(i1);
         //判断集合中是否包含i1
         System.out.println(c.contains(i1));//true

         Integer i2= new Integer(10);
         System.out.println(c.contains(i2));//true

         Manager m1=new Manager(100,"JACK");
         c.add(m1);
         //contasins方法调用底层的是equals方法，如果equals方法返回True，就是包含
         System.out.println(c.contains(m1));//true

         Manager m2=new Manager(100,"JACK");
         //重写equas方法之前返回false，（比较内存地址）
         //System.out.println(c.contains(m2));//false
         //重写equas方法之后返回True，集合中的对象都要重写equalos方法（比较内容）
         System.out.println(c.contains(m2));//true

     }
 }
 class Manager
 {
    int no;
    String name;
    Manager(int no,String name)
    {
        this.no=no;
        this.name=name;
    }
    public boolean equals(Object o)
    {
        if(this==o) return true;
        if(o instanceof Manager)
        {
          Manager m = (Manager)o;
          if(m.no == this.no && m.name.equals(this.name))
            {
              return true;
            }
        }
        return false;
    }

 }

（4）remove方法：boolean remove(object o);删除集合中的某个元素

 import java.util.*;
 /*
   boolean remove(Object o)
   集合中的元素都需要重写equals方法，在Object的equals方法比较内存地址，在解决实际问题的时候应该比较内容
 */

 class  Remove
 {
     public static void main(String[] args)
     {
         Collection c = new ArrayList();
         Integer i1 = new Integer(10);
         c.add(i1);
         Integer i2=new Integer(10);
         c.remove(i2);
         System.out.println(c.size());//
         Manager m2=new Manager(100,"ZHANG");
         c.remove(m2);
         System.out.println(c.size());//
     }
 }
 class Manager
 {
    int no;
    String name;
    Manager(int no,String name)
    {
        this.no=no;
        this.name=name;
    }

 }

（5）两种remove方法的区别

　　a.迭代器的remove方法

 import java.util.*;

 class  Remove1
 {
     public static void main(String[] args)
     {
         Collection c = new ArrayList();
         c.add(1);
         c.add(2);
         c.add(3);
         Iterator it = c.iterator();
         while(it.hasNext())
         {
             Object element = it.next();
             it.remove();
         }
         System.out.println(c.size());
     }
 }

　　b.集合自身带的remove方法

 import java.util.*;

 class  Remove1
 {
     public static void main(String[] args)
     {
         Collection c = new ArrayList();
         c.add(1);
         c.add(2);
         c.add(3);
         Iterator it = c.iterator();
         while(it.hasNext())
         {
             Object element = it.next();
             c.remove(element);
             //集合自身带的remove在将元素删除后，迭代器失效，需要重新获得迭代器，若不添加此语句，则会出现异常
             it = c.iterator();
         }
         System.out.println(c.size());
     }
 }

2.1.3、List接口中的方法分析:（有序可重复）

（1）.添加元素，遍历元素

 import java.util.*;

 class Main   //有序可重复
 {
     public static void main(String[] args)
     {
         List L = new ArrayList();
         L.add(100);
         L.add(200);
         L.add(1300);
         L.add(120);
         L.add(100);
         Iterator it = L.iterator();
         while (it.hasNext())
         {
            Object element =  it.next();
            System.out.println(element);
         }

     }
 }

（2）ArrayList底层原理

 package shili;

 import java.util.*;
 /**
  * ArrayList底层集合是数组
  * ArrayList默认容量是10，扩容后的新容量是原容量的1.5倍
  * vector集合底层默认初始容量是10，扩容后是原容量的2倍。
  * 如果优化ArrayList和Vector？
  * 尽量减少扩容操作，扩容需要拷贝数组，拷贝很消耗内存，一般在创建集合时指定初始化
 */
 class Main
 {
     public static void main(String[] args)
     {
         //创建List集合
         List l = new ArrayList();
         l.add(10);
         l.add(20);
         l.add(30);
         //在下标为1的位置上添加100
         l.add(1,100);
         //获取第一个元素
         System.out.println(l.get(0));
         //便利（List集合特有的便利方式）
         System.out.println("--------------------");
         for(int i=0;i<l.size();i++){
             Object element= l.get(i);
             System.out.println(element);
         }

     }
 }

（3）ArrayList与Vector的区别

　　a.Vector是线程安全的，Arrayliast是线程不安全的 。

　　b.ArrayList在底层数组不够用的时候扩展为原来的1.5倍，Vector默认扩展为你原来的2倍。

　　对于第一点可以通过原码来观察：

　　vector原码:

 public class Vector<E>
     extends AbstractList<E>
     implements List<E>, RandomAccess, Cloneable, java.io.Serializable
 {
     /**
      * The array buffer into which the components of the vector are
      * stored. The capacity of the vector is the length of this array buffer,
      * and is at least large enough to contain all the vector's elements.
      *
      * <p>Any array elements following the last element in the Vector are null.
      *
      * @serial
      */
     protected Object[] elementData;

　　Vector的add方法:

 public synchronized boolean add(E e) {
         modCount++;
         ensureCapacityHelper(elementCount + 1);
         elementData[elementCount++] = e;
         return true;
     }

　　ArrayList的add方法

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

　　分析：从add方法中可以看到，vector的add方法中添加了synchronized关键字来保证vector的线程是安全的。

其实vector的其他方法中，也都加了synchronized关键字。

2.1.4  set接口中的方法分析:（无序不可重复）

（1）.HasHset

 /*
   set集合中存储元素，该元素的hashCode和equals方法
   HashMap中有一个put的方法，put(key,value) key是无序不可重复的
   存储在hashSet集合或者HashMap集合Key部分的元素，需要同时重写hashCode方法和equals方法
 */
 import java.util.*;
 class  SetTest
 {
     public static void main(String[] args)
     {
         //创建集合
         Set es =new HashSet();
         Employee e1 = new Employee("1000","u1");
         Employee e2 = new Employee("1001","u2");
         Employee e3 = new Employee("2000","u3");
         Employee e4 = new Employee("2001","u4");
         Employee e5 = new Employee("2001","u4");

        es.add(e1);
        es.add(e2);
        es.add(e3);
        es.add(e4);
        es.add(e5);
       System.out.println(es.size());

     }
 }

 //员工编号1000~9999
 class Employee
 {
     String no;
     String name;
     Employee(String no,String name)
     {
         this.no=no;
         this.name=name;
     }
     //重写equals方法，如果员工编号相同，并且名字相同，则是同一个对象
     public boolean equals(Object o)
     {
         if(this == o) {
          return true;
         }
         if(o instanceof Employee){
           Employee e= (Employee)o;
           if(e.no.equals(this.no) && e.name.equals(this.name)){
             return true;
           }
         }
         return false;
     }
     //重写hashCode方法
     public int hashCode()
     {
         return no.hashCode();
     }

 }

（2）SortedSet

 /*
   java.util.Set;
     java.util.SortSet;无序不可重复，但是进去的元素可以按照元素的大小顺序自动进行排序
       java.util.TreeSet;
 */
 import java.util.*;
 import java.text.*;
 class  SortSettest
 {
     public static void main(String[] args) throws ParseException
     {
         //创建集合
         SortedSet ss = new TreeSet();
         //天加元素 自动装箱
         ss.add(30);
         ss.add(20);
         ss.add(33);
         ss.add(10);
         ss.add(60);
         ss.add(8);
         //遍历
         Iterator it = ss.iterator();
         while(it.hasNext()){
            Object e = it.next();
            System.out.println(e);
         }
         //String
         SortedSet str = new TreeSet();
         str.add("zhangsan");
         str.add("lisi");
         str.add("wangwu");
         str.add("maliu");
         str.add("liuba");
         //遍历
         it = str.iterator();
         while(it.hasNext()){
            Object e = it.next();
            System.out.println(e);
         }
         //Date
      SortedSet times =  new TreeSet();
         String t1 = "2009-10-01";
         String t2 = "2012-01-01";
         String t3 = "2014-06-08";
         String t4 = "2018-07-01";
         String t5 = "2008-08-08";
         //设置格式
       SimpleDateFormat def = new SimpleDateFormat("yyyy-MM-dd");
         //日期格式化
         Date ut1 = def.parse(t1);
         Date ut2 = def.parse(t2);
         Date ut3 = def.parse(t3);
         Date ut4 = def.parse(t4);
         Date ut5 = def.parse(t5);
         //添加
         times.add(ut1);
         times.add(ut2);
         times.add(ut3);
         times.add(ut4);
         times.add(ut5);
         //遍历

         it = times.iterator();
         while(it.hasNext()){
            Object e = it.next();
            if(e instanceof Date){
              Date d = (Date)e;
              System.out.println(def.format(d));
            }

         }

     }
 }

（3）SortedSet内部的比较方法compareTo()

 /*
    SortedSet集合存储元素内部排序方法
    sun编写TreeSe集合添加元素的时候，会调用compareTo方法完成比较
 */
 import  java.util.*;
 class  SortSet
 {
     public static void main(String[] args)
     {
         SortedSet users = new TreeSet();
         User u1 = new User(10);
         User u2 = new User(20);
         User u3 = new User(13);
         User u4 = new User(15);
         User u5 = new User(2);
         users.add(u1);
         users.add(u2);
         users.add(u3);
         users.add(u4);
         users.add(u5);
         //遍历
         Iterator it = users.iterator();
         while(it.hasNext())
         {
            System.out.println(it.next());
         }
     }
 }
 class User implements Comparable //必须实现comparable接口
 {
     int age;
     User(int age)
     {
         this.age=age;
     }
     public String toString(){
        return "User[age="+age+"]";
     }
     //实现java.lang.Comparable;接口中的comparable方法
     //按照user的age进行排序
     @Override
     public int compareTo(Object o) {
         // TODO 自动生成的方法存根
         int age1=this.age;
         int age2=((User)o).age;
         return age2-age1;
     }
 }

（4）SortedSet内部的比较方法Comparator

 /*
 SortedSet集合存储元素内部排序方法
 */
 import java.util.*;
 import java.util.Comparator;
 class Main
 {
     public static void main(String[] args)
     {
         //创建TreeSet集合的时候提供一个比较器
         SortedSet products = new TreeSet(new ProductComparator());
         Product p1 = new Product(2.0);
         Product p2 = new Product(3.0);
         Product p3 = new Product(1.0);
         Product p4 = new Product(6.0);
         Product p5 = new Product(5.0);
         //添加元素
         products.add(p1);
         products.add(p2);
         products.add(p3);
         products.add(p4);
         products.add(p5);
         //遍历
         Iterator it = products.iterator();
         while(it.hasNext()){
            System.out.println(it.next());
         }
     }
 }

 class Product
 {
     double price;
     Product(double price)
     {
         this.price=price;
     }
     public String toString(){
       return price + "";
     }
 }

 class ProductComparator implements Comparator
 {
     @Override
     public int compare(Object o1, Object o2) {
         // TODO 自动生成的方法存根
         double price1 = ((Product)o1).price;
         double price2 = ((Product)o2).price;
         if(price1 == price2){
          return 0;
         }
         else if(price1>price2){
         return 1;
         }
         else{
         return -1;
         }
     }
 }

2.2  常见集合的继承结构-Map

2.2.1 Map集合中常用实现类的数据结构及特点

　　（1）HashMap :

　　哈希表/散列表，底层是一个哈希表，HashMap中的Key等同一个Set集合（无序不重复，结构如下图），允许key或vaue为空，线程不安全。如果要使map线程安全，方法参考：http://www.cnblogs.com/cloudwind/archive/2012/08/30/2664003.html

图. 哈希表/散列表

（2）Hashtable

　　线程安全的效率低。不允许key或vaue为空，线程安全。

（3）Properties

　　 属性类，也可以是Key 和value的方式存储元素，但是Key 和value只能是字符串类型。Properties是HashTable的子类，不过Properties添加了两个方法，load（）和store（）可以直接导入或者将映射写入文件。

（4）SortedMap

　　SortedMap中的key存储元素的特点是：无序不可重复，但可以按照元素的大小进行自动排序，SortedMap中的key等同于SortedSet。

（5）TreeMap

　　TreeMap的Key就是一个TreeSet。

（6）LinkedHashMap

　　详解：http://www.cnblogs.com/chenpi/p/5294077.html

2.2.2、 Map集合中常用的方法分析

                           

 /*
   Map中常用的方法举例
   *存储在Map集合key部分的元素需要重写hashCode+equals方法
 */
 import java.util.*;
 class Maptest
 {
     public static void main(String[] args)
     {
         //创建Map集合
         Map persons = new HashMap();//HashMap的默认初始化容量是16，默认加载因子是0.75
         //存储键值对
         persons.put("10000","lisi");
         persons.put("10001","张三");
         persons.put("10002","wangwu");
         persons.put("10003","maliu");
         persons.put("10004","zhaoqi");
         //判断键值对你的个数，map中的key是无序不可重复的，和HashSet相同
         System.out.println(persons.size());

         System.out.println(persons.containsKey("10000"));

         System.out.println(persons.containsValue("张三"));

         System.out.println(persons.get("10000"));

         persons.remove("10004");
         System.out.println(persons.size());

         //获取所有的value
         Collection value = persons.values();
         Iterator it = value.iterator();
         while(it.hasNext())
         {
             System.out.println(it.next());
         }
         //获取所有的Key
         Set keys = persons.keySet();
         Iterator it2 = keys.iterator();
         while(it2.hasNext())
         {
             Object id = it2.next();
             Object name = persons.get(id);
             System.out.println(id+"->"+name);
         }
         //返回此映射中包含的映射关系的Set图
         Set entrySet = persons.entrySet();
         Iterator it3 = entrySet.iterator();
         while(it3.hasNext())
         {
             System.out.println(it3.next());
         }
         /*
           输出结果
           10001=张三
           10002=wangwu
           10000=lisi
           10003=maliu
         */
     }
 }

（1）Hashtable集合中常用的方法分析

 /*
    HashMap默认初始化容量是16，默认加载因子是0.75
    Hashtable 默认初始化容量是11，默认家在因子是0.75
    java.util.Properties,是由key和value都是字符串类型
 */
 import java.util.Properties;
 class  MapProperties
 {
     public static void main(String[] args)
     {
         //创建属性类对象
         Properties p = new Properties();
         //存数据
         p.setProperty("1000","z");
         p.setProperty("1001","d");
         p.setProperty("1002","s");
         p.setProperty("1003","j");
         //遍历，通过key获取value
         String v1 = p.getProperty("1000");
         String v2 = p.getProperty("1001");
         String v3 = p.getProperty("1002");
         String v4 = p.getProperty("1003");

         System.out.println(v1);
         System.out.println(v2);
         System.out.println(v3);
         System.out.println(v4);
     }
 }
 /*
 运行结果
    z
    d
    s
    j
 */

（2）SortedMap集合的用法

 import java.util.*;

 /*
 SortedMap中的key特点：无序不可重复，但存进去的元素可以按照大小自动排序
 key的特点：1.实现Comparable接口2，,单独写一个比较器
 */
 class  SortedMaptest02
 {

     public static void main(String[] args)
     {
         //Map，Key存储Product，value个数
         SortedMap<Product, Double> product = new TreeMap<Product, Double>();
         //准备对象
         Product p1 = new Product("肉1",12.0);
         Product p2 = new Product("肉2",10.0);
         Product p3 = new Product("肉3",11.0);
         Product p4 = new Product("肉4",15.0);
         Product p5 = new Product("肉5",17.0);

         product.put(p1,2.0);
         product.put(p2,2.0);
         product.put(p3,2.0);
         product.put(p4,2.0);
         product.put(p5,2.0);
     //遍历
        Set keys = product.keySet();
        Iterator it = keys.iterator();
        while(it.hasNext())
         {
            Object k = it.next();
            Object v = product.get(k);
            System.out.println(k+"..."+v);
         }
     }
 }
 //实现Comparable接口
 class Product implements Comparable
 {
      String name;
      double price;
      Product(String name,double price){
     this.name = name;
        this.price = price;
      }
      public String toString()
     {
          return "Product[name = "+name+",price = "+price+"]";
     }
     //实现compareo方法,按照商品价格进行排序
     public int compareTo(Object o)
     {
         double price1 = this.price;
         double price2 = ((Product)o).price;
         if(price1>price2)
             return 1;
         else if(price2>price1)
             return -1;
         else return 0;

     }
 }

2.3  Collections集合工具类的用法

 package test;

 /*
 1.集合工具类 java.util.Collections （类）
 2.Java.util.Collection 接口
 */
 import java.util.*;
 class Main
 {
     @SuppressWarnings("unchecked")
     public static void main(String[] args)
     {
         @SuppressWarnings("rawtypes")
         List list = new ArrayList();
         list.add("5");
         list.add("9");
         list.add("8");
         list.add("4");
         list.add("6");
         @SuppressWarnings("rawtypes")
         Iterator it = list.iterator();
         while(it.hasNext()){
           System.out.println(it.next());
         }
         System.out.println(".........................");
         Collections.sort(list);
         it = list.iterator();
         while(it.hasNext()){
           System.out.println(it.next());
         }

         //对set集合进行排序
         Set s =  new HashSet();
         s.add("3");
         s.add("1");
         s.add("8");
         s.add("4");
         s.add("6");
         System.out.println(".........................");
         //不能更直接使用Collections。sort（s）进行排序
         //将Set集合转换成List集合
         List lists = new ArrayList(s);
         Collections.sort(lists);
         it = lists.iterator();
         while(it.hasNext()){
           System.out.println(it.next());
         }
         //将ArrayList转换成线程安全的
         List mylist = new ArrayList<>();
         Collections.synchronizedList(mylist);

     }
 }

3.泛型

　　泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 JAVA语言引入泛型的好处是安全简单。在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

　　泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率

package test;

/*
JDk5.0新特性：泛型（编译阶段的语法，在编译阶段同一集合中的类型）
1.语法实现
2.优点：使集合中的元素的类型统一，减少强制类型转换
3.缺点：只能存储一种数据类型
*/
import java.util.*;
class  Main
{
    public static void main(String[] args)
    {
        //创建一个List集合，只能存储字符串类型
        List <String> str = new ArrayList<String>();
        str.add("sd");
        str.add("sfhj");
        str.add("dsf");
        str.add("hjk");
        str.add("sdf");
        Iterator <String> it  = str.iterator();
        while(it.hasNext()){
            String s = it.next();
           System.out.println(s);
        }
    }
}