第一篇：对java集合类的一些总结
13、java中的集合类
答：所有的集合类都实现了iterator接口，用于遍历集合中的元素，iterator接口中的方法有hashNext(),next(),remove()三种方法，不同的集合类提供了不同的实现（无序集合实现这个接口，只能向后遍历）。如果要实现向前遍历，也就是说集合中的元素是有序的，实现的是linkedIterator接口，这是iterator的子接口，实现了这个接口的类能实现双向（前后）遍历。
Hashset：hashset继承了抽象类AbstractSet，而AbstractSet类又实现了set接口，并且AbstactSet又继承了AbstractCollection,AbstractCollection实现了Collection接口，因此hashset实际上实现了collection接口，又实现了set接口，因为所有的集合接口都实现了iterator接口，因此hashset可以上转型为set，collection，以及iterator，并且调用响应的方法。特点：hashset不能存放重复的元素，并且采用散列的存储方法，因此元素的插入与输出并不是一致的。附：散列是使用了数组和链表来进行存储的一种结构，数组是连续的，每个数组的元素都是一条链表。
ArrayList:ArrayList继承了AbstractList并且实现了List接口。其中AbstractList继承了AbstractCollection并且实现了List接口,AbstractCollection实现了Collection接口，因此AbstractList可以说是间接或者是直接实现了List，Collection，iterator接口。ArrayList使用的数据结构是数组。方便对元素的检索，但是增删需要移动数组元素，因此不适合增删，增删使用链式存储的线性表（如：LinkedList）会比较方便,详细见LinkedList。
LinkedList:linkedList继承了AbstractSequentialList并且实现了List接口，AbstractSequentialList继承了AbstractList,Abstractlist继承了AbstractCollection接口，因此LinkedList也是有序集合。LinkedList在java中的实现是双向链表，因此LinkedList对空间的利用率比较高，但是对元素的检索较慢，但是增删较快，只需要简单调整链的指向即可。
Vector：Vector的结构和ArrayList几乎相同，不同的地方就是在公有方法层次上，Vector加了关键字synchronized，因此理论上来说，Vector每个方法都是现成安全的。但是个人认为（包括查资料了解到）这并不能完全保证并发访问下的线程安全。在并发访问情况下，任何时候都只能有一个线程去访问其中的共有方法，在方法级别是线程安全的。但是现在有两个线程A、B，线程A向Vector添加一个对象，此时线程B查询Vector的长度是1，但是线程B并没有进行任何操作（插入操作），这样仍然会造成并发问题，但是在线程A、B都进行插入操作的时候，jvm会根据自动进行线程调度从而确保在任何时刻只有一个线程操作Vector的插入操作。因此在Vector之后，新版的jdk里面有了arraylist（非线程安全），其实我认为就是把并发控制的问题交给程序员处理。
Stack:Stack是栈结构，后进先出。Stack继承Vector，并且新增了一些方法，例如出栈，入栈操作。Stack内部的方法也是加了synchronized关键字的，因此，也是“线程安全”的。
HashMap：HashMap继承了AbstractMap并且实现了Map接口，而AbstractMap也实现了Map接口，总的来说hashMap实现了Map接口以及abstractMap的一些方法。hashMap是通过键值对来存储以及检索数据的。HashMap是通过一个数组以及链表组合来存储数据的。java中的hashMap的实现是一个长度为16的数组，并且每个数组存储都是一个单链表，存储一个数据的时候，根据key的hash值去判断到底应该存在下标为多少的数组中，找到对应的数组位置后，并且一直对这个位置的链向后索引，查到链的最后面。hashMap综合了线性表以及链表的优点，使检索以及增删都变得方便。附：非线程安全，并且hashMap可以存储null值
HashTable：HashTable也是一个散列表（和hashMap一样），存储的是键值对，HashTable继承于Dictionary,实现了Map接口，和hashMap最大的区别是：hashTable的读写方法是线程安全的，加了synchronized关键字，而且hashtable不能存储null。
ConcurrenHashMap:其实ConcurrenHashMap,HashMap和HashTable三者的数据结构是一致的，唯一不同的是锁机制。ConcurrtnHashMap的锁机制控制得更加细粒度，不是像hashMap那样在方法层面上加锁，而是在访问的数组特定索引位置加锁，例如插入操作，加入两个线程都需要对下边为5的线程执行插入操作，那么只能在一个线程插入操作完成之后释放锁，另一个线程才能执行插入操作，但是两个操作分别在不同的下标索引进行插入，则两个线程可以并发进行。(这和好老师项目中投票功能中数据库数据访问带来的并发问题基本一样，本来通过对整个投票功能加锁，但是考虑到对同一个老师投票才加锁，对不同的老师投票不需要加锁，因此对数据库中的特定老师的特定字段加锁，从而提高了系统性能)而hashtable在方法层面上加锁，也就是说无论多个线程往哪一条链插入操作，都会锁表，因此高并发的情况下会造成阻塞，严重影响系统性能，而ConcurrentHashMap则很好得权衡了这个问题，保证了数据的正确性，又减少系统性能消耗。
第二篇：【java总结】集合框架
【java总结】集合框架
Collection是集合框架层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。Collection接口下有最常用的接口为List跟Set。需要注意的是，Map并没有实现Collection接口。
List接口实现类ArrayList 优点：类似数组的形式进行存储，因此它的随机访问速度极快。缺点：不适合于在线性表中间需要频繁进行插入和删除操作。因为每次插入和删除都需要移动数组中的元素，它是用数组存储元素的，这个数组可以动态创建，如果元素个数超过了数组的容量，那么就创建一个更大的新数组，并将当前数组中的所有元素都复制到新数组中。[html] view plain copy public class ArrayListTest {
public static void main(String[] args){
List
arrayList.add(“Welcome”);
arrayList.add(“to”);
arrayList.add(“java”);
//把ArrayList变为数组相关的内容进行遍历
String[] strArray=new String[arrayList.size()];
arrayList.toArray(strArray);
for(int i=0;i //使用迭代器进行ArrayList遍历 Iterator while(iter.hasNext()){ System.out.println(iter.next()); } } } List接口实现类LinkedList 优点：适合于在链表中间需要频繁进行插入和删除操作。 缺点： 随机访问速度较慢。查找一个元素需要从头开始一个一个的找。此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作LinkedList是在一个链表中存储元素。[html] view plain copy public class LinkedListTest { public static void main(String[] args){ List //使用ForEach遍历linkedList String[] strArray2=new String[linkedList.size()]; linkedList.toArray(strArray2); for(int i=0;i //foreach遍历LinkedList for(String str:linkedList){ System.out.println(str); } //使用迭代器进行ArrayList遍历 Iterator while(iter.hasNext()){ System.out.println(iter.next()); } } } List接口实现类Vector： Vector使用了关键字synchronized将访问和修改向量的方法都变成同步的了，所以对于不需要同步的应用程序来说，类ArrayList比类Vector更高效。相同点： ①都继承于AbstractList，并且实现List接口 ②都实现了RandomAccess和Cloneable接口 ③都是通过数组实现的，本质上都是动态数组，默认数组容量是10 ④都支持Iterator和listIterator遍历 不同点： ①ArrayList是非线程安全，而Vector是线程安全的 ②容量增加方式不同，Vector默认增长为原来一倍，而ArrayList却是原来的一半+1 ③Vector支持通过Enumeration去遍历，而List不支持 [html] view plain copy public class VectorTest { public static void main(String[] args){ Vector for(int i = 0;i < 10;i++){ vector.add(i); } //直接打印 System.out.println(vector.toString()); //size() System.out.println(vector.size()); //contains System.out.println(vector.contains(2)); //总结：对比Vector的遍历方式，使用索引的随机访问方式最快，使用迭代器最慢 //iterator遍历 Iterator while(iterator.hasNext()){ System.out.print(iterator.next()+ “ ”); } //Enumeration遍历 Enumeration enu = vector.elements(); while(enu.hasMoreElements()){ System.out.println((Integer)enu.nextElement()); } //toArray Object[] objArr = vector.toArray(); System.out.println(“nobjArr:” + Arrays.asList(objArr)); Integer[] intArr = vector.toArray(new Integer[vector.size()]); System.out.println(“intArr:” + Arrays.asList(intArr)); //add vector.add(5); //remove vector.remove(5); System.out.println(vector); //containsAll System.out.println(vector.containsAll(Arrays.asList(5,6))); //addAll vector.addAll(Arrays.asList(555,666)); System.out.println(vector); //removeAll vector.removeAll(Arrays.asList(555,666)); System.out.println(vector); //addAll方法 vector.addAll(5, Arrays.asList(666,666, 6)); System.out.println(vector); //get方法 System.out.println(vector.get(5)); //set方法 vector.set(5, 55); System.out.println(vector.get(5)); //add方法 vector.add(0, 555); System.out.println(vector); //remove方法 vector.remove(0); System.out.println(vector); //indexof方法 System.out.println(vector.indexOf(6)); //lastIndexOf方法 System.out.println(vector.lastIndexOf(6)); //listIterator方法 ListIterator System.out.println(listIterator.hasPrevious()); //listIterator(index)方法 ListIterator System.out.println(iListIterator.previous()); //subList方法 System.out.println(vector.subList(5, 7)); //clear vector.clear(); System.out.println(vector); } } List接口实现类Stack 栈类，是Java2之前引入的，继承自类Vector。同样是线程同步的 [html] view plain copy public class StackTest { public static void main(String[] args){ Stack for(int i = 0;i < 10;i++){ stack.add(i); } System.out.println(stack); System.out.println(stack.peek()); stack.push(555); System.out.println(stack); System.out.println(stack.pop()); System.out.println(stack); System.out.println(stack.empty()); System.out.println(stack.search(6)); System.out.println(“stack遍历：”); while(!stack.empty()){ System.out.print(stack.pop()+ “ ”); } } } List接口总结：实际使用中我们需要根据特定的需求选用合适的类，如果 除了在末尾外不能在其他位置插入或者删除元素，那么ArrayList效率更高，如果需要经常插入或者删除元素，就选择LinkedList。 Set接口实现类HashSet： HashSet是Set接口最常见的实现类，其底层是基于hash算法进行存储相关元素的。HashSet中存储元素的位置是固定的（由hashCode决定），并且是无序的。Set集合中的去重和hashCode与equals方法相关。[html] view plain copy public class Num implements Comparable{ private int num; public Num(int num){ this.num=num; } @Override public int compareTo(Object o){ // TODO Auto-generated method stub Num x=(Num)o; if(num>x.num)return 1; else if(num==x.num)return 0; else return-1; } public String toString(){ return “num=”+num; } } [html] view plain copy public class HashSetTest { public static void main(String[] args){ Set hashSet.add(“hello”); hashSet.add(“world”); hashSet.add(“world”); //使用数组的方法遍历HashSet集合String[] strArray=new String[hashSet.size()]; strArray=hashSet.toArray(strArray); for(String str:strArray){ System.out.println(str); } //使用HashSet集合直接遍历 for(String str:hashSet){ System.out.println(str); } //用迭代器遍历HashSet集合Iterator while(iterator.hasNext()){ System.out.println(iterator.next()); } //无重写hashCode跟equals方法的类，不会自动根据类中的值进行去重 Set set2.add(new Num(1)); set2.add(new Num(3)); set2.add(new Num(2)); set2.add(new Num(3)); set2.add(new Num(3)); set2.add(new Num(6)); System.out.println(set2.size()); Iterator while(iterator2.hasNext()){ System.out.println(iterator2.next()); } } } Set接口实现类LinkedHashSet: LinkedHashSet继承HashSet,是用一个链表实现来扩展HashSet类，它支持对规则集内的元素排序。HashSet中的元素是没有被排序的，而LinkedHashSet中的元素可以按照它们插入规则集的顺序提取。[html] view plain copy public class LinkedHashSetTest { public static void main(String[] args){ Set linkedHashSet.add(“hello”); linkedHashSet.add(“world”); linkedHashSet.add(“world”); //使用数组的方法遍历HashSet集合String[] strArray=new String[linkedHashSet.size()]; strArray=linkedHashSet.toArray(strArray); for(String str:strArray){ System.out.println(str); } //使用HashSet集合直接遍历 for(String str:linkedHashSet){ System.out.println(str); } //用迭代器遍历HashSet集合Iterator while(iterawww.xiexiebang.comtor.hasNext()){ System.out.println(iterator.next()); } } } Set接口实现类TreeSet： TreeSet实现了Set接口，它与HashSet的区别主要在于TreeSet中的元素会按照相关的值进行排序。HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key。由于TreeMap需要排序,所以需要一个Comparator为键值进行大小比较.当然也是用Comparator定位的.如果创建时没有确定,那么就会使用key.compareTo()方法,这就要求key必须实现Comparable接口.TreeMap是使用Tree数据结构实现的,所以使用compare接口就可以完成定位了.注意：TreeSet是根据对象的CompareTo方法来去重的，如果CompaerTo返回0说明两个对象相等，不能同时存在于TreeSet中。 [html] view plain copy public class TreeSetTest { public static void main(String[] args){ Set treeSet.add(“d”); treeSet.add(“c”); treeSet.add(“b”); treeSet.add(“a”); //String实体类中实现Comparable接口，所以在初始化TreeSet的时候， //无需传入比较器 Iterator while(iterator.hasNext()){ System.out.println(iterator.next()); } Set treeSet2.add(new Num(1)); treeSet2.add(new Num(3)); treeSet2.add(new Num(2)); treeSet2.add(new Num(3)); treeSet2.add(new Num(3)); treeSet2.add(new Num(6)); System.out.println(treeSet2.size()); Iterator while(iterator2.hasNext()) { System.out.println(iterator2.next()); } TreeSet set.add(1111); set.add(2222); set.add(3333); set.add(4444); set.add(5555); System.out.println(set.first());// 输出第一个元素 System.out.println(set.lower(3333));//小于3333的最大元素 System.out.println(set.higher(2222));//大于2222的最大元素 System.out.println(set.floor(3333));//不大于3333的最大元素 System.out.println(set.ceiling(3333));//不小于3333的最大元素 System.out.println(set.pollFirst());//删除第一个元素 System.out.println(set.pollLast());//删除最后一个元素 System.out.println(set); } } Set接口区别于List接口在于： 所有Set中的元素实现了不重复，有点像数学中集合的概念，无序，不允许有重复的元素，最多允许有一个null元素对象 Map接口： Map接口储存一组成对的键-值对象，提供key（键）到value（值）的映射，Map中的key不要求有序，不允许重复。value同样不要求有序，但可以重复。 Map实现类HashMap 最常见的Map实现类，他的储存方式是哈希表，优点是查询指定元素效率高。HashMap采用数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当链表中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。 无论什么情况HashMap中哈希表的容量总是2的n次方的一个数。并且有这样一个公式：当length=2^n时，hashcode &(length-1)== hashcode % length HashMap与Hashtable的区别： Hashtable实现Map接口，继承自古老的Dictionary类，实现一个key-value的键值映射表。任何非空的（key-value）均可以放入其中。区别主要有三点： 1.Hashtable是基于陈旧的Dictionary实现的，而HashMap是基于Java1.2引进的Map接口实现的； 2.Hashtable是线程安全的，而HashMap是非线程安全的，我们可以使用外部同步的方法解决这个问题。 3.HashMap可以允许你在列表中放一个key值为null的元素，并且可以有任意多value为null，而Hashtable不允许键或者值为null。 [html] view plain copy public class HashMapTest { public static void main(String[] args){ Map hashMap.put(“a”,1); hashMap.put(“b”,2); hashMap.put(“JAVA”,3); System.out.println(hashMap.get(“JAVA”)); //第一种遍历方法：普遍使用，二次取值 for(String key : hashMap.keySet()){ System.out.println(“key= ”+ key + “ and value= ” + hashMap.get(key)); } //第二种:通过Map.entrySet使用iterator遍历key和value Iterator while(iter.hasNext()){ System.out.println(iter.next()); } //第三种：通过Map.entrySet遍历key和value.推荐，尤其是容量大时 for(Map.Entry System.out.println(“key= ” + entry.getKey()+ “ and value= ” + entry.getValue()); } //第四种:通过Map.values()遍历所有的value，但不能遍历key for(Integer v : hashMap.values()){ System.out.println(“value= ” + v); } } } Map实现类LinkedHashMap LinkedHashMap继承自HashMap，它主要是用链表实现来扩展HashMap类，HshMap中条目是没有顺序的,但是在LinkedHashMap中元素既可以按照它们插入图的顺序排序，也可以按它们最后一次被访问 的顺序排序。LinkedHashMap继承自HashMap并且实现了Map接口。和HashMap一样，LinkedHashMap 允许key和value均为null。于该数据结构和HashMap一样使用到hash算法，因此它不能保证映射的顺序，尤其是不能保证顺序持久不变（再哈希）。 [html] view plain copy public class LinkedHashMapTest { public static void main(String[] args){ Map linkedHashMap.put(“a”, 1); linkedHashMap.put(“java”,2); linkedHashMap.put(“C”, 3); System.out.println(linkedHashMap.get(“a”)); Set Iterator while(iter.haswww.xiexiebang.comn(String[] args){ Map treeMap.put(“b”,2); treeMap.put(“a”,1); treeMap.put(“e”,5); treeMap.put(“d”,4); treeMap.put(“c”,3); Set Iterator while(iter.hasNext()){ System.out.println(iter.next()); } Set for(String x:keySet){ System.out.println(x+“=”+treeMap.get(x)); } Map treeMap2.put(new Num(2),“a”); treeMap2.put(new Num(1),“b”); treeMap2.put(new Num(5),“c”); treeMap2.put(new Num(4),“d”); treeMap2.put(new Num(3),“c”); Set for(Num x:kewww.xiexiebang.comySet2){ System.out.println(x+“=”+treeMap2.get(x)); } //根据value排序 Map map.put(“d”, 2); map.put(“c”, 1); map.put(“b”, 4); map.put(“a”, 3); List new ArrayList //排序前 for(int i = 0;i < infoIds.size();i++){ String id = infoIds.get(i).toString(); System.out.println(id); } //排序 Collections.sort(infoIds, new Comparator public int compare(Map.Entry return(o2.getValue()-o1.getValue()); //return(o1.getKey()).toString().compareTo(o2.getKey()); } }); //排序后 for(int i = 0;i < infoIds.size();i++){ String id = infoIds.get(i).toString(); System.out.println(id); } } } Map接口总结：在实际使用中，如果更新图时不需要保持图中元素的顺序，就使用HashMap，如果需要保持图中元素的插入顺序或者访问顺序，就使用LinkedHashMap，如果需要使图按照键值排序，就使用TreeMap。 java集合总结 （一）一、数组、集合数组、集合：都是一种容器，用一个对象管理多个对象； 数组：不能自动增长；只能存放同类型的元素 集合：能自动扩容；部分集合允许存放不同类型的元素； 二、学习这些集合类要掌握哪些东西： 1）怎样得到（选择）集合对象； 2）怎样添加元素 3）怎样删除元素 4）怎样循环遍历没一个元素 三、list、set、map collection:父接口； Set:接口---一个实现类：HashSet List:接口---三个实现类：LinkedList,Vector,ArrayList SortedSet:接口---实现类：TreeSet1、List: List:有序列表，允许存放重复的元素； 实现类： ArrayList：数组实现，查询快，增删慢，线程不安全，轻量级；下标也是从0开始； LinkedList：链表实现，增删快，查询慢 Vector：数组实现，线程安全，重量级 2.Set: 无序集合，不允许存放重复的元素； 实现类HashSet：equals返回true，hashCode返回相同的整数；哈希表； 子接口SortedSet：对Set排序实现类:TreeSet：二叉树实现的； 看API： Iterator:接口，迭代器； java.util； hasNext(); next(); remove(); Iterable:可迭代的，访问的； ng;实现了可迭代的接口就可以用迭代的方式访问； 只需实现iterator();方法即可；Iteratoriterator(); 三种循环的访问方式： 只有实现了Iterable接口的才能用第三种；能用第二种的也一定能用第三种； ArrayList:自动扩容，是数组照搬过来的； 3.Map HashMap:键值对，key不能重复，但是value可以重复；key的实现就是HashSet；value对应着放； HashSet的后台有一个HashMap;初始化后台容量；只不过生成一个HashSet的话，系统只提供key的访问； 如果有两个Key重复，那么会覆盖之前的； Hashtable:线程安全的Properties:java.util.Properties;key和value都是String类型，用来读配置文件； HashMap与Hashtable区别： HashMap线程不安全的，允许null作为key或value; Hashtable线程安全的，不允许null作为key或value; TreeMap:对key排好序的Map;key就是TreeSet,value对应每个key; key要实现Comparable接口或TreeMap有自己的构造器； HashSet:remove(Objecto)的原则看这个对象O的Hashcode和equals是否相等，并不是看是不是一个对象； 定义一个Map;key是课程名称，value是Integer表示选课人数； map.put(cou,map.get(cou)+newInteger(1)); 四、Hashtable、Properties 1，Hashtable：实现了Map接口，此类实现一个哈希表，作用和HashMap相同。任何非null对象都可以用作键或值。为了成功地在哈希表中存储和获取对象，用作键的对象必须实现hashCode方法和equals法。 2，Properties：继承自Hashtable，比Hashtable更严格属性列表中每个键及其对应值都是一个字符串。 常用方法StringgetProperty(String?key)和setProperty(Stringkey,Stringvalue); 用法：我在C盘下建了一个名为yy.dat的文件，文件的内容为： name=hehe password=1234 5执行以下程序，输出hehe，可见用Properties可以很方便的解析配置文件 Propertiesp=newProperties(); p.load(newFileInputStream(“C:yy.dat”)); System.out.println(p.getProperty(“name”)) 五、两个工具类Arrays和Collections 1.Arrays、此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂 2.Collections、主要提供了在collection上进行操作的静态方法 六、遗留的几个类 1.Hashtable,作用和HashMap相同，不过它是线程安全的，如果不需要线程安全，应该使用HashMap 2.Enumeration,遗留集合使用枚举接口来遍历元素，它有两个方法,hasMoreElements和nextElement，用法类似Iterator。 3.Stack,继承自Vector，实现了栈的功能，提供了push()方法押栈和pop()方法出栈。 4.BitSet,位集。如果需要高效率的存储一个位序列，例如一个标志序列，请使用位集。它可以对各个位进行 读取get(i) 设置set(i) 清楚clear(i) 七、常见笔试题目汇总 1.Collection和Collections的区别。 Collection是集合类的上级接口，继承与他的接口主要有Set和List.Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。 2.List,Set,Map是否继承自Collection接口? List，Set是，Map不是 3.两个对象值相同(x.equals(y)==true)，但却可有不同的hashcode，这句话对不对? 不对，有相同的hashcode。 4.你所知道的集合类都有哪些？主要方法？ 最常用的集合类是List和Map。List的具体实现包括ArrayList和Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。List适用于按数值索引访问元素的情形。 Map提供了一个更通用的元素存储方法。Map集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。 5.排序都有哪几种方法？请列举。用JAVA实现一个快速排序。 排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序） 快速排序的伪代码。 //使用快速排序方法对a[0:n-1]排序 从a[0:n-1]中选择一个元素作为middle，该元素为支点 把余下的元素分割为两段left和right，使得left中的元素都小于等于支点，而right中的元素都大于等于支点 递归地使用快速排序方法对left进行排序 递归地使用快速排序方法对right进行排序 所得结果为left+middle+right 6.HashMap和Hashtable的区别 都属于Map接口的类，实现了将惟一键映射到特定的值上。 HashMap类没有分类或者排序。它允许一个null键和多个null值。 Hashtable类似于HashMap，但是不允许null键和null值。它也比HashMap慢，因为它是同步的。 7.Set里的元素是不能重复的，那么用什么方法来区分重复与否呢?是用==还是equals()它们有何区别? Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。 equals()是判读两个Set是否相等。 equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。 java集合总结 （二）java集合类主要负责保存、盛装其他数据，因此集合类也称容器类。java集合类分为：set、list、map、queue四大体系。其中set代表无序、不可重复的集合；list代表有序、可重复的集合。map代表具有映射关系的集合；queue代表队列集合。 java集合类主要由两个接口派生：Collection和Map，是集合框架的根接口。下面是其接口、子接口和实现类的继承树。 下面就一一介绍四大接口及其实现类。 Set接口。set集合不允许包含相同的元素。set判断两个对象是否相同是根据equals方法。如果两个对象用equals方法返回的是true，set不会接受这两个对象。 HashSet是set接口的典型实现，HashSet按hash算法来存储集合中的元素。因此具有很好的存储和查找性能。HashSet判断两个元素的标准是两个元素的equals方法比较相等，同时两个对象的hasCode()方法返回值也相等。HashSet可以保存null元素。 List集合代表一个有序集合。集合中的每个元素都有其对应的顺序索引。Arraylist和vector是list接口的两个典型实现。他们之间的显着区别就是：vector是线性安全的，而arraylist不是。它们两个都是基于数组实现的list类。List还有一个基于链表实现的LinkedList类。当插入、删除元素的速度非常快。这个类比较特殊，功能也特别多，即实现了List接口，也实现了Dueue接口(双向队列)。可以当成双向队列使用，也可以当成栈使用。 Queue用于模拟队列的数据结构。LinkedList和ArrayDueue是其两个比较常用的实现类。 Map用于保存具有映射关系的数据。Map接口有如下几个常用的实现类：HashMap、HashTable、TreeMap。TreeMap是基于红黑树对TreeMap中所有key进行排序。HashMap和HashTable主要区别有两点： 1、Hashtable是线性安全的，因此性能差些。 2、HashMap可以使用null作为key或者value。 集合类还提供了一个工具类Collections。主要用于查找、替换、同步控制、设置不可变集合。 上面是对java集合类的一般概述，下面就set、list、map三者之间的关系进行剖析。 Set与Map的关系。Map集合中所有key集中起来，就组成了一个set集合。所以Map集合提供Set Map与List的关系。把Map的key-value分开来看，从另一个角度看，就可以把Map与List统一起来。 Map集合是一个关联数组，key可以组成Set集合，Map中的value可以重复，所以这些value可以组成一个List集合。但是需要注意的是，实质Map的values方法并未返回一个List集合。而是返回一个不存储元素的Collection集合，换一种角度来看对List集合，它也包含了两组值，其中一组就是虚拟的int类型的索引，另一组就是list集合元素，从这个意思上看，List就相当于所有key都是int型的Map。 下面讲解几个相似类之间的差异。 ArrayList和LinkedList。ArrayList是一种顺序存储的线性表，其底层是采用数组实现的，而LinkedList是链式存储的线性表。其本质就是一个双向链表。对于随机存储比较频繁的元素操作应选用ArrayList，对于经常需要增加、删除元素应该选用LinkedList。但总的来说ArrayList的总体性能还是优于LinkedList。 HashSet与HashMap的性能选项。主要有两个方面：容量和负载因子(尺寸/容量)。较低负载因子会增加查询数据的性能，但是会降低hash表所占的内存开销。较高负载因子则反之，一般对数据的查询比较频繁，所以一般情况下初始容量应该大一点，但也不能太大，否则浪费内存空间。 黑马程序员：Java集合简单总结 在Java语言中，学好集合是非常重要的，下面简单的对集合进行总结，以便大家学习，有 问题再相互交流。 集合框架图 在集合框架图中可以看出，Collection接口中主要有两个子接口，分别是List和Set。List集合的特点是元素有序、包含重复元素，Set集合的特点是元素无序、不包含重复元素。Map集合中存储的是键值映射关系，元素都是成对出现的。Map接口的主要子接口有HashMap和TreeMap。 总结ist有顺序有重复没有排序，set无重复有排序，map的key也和set一样。 List接口 List : 特点是元素有序、可以包含重复元素。它有两个实现类分别是：ArrayList和LinkedList。 ArrayList : 内部维护一个数组结构，允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。 LinkedList : 内部维护了一个双向链表结构，即通过节点之间彼此连接来实现的，每一个节点都包含前一个节点和后一个节点的引用。当一个新节点插入时，只需要修改其中保持先后关系的节点引用即可，这样的存储结构保证了LinkedList集合在增删元素时效率非常高。 Set接口 Set具有与Collection完全一样的接口，因此没有任何额外的功能，不像前面的List。实际上Set就是Collection只是行为不同，也就是说Set集合并没有对Collection接口进行扩充，只是比collection接口要求更加严了。 Set : 存入Set的每个元素都必须是唯一的，因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。 HashSet : 为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。 TreeSet : 保存有序的Set, 底层为树结构。使用它可以从Set中提取有序的序列。 LinkedHashSet : 具有HashSet的查询速度，且内部使用链表维护元素的顺序。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。 Map接口 Map用于保存具有映射关系的数据，因此Map集合里存储两组值，一组用于保存Map里的key，另一组用于保存Map中的value,key和value都可以是任意引用类型数据，其中，作为key的值是不允许重复的，而value中可以出现重复。Map : 维护“键值对”的关联性，使你可以通过“键”查找“值”。 HashMap就是使用对象的hashCode()进行快速查询的。此方法能够显著提高性能。HashMap集合是基于哈希表的Map接口实现，并允许使用null键null值，但必须保证键的唯一性。 LinkedHashMap : 类似于HashMap，但是迭代遍历它时，取得“键值对”的顺序是其插入次序。而在迭代访问时发而更快，因为它使用链表维护内部次序。 TreeMap : 基于红黑树数据结构的实现。查看“键”或“键值对”时，它们会被排序(顺序由Comparabel或Comparator决定)。TreeMap的特点在于，你得到的结果是经过排序的。 Hashtable线程安全，但是存取速度很慢，且不允许存放null键null值，目前基本上被hashMap类所取代。Hashtable有一个重要的子类Properties。 Properties:java.util.Properties;key和value都是String类型，用来读配置文件。继承自Hashtable，比 Hashtable 更严格 属性列表中每个键及其对应值都是一个字符串。常用方法 String getProperty(String?key)和 setProperty(String key,String value); 用法：我在D盘下建了一个名为 AA.dat 的文件，文件的内容为： name=ch password=12345 执行以下程序，输出 ch，可见用 Properties 可以很方便的解析配置文件 Properties p = new Properties();p.load(new FileInputStream(“D:AA.dat”));System.out.println(p.getProperty(“name”)) 前言： 本文是对Java集合框架做了一个概括性的解说，目的是对Java集合框架体系有个总体认识，如果你想学习具体的接口和类的使用方法，请参看Java API文档。 一、概述 数据结构对程序设计有着深远的影响，在面向过程的C语言中，数据库结构用struct来描述，而在面向对象的编程中，数据结构是用类来描述的，并且包含有对该数据结构操作的方法。 在Java语言中，Java语言的设计者对常用的数据结构和算法做了一些规范（接口）和实现（具体实现接口的类）。所有抽象出来的数据结构和操作（算法）统称为Java集合框架（Java Collection Framework）。 Java程序员在具体应用时，不必考虑数据结构和算法实现细节，只需要用这些类创建出来一些对象，然后直接应用就可以了。这样就大大提高了编程效率。 二、集合框架的层次结构 Collection是集合接口 |————Set子接口:无序，不允许重复。 |————List子接口:有序，可以有重复元素 区别：Collections是集合类 Set和List对比： Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。 List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。 Set和List具体子类： Set |————HashSet：以哈希表的形式存放元素，插入删除速度很快。 List |————ArrayList：动态数组 |————LinkedList：链表、队列、堆栈。 Array和java.util.Vector Vector是一种老的动态数组，是线程同步的，效率很低，一般不赞成使用。 三、Iterator迭代器（接口） Iterator是获取集合中元素的过程，实际上帮助获取集合中的元素。 迭代器代替了 Java Collections Framework 中的 Enumeration。迭代器与枚举有两点不同： 迭代器允许调用方利用定义良好的语义在迭代期间从迭代器所指向的集合移除元素。方法名称得到了改进。 Iterator仅有一个子接口ListIterator，是列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。ListIterator 没有当前元素；它的光标位置 始终位于调用 previous()所返回的元素和调用 next()所返回的元素之间。在长度为 n 的列表中，有 n+1 个有效的索引值，从 0 到 n（包含）。 四、集合框架之外的Map接口 Map将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值。Map接口是Dictionary（字典）抽象类的替代品。 Map 接口提供三种collection 视图，允许以键集、值集合或键-值映射关系集的形式查看 某个映射的内容。映射的顺序 定义为迭代器在映射的 collection 视图中返回其元素的顺序。某些映射实现可明确保证其顺序，如 TreeMap 类；某些映射实现则不保证顺序，如 HashMap 类。 有两个常见的已实现的子类： HashMap：基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 TreeMap：它实现SortedMap 接口的基于红黑树的实现。此类保证了映射按照升序顺序排列关键字，根据使用的构造方法不同，可能会按照键的类的自然顺序 进行排序（参见 Comparable），或者按照创建时所提供的比较器进行排序。 Hashtable：此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。 五、线程安全类 在集合框架中，有些类是线程安全的，这些都是JDK1.1中的出现的。在JDK1.2之后，就出现许许多多非线程安全的类。 下面是这些线程安全的同步的类： Vector：就比ArrayList多了个同步化机制（线程安全）。 Statck：堆栈类，先进后出。 Hashtable：就比HashMap多了个线程安全。 Enumeration：枚举，相当于迭代器。 除了这些之外，其他的都是非线程安全的类和接口。 线程安全的类其方法是同步的，每次只能一个访问。是重量级对象，效率较低。对于非线程 安全的类和接口，在多线程中需要程序员自己处理线程安全问题。 六、其他一些接口和类介绍 Dictionary和Hashtable类： Dictionary提供键值映射的功能，是个抽象类。一般使用它的子类HashTable类。遍历Hashtable类要用到枚举。 Properties类 Properties 继承于 Hashtable，Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。一般可以通过读取properties配置文件来填充Properties对象。第三篇：java集合总结
第四篇：黑马程序员：Java集合简单总结
第五篇：Java集合框架使用总结
点击咨询 