Collection 集合框架

1. Collection 集合框架：在实际开发中，传统的容器(数组)在进行增、删等操作算法和具体业务耦合在一起，会增加程序的开发难度；这时JDK提供了这样的容器---Collection 集合框架，集合框架中 ，将使用的对象储存于特定数据结构的容器中 ，包含了一系列数据不同数据结构(线性表、查找表)的实现类。

 import java.util.ArrayList;
 import java.util.Collection;

 public class Test1 {
     public static void main(String[] args) {
         /**
          * 增：add/addAll;
          * 删：clear/removeAll/retainAll;
          * 改
          * 查：contains/containsAll/isEmpty/size;
          */

         Collection c1 = new ArrayList();
         //追加
         c1.add("apple");//多态，父类引用子类：Object object = new String("apple");
         c1.add("banana");//多态，父类引用子类：Object object = new String("banana");
         System.out.println(c1);//输出[apple, banana]
     }

 }

1）Collection 部分方法

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;

 public class Test1 {
     public static <E> void main(String[] args) {

         Collection<E> c1 = new ArrayList<E>();
         c1.add((E) "apple");
         c1.add((E) "apple2");
         c1.add((E) "apple3");
         c1.add((E) "apple4");
         System.out.println(c1.toString());

             //快速遍历
         for (Object item : c1) {
             System.out.println(item.toString());
         }

         //另一写法
         Iterator<E> it = c1.iterator();
         while (it.hasNext()) {
             Object item = it.next();
             System.out.println(item.toString());
         }

         //优化写法，for循环结束后，少占用JVM内存
         for (Iterator<E> it2 = c1.iterator(); it2.hasNext();) {
             Object item = it2.next();
             System.out.println(item.toString());
         }

                 Collection<E> c2 = new ArrayList<E>();
         c2.add((E) "java");
         c2.add((E) "C++");
         c1.addAll(c2);

                 //clear
         //c1.clear();//移除此 collection 中的C1所有元素
         //c1.remove("apple");//移除此 collection 中的C1的"apple"元素
         //System.out.println(c1.toString());

         System.out.println(c1.contains("apple"));//返回true , c1中含有指定元素"apple"。
         System.out.println(c1.contains(c2));//返回false，c1中含有c2的多个元素，不是指定的一个元素。
         System.out.println(c1.containsAll(c2));//返回true，c1中包含指定 collection 中的C2所有元素
         //c1.clear();//移除此 collection 中的C1所有元素，一下语句就返回true；
         System.out.println(c1.isEmpty());//返回false，如果此collection中c1不含元素就返回true； 

         System.out.println(c1.size());//返回7； //返回集合collection 中的元素的数量

         System.out.println(c1.equals(c2));//返回false； //判断指定对象是否相等

     }

 }

1.2 List接口是Collection的子接口，用于定义线性表数据结构，元素可重复、有序的；可以将List理解为存放对象的数组，只不过其元素个数可以动态的增加或减少。

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;

 public class Test2 {
     public static <E> void main(String[] args) {
         List<E> list1 = new ArrayList<E>();
         list1.add((E) "apple");// 添加元素
         list1.add((E) "banana");// 添加元素
         list1.add((E) "orange");// 添加元素
         list1.add((E) "lemon");// 添加元素

         for (E item : list1) {
             System.out.print(item.toString() + "\t\t");
         }// 快速遍历

         System.out.println();// 换行

         list1.add(0, (E) "fruit");// 在指定位置添加元素

         System.out.println();// 换行

         // 快速遍历(优化写法)
         for (Iterator<E> it = list1.iterator(); it.hasNext();) {
             E item = it.next();
             System.out.print(item + "\t\t");
         }

         System.out.println();// 换行

         List<E> list2 = new ArrayList<E>();
         list2.add((E) "cabbage");
         list2.add((E) "spinach");

         System.out.println(list2.toString());// 输出[cabbage, spinach]
         System.out.println();// 换行

         list1.addAll(list2);
         System.out.println(list1.toString());// 输出[fruit, apple, banana, orange,
                                                 // lemon, cabbage, spinach]
         System.out.println();// 换行

         list1.remove(0);// 删除指定位置元素
         System.out.println(list1);// 输出[apple, banana, orange, lemon, cabbage,
                                     // spinach]
         list1.remove("spinach");// 删除指定元素
         System.out.println(list1);// 输出[apple, banana, orange, lemon, cabbage]

         list1.set(0, (E) "python");// 修改：把集合的第0位上的apple修改为python;
         System.out.println(list1);// 输出[python, banana, orange, lemon, cabbage]

         System.out.println(list1.get(0));// 输出python； 查询集合里第0位上的元素
         list1.add((E) "c++");
         list1.add((E) "c++");
         list1.add((E) "c++");
         System.out.println(list1);
         System.out.println(list1.indexOf("c++"));// 返回此列表中第一次出现的指定元素的索引
         System.out.println(list1.lastIndexOf("c++"));// 返回此列表中最后出现的指定元素的索引

         // 正向遍历 hasNext / next
         ListIterator<E> it2 = list1.listIterator();
         while (it2.hasNext()) {
             System.out.print(it2.next() + "\t");

         }

         // 逆向遍历 hasPrecious / previous
         System.out.println();
         while (it2.hasPrevious()) {
             System.out.print(it2.previous() + "\t");
         }

         // 正向遍历优化写法
         System.out.println();
         for (ListIterator<E> it3 = list1.listIterator(); it3.hasNext();) {
             E item = it3.next();
             System.out.print(item + "\t");
         }

     }

 }

1.3ArrayList/Vector

1）ArryList是List接口的实现类，底层数据结构是数组，并且实现可变的数组。 线程不安全的

2）Vector 是List接口的实现类，底层数据结构是数组，也是实现可变的数组。 线程安全的

① ArryList

 import java.util.ArrayList;
 import java.util.Iterator;

 public class Test3 {
     public static <E> void main(String[] args) {
         // ArryList是List接口的实现类，底层数据结构是数组，并且实现可变的数组。 线程不安全的
         // Vector 是List接口的实现类，底层数据结构是数组，也是实现可变的数组。 线程安全的

         ArrayList<E> list = new ArrayList<E>();
         list.add((E) "cabbage");
         list.add((E) "spinage");
         list.add((E) "turnip");
         list.add((E) "pumpkin");

         System.out.println(list.toString());
         //System.out.println(list.size()); 输出集合元素的个数

         System.out.println();

         // 快速遍历
         for (Object item : list) {
             System.err.print(item.toString() + "\t");
         }

         System.out.println();

         // 迭代器遍历
         for (Iterator<E> it = list.iterator(); it.hasNext();) {
             E item = it.next();
             System.out.print(item.toString() + "\t");
         }

     }

 }

② Vector

 import java.util.Iterator;
 import java.util.Vector;

 public class Test4 {
     public static <E> void main(String[] args) {
         Vector<E> list = new Vector<E>();
         list.add((E) "lemon");
         list.add((E) "orange");
         list.add((E) "pomegranate");

         System.out.println(list.toString());

         //快速遍历
         for (Object item : list) {
             System.out.print(item.toString() + "\t");
         }

         System.out.println();
         //迭代器遍历
         for (Iterator<E> it = list.iterator(); it.hasNext();) {
             E item = it.next();
             System.out.print(item.toString() + "\t");
         }

     }

 }

1.3 LinkedList

1) LinkedList是List接口的实现类，底层数据结构是链表。

2) LinkedList常用方法和遍历方法参照List接口。（线程不安全）

堆栈操作

 import java.util.LinkedList;

 public class Test1 {
     public static <E> void main(String[] args) {
         // 堆栈操作LinkedList

         LinkedList<E> list = new LinkedList<E>();
         list.push((E) "lemon");
         list.push((E) "orange");
         list.push((E) "pomegranate");

         System.out.print(list.pop() + "\t");
         System.out.print(list.pop() + "\t");
         System.out.print(list.pop() + "\t");

         //System.out.print(list.pop() + "\t");//出错 java.util.NoSuchElementException
     }

 }

队列形式操作

 import java.util.LinkedList;

 public class Test2 {
     public static <E> void main(String[] args) {
         //LinkedList  队列形式操作
         LinkedList<E> queue = new LinkedList<E>();
         //入队
         queue.add((E) "lemon");
         queue.add((E) "orange");
         queue.add((E) "pomegranate");
         System.out.println(queue);
         //System.out.println(queue.element());//获取头元素

         //出对
         //System.out.println(queue.remove(2));//指定位置出队
         //System.out.println(queue.remove(1));
         //System.out.println(queue.remove(0));

         System.out.println(queue.remove());
         System.out.println(queue.remove());
         System.out.println(queue.remove());

         //System.out.println(queue.remove());//出错java.util.NoSuchElementException

         queue.add((E) "lemon4");

         System.out.println();

         //System.out.println(queue.remove(0));

         System.out.println(queue.element());//获取头元素 ， 输出lemon4    此时lemon4为 表头元素
     }

 }

1.4  Iterator和ListIterator

1）Iterator集合迭代器遍历集合过程中，不能再向集合汇总添加元素，否则出现 ConcurrentModificationException 并发修改异常。

 import java.awt.event.ItemEvent;
 import java.util.ArrayList;
 import java.util.Iterator;

 public class Test3 {
     //Iterator和Listlterator
     //Iterator在迭代过程中不予许向集合中添加元素
     public static <E> void main(String[] args) {
         ArrayList<E> list = new ArrayList<E>();
         list.add((E) "lemon");
         list.add((E) "orange");
         list.add((E) "peach");

         for (Iterator<E> it = list.iterator(); it.hasNext(); ) {
             String item = (String)it.next();
             if(item.equals("lemon")){
                 list.add((E) "test");//遍历过程中添加元素，会出现ConcurrentModificationException 并发修改异常。
             }
         System.out.println(list.toString());

         }

     }
 }

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

 import java.util.ArrayList;
 import java.util.ListIterator;

 public class Test4 {
     public static <E> void main(String[] args) {
         //ListIterator允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的位置。
         ArrayList<E> list = new ArrayList<E>();
         list.add((E) "lemon");
         list.add((E) "orang");
         list.add((E) "peach");

         //迭代遍历
         for (ListIterator<E> it = list.listIterator(); it.hasNext();) {
             String item = (String)it.next();
             if (item.equals("lemon")) {
                 it.add((E) "test");
             }
         }

         System.out.println(list.toString());
         //输出[lemon, test, orang, peach]，ListIterator迭代期间可以修改列表

     }

 }

重点：Iterator实现类的源码hasNext/next

1.5 泛型

1）泛型是JDK1.5引入的新特性，泛型的本质是参数化类型。在类、接口、方法的定义过程中，所操作的数据类型为传入的指定参数类型。所有的集合类型都带有泛型参数，这样在创建集合时可以指定放入集合中的对象类型。同时，编译器会以此类型进行检查。

2）ArrayList支持泛型，泛型尖括号里的符号可随便些，但通常大写E。

3）迭代器也支持泛型，但是迭代器使用的泛型应该和它所迭代的集合的泛型类型一致！

4）泛型只支持引用类型，不支持基本类型，但可以使用对应的包装类。

5）如果泛型不指定类型的话，默认为Object类型。

 import java.awt.Point;
 import java.util.ArrayList;
 import java.util.Iterator;

 public class Test5 {
     public static void main(String[] args) {
         ArrayList<Point> list = new ArrayList<Point>();
         list.add(new Point(1, 2));
         list.add(new Point(3, 4));

         System.out.println(list);

         for (int i = 0; i < list.size(); i++) {
             Point p = list.get(i); //只运行Point类型，否则造型异常
             System.out.println(p.getX());//输出两个点X的坐标
         }

         //遍历
         for (Iterator<Point> it = list.iterator(); it.hasNext();) {
             Point p = it.next();
             System.out.println(p);
         }
     }

 }

6）泛型方法可以定义多个泛型类型

 // 可以定义多个泛型的类型
     public <A,B> void showInfo(A a,B b) {
         System.out.println(a);
         System.out.println(b);
     }