JAVA集合类——难得的总结

本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/41346969

以下资料是在学习中总结出来的，希望对你有所帮助。如果需要请转载，谢谢。

1. StringBuffer 线程安全，StringBuilder 线程不安全 效率稍高些

集(Set)：集里的对象不按任何特定的方式排列，按索引值来操作数据，不能有重复的元素

列表(List)：序列中的对象以线性方式存储，按索引值来操作数据，可以有重复的元素

映射(Map)：映射的每一项为“名称—数值”对，名称不可以重复，值可以重复，一个名称对应一个唯一的值

显示指定集合类型：不经历装箱过程。

Collection<TaskVO> resulte = dao.retrieveByClause(TaskVO.class, sql);

转换为数组时，明确指定返回数组的大小

return result.toArray(new TaskVO[result.size()]);

数组不能强制转型：

String[] s= (String[])list.toArray();——错误

String[] s= (String[])list.toArray(new String[list.size()]);——正确



迭代器是按次序一个一个地获取集合中所有的对象，是访问集合中每个元素的标准机制。

迭代器的创建：Collection接口的iterator()方法返回一个Iterator

Iterator it=test.iterator(); //将test集合对象转为迭代器

迭代器的常用方法：

hasNext() //判断迭代器中是否有下一个元素

next() //返回迭代的下一个元素

Remove() //将迭代器新返回的元素删除



The Iterator interface is shown below: public interface Iterator {

boolean hasNext();

Object next();

void remove(); // Optional

}

可以认为迭代器是指向两个元素之间的位置.

在调用remove()方法的时候, 必须调用一次next()方法.

remove()方法实际上是删除上一个返回的元素.



List常用方法：

void add(int index, Object element) ：添加对象element到位置index上

boolean addAll(int index, Collection collection) ：在index位置后添加容器collection中所有的元素

Object get(int index) ：取出下标为index的位置的元素

int indexOf(Object element) ：查找对象element 在List中第一次出现的位置

int lastIndexOf(Object element) ：查找对象element 在List中最后出现的位置

Object remove(int index) ：删除index位置上的元素

ListIterator listIterator(int startIndex) ：返回一个ListIterator 跌代器，开始位置为startIndex

List subList(int fromIndex, int toIndex) ：返回一个子列表List ,元素存放为从 fromIndex 到toIndex之前的一个元素

ArrayList：我们可以将其看作是能够自动增长容量的数组。

利用ArrayList的toArray()返回一个数组。

Arrays.asList()返回一个列表。

迭代器(Iterator) 给我们提供了一种通用的方式来访问集合中的元素。

View方式：

一种是测量迭代元素的时间：

另一种测量使用toArray调用创建数组：

最后得到结果：

使用toArray调用中创建的数组迭代元素的速度要比使用iterator的速度大约快30%到60%。

但如果将使用toArray方法创建数组的时间开销含在内。则使用iterator实际上要快10%到20%，所以我们尽量不要创建中间数组。而使用迭代的方式。



ArrayList自动扩充机制

实现机制：ArrayList.ensureCapacity(int minCapacity)

首先得到当前elementData　属性的长度oldCapacity。

然后通过判断oldCapacity和minCapacity参数谁大来决定是否需要扩容, 如果minCapacity大于

oldCapacity，那么我们就对当前的List对象进行扩容。

扩容的的策略为：取(oldCapacity * 3)/2 + 1和minCapacity之间更大的那个。然后使用数组拷

贝的方法，把以前存放的数据转移到新的数组对象中

如果minCapacity不大于oldCapacity那么就不进行扩容。



LinkedList

LinkedList是采用双向循环链表实现的。

利用LinkedList实现栈(stack)、队列(queue)、双向队列(double-ended queue )。

它具有方法addFirst()、addLast()、getFirst()、getLast()、removeFirst()、removeLast()等。



用LinkedList实现队列：

队列(Queue)是限定所有的插入只能在表的一端进行，而所有的删除都在表的另一端进行的线性表。

表中允许插入的一端称为队尾(Rear)，允许删除的一端称为队头(Front)。

队列的操作是按先进先出(FIFO)的原则进行的。

队列的物理存储可以用顺序存储结构，也可以用链式存储结构。



用LinkedList实现栈：

栈(Stack)也是一种特殊的线性表，是一种后进先出(LIFO)的结构。

栈是限定仅在表尾进行插入和删除运算的线性表，表尾称为栈顶(top)，表头称为栈底(bottom)。

栈的物理存储可以用顺序存储结构，也可以用链式存储结构。



ArrayList和LinkedList的比较：

ArrayList底层采用数组完成，而LinkedList则是以一般的双向链表(double-linked list)完成，其内每个对象除了数据本身外，还有两个 引用，分别指向前一个元素和后一个元素。

如果我们经常在List的开始处增加元素，或者在List中进行插入和删除操作，我们应该使用LinkedList，否则的话，使用ArrayList将更加快速。

小结：

集合是一个保存其他对象的对象

Collection接口除了实现映射的集合类之外的所有集合类定义了一些方法

List集合类型描述了一种按位置存储数据的对象，有序的。

ArrayList是一种在内存连续区域 中存储数据的通用数组



编码习惯：

面向接口的编程,尽可能降低代码变化率：

List<T> lst = new ArrayList<T>();

尽量避免创建不必要的对象：vo应在if判断成立时创建

TaskReportVO reportvos = new TaskReportVO();

if(i > 0){

lstAllVos.add(reportvos); }

尽量避免同时遍历和删除集合。因为这会改变集合的大小；

for( Iterator<ComType> iter = ComList.iterator(); iter.hasNext();){

ComType com = iter.next();

if ( !com.getName().contains("abc")){

ComList.remove(com);}

}



推荐：

for( Iterator<ComType> iter = ComList.iterator(); iter.hasNext();){

ComType com = iter.next();

if ( !com.getName().contains("abc")){

iter.remove(com); }



预估集合内持有对象的大小，不能持有大量对象，占据内存：

List<T> lst = new ArrayList<T>();

无限制的在lst中add element，势必会造成lst占用内存过高。造成内存溢出



Map接口：

集合框架的第二类接口树。

它提供了一组键值的映射。其中存储的每个对象都有一个相应的关键字(key)，关键字决定了对象在Map中的存储位置。

关键字应该是唯一的，每个key 只能映射一个value。

常用方法：

Object put(Object key,Object value)：用来存放一个键-值对Map中

Object remove(Object key)：根据key(键)，移除键-值对，并将值返回

void putAll(Map mapping) ：将另外一个Map中的元素存入当前的Map中

void clear() ：清空当前Map中的元素

Object get(Object key) ：根据key(键)取得对应的值

boolean containsKey(Object key) ：判断Map中是否存在某键（key）

boolean containsValue(Object value):判断Map中是否存在某值(value)

public Set keySet() ：返回所有的键（key），并使用Set容器存放

public Collection values() ：返回所有的值（Value），并使用Collection存放

public Set entrySet() ：返回一个实现 Map.Entry 接口的元素 Set



HashMap：

Map 主要用于存储键(key)值(value)对，根据键得到值，因此键不允许重复,但允许值重复。

HashMap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度。

HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;

HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步，可以用 Collections的synchronizedMap方法使HashMap具有同步的能力。



HashMap实现原理---散列

Hash哈希算法的意义在于提供了一种快速存取数据的方法,它用一种算法建立键值与真实值之间的对应关系。散列表又称为哈希表。散列表算法的基本思想是：以结点的关键字为自变量，通过一定的函数关系（散列函数）计算出对应的函数值，以这个值作为该结点存储在散列表中地址。

当散列表中的元素存放太满，就必须进行再散列，将产生一个新的散列表，所有元素存放到新的散列表中，原先的散列表将被删除。在Java语言中，通过负载因子(load factor)来决定何时对散列表进行再散列。例如：如果负载因子0.75，当散列表中已经有75%位置已经放满，那么将进行再散列。

负载因子越高(越接近1.0)，内存的使用效率越高，元素的寻找时间越长。负载因子越低(越接近0.0)，元素的寻找时间越短，内存浪费越多。



何时需重写equals？

当一个类有自己特有的“逻辑相等”概念（不同于对象身份的概念）；

Object类仅仅提供了一个对引用的比较，如果两个引用不是同一个那就返回false，这是无法满足大多数对象比较的需要的，所以要覆盖；

使用==操作符检查实参是否为指向对象的引用”

使用instanceof操作符检查实参是否为正确的类型

把实参转换到正确的类型；

对于该类中每一个“关键”域，检查实参中的域与当前对象中对应的域值是否匹 配。对于既不是float也不是double类型的基本类型的域，可以使用==操作符 进行比较；对于对象引用类型的域，可以递归地调用所引用的对象的equals方法，对于float和double类型的域，先转换成int或long类型的值，然后使用==操作符比较；

当你编写完成了equals方法之后，应该问自己三个问题：它是否是对称的、传 递的、一致的？ 如果答案是否定的，那么请找到 这些特性未能满足的原因，再修改equals方法的代码



equals()和hashCode()同时覆写

尤其强调当一个对象被当作键值（或索引）来使用的时候要重写这两个方法；

覆写equals后，两个不同实例可能在逻辑上相等，但是根据Object.hashCode方法却产生不同的散列码，违反“相等的对象必须具有相等的散列码”。

导致，当你用其中的一个作为键保存到hashMap、hasoTable或hashSet中，再以“相等的”找另 一个作为键值去查找他们的时候，则根本找不到

不同类型的hashCode取值

如果该域是布尔型的，计算（f？0：1）

如果是char,short,byte或int，计算(int)f

如果是long类型，计算（int）(f^(f>>>32))

如果是float类型，计算Float.floatToIntBits（f）

如果是double类型，计算Dobule.doubleToLongBits(f)

如果该域是一个对象引用，递归调用hashCode

如果该域是一个数组，则把每个元素当做单独的域来处理，对每个重要的元素计算一个散列码，

比较：

HashMap的存入顺序和输出顺序无关。

LinkedHashMap 则保留了键值对的存入顺序。

TreeMap则是对Map中的元素进行排序。

因为HashMap和LinkedHashMap 存储数据的速度比直接使用TreeMap 要快，存取效率要高。

当完成了所有的元素的存放后，我们再对整个的Map中的元素进行排序。这样可以提高整个程序的运行的效率，缩短执行时间。

注意：TreeMap中是根据键（Key）进行排序的。而如果我们要使用TreeMap来进行正常的排序的话，Key 中存放的对象必须实现Comparable 接口。



Set:

扩展Collection接口

不允许重复元素

对 add()、equals() 和 hashCode() 方法添加了限制

HashSet和TreeSet是Set的实现

Set—》hashSet linkedHashSet

SortedSet —》 TreeSet



HashSet常用方法:

public boolean contains(Object o) ：如果set包含指定元素，返回true

public Iterator iterator()返回set中元素的迭代器

public Object[] toArray() ：返回包含set中所有元素的数组public Object[] toArray(Object[] a) ：返回包含set中所有元素的数组，返回数组的运行时类型是指定数组的运行时类型

public boolean add(Object o) ：如果set中不存在指定元素，则向set加入

public boolean remove(Object o) ：如果set中存在指定元素，则从set中删除

public boolean removeAll(Collection c) ：如果set包含指定集合，则从set中删除指定集合的所有元素

public boolean containsAll(Collection c) ：如果set包含指定集合的所有元素，返回true。如果指定集合也是一个set，只有是当前set的子集时，方法返回true



实现Set接口的HashSet，依靠HashMap来实现的。

我们应该为要存放到散列表的各个对象定义hashCode()和equals()。

如何达到不能存在重复元素的目的？

“键”就是我们要存入的对象，“值”则是一个常量。这样可以确保，我们所需要的存储的信息

之是“键”。而“键”在Map中是不能重复的，这就保证了我们存入Set中的所有的元素都不重复。

HashSet如何过滤重复元素

调用元素HashCode获得哈希码--》判断哈希码是否相等，不相等则录入

---》相等则判断equals()后是否相等，不相等在进行 hashcode录入，相等不录入



TreeSet：

TreeSet是依靠TreeMap来实现的。

TreeSet是一个有序集合，TreeSet中元素将按照升序排列，缺省是按照自然顺序进行排列，意味着TreeSet中元素要实现Comparable接口

我们可以在构造TreeSet对象时，传递实现了Comparator接口的比较器对象。



几种Set的比较：

HashSet外部无序地遍历成员。

成员可为任意Object子类的对象，但如果覆盖了equals方法，同

时注意修改hashCode方法。

TreeSet外部有序地遍历成员；

附加实现了SortedSet, 支持子集等要求顺序的操作

成员要求实现Comparable接口，或者使用Comparator构造

TreeSet。成员一般为同一类型。

LinkedHashSet外部按成员的插入顺序遍历成员

成员与HashSet成员类似

HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet。



HashSet的元素存放顺序和我们添加进去时候的顺序没有任何关系，而LinkedHashSet 则保持元素的添加顺序。TreeSet则是对我们的Set中的元素进行排序存放。



一般来说，当您要从集合中以有序的方式抽取元素时，TreeSet 实现就会有用处。为了能顺利进行，添加到 TreeSet 的元素必须是可排序的。 而您同样需要对添加到TreeSet中的类对象实现 Comparable 接口的支持。一般说来，先把元素添加到 HashSet，再把集合转换为 TreeSet 来进行有序遍历会更快。



Comparable和Comparator

Comparable 接口以提供自然排序顺序。

对于那些没有自然顺序的类、或者当您想要一个不同于自然顺序的顺序时，您可以实现

Comparator 接口来定义您自己的排序函数。可以将Comparator传递给Collections.sort或Arrays.sort。



Comparator接口

当一个类并未实现Comparable，或者不喜欢缺省的Comaparable行为。可以实现Comparator接口

直接实现Comparator的compare接口完成自定义比较类。

例：Arrays.sort(results, new Comparator<RepDataQueryResultVO>() 数组排序 RepDataQueryExecutor

例：Collections.sort(lst,new Comparator<TaskPrintSchemeVO>()