当前位置:金浩范文网>述职报告 >

java集合总结

时间:2021-09-18 16:28:59 浏览量:

篇一:Java集合类总结2

Java中集合类用法总结

Collection

├List

│├LinkedList

│├ArrayList │└Vector

│ └Stack

└Set

├HashSet

└TreeSet

Map

├Hashtable

├HashMap

├WeakHashMap

└TreeMap

Map接口:

|

+ -- WeakHashMap: 以弱键 实现的基于哈希表的 Map。在 WeakHashMap 中,当某个键不再正常使用时,将自动移除其条目。更精确地说,对于一个给定的键,其映射的存在并不阻止垃圾回收器对该键的丢弃,这就使该键成为可终止的,被终止,然后被回收。丢弃某个键时,其条目从映射中有效地移除,因此,该类的行为与其他的 Map 实现有所不同。此实现不是同步的。

|

+ -- TreeMap:该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法。此实现不是同步的。 |

+ -- HashMap:基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作,并允许使用 null 值和 null 键。此类不保证映射的顺序,特别是它不保证该顺序恒久不变。此实现不是同步的。

|

+-- Sorted Map: 进一步提供关于键的总体排序 的 Map。该映射是根据其

键的自然顺序进行排序的,或者根据通常在创建有序映射时提供的 Comparator 进行排序。对有序映射的 collection 视图进行迭代时,此顺序就会反映出来。要采用此排序方式,还需要提供一些其他操作。

Collection接口:

|

+ -- Set接口:一个不包含重复元素的 collection。更正式地说,set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2,并且最多包含一个 null 元素。正如其名称所暗示的,此接口模仿了数学上的 set 抽象。

||

|+ -- HashSet:此类实现 Set 接口,由哈希表支持。它不保证 set 的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用 null 元素。此类为基本操作提供了稳定性能,此实现不是同步的。

||

|+ -- LinkedHashSet:具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于,后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序,即按照将元素插入到 set中 的顺序进行迭代。注意,插入顺序不 受在 set 中重新插入的 元素的影响。此实现不是同步的。

||

|+ -- TreeSet:基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序,或者根据创建 set 时提供的 Comparator 进行排序,具体取决于使用的构造方法。此实现为基本操作提供受保证的 log(n) 时间开销。此实现不是同步的。

|

+ -- List接口:有序的 collection。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引访问元素,并搜索列表中的元素。

|

+ -- ArrayList:List 接口的大小可变数组的实现。实现了所有可选列表操作,并允许包括 null 在内的所有元素。除了实现 List 接口外,此类还提供一些方法来操作内部用来存储列表的数组的大小。每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向

ArrayList 中不断添加元素,其容量也自动增长。并未指定增长策略的细节,因为这不只是添加元素会带来分摊固定时间开销那样简单。此实现不是同步的。|

+ -- LinkedList:List 接口的链接列表实现。实现所有可选的列表操作,并且允许所有元素。除了实现 List 接口外,LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。提供先进先出队列操作(FIFO)。此实现不是同步的。

|

+ -- Vector:Vector 类可以实现可增长的对象数组。与数组一样,它包含可以使用整数索引进行访问的组件。但是 ,Vector 的大小可以根据需要增大或缩小,以适应创建 Vector 后进行添加或移除项的操作。此实现是同步的.

1. Collection的功能

下面这张表给出了Collection的所有功能,也就是你能用Set和List做什么事。Map不是继承Collection的,所以我们会区别对待。

boolean add(Object):确保容器能持有你传给它的那个参数。如果没有把它加进去,就返回false。 boolean addAll(Collection):加入参数Collection所含的所有元素。只要加了元素,就返回true。

void clear():清除容器所保存的所有元素。

boolean contains(Object):如果容器持有参数Object,就返回true。 boolean containsAll(Collection):如果容器持有参数Collection所含的全部元素,就返回true。

boolean isEmpty():如果容器里面没有保存任何元素,就返回true。

Iterator iterator():返回一个可以在容器的各元素之间移动的Iterator。 boolean removeAll(Collection):删除容器里面所有参数Collection所包含的元素。只要删过东西,就返回true。

boolean retainAll(Collection):只保存参数Collection所包括的元素。如果发生过变化,则返回true。 int size():返回容器所含元素的数量。

Object toArray():返回一个包含容器中所有元素的数组。

Object toArray(Object a):返回一个包含容器中所有元素的数组,且

这个数组不是普通的Object数组,它的类型应该同参数数组a的类型相同。

注意,这里没有能进行随机访问的get()方法。这是因为Collection还包括Set。而Set有它自己的内部顺序。所以如果你要检查Collection的元素,你就必须使用迭代器。

2.List的功能

List的基本用法事相当将但的。虽然绝大多数时候,你只是用add()加对象,用get()取对象,用iterator()获取这个序列的Iterator,但List还有一些别的很有用的方法。

实际上有两种List:擅长对元素进行随机访问的,较常用的ArrayList,和更强大的LinkedList。LinkedList不是为快速的随机访问而的,但是它却有一组更加通用的方法。

Lisk:List的最重要的特征就是有序;它会确保以一定的顺序保存元素。List在Collection的基础上添加了大量方法,使之能在序列中间插入和删除元素。List可以制造ListIterator对象,你除了能用它在List的中间插入和删除元素之外,还能用它沿两个方法遍历List。

ArrayList*:一个用数组实现的List。能进行快速的随机访问,但是往列表中间插入和删除元素的时候比较慢。ListIterator只能用在反向遍历ArrayList的场合,不要用它来插入和删除元素,因为相比LinkedList,在ArrayList里面用ListIterator的系统开销比较高。

LinkedList:对顺序访问进行了优化。在List中间插入和删除元素的代价也不高。随机访问的速度相对较慢。此外它还有addFirst(),addLast(),getFirst(),getLast(),removeFirst()和removeLast()等方法,你能把它当成栈,队列或双向队列来用。

记住,容器只是一个存储对象的盒子。如果这个笑盒子能帮你解决所有的问题,那你就用不着取管它事怎么实现的。如果开发环境里面还有一些别的,会造成固定的性能开销的因素存在,那么ArrayList和LinkedList之间的性能差别就会变得不那么重要了。你只需要它们中的一个,你甚至可以想象有这样一种“完美”的抽象容器;它能根据用途,自动地切换其底层的实现。

用LinkedList做一个栈

“栈”有时也被称为“后进先出”的容器。就是说,最后一个被“压”进栈中的东西,会第一个“弹”出来。同其他Java容器一样,压进去和弹出来的东西都是Object,所以除非你只用Object的功能,否则就必须对弹起来的东西进行类型转换。

LinkedList的方法能直接实现栈的功能,所以你完全可以不写Stack而直接使用LinkedList。

如果你只想要栈的功能,那么继承就不太合适了,因为继承出来的是一个拥有LinkedList的所有方法的类。

用LinkedList做一个队列

队列是一个“先进先出”容器。也就是,你把一端把东西放进去,从另一端把东西取出来。所以你放东西的顺序也就是取东西的顺序。LinkedList有支持队列的功能的方法,所以它也能被当作Queue来用。

还能很轻易地用LinkedList做一个deque。它很像队列,只是你可以从任意一端添加和删除元素。

Vector类

Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的

Iterator,虽然和ArrayList创建的Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态,这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该异常。

Stack 类

Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法,还有peek方法得到栈顶的元素,empty方法测试堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

3.Set的功能

Set的接口就是Collection的,所以不像那两个List,它没有额外的功能。实际上Set确确实实就是一个Collection--只不过行为方式不同罢了。Set会拒绝持有多个具有相同值的对象的实例。

Set:加入Set的每个元素必须是唯一的;否则,Set是不会把它加进

篇二:【java】集合框架

【java总结】集合框架

Collection是集合框架层次结构中的根接口。Collection 表示一组对象,这些对象也称为 collection 的元素。一些 collection 允许有重复的元素,而另一些则不允许。一些 collection 是有序的,而另一些则是无序的。Collection接口下有最常用的接口为List跟Set。需要注意的是,Map并没有实现Collection接口。

List接口实现类ArrayList

优点:类似数组的形式进行存储,因此它的随机访问速度极快。

缺点:不适合于在线性表中间需要频繁进行插入和删除操作。因为每次插入和删除都需要移动数组中的元素,它是用数组存储元素的,这个数组可以动态创建,如果元素个数超过了数组的容量,那么就创建一个更大的新数组,并将当前数组中的所有元素都复制到新数组中。

view plain copy

span style=font-size:14px;public class ArrayListTest {

public static void main(String args){

ListString arrayList=new ArrayListString();

arrayList.add(Welcome);

arrayList.add(to);

arrayList.add(java);

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

String strArray=new String;

arrayList.toArray(strArray);

for(int i=0;istrArray.length;i++)System.out.println(strArray);

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

IteratorString iter=arrayList.iterator();

while(iter.hasNext()){

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

}

}

}/span

List接口实现类LinkedList

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

缺点: 随机访问速度较慢。查找一个元素需要从头开始一个一个的找。此类实现 Deque 接口,为 add、poll 提供先进先出队列操作,以及其他堆栈和双端队列操作LinkedList是在一个链表中存储元素。

view plain copy

span style=font-size:14px;public class LinkedListTest {

public static void main(String args){

ListString linkedList=new LinkedListString();

//使用ForEach遍历linkedList

String strArray2=new String;

linkedList.toArray(strArray2);

for(int i=0;istrArray2.length;i++)System.out.println(strArray2);

//foreach遍历LinkedList

for(String str:linkedList){

System.out.println(str);

}

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

IteratorString iter=linkedList.iterator();

while(iter.hasNext()){

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

}

}

}/span

List接口实现类Vector:

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

相同点:

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

②都实现了RandomAccess和Cloneable接口

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

④都支持Iterator和listIterator遍历

不同点:

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

②容量增加方式不同,Vector默认增长为原来一倍,而ArrayList却是原来的一半+1 ③Vector支持通过Enumeration去遍历,而List不支持

view plain copy

span style=font-size:14px;public class VectorTest {

public static void main(String args){

VectorInteger vector = new VectorInteger();

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遍历

IteratorInteger 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);

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

ListIteratorInteger listIterator = vector.listIterator();

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

//listIterator(index)方法

ListIteratorInteger iListIterator = vector.listIterator(5);

System.out.println(iListIterator.previous());

//subList方法

System.out.println(vector.subList(5, 7));

//clear

vector.clear();

System.out.println(vector);

}

}/span

List接口实现类Stack

栈类,是Java2之前引入的,继承自类Vector。同样是线程同步的

view plain copy

span style=font-size:14px;public class StackTest {

public static void main(String args){

StackInteger stack = new StackInteger();

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() + );

}

}

}/span

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

Set接口实现类HashSet:

HashSet是Set接口最常见的实现类,其底层是基于hash算法进行存储相关元素的。HashSet中存储元素的位置是固定的,并且是无序的。Set集合中的去重和hashCode与equals方法相关。

view plain copy

span style=font-size:14px;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(numx.num)return 1;

else if(num==x.num) return 0;

else return -1;

}

public String toString(){

return num=+num;

}

}/span

篇三:JAVA集合之Map映射深刻总结案例附上解释跟总结

一.HashMap实例

案例1:HashMapDemo1

package Map映射;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

/** Java集合系列之Map映射学习总结

* 顺序结构

* 基于哈希表的 Map 接口的实现 。

* 键和值都允许是null,值可以重复。

* 无序的

* 线程不安全的。

* 遍历无序输出.

* 和Set集一样,没有for循环遍历的方法。

* 遍历Map方法有两种:

* ①调用keySet方法:

*Set keys = map.keySet();

* Iterator it = keys.iterator();

* ②调用entrySet方法:

*Set keys = map.entrySet();

*Iterator it = keys.iterator();

* 本例子遍历的是基本类型

*

*/

public class HashMapDemo1 {

public static void main(String args) {

HashMap map = new HashMap();

map.put(1, 111);

map.put(1, 上海);

map.put(5, 广州);

map.put(3, 西安);

map.put(null,武汉); //键允许是null

map.put(2, null);//值允许是null

map.put(null,null);//键和值都允许是null,会替换前面的null:武汉.

System.out.println(**********迭代器遍历调用keySet方法*********);Set keys = map.keySet();//获取所有的键,放入一个集合中

Iterator it = keys.iterator();//取得迭代器才可以遍历

//遍历出来的结果是无序的。

}

} while(it.hasNext()) { Object obj = it.next();//切记这个至少遍历键,不是值。 System.out.println(obj+------+map.get(obj));//取得键对应的值 } System.out.println(**********迭代器遍历调用entrySet方法*********); Set set1=map.entrySet(); Iterator iterator1=set1.iterator(); while (iterator1.hasNext()) { Map.Entry object = (Map.Entry) iterator1.next(); System.out.println(object.getKey()+------+object.getValue()); }

案例2:HashMapDemo2

package Map映射;

import java.util.*;

public class HashMapDemo2 {

@SuppressWarnings(rawtypes) public static void main(String args){ HashMapComparable, Comparable map=new HashMapComparable, HashMapInteger,Person2 map1=new HashMapInteger,Person2(); Person2 p1=new Person2(李川,111,80); Person2 p2=new Person2(李您,111,80); Comparable();//一个键对应一个值,而且键不能重复,会被覆盖 Person2 p3=new Person2(林是,111,80); map1.put(1, p1); map1.put(2, p2); map1.put(3, p3);map.put(1, 110); map.put(2, 220); map.put(城市,福建); map.put(null, null); System.out.println(***********用keySet方法遍历*********); Set keys=map.keySet();//取得键值,取得map所有的键值,存入set集合中 Iterator iterator=keys.iterator();//利用键值取得value值while(iterator.hasNext()){ Object object=iterator.next(); System.out.println(object+-------+map.get(object));//输出是无序的 }

System.out.println(***********用entrySet方法遍历*********); SetMap.EntryInteger,Person2 keys1=map1.entrySet();//查找文档,发现map1调用entrySet方法返回的的是SetMap.EntryK,V,所以要用相应的接收。Map.EntryInteger,Person2可写或不写

IteratorMap.EntryInteger,Person2 iterator1=keys1.iterator(); //while(iterator1.hasNext()){ Map.EntryInteger,Person2 entry = (Map.EntryInteger,Person2) // entry.getValue();表示取得该键对应的值,这个值要是基本类型的话,那就 System.out.println((entry.getKey()+-------+姓名:得到一个Set的迭代器,在后面的遍历中使用。SetMap.EntryK,V可写可不写。 iterator1.next(); 直接输出,要是引用类型的话,还需要调用方法取得相应的值

+(entry.getValue()).getname()+学号:+(entry.getValue()).getno()+分数:+(entry.getValue()).getscore()));//输出是无序的

}

class Person2{

String name; int no; int score; public Person2(String name,int no,int score){ this.name=name; this.no=no; this.score=score;} } } public void setname(String name){ this.name=name; } public void setno(int no){ this.no=no; } public void setscore(int score){ this.score=score; } public String getname(){ return name; } public int getno(){ return no; } public int getscore(){

} }

案例3:HashMapDemo3

package Map映射;

/**

*总结:HashMap用entrySet()方法遍历用法:

*①SetMap.EntryInteger, Object keys = map3.entrySet();也是先取得集合中的(键-值)映射关系,放入keys集合中

*②IteratorMap.EntryInteger, Object iterator = keys.iterator();取得迭代器,用来遍历(键-值)映射关系的集合.

*③iterator.hasNext();判断是否有键

*④Map.EntryInteger,Object entry = iterator.next();遍历第一个(键-值)映射关系,请注意,Map.entrySet 方法返回映射的 collection 视图,用Map.Entry接收。

*这样就可以通过调用entry.getKey()和entry.getValue()这两个方法取得(键-值)映射关系中对应的值了。

*注意了,对于entry.getValue(),若是基本数据怎么不需要改变,若是引用类型: *Person3 p=(Person3) entry.getValue();

*System.out.println(entry.getKey()+----+pp.getname());

*/

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

public class HashMapDemo3 {

public static void main(String args){

HashMapInteger, Object map3=new HashMapInteger,Object();

Person3 p1=new Person3(李川,111,80); Person3 p2=new Person3(李川,111,80); Person3 p3=new Person3(李川,111,80); map3.put(1,11); map3.put(2, 110); map3.put(3, 220); map3.put(6, p1); map3.put(4,福建); map3.put(5, a); map3.put(null, null); map3.put(7, p2); map3.put(8, p3); map3.remove(6); SetMap.EntryInteger, Object keys = map3.entrySet();

IteratorMap.EntryInteger, Object iterator = keys.iterator();

while (iterator.hasNext()) {

Map.EntryInteger,Object entry = iterator.next();

if(entry.getValue() instanceof Person3){//entry.getValue()这是表示值,但是对应的是引用类型对象

Person3 pp=(Person3) entry.getValue();

System.out.println(entry.getKey()+----+pp.getname());

}

else {

System.out.println(entry.getKey()+----+entry.getValue());

}

}

}

}

class Person3{

String name;

int no;

int score;

public Person3(String name,int no,int score){

this.name=name;

this.no=no;

this.score=score;

}

public void setname(String name){

this.name=name;

}

public void setno(int no){

this.no=no;

}

public void setscore(int score){

this.score=score;

}

public String getname(){

return name;

}

public int getno(){

return no;

}

public int getscore(){

return score;

}