java总结集合框架Word格式文档下载.docx

java总结集合框架Word格式文档下载.docx

《java总结集合框架Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《java总结集合框架Word格式文档下载.docx（19页珍藏版）》请在冰豆网上搜索。

arrayList=newArrayList<

（）;

arrayList.add（"

Welcome"

）;

to"

java"

//把ArrayList变为数组相关的内容进行遍历

String[]strArray=newString[arrayList.size（）];

arrayList.toArray（strArray）;

for（inti=0;

i<

strArray.length;

i++）System.out.println（strArray[i]）;

//使用迭代器进行ArrayList遍历

Iterator<

iter=arrayList.iterator（）;

while（iter.hasNext（））{

System.out.println（iter.next（））;

}

}<

/span>

List接口实现类LinkedList

适合于在链表中间需要频繁进行插入和删除操作。

随机访问速度较慢。

查找一个元素需要从头开始一个一个的找。

此类实现Deque接口，为add、poll提供先进先出队列操作，以及其他堆栈和双端队列操作LinkedList是在一个链表中存储元素。

publicclassLinkedListTest{

linkedList=newLinkedList<

//使用ForEach遍历linkedList

String[]strArray2=newString[linkedList.size（）];

linkedList.toArray（strArray2）;

strArray2.length;

i++）System.out.println（strArray2[i]）;

//foreach遍历LinkedList

for（Stringstr:

linkedList）{

System.out.println（str）;

iter=linkedList.iterator（）;

List接口实现类Vector：

Vector使用了关键字synchronized将访问和修改向量的方法都变成同步的了，所以对于不需要同步的应用程序来说，类ArrayList比类Vector更高效。

相同点：

①都继承于AbstractList，并且实现List接口

②都实现了RandomAccess和Cloneable接口

③都是通过数组实现的，本质上都是动态数组，默认数组容量是10

④都支持Iterator和listIterator遍历

不同点：

①ArrayList是非线程安全，而Vector是线程安全的

②容量增加方式不同，Vector默认增长为原来一倍，而ArrayList却是原来的一半+1

③Vector支持通过Enumeration去遍历，而List不支持

publicclassVectorTest{

Vector<

Integer>

vector=newVector<

for（inti=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=vector.iterator（）;

while（iterator.hasNext（））{

System.out.print（iterator.next（）+"

"

//Enumeration遍历

Enumerationenu=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（newInteger[vector.size（）]）;

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））;

//removeAll

vector.removeAll（Arrays.asList（555,666））;

//addAll方法

vector.addAll（5,Arrays.asList（666,666,6））;

//get方法

System.out.println（vector.get（5））;

//set方法

vector.set（5,55）;

//add方法

vector.add（0,555）;

//remove方法

vector.remove（0）;

//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）方法

iListIterator=vector.listIterator（5）;

System.out.println（iListIterator.previous（））;

//subList方法

System.out.println（vector.subList（5,7））;

//clear

vector.clear（）;

List接口实现类Stack

栈类，是Java2之前引入的，继承自类Vector。

同样是线程同步的

publicclassStackTest{

Stack<

stack=newStack<

stack.add（i）;

System.out.println（stack）;

System.out.println（stack.peek（））;

stack.push（555）;

System.out.println（stack.pop（））;

System.out.println（stack.empty（））;

System.out.println（stack.search（6））;

stack遍历：

while（!

stack.empty（））{

System.out.print（stack.pop（）+"

List接口总结：

实际使用中我们需要根据特定的需求选用合适的类，如果除了在末尾外不能在其他位置插入或者删除元素，那么ArrayList效率更高，如果需要经常插入或者删除元素，就选择LinkedList。

Set接口实现类HashSet：

HashSet是Set接口最常见的实现类，其底层是基于hash算法进行存储相关元素的。

HashSet中存储元素的位置是固定的（由hashCode决定），并且是无序的。

Set集合中的去重和hashCode与equals方法相关。

publicclassNumimplementsComparable{

privateintnum;

publicNum（intnum）{

this.num=num;

@Override

publicintcompareTo（Objecto）{

//TODOAuto-generatedmethodstub

Numx=（Num）o;

if（num>

x.num）return1;

elseif（num==x.num）return0;

elsereturn-1;

publicStringtoString（）{

return"

num="

+num;

publicclassHashSetTest{

Set<

hashSet=newHashSet<

hashSet.add（"

hello"

world"

//使用数组的方法遍历HashSet集合

String[]strArray=newString[hashSet.size（）];

strArray=hashSet.toArray（strArray）;

strArray）{

//使用HashSet集合直接遍历

hashSet）{

//用迭代器遍历HashSet集合

iterator=hashSet.iterator（）;

System.out.println（iterator.next（））;

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

Num>

set2=newHashSet<

set2.add（newNum

（1））;

set2.add（newNum（3））;

set2.add（newNum

（2））;

set2.add（newNum（6））;

System.out.println（set2.size（））;

iterator2=set2.iterator（）;

while（iterator2.hasNext（））{

System.out.println（iterator2.next（））;

Set接口实现类LinkedHashSet:

LinkedHashSet继承HashSet,是用一个链表实现来扩展HashSet类，它支持对规则集内的元素排序。

HashSet中的元素是没有被排序的，而LinkedHashSet中的元素可以按照它们插入规则集的顺序提取。

publicclassLinkedHashSetTest{

linkedHashSet=newLinkedHashSet<

linkedHashSet.add（"

String[]strArray=newString[linkedHashSet.size（）];

strArray=linkedHashSet.toArray（strArray）;

linkedHashSet）{

iterator=linkedHashSet.iterator（）;

while（tor.hasNext（））{

Set接口实现类TreeSet：

TreeSet实现了Set接口，它与HashSet的区别主要在于TreeSet中的元素会按照相关的值进行排序。

HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key。

由于TreeMap需要排序,所以需要一个Comparator为键值进行大小比较.当然也是用Comparator定位的.如果创建时没有确定,那么就会使用pareTo（）方法,这就要求key必须实现Comparable接口.TreeMap是使用Tree数据结构实现的,所以使用compare接口就可以完成定位了.

注意：

TreeSet是根据对象的CompareTo方法来去重的，如果CompaerTo返回0说明两个对象相等，不能同时存在于TreeSet中。

publicclassTreeSetTest{

white-space:

pre"

<

Set<

treeSet=newTreeSet<

treeSet.add（"

d"

c"

b"

a"

//String实体类中实现Comparable接口，所以在初始化TreeSet的时候，

//无需传入比较器

Iterator<

iterator=treeSet.iterator（）;

while（iterator.hasNext（））{

System.out.println（iterator.next（））;

}

treeSet2=newTreeSet<

treeSet2.add（newNum

（1））;

treeSet2.add（newNum（3））;

treeSet2.add（newNum

（2））;

treeSet2.add（newNum（6））;

System.out.println（treeSet2.size（））;

iterator2=treeSet2.iterator（）;

while（iterator2.hasNext（））

{<

TreeSet<

set=newTreeSet<

set.add（1111）;

set.add（2222）;

set.ad