java之持有对象

1.基本概念：

java容器类类库的用途是“保存对象”，并将其划分为两个不同的概念：

1）Collection，一个独立的元素的序列，这些元素都服从一条或多条规则。List必须按照插入的顺序报错元素。而Set不能有重复的元素。Queue按照排队规则来确定对象产生的顺序（通常和插入的顺序相同）；

2)   Map，一组成对的“键值对”对象，允许使用键来查找值，ArrayList允许使用数字来查找值，映射表允许使用另一个对象来查找某一个对象，也可以称为"关联数组",因为它将某些对象与另外一些对象关联在一起，或称为"字典"。

e.g:

List<Apple> apples = new ArrayList<Apple>();

这个例子使用的是List接口，把ArrayList向上转型，这样的话若需要修改实现则只是在创建的时候修改就可以了

2. 添加一组元素：

1）.Arrays.asList()方法接受一个数组或是一个用逗号分隔的元素列表（使用可变参数）,并将其转换为一个List对象。

2).Collections.addAll()方法接受一个Collection对象，以及一个数组或是一个逗号分隔的列表。将元素添加到Collection中。

public class AddingGroups {


/**
* <b>方法说明：</b>
* <ul>
* 
* </ul>
* @param args 
*/
public static void main(String[] args) {
Collection<Integer> collection = 
// Arrays.asList()接受逗号分隔的元素列表
new ArrayList<Integer>(Arrays.asList(1,2,3,4,5));
// 数组
Integer[] moreInts = {6,7,8,9,10};
// Arrays.asList 接受一个数组
collection.addAll(Arrays.asList(moreInts));
// Collections.addAll()接受一个Collection对象。以及一个逗号分隔的列表，并将元素添加到Collection
Collections.addAll(collection, 11,12,13,14,15);
// Collections.addAll()接受一个collection对象和一个数组，并将元素添加到Collection
Collections.addAll(collection,moreInts);

List<Integer> list = Arrays.asList(16,17,18,19,20);
// 把索引为1的值替换为99
list.set(1, 99);

for (Integer integer : list) {
System.out.print(integer+",");
}
System.out.println();
for (Integer integer : collection) {
System.out.print(integer+",");
}
}
}

三种Map的基本风格：HashMap,TreeMap,LinkedHashMap,和HashSet一样，HashMap特提供了最快的查找技术，也没有按照任何明显的顺序来保存其元素。TreeMap按照比较结果的升序保存键，而LinkedHashMap则是按照插入顺序保存键，同事还保留了HashMap的查询速度。

3. List

List将元素维护在特定的序列中，List接口在Collection的基础上添加了大量的方法，使得可以在List的中间插入和移除元素。

List 有两种类型：

基本的ArrayList, 长于随机访问元素，但是在List的中间插入和移除元素比较慢.（需要移动数据）

LinkedList, 通过代价较低的在List中间进行的插入和删除操作，提供了优化的顺序访问，LinkedList在随机访问方面相对较慢，但是其特性集较ArrayList更大（需要移动指针）

若只对单条数据插入或删除，ArrayList的速度反而优于LinkedList。但若是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList. 因为ArrayList每插入一条数据，要移动插入点及之后的所有数据

4. 迭代器：是一个对象，遍历并选择序列中的对象，而客户端程序员不必知道或关心该序列底层的结构，创建的代价小，是轻量级对象，经常可以看到对迭代器有些奇怪的限制；

例如：Iterator

1) 使用方法iterator()要求容器返回一个Iterator，Iterator将准备好返回序列的第一个元素；

2） 使用next获得序列中的下一个元素；

3） 使用hasNext()检查序列中是否还有元素；

4） 使用remove()将迭代器新近返回的元素删除。

public class ListFeatures {


/**
* <b>方法说明：</b>
* <ul>
* 
* </ul>
* @param args 
*/
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
list.add(i);
}

Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
Integer i = it.next();
System.out.print(i+",");
}
System.out.println();
for (Integer integer : list) {
System.out.print(integer+",");
}
System.out.println();

it = list.iterator();
for (int i = 0; i < 6; i++) {
it.next();
it.remove();
}
System.out.println(list);
}
}

Iterator不必为容器中元素的数量担心，那是hasNext()和Next()关系的事；

若只需要向前遍历List，不打算修改其本身，那么使用foreach更为方便；

Iterator还可以移除由next（）产生的最后一个元素，这意味着在调用remove（）之前必须先调用next()；

1）. ListIterator:

ListIterator是一个更加强大的Iterator的子类型，它只能用于各种List类的访问，尽管Iterator只能向前移动，但是ListIterator可以双向移动，它还可以产生相对于迭代器在列表中指向的当前位置的前一个和后一个元素的索引，并且可以使用set() 方法替换它访问过的最后一个元素，你可以通过调用listIterator()方法产生一个指向List开始处的ListIterator，并且还可以通过调用listIterator(n)方法创建一个开始就指向列表索引为n的元素处的ListIterator

public class ListIteratorTest {


/**
* <b>方法说明：</b>
* <ul>
* 
* </ul>
* @param args 
*/
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
list.add(i);
}
//----------------------------------------------------
ListIterator<Integer> it = list.listIterator();

// 上一个和下一个元素的索引
while(it.hasNext()){
System.out.print(it.next()+","+it.nextIndex()+","+it.previousIndex()+",");
}
System.out.println();


// 访问上一个元素
while(it.hasPrevious()){
System.out.print(it.previous()+",");
}
System.out.println();
System.out.println(list);

it = list.listIterator();
while (it.hasNext()) {
// 替换访问的最后一个元素
it.next();
it.set(20);
}
System.out.println(list);
}
}

5 . LinkedList

LinkedList 也像ArrayList一样实现了基本的List接口，还添加了可以使其用作栈、队列或双端队列的方法。

public class LinkedListTest {


/**
* <b>方法说明：</b>
* <ul>
* 
* </ul>
* @param args 
*/
public static void main(String[] args) {

LinkedList<Integer> list = new LinkedList<Integer>();

for (int i = 0; i < 10; i++) {
list.add(i);
}

System.out.println(list);
// getFirst()和element()完全一样，都返回列表的头（即第一个元素），但并不移除，若list为空，则抛出NoSuchElementException
System.out.println("list.getFirst(): "+list.getFirst());
System.out.println("list.element(): "+list.element());
// getLast返回最后一个
System.out.println("list.getLast(): "+list.getLast());
// peek()方法与这两个方式只是稍有差异，在列表为空时返回null
System.out.println("list.peek(): "+list.peek());

// removeFirst()和remove（）一样，都是移除并且返回列表的头，列表为空，抛出NoSuchElementException
System.out.println("list.remove(): "+list.remove());
System.out.println("list.removeFirst(): "+list.removeFirst());
// 移除并返回列表的最后一个元素
System.out.println("list.removeLast(): "+list.removeLast());
// poll（）在列表为空是返回null
System.out.println("list.poll(): "+list.poll());
System.out.println("list.pollFirst(): "+list.pollFirst());
System.out.println("list.pollLast(): "+list.pollLast());

// 都是把元素添加到列表的头，尾
System.out.println(list);
list.addFirst(50);
System.out.println("after addFirst: "+list);
list.addLast(50);
System.out.println("after addLast: "+list);

list.offer(90);
System.out.println("after offer: "+list);
list.offerFirst(90);
System.out.println("after offerFirst: "+list);
list.offerLast(90);
System.out.println("after offerLast: "+list);
list.add(30);
System.out.println("after add: "+list);
list.addFirst(30);
System.out.println("after addFirst: "+list);
list.addLast(30);
System.out.println("after addLast: "+list);

}

}

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list.getFirst(): 0
list.element(): 0
list.getLast(): 9
list.peek(): 0
list.remove(): 0
list.removeFirst(): 1
list.removeLast(): 9
list.poll(): 2
list.pollFirst(): 3
list.pollLast(): 8
[4, 5, 6, 7]
after addFirst: [50, 4, 5, 6, 7]
after addLast: [50, 4, 5, 6, 7, 50]
after offer: [50, 4, 5, 6, 7, 50, 90]
after offerFirst: [90, 50, 4, 5, 6, 7, 50, 90]
after offerLast: [90, 50, 4, 5, 6, 7, 50, 90, 90]
after add: [90, 50, 4, 5, 6, 7, 50, 90, 90, 30]
after addFirst: [30, 90, 50, 4, 5, 6, 7, 50, 90, 90, 30]
after addLast: [30, 90, 50, 4, 5, 6, 7, 50, 90, 90, 30, 30]

6. Stack

"栈" 通常是指“后进先出”的容器，也有称为叠加栈，因为最后压入的元素，第一个出来，LinkedList具有能够直接实现栈的所有功能的方法，因此可以直接将LinkedList作为栈使用，但有时候一个真正的栈更能体现出问题；