Java集合框架使用总结

第一篇：Java集合框架使用总结

前言：

本文是对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总结】集合框架

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=new ArrayList();

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 iter=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 linkedList=new LinkedList();

//使用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 iter=linkedList.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 vector = new 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 iterator = vector.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 listIterator = vector.listIterator();

System.out.println(listIterator.hasPrevious());

//listIterator(index)方法

ListIterator iListIterator = vector.listIterator(5);

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 stack = new 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=new HashSet();

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 iterator=hashSet.iterator();

while(iterator.hasNext()){

System.out.println(iterator.next());

}

//无重写hashCode跟equals方法的类，不会自动根据类中的值进行去重

Set set2=new HashSet();

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 iterator2=set2.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=new LinkedHashSet();

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 iterator=linkedHashSet.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=new TreeSet();

treeSet.add(“d”);

treeSet.add(“c”);

treeSet.add(“b”);

treeSet.add(“a”);

//String实体类中实现Comparable接口，所以在初始化TreeSet的时候， //无需传入比较器

Iterator iterator=treeSet.iterator();

while(iterator.hasNext()){

System.out.println(iterator.next());

}

Set treeSet2=new TreeSet();

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 iterator2=treeSet2.iterator();

while(iterator2.hasNext())

{

System.out.println(iterator2.next());

}

TreeSet set = new 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=new HashMap();

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> iter=hashMap.entrySet().iterator();

while(iter.hasNext()){

System.out.println(iter.next());

}

//第三种：通过Map.entrySet遍历key和value.推荐，尤其是容量大时

for(Map.Entry entry : hashMap.entrySet()){

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=new LinkedHashMap();

linkedHashMap.put(“a”, 1);

linkedHashMap.put(“java”,2);

linkedHashMap.put(“C”, 3);

System.out.println(linkedHashMap.get(“a”));

Set> entry=linkedHashMap.entrySet();

Iterator> iter=entry.iterator();

while(iter.haswww.xiexiebang.comn(String[] args){

Map treeMap=new TreeMap();

treeMap.put(“b”,2);

treeMap.put(“a”,1);

treeMap.put(“e”,5);

treeMap.put(“d”,4);

treeMap.put(“c”,3);

Set> entry=treeMap.entrySet();

Iterator> iter=entry.iterator();

while(iter.hasNext()){

System.out.println(iter.next());

}

Set keySet=treeMap.keySet();

for(String x:keySet){

System.out.println(x+“=”+treeMap.get(x));

}

Map treeMap2=new TreeMap();

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 keySet2=treeMap2.keySet();//根据compareTo方法去重

for(Num x:kewww.xiexiebang.comySet2){

System.out.println(x+“=”+treeMap2.get(x));

}

//根据value排序

Map map = new HashMap();

map.put(“d”, 2);

map.put(“c”, 1);

map.put(“b”, 4);

map.put(“a”, 3);

List> infoIds =

new ArrayList>(map.entrySet());

//排序前

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 o1, Map.Entry o2){

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程序员集合框架面试题

Java集合框架是最常被问到的Java面试问题，要理解Java技术强大特性，就有必要掌握集合框架。这里有一些实用问题，常在Java面试中问到。

1、什么是Java集合API

Java集合框架API是用来表示和操作集合的统一框架，它包含接口、实现类、以及帮助程序员完成一些编程的算法。简言之，API在上层完成以下几件事：

● 编程更加省力，提高城程序速度和代码质量

● 非关联的API提高互操作性

● 节省学习使用新API成本

● 节省设计新API的时间

● 鼓励、促进软件重用

具体来说，有6个集合接口，最基本的是Collection接口，由三个接口Set、List、SortedSet继承，另外两个接口是Map、SortedMap,这两个接口不继承Collection，表示映射而不是真正的集合。

2、什么是Iterator

一些集合类提供了内容遍历的功能，通过java.util.Iterator接口。这些接口允许遍历对象的集合。依次操作每个元素对象。当使用Iterators时，在获得Iterator的时候包含一个集合快照。通常在遍历一个Iterator的时候不建议修改集合本省。

3、Iterator与ListIterator有什么区别？

Iterator:只能正向遍历集合，适用于获取移除元素。ListIerator：继承Iterator,可以双向列表的遍历，同样支持元素的修改。

4、什么是HaspMap和Map？

Map是接口，Java 集合框架中一部分，用于存储键值对，HashMap是用哈希算法实现Map的类。

5、HashMap与HashTable有什么区别？对比Hashtable VS HashMap

两者都是用key-value方式获取数据。Hashtable是原始集合类之一(也称作遗留类)。HashMap作为新集合框架的一部分在Java2的1.2版本中加入。它们之间有一下区别： ● HashMap和Hashtable大致是等同的，除了非同步和空值(HashMap允许null值作为key和value，而Hashtable不可以)。

● HashMap没法保证映射的顺序一直不变，但是作为HashMap的子类LinkedHashMap，如果想要预知的顺序迭代(默认按照插入顺序),你可以很轻易的置换为HashMap，如果使用Hashtable就没那么容易了。

● HashMap不是同步的，而Hashtable是同步的。

● 迭代HashMap采用快速失败机制，而Hashtable不是，所以这是设计的考虑点。

6、在Hashtable上下文中同步是什么意思？

同步意味着在一个时间点只能有一个线程可以修改哈希表，任何线程在执行hashtable的更新操作前需要获取对象锁，其他线程等待锁的释放。

7、什么叫做快速失败特性

从高级别层次来说快速失败是一个系统或软件对于其故障做出的响应。一个快速失败系统设计用来即时报告可能会导致失败的任何故障情况，它通常用来停止正常的操作而不是尝试继续做可能有缺陷的工作。当有问题发生时，快速失败系统即时可见地发错错误告警。在Java中，快速失败与iterators有关。如果一个iterator在集合对象上创建了，其它线程欲“结构化”的修改该集合对象，并发修改异常(ConcurrentModificationException)抛出。

8、怎样使Hashmap同步？

HashMap可以通过Map m = Collections.synchronizedMap（hashMap）来达到同步的效果。

9、什么时候使用Hashtable，什么时候使用HashMap

基本的不同点是Hashtable同步HashMap不是的，所以无论什么时候有多个线程访问相同实例的可能时，就应该使用Hashtable，反之使用HashMap。非线程安全的数据结构能带来更好的性能。

如果在将来有一种可能—你需要按顺序获得键值对的方案时，HashMap是一个很好的选择，因为有HashMap的一个子类LinkedHashMap。所以如果你想可预测的按顺序迭代(默认按插入的顺序)，你可以很方便用LinkedHashMap替换HashMap。反观要是使用的Hashtable就没那么简单了。同时如果有多个线程访问HashMap，Collections.synchronizedMap()可以代替，总的来说HashMap更灵活。

10、为什么Vector类认为是废弃的或者是非官方地不推荐使用？或者说为什么我们应该一直使用ArrayList而不是Vector

你应该使用ArrayList而不是Vector是因为默认情况下你是非同步访问的，Vector同步了每个方法，你几乎从不要那样做，通常有想要同步的是整个操作序列。同步单个的操作也不安全(如果你迭代一个Vector,你还是要加锁，以避免其它线程在同一时刻改变集合).而且效率更慢。当然同样有锁的开销即使你不需要，这是个很糟糕的方法在默认情况下同步访问。你可以一直使用Collections.sychronizedList来装饰一个集合。

事实上Vector结合了“可变数组”的集合和同步每个操作的实现。这是另外一个设计上的缺陷。Vector还有些遗留的方法在枚举和元素获取的方法，这些方法不同于List接口，如果这些方法在代码中程序员更趋向于想用它。尽管枚举速度更快，但是他们不能检查如果集合在迭代的时候修改了，这样将导致问题。尽管以上诸多原因，oracle也从没宣称过要废弃Vector.

第四篇：java的SSH框架总结（范文）

对于java中SSH框架的理解

SSH 是指 Struts+ spring+ hibernate 的一个集成框架，这是一种比较流行的java web应用程序开源框架。

Struts

Struts是一个基于Sun J2EE平台的MVC框架，主要采用Servlet和JSP技术来实现的。由于Struts能充分满足引用开发的需求，简单易用，敏捷迅速，所以很受关注。Struts 吧Servlet、JSP、自定义标签和信息资源（message resource）整合到一个统一的框架中，开发人员利用其进行开发室不用再自己编写实现全套的MVC模式，极大的节省了时间。

Spring Spring是一个解决了许多在J2EE开发中常见的问题的强大框架。Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。

Spring的架构基础是基于JavaBean属性的Inversion of Control 容器。然而，这仅仅是完整图景中的一部分：在Spring使用IOC容器作为构建完关注所有架构层的完整解决方案是独一无二的。Spring提供了唯一的数据访问抽象，包括简单和有效率的JDBC框架，极大的改进了效率并且减少了可能的错误。Spring的数据访问架构还集成了Hibernate 和其他O/R mapping 解决方案。Spring还提供了唯一的事物管理抽象。它能够在各种底层事务管理技术，例如JTA 或者JDBC事务提供一个一致的编程模型。Spring提供了一个标准Java语言编写的AOP框架，他给POJOs提供了声明式的事务管理和其他企业事务——如果有必要还可以实现自己的aspects。这个框架提供了可以和IOC容器集成的强大而灵活的MVC web框架。

Hibernate Hibernate 是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，是的java程序员可以随心所欲的适用对象编程思维来操控数据库。Hibernate 可以应用在任何使用JDBC的场合，既可以在java客户端程序中使用，也可以在Servlet/jsp的web应用中使用，其最具革命性意义的是：Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

在SSH的组合框架模式中，三者各自的作用 Struts 是一个很好的MVC框架，主要技术是Servlet和JSP。Struts的MVC设计模式可以让我们的逻辑思维变得很清晰，让我们写程序层次分明。

Spring提供了管理业务对象的一致方法，并鼓励注入对接口编程而不是对类编程的良好习惯，使我们的产品在最大程度上解耦。

Hibernate 是用来持久化数据的，提供了完全面向对象的数据库操作。Hibernate对JDBC进行了非常轻量级的封装，使得他与关系型数据库打交道变得非常轻松。

负责Web层：

ActionFormBean接收网页中表单提交的数据，然后通过Action进行处理，再Forward到对应的网页，在Struts-config.xml中定义了，ActionServlet会加载进来。

Spring负责业务层管理，即Service：

Service为Action提供统一的调用接口，封装持久层的DAO，并集成Hibernate，Spring可对JavaBean和事物进行统一管理。

Hibernate负责持久层，完成数据库的CRUD操作：

Hibernate有一组hbm.xml文件和PO，是与数据库中的表相对应的，然后定义DAO，这些是与数据库打交道的类。

在Struts+Spring+Hibernate系统中，对象之间的调用流程如下：

Struts——>Spring——>Hibernate

JSP——>Action——>Service——>DAO——>Hibernate

第五篇：java web框架简介

Java Web框架简介

Web框架是人们在使用某种语言编写Web应用服务端时关于架构的最佳实践。

有些Web框架是从实际的Web项目抽取出来的，也就是说，做一个具体的应用项目时，采取的架构比较理想，就把这部分和领域无关，而仅和Web的请求和响应处理有关的设计拿出来，形成一个基础，在开发别的应用项目的时候则可以从这基础做起，让开发者更关注领域问题，而不是Web的请求和响应的控制。

也有些Web框架是直接设计出来的，很多Web框架在设计的时候也都借鉴了别的框架，吸取优点，修改不足，并根据自己的框架的定位，在特定方面有自己的发挥，形成了自己的特点，比如有的web框架追求的是松耦合性，层次，结构之间都不密切绑定，有的Web框架则追求敏捷性，强调约定而不是配置。

Java 的 Web框架虽然各不相同，但基本也都是遵循特定的路数的：使用Servlet或者Filter拦截请求，使用MVC的思想设计架构，使用约定，XML或 Annotation实现配置，运用Java面向对象的特点，面向抽象实现请求和响应的流程，支持Jsp，Freemarker，Velocity等视图。

JSF

优点：

Java EE标准，这意味着有很大的市场需求和更多的工作机会

上手快速并且相对容易

有大量可用的组件库

缺点：

大量的JSP标签

对REST和安全支持不好

没有一个统一的实现。既有SUN的实现，又有Apache的实现——MyFaces。

国内的OperaMasks还支持AJAX，以及有开发工具支持

Spring MVC

优点：

对覆盖绑定（overriding binding）、验证（validation）等提供生命周期管理

与许多表示层技术/框架无缝集成：JSP/JSTL、Tiles、Velocity、FreeMarker、Excel、XSL、PDF 等

便于测试——归功于IoC

缺点：

大量的XML配置文件

太过灵活——没有公共的父控制器

没有内置的Ajax支持

Stripes

优点：

不需要书写XML配置文件

良好的学习文档

社区成员很热心

缺点：

社区比较小

不如其他的项目活跃

ActionBean里面的URL是硬编码的 Struts 2

优点：

架构简单——易于扩展

标记库很容易利用FreeMarker或者Velocity来定制

基于控制器或者基于页面的导航

缺点：

文档组织得很差

对新特征过分关注

通过Google搜索到的大多是Struts 1.x的文档

Tapestry

优点：

一旦学会它，将极大地提高生产率

HTML模板——对页面设计师非常有利

每出一个新版本，都会有大量的创新

缺点：

文档过于概念性，不够实用

学习曲线陡峭

发行周期长——每年都有较大的升级

Wicket

优点：

对Java开发者有利（不是Web开发者）

页面和显示绑定紧密

社区活跃——有来自创建者的支持

缺点：

HTML模板和Java代码紧挨着

需要对OO有较好的理解

Wicket逻辑——什么都用Java搞定