java集合

Set、List和Map可以看做集合的三大类。

     List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。

     Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是不能集合里元素不允许重复的原因）。

     Map集合中保存Key-value对形式的元素，访问时只能根据每项元素的key来访问其value。

1、介绍Collection框架的结构

集合是Java中的一个非常重要的一个知识点，主要分为List、Set、Map、Queue三大数据结构。它们在Java中的结构关系如下：

Collection接口是List、Set、Queue的父级接口。

Set接口有两个常用的实现类：HashSet和TreeSet。List接口的常用接口有ArrayList和Vector接口。

Map接口有两个常用的实现类：Hashtable和HashMap。

2、Collection框架中实现比较要实现什么接口

要实现比较有两种方式：第一种，实体类实现Comparable<T>接口，并实现 compareTo(T t) 方法，我们称为内部比较器。第二种，创建一个外部比较器，这个外部比较器要实现Comparator接口的 compare(T t1, T t2)。

第一种，实现Comparable接口：

package com.chanshuyi.comparable;import java.util.*;public class Student implements Comparable<Student> {    private String name;    private int age;    public Student() {    }    public Student(String name, int age) {        this.name = name;        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    @Override    public int compareTo(Student o) {        if ( getAge() > o.getAge()) {            return 1;        } else if ( getAge() < o.getAge()) {            return -1;        } else {            return 0;        }    }    //重写toString() 用于输出    public String toString() {        return "[" + name + "," + age + "]";    }    public static void main(String args[]){        Student s1 = new Student("Tom", 12);        Student s2 = new Student("Marry", 9);        Student s3 = new Student("Json", 88);        List<Student> studentList = new ArrayList<Student>();        studentList.add(s1);        studentList.add(s2);        studentList.add(s3);        Collections.sort(studentList);        System.out.printf("Original  sort, list:%s\n", studentList);    }}

第二种，实现Comparator接口：

public class Student {    private String name;    private int age;    public Student() {    }    public Student(String name, int age) {        this.name = name;        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

先定义一个Student类，无须实现任何接口。

定义一个外部比较器类，实现Comparator接口：

public class StudentComparator implements Comparator<Student>{    @Override    public int compare(Student o1, Student o2) {        if (o1.getAge() > o2.getAge()) {            return 1;        }else if (o1.getAge() == o2.getAge()) {            return 0;        }else{            return -1;        }    }    public static void main(String args[]) {        Student marry = new Student("marry", 12);        Student tom = new Student("tom", 3);        Student jackson = new Student("jackson", 88);        StudentComparator comparator = new StudentComparator();        System.out.println(comparator.compare(marry, tom)); //1        System.out.println(comparator.compare(tom, jackson));  //-1    }}

由此可见，如果你希望该实体类在放入集合的时候能按照你希望的方式排序（如果集合支持），那么你需要让实体类实现Comparable接口。如果你只是需要简单比较两个实体类的大小，最后返回一个结果，那么用Comparator接口实现一个外部比较器更合适。

3、ArrayList和Vector的区别（是否有序、是否重复、数据结构、底层实现）

ArrayList和Vector都实现了List接口，他们都是有序集合，并且存放的元素是允许重复的。它们的底层都是通过数组来实现的，因此列表这种数据结构检索数据速度快，但增删改速度慢。

而ArrayList和Vector的区别主要在两个方面：

第一，线程安全。Vector是线程安全的，而ArrayList是线程不安全的。因此在如果集合数据只有单线程访问，那么使用ArrayList可以提高效率。而如果有多线程访问你的集合数据，那么就必须要用Vector，因为要保证数据安全。

第二，数据增长。ArrayList和Vector都有一个初始的容量大小，当存储进它们里面的元素超过了容量时，就需要增加它们的存储容量。ArrayList每次增长原来的0.5倍，而Vector增长原来的一倍。ArrayList和Vector都可以设置初始空间的大小，Vector还可以设置增长的空间大小，而ArrayList没有提供设置增长空间的方法。

4、HashMap和Hashtable的区别

HashMap和Hashtable都实现了Map接口，并且都是key-value的数据结构。它们的不同点主要在三个方面：

第一，Hashtable是Java1.1的一个类，它基于陈旧的Dictionary类。而HashMap是Java1.2引进的Map接口的一个实现。

第二，Hashtable是线程安全的，也就是说是线程同步的，而HashMap是线程不安全的。也就是说在单线程环境下应该用HashMap，这样效率更高。

第三，HashMap允许将null值作为key或value，但Hashtable不允许（会抛出NullPointerException）。

5、List 和 Map 区别？（数据结构，存储特点）

这个要从两个方面来回答，一方面是List和Map的数据结构，另一方面是存储数据的特点。在数据结构方面，List存储的是单列数据的集合，而Map存储的是key、value类型的数据集合。在数据存储方面，List存储的数据是有序且可以重复的，而Map中存储的数据是无序且key值不能重复（value值可以重复）。

6、List、Map、Set三个接口，存取元素时，各有什么特点？

简单答案：List以特定索引来存取元素，可以有重复元素。Set不能存放重复元素（用对象的equals()方法来区分元素是否重复）。Map保存键值对（key-value pair）映射，映射关系可以是一对一或多对一。Set和Map容器都有基于哈希存储和排序树的两种实现版本，基于哈希存储的版本理论存取时间复杂度为O(1)，而基于排序树版本的实现在插入或删除元素时会按照元素或元素的键（key）构成排序树从而达到排序和去重的效果。

另：

List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口，叫Collection。Set里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不是仅仅是相同）的对象 ，即假设Set集合中有了一个A对象，现在我要向Set集合再存入一个B对象，但B对象与A对象equals相等，则B对象存储不进去。所以，Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。

List表示有先后顺序的集合， 注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Obj e)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。

Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Object key)返回值为key 所对应的value。另外，也可以获得所有的key的结合（map.keySet()），还可以获得所有的value的结合（map.values()），还可以获得key和value组合成的Map.Entry对象的集合（map.entrySet()）。

List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。

    7、阐述ArrayList、Vector、LinkedList的存储性能和特性。 
答：1、ArrayList 和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector中的方法由于添加了synchronized修饰，因此Vector是线程安全的容器，但性能上较ArrayList差，因此已经是Java中的遗留容器。

2、LinkedList使用双向链表实现存储（将内存中零散的内存单元通过附加的引用关联起来，形成一个可以按序号索引的线性结构，这种链式存储方式与数组的连续存储方式相比，内存的利用率更高），按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

8、Collection和Collections的区别？ 
答：Collection是一个接口，它是Set、List等容器的父接口；Collections是个一个工具类，提供了一系列的静态方法来辅助容器操作，这些方法包括对容器的搜索、排序、线程安全化等等。

遍历

list的三种遍历方法

1.增强for循环

for(String str : list) {//其内部实质上还是调用了迭代器遍历方式，这种循环方式还有其他限制，不建议使用。    System.out.println(str);}

2.普通for循环

for( int i = 0 ; i < list.size() ; i++) {//内部不锁定，效率最高，但在多线程要考虑并发操作的问题。    System.out.println(list.get(i));}

3.迭代器遍历

Iterator<String> iter = list.iterator();while(iter.hasNext()){  //执行过程中会执行数据锁定，性能稍差，若在循环过程中要去掉某个元素只能调用iter.remove()方法。    System.out.println(iter.next());}

 

set的遍历方法

1.迭代遍历

Set<String> set = new HashSet<String>();  Iterator<String> it = set.iterator();  while (it.hasNext()) {    String str = it.next();    System.out.println(str);  }  

2.foreach遍历

for (String str : set) {        System.out.println(str);  }  

集合使用场景

1、ArrayList与LinkedList的区别和适用场景

Arraylist：

优点：ArrayList是实现了基于动态数组的数据结构,因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。

缺点：因为地址连续， ArrayList要移动数据,所以插入和删除操作效率比较低。   

LinkedList：

优点：LinkedList基于链表的数据结构,地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，对于新增和删除操作add和remove，LinedList比较占优势。

缺点：因为LinkedList要移动指针,所以查询操作性能比较低。

适用场景分析：

当需要对数据进行对此访问的情况下选用ArrayList，当需要对数据进行多次增加删除修改时采用LinkedList。

2、ArrayList与Vector的区别和适用场景

ArrayList有三个构造方法：

Java代码  

public ArrayList(int initialCapacity)//构造一个具有指定初始容量的空列表。    public ArrayList()//构造一个初始容量为10的空列表。    public ArrayList(Collection<? extends E> c)//构造一个包含指定 collection 的元素的列表 

 Vector有四个构造方法：

Java代码  

public Vector()//使用指定的初始容量和等于零的容量增量构造一个空向量。    public Vector(int initialCapacity)//构造一个空向量，使其内部数据数组的大小，其标准容量增量为零。    public Vector(Collection<? extends E> c)//构造一个包含指定 collection 中的元素的向量    public Vector(int initialCapacity,int capacityIncrement)//使用指定的初始容量和容量增量构造一个空的向量    

ArrayList和Vector都是用数组实现的，主要有这么三个区别：

1.Vector是多线程安全的，而ArrayList不是，这个可以从源码中看出，Vector类中的方法很多有synchronized进行修饰，这样就导致了Vector在效率上无法与ArrayList相比；

2.两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同。

3.Vector可以设置增长因子，而ArrayList不可以。

适用场景分析：

1.Vector是线程同步的，所以它也是线程安全的，而ArrayList是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用ArrayList效率比较高。
2.如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用Vector有一定的优势。

3、HashSet与Treeset的适用场景

1.TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值 

2.HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束 

3.HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例

   适用场景分析:HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。

4、HashMap与TreeMap的适用场景

HashMap 非线程安全  

HashMap：基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()]，为了优化HashMap空间的使用，您可以调优初始容量和负载因子。 

(1)HashMap(): 构建一个空的哈希映像 
(2)HashMap(Map m): 构建一个哈希映像，并且添加映像m的所有映射 
(3)HashMap(int initialCapacity): 构建一个拥有特定容量的空的哈希映像 
(4)HashMap(int initialCapacity, float loadFactor): 构建一个拥有特定容量和加载因子的空的哈希映像 
TreeMap：非线程安全基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。 

(1)TreeMap():构建一个空的映像树 
(2)TreeMap(Map m): 构建一个映像树，并且添加映像m中所有元素 
(3)TreeMap(Comparator c): 构建一个映像树，并且使用特定的比较器对关键字进行排序 
(4)TreeMap(SortedMap s): 构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序 

适用场景分析：

HashMap：适用于在Map中插入、删除和定位元素。 
Treemap：适用于按自然顺序或自定义顺序遍历键(key)。 

测试代码如下（部分代码来源于teye博客及论坛）

Java代码  

import java.util.HashMap;   import java.util.Hashtable;   import java.util.Iterator;   import java.util.Map;   import java.util.TreeMap;   public class HashMaps {   public static void main(String[] args) {   Map<String, String> map = new HashMap<String, String>();   map.put("a", "aaa");   map.put("b", "bbb");   map.put("c", "ccc");   map.put("d", "ddd");   Iterator<String> iterator = map.keySet().iterator();   while (iterator.hasNext()) {   Object key = iterator.next();   System.out.println("map.get(key) is :" + map.get(key));   }   // 定义HashTable,用来测试   Hashtable<String, String> tab = new Hashtable<String, String>();   tab.put("a", "aaa");   tab.put("b", "bbb");   tab.put("c", "ccc");   tab.put("d", "ddd");   Iterator<String> iterator_1 = tab.keySet().iterator();   while (iterator_1.hasNext()) {   Object key = iterator_1.next();   System.out.println("tab.get(key) is :" + tab.get(key));   }   TreeMap<String, String> tmp = new TreeMap<String, String>();   tmp.put("a", "aaa");   tmp.put("b", "bbb");   tmp.put("c", "ccc");   tmp.put("d", "cdc");   Iterator<String> iterator_2 = tmp.keySet().iterator();   while (iterator_2.hasNext()) {   Object key = iterator_2.next();   System.out.println("tmp.get(key) is :" + tmp.get(key));   }   }   }   

 运行结果如下： 

map.get(key) is :ddd 
map.get(key) is :bbb 
map.get(key) is :ccc 
map.get(key) is :aaa 
tab.get(key) is :bbb 
tab.get(key) is :aaa 
tab.get(key) is :ddd 
tab.get(key) is :ccc 
tmp.get(key) is :aaa 
tmp.get(key) is :bbb 
tmp.get(key) is :ccc 
tmp.get(key) is :cdc 
HashMap的结果是没有排序的，而TreeMap输出的结果是排好序的。 
下面就要进入本文的主题了。先举个例子说明一下怎样使用HashMap: 

Java代码  

import java.util.*;   public class Exp1 {   public static void main(String[] args){   HashMap h1=new HashMap();   Random r1=new Random();   for (int i=0;i<1000;i++){   Integer t=new Integer(r1.nextInt(20));   if (h1.containsKey(t))   ((Ctime)h1.get(t)).count++;   else   h1.put(t, new Ctime());   }   System.out.println(h1);   }   }   class Ctime{   int count=1;   public String toString(){   return Integer.toString(count);   }   }   

 在HashMap中通过get()来获取value，通过put()来插入value，ContainsKey()则用来检验对象是否已经存在。可以看出，和ArrayList的操作相比，HashMap除了通过key索引其内容之外，别的方面差异并不大。 

前面介绍了，HashMap是基于HashCode的，在所有对象的超类Object中有一个HashCode()方法，但是它和equals方法一样，并不能适用于所有的情况，这样我们就需要重写自己的HashCode()方法。下面就举这样一个例子： 

Java代码  

import java.util.*;   public class Exp2 {   public static void main(String[] args){   HashMap h2=new HashMap();   for (int i=0;i<10;i++)   h2.put(new Element(i), new Figureout());   System.out.println("h2:");   System.out.println("Get the result for Element:");   Element test=new Element(5);   if (h2.containsKey(test))   System.out.println((Figureout)h2.get(test));   else   System.out.println("Not found");   }   }   class Element{   int number;   public Element(int n){   number=n;   }   }   class Figureout{   Random r=new Random();   boolean possible=r.nextDouble()>0.5;   public String toString(){   if (possible)   return "OK!";   else   return "Impossible!";   }   }   

 在这个例子中，Element用来索引对象Figureout,也即Element为key，Figureout为value。在Figureout中随机生成一个浮点数，如果它比0.5大，打印"OK!"，否则打印"Impossible!"。之后查看Element(3)对应的Figureout结果如何。

结果却发现，无论你运行多少次，得到的结果都是"Not found"。也就是说索引Element(3)并不在HashMap中。这怎么可能呢？ 
原因得慢慢来说：Element的HashCode方法继承自Object，而Object中的HashCode方法返回的HashCode对应于当前的地址，也就是说对于不同的对象，即使它们的内容完全相同，用HashCode（）返回的值也会不同。这样实际上违背了我们的意图。因为我们在使用 HashMap时，希望利用相同内容的对象索引得到相同的目标对象，这就需要HashCode()在此时能够返回相同的值。在上面的例子中，我们期望 new Element(i) (i=5)与 Elementtest=newElement(5)是相同的，而实际上这是两个不同的对象，尽管它们的内容相同，但它们在内存中的地址不同。因此很自然的，上面的程序得不到我们设想的结果。下面对Element类更改如下：

Java代码  

class Element{   int number;   public Element(int n){   number=n;   }   public int hashCode(){   return number;   }   public boolean equals(Object o){   return (o instanceof Element) && (number==((Element)o).number);   }   }   

 在这里Element覆盖了Object中的hashCode()和equals()方法。覆盖hashCode()使其以number的值作为 hashcode返回，这样对于相同内容的对象来说它们的hashcode也就相同了。而覆盖equals()是为了在HashMap判断两个key是否相等时使结果有意义修改后的程序运行结果如下： 

h2: 
Get the result for Element: 
Impossible! 
请记住：如果你想有效的使用HashMap，你就必须重写在其的HashCode()。 
还有两条重写HashCode()的原则： 
[list=1] 
不必对每个不同的对象都产生一个唯一的hashcode，只要你的HashCode方法使get()能够得到put()放进去的内容就可以了。即"不为一原则"。 

生成hashcode的算法尽量使hashcode的值分散一些，不要很多hashcode都集中在一个范围内，这样有利于提高HashMap的性能。即"分散原则"。至于第二条原则的具体原因，有兴趣者可以参考Bruce Eckel的《Thinking in Java》，在那里有对HashMap内部实现原理的介绍，这里就不赘述了。 
掌握了这两条原则，你就能够用好HashMap编写自己的程序了。不知道大家注意没有，java.lang.Object中提供的三个方法：clone()，equals()和hashCode()虽然很典型，但在很多情况下都不能够适用，它们只是简单的由对象的地址得出结果。这就需要我们在自己的程序中重写它们，其实java类库中也重写了千千万万个这样的方法。利用面向对象的多态性——覆盖，Java的设计者很优雅的构建了Java的结构，也更加体现了Java是一门纯OOP语言的特性。

细节注意：

时间测试方法：System.currentTimeMillis()

遍历方法：Iterator迭代器

超级for

TreeSet xx = new TreeSet();

         for(Object obj:xx){

         System.out.println(obj);

         }

Java中的泛型：泛型是程序设计语言的一种特性。允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。

Java 泛型的参数只可以代表类，不能代表个别对象。由于 Java 泛型的类型参数之实际类型在编译时会被消除，所以无法在运行时得知其类型参数的类型。Java 编译器在编译泛型时会自动加入类型转换的编码，故运行速度不会因为使用泛型而加快。