java容器类知识点详细总结

1.java容器分类图

2.容器类接口和抽象容器类

2.1 说明

容器接口是容器的基础。使用接口可以将容器的实现与容器接口分开，因而可以使用相同的方法访问容器而不需关心容器具体的数据结构。

同理，iterator接口也使用户能够使用相同的方法访问不同的容器类。

2.2 容器接口（collection，map，iterator）

1）collection接口

boolean add(object obj): 添加对象，集合发生变化则返回true
iterator iterator()：返回iterator接口的对象
int size()
boolean isempty()
boolean contains(object obj)
void clear()
<t> t[] toarray(t[] a)

2）map接口（存放键值对，map中的值也可以是一个容器）

object get（object key）
object put（object key, object value）
set keyset() : returns the keys set set<k> keyset()
set entryset(): returns mappings set set<map.entry<k,v>> entryset()
containskey()
containsvalue() 

3）iterator接口

object next()
boolean hasnext()
void remove()

注意：remove函数不能连续执行多次，否则返回illegalstateexception

（ if the next method has not yet been called, or the remove method has already been called after the last call to the next method.）

通常用法：

iterator it=collection.iterator();
　　　　while(it.hasnext())
　　　　{
　　　　 object obj=it.next();
　　　　//do something 
　　　　}

2.3 子接口（list，set，listiterator，sortedmap，sortedset）

1）list（有顺序可以重复，有顺序所以操作时可以在方法中加入索引参数，如下：）

boolean add(e element)
void add(int index, e element) 
e set（int index, e element）
e get(int index);

2）set（无顺序不可以重复，无序因而不能通过索引操作对象）

3）listiterator（iterator for list，list是双向表，因而在iterator上增加了一些新的方法，允许traverse the list in either direction）

boolean hasprevious();
e previous();
int previousindex()

4) sortedmap

说明：保证按照键的升序排列的映射，可以按照键的自然顺序（ comparable 接口）进行排序， 或者通过创建有序映射时提供的比较器进行排序

(a map that further provides a total ordering on its keys. the map is ordered according to the natural ordering of its keys, or by a comparator typically provided at sorted map creation time)

public interface sortedmap<k,v>extends map<k,v>
comparator comparator()
object firstkey()
object lastkey()

5)sortedset　

主要用于排序操作，实现此接口的子类都是排序的子类

public interface sortedset<e>extends set<e>
　　* comparator comparator()
　　*　e first() ：返回第一个元素
　　*　e last() 
* sortedset<e> headset(e toelement): 返回less than toelement
　　* sortedset<e> tailset(e fromelement)
　　* sortedset<e> subset(e fromelement) 

2.4抽象容器类

1）说明：使用抽象容器类可以方便的定义类，而不用在每个类中都实现容器接口container 中的所有的方法

2）包含：

* abstractcollection 　　　 public abstract class abstractcollection<e>extends objectimplements collection<e>
　 * abstractlist public abstract class abstractlist<e>extends abstractcollection<e>implements list<e>
　 * abstractset 　　　　　　 public abstract class abstractset<e>extends abstractcollection<e>implements set<e>
　　* abstactmap public abstract class abstractmap<k,v>extends object implements map<k,v>
　 * abstractsequentiallist public abstract class abstractsequentiallist<e> extends abstractlist<e>

3.具体容器类
3.1概括

1）collection: arraylist,linkedlsit,vector,stack

treeset,hashset,linkedhashset

2) map: hashmap,linkedhashmap,weakhashmap, treemap, hashtable, identityhashtable(其中key的比较是通过==而不是equals)

3.2常用的容器类

1）arraylist 与 linkedlist（均非同步，多线程时需要考虑线程安全问题），vector（同步）,stack

1. list 接口支持通过索引的方法来访问元素：arraylist 随机访问快改慢；linkedlist改快随机访问慢；vector实现了同步，因而比arraylist慢

2. linkedlist使用双向链表实现linkedlist提供额外的get，remove，insert方法在linkedlist的首部或尾部。这些操作使linkedlist可被用作堆栈（stack），队列（queue）或双向队列（deque）。

3. arraylist没有定义增长算法，当需要插入大量元素是，可调用ensurecapacity方法提高添加效率

4. vector类似与arraylist，但是是同步的，多线程安全（另外一点区别是arraylist扩容时默认增长一半，vector增长一倍）。无论是单线程还是多线程，vector都比arraylist慢

5. stack继承自vector，实现一个后进先出的堆栈

6.若需要实现同步可以调用collections工具类的synchronizedlist方法，如下：

list list = collections.synchronizedlist(new arraylist());
synchronized(list) {
iterator i = list.iterator(); // must be in synchronized block
while (i.hasnext())
foo(i.next());
}
或者：
list list = collections.synchronizedlist(new linkedlist());

7.定义如下：（注意linkedlist实现了deque）

public class arraylist<e>extends abstractlist<e>implements list<e>, randomaccess, cloneable, serializable
public class linkedlist<e>extends abstractsequentiallist<e>implements list<e>, deque<e>, cloneable, serializable
public class vector<e>extends abstractlist<e>implements list<e>, randomaccess, cloneable, serializable

　　

2）treeset, hashset, linkedhashset（hashset，treeset不是线程安全的）

1. treeset是sortedset接口的唯一实现类，treeset可以确保集合元素处于排序状态，效率很高，可提高程序的效率；treeset通过compareto或者compare排序，因而只要值相等即使equals不等（不同对象）也不能加到集合中（fails to obey set interface）

2. hashset，效率很高，和treeset不同的是通过比较对象的equals区分不同对象，这样不同的对象可以不被重复的加入到集合中。

hashcode()函数不好确定，对象默认的hashcode函数试对象的内存地址值，hashcode函数的好坏是hashset性能的关键。

3. linkedhashset,和hashset相同，同样是根据元素的hashcode值来决定元素的存储位置，但是它同时使用链表维护元素的次序。linkedhashset在迭代访问set中的全部元素时，性能比hashset好，但是插入时性能稍微逊色于hashset。

4. set可以插入null，最多一个null

3) hashmap（非同步）, hashtable（线程安全）, treemap, weakhashmap

1.hashtable与hashmap区别：（详情请查看hashtable与hashmap）

•  hashtable继承自dictionary类，而hashmap继承自abstractmap类。但二者都实现了map接口。
• hashtable 中的方法是synchronize的，而hashmap中的方法在缺省情况下是非synchronize的
• hashtable中，key和value都不允许出现null值;hashmap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应 的值为null
• hashtable直接使用对象的hashcode。而hashmap重新计算hash值。

2. weakhashmap是一种改进的hashmap，它对key实行“弱引用”，weakhashmap使用元素的引用而不是值作为key，也就是说必须在引用相同（a==b）的情况下才能找到相关的值。另外，如果一个key不再被外部所引用，那么该key可以被gc回收。

3. treemap是sortedmap接口的基于红黑树的实现。此类保证了映射按照升序顺序排列关键字， 根据使用的构造方法不同，可能会按照键的类的自然顺序进行排序

4.定义如下：

public class hashtable extends dictionary implements map, cloneable, serializable 
public class hashmap extends abstractmap implements map, cloneable, serializable 
public class treemap<k,v>extends abstractmap<k,v>implements navigablemap<k,v>, cloneable, serializable

4.容器类使用补充

1）使用抽象编程思想，创建时使用父类引用指向子类对象，返回时返回抽象接口

2）如果涉及到堆栈，队列等操作，应该考虑用list，对于需要快速插入，删除元素，应该使用linkedlist，如果需要快速随机访问元素，应该使用arraylist。

3）如果程序在单线程环境中使用非同步的类，其效率较高

4）可以使用collections 工具类中unmodifiablelist/unmodifiablemap/unmodifiableset/unmodifiablesortedmap/unmodifiablesortedset等创建不能修改的list,map,list等

5）可以使用collections工具类中collections.synchronizedlist(new arraylist())等实现同步

6) 可以使用arrays.equal()判断两个数组是否相等

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。