Phase2 Day1 Collection&集合输出&List

Collection

Collection 层次结构中的根接口。

• Collection是进行单对象保存得最大父接口,即每次利用Collection接口都只能保存一个对象信息,同时Collection接口输入Iterable的子接口.
• Collection 表示一组对象，这些对象也称为collection 的元素。一些 collection 允许有重复的元素(List)，而另一些则不允许(S,et)。 一些 collection 是有序的，而另一些则是无序的。
• 虽然Collection是单对象操作最大的父接口,但是Collection本身无法区分保存的数据是否重复,所以在实际开发中往往使用他的两个子接口:List和Set.

API:

  增：
  boolean add(E e)
  boolean addAll(Collection c)  如果原集合发生了修改，返回true, 否则返回false.
    
  删:
  void clear()
  boolean remove(Object o)
  boolean removeAll(Collection c)  如果原集合发生了修改，返回true, 否则返回false.
  
  查:
  boolean contains(Object o)
  boolean containsAll(Collection c)  如果c中的每一个元素都在集合中存在，就返回true,否则返回false.
  
  获取集合的属性:
  boolean isEmpty()
  int size()  返回集合大小
    
  Iterator<E> iterator()迭代器

 遍历:
  Object[] toArray()将集合转换成数组
	 Collection c = new ArrayList();
        c.add("hello");
        c.add("world");
        c.add("java");
        Object[] array = c.toArray();
        for (int i = 0; i < array.length; i++) {
            String s = ((String) array[i]);
            System.out.println(s.toUpperCase());
        }
        // 修改数组不会影响到集合。
        array[2] = "javase";
        System.out.println(Arrays.toString(array)); 
        System.out.println(c); 
        // 修改集合也不会影响到数组.

集合类的特点
a. 可以自动地调整自己的大小
b. 只能存储引用数据类型

数组和集合的不同
a. 数组可以存储基本数据类型的数据，集合不可以。
b. 数组的长度是固定的，集合可以自动调整自己的大小。
c. 数组的效率高，相对来说集合效率比较低。
d. 数组没有API，集合有丰富的API。

转化
a. 基本数据类型–>引用数据类型Integer Integer.valueOf(int i)
b. 引用数据类型–>基本数据类型int Integer.intValue(Integer obj)

自动装箱和自动拆箱(JDK1.5)
a. 自动装箱：基本数据类型可以自动转换成相应的引用数据类型。
b. 自动拆箱：引用数据类型可以自动转换成相应的基本数据类型

集合输出

由于集合中往往会保存多个对象,所以一般对集合的遍历都会采用循环的方式完成,共有四种形式

• Iterator输出
• ListIteror输出
• foreach
• Enumeration输出

1.Iterator

lterator

• Iterator(迭代器)时集合输出操作中最为常用的接口,而在Collection接口种就已经提供了Iterator接口实例化的方法(iterator()),所以任何集合类都可以转换为Iterator接口输出.
• 在JDK1.5之后,为了让更多操作支持Iterator迭代输出,单独创建了Iterable接口,同时在其中定义了iterator的抽象方法.
• iterator为Java中的迭代器对象，是能够对Collection这样的集合进行迭代遍历的底层依赖。而iterable接口里定义了返回iterator的方法，相当于对iterator的封装，同时实现了iterable接口的类可以支持for
  each循环。，实质上是接口，依赖集合对象而存在。

jdk中Iterator接口主要方法如下：

public interface Iterator<E> {
	boolean hasNext();
  	E next();
}

iterator通过以上两个方法定义了对集合迭代访问的方法，而具体的实现方式依赖于不同的实现类，
具体的集合类实现Iterator接口中的方法以实现迭代。

迭代器模型

										
		interface Iterator											
		{											
			public boolean hasNext();										
			public Object next();										
		}											
													
		class ArrayList											
		{											
			public Iterator iterator()										
			{										
				return new Itr();									
			}										
													
													
			private class Itr implements Iterator										
			{										
				public boolean hasNext()									
				{									
					code...;								
				}									
				public Object next()									
				{									
					code...;								
				}									
			}										
		}											

Iterator的API

我们通过Iterator it = c.iterator()创建迭代器，it是Arrays的成员内部类型，如此设计可以让迭代器访问集合私有的数据结构。这种设计模式称为迭代器模型。

API:

boolean hasNext():如果仍有元素可以迭代，则返回 true。
E next(): 返回迭代的下一个元素。越界报错NoSuchElementException
void remove(): 删除的是最近返回的元素

使用迭代器时的注意事项：
a. 警惕ConcurrentModificationException
b. 不建议使用while循环, 可以使用for循环, 最好使用foreach循环.
c.用迭代器对集合遍历的时候，不要使用集合的API对集合进行修改

2.双向迭代:ListIterator

• 专门为List子接口定义的输出接口
• 提供了集合追加数据和修改数据的支持
• 具备了向前迭代的功能
  API

boolean hasPrevious() 
          判断是否有前一个元素
E previous() 
          返回列表中的前一个元素。  
void add(E e) 
          将指定的元素插入列表（可选操作）。 
void set(E e) 
          用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。
int nextIndex() 
          返回对 next 的后续调用所返回元素的索引。  
int previousIndex() 
          返回对 previous 的后续调用所返回元素的索引。 

List

list：

• 有序的collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
• 与 set 不同，列表通常允许重复的元素。更确切地讲，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个 null 元素。

特有的API:

增：
void add(int index, E element) 越界IndexOutOfBoundsException

boolean addAll(int index, Collection c)  范围：[0, size]

查：
 E get(int index)  [0, size()-1]
 
 int indexOf(Object o)
 获取集合中第一个与指定对象o相等元素的索引，如果集合中没有和o相等的元素, 返回-1.
 
 int lastIndexOf(Object o)
 获取集合中最后一个与指定对象o相等元素的索引，如果集合中没有和o相等的元素, 返回-1.
 
 删：
 E remove(int index) 范围：[0, size()-1]
 删除指定索引位置的元素, 并把被删除的元素返回
 
 改：
 E set(int index, E element)
 用element替换指定索引位置的元素，并把该位置原来的元素返回
 
 遍历：
 ListIterator<E> listIterator()  迭代器位于最前面
 
 ListIterator<E> listIterator(int index)  可以指定迭代器的位置，下一个元素的索引位置为index，范围：[0, size()]
 
 截取：
 List<E> subList(int fromIndex, int toIndex) 包左不包右

ListIterator extends Iterator
概述：系列表迭代器，允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置。

在List中并没有实现Iterator接口，而是实现的Iterable接口。
进一步观察Iterable接口的源码可以发现其只是返回了一个Iterator对象。

public interface Iterable<T> {
  Iterator<T> iterator();
}

所以我们可以使用如下方式来对List进行迭代了（通过调用iterator()方法）

Iterator it = list.iterator();
while (it.hasNext()) {
    System.out.print(it.next() + ",");
}
同时实现了Iterable接口的还可以使用for each循环。

API:

	boolean hasNext()
    boolean hasPrevious()
    E next()
    E previous()
    int previousIndex(): 迭代器前一个元素的索引
    int nextIndex()：迭代器后一个元素的索引
    void add(E e)：在光标的后面添加元素e
    void remove()：删除最近返回的元素，最近没有返回元素 IllegalStateException
    void set(E e)：替换的是最近返回的元素

截取功能的视图技术

List<E> subList(int fromIndex, int toIndex) 包左不包右
//
 		List list = new ArrayList();
        list.add("赵灵儿");
        list.add("王语嫣");
        list.add("小龙女");
        List subList = list.subList(1, 2);
        System.out.println(subList);//[王语嫣]
        System.out.println(subList.size());//1

        subList.remove(0);
        System.out.println(subList);//[]
        System.out.println(list); //[赵灵儿, 小龙女]