集合，ArrayList,LinkedList,Vector,泛型概述，增强for循环

集合和数组的特点：
1.共同点：都作为容器，存储元素。
2.不同点：数组：数组只能存同一种类型的数据，可以存储基本类型和引用类型，创建完成之后长度固定，不可以临时增加或者删除集合：只能存储引用类型的数据，集合的长度是可以变的。一个集合可以存储各种类型的数据。
Collection集合
数组，不仅能存储基本数据类型，也能存储引用数据类型。
数组作为容器，可存储元素，但是数组作为容器，并不是很方便，如果我要对容器中的元素进行增删，就不方便。因为数组一旦定义，长度就固定了，如果你中途增删元素，就会改变数组的长度，就会报错。因此，Java中为了我们更加方便的对容器中的元素进行更加方便地操作，给我们提供了另外一种容器，叫集合。
Collection中的方法：
（1）采用多态：Collection collection = new ArrayList();
add添加元素：集合中存储的是引用数据类型，collection.add(“abc”).
collection.add(100);//自动装箱
collection.add(new Integer(200));
collection.add(Integer.valueOf(300));
addAll:A集合.addAll(B集合)，把B集合中的元素全部添加到A集合中。

import java.util.ArrayList;
import java.util.Collection;
public class Mytest2 {
    public static void main(String[] args) {
        Collection collection =new ArrayList();
        collection.add(100);
        collection.add(200);
        collection.add(300);
        Collection collection1=new ArrayList();
        collection1.add(100);
        collection1.add(200);
        collection1.add(400);
         //addAll把集合2中的元素添加到集合1中
        //A集合addAll(B集合); 把B集合中的元素，放到A集合里面去
        boolean b = collection.addAll(collection1);
        System.out.println(b);
        System.out.println(collection);
        System.out.println(collection1);
    }
}

（2）remove:删除集合中某个元素。
clear:清空集合中元素。
emoveAll:A集合.removeAll(B集合)，在A集合中删除AB集合的交集元素。

import java.util.ArrayList;
import java.util.Collection;
public class Mytest {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add(100);
        collection.add(200);
        collection.add(300);
        collection.add(400);
        collection.add(500);
         //remove:删除集合中的某个元素
        boolean b = collection.remove(300);
        System.out.println(b);
        System.out.println(collection);
        //clear:清空集合中的元素
         collection.clear();
        System.out.println(collection);
        System.out.println("------------------------");
        

（3）contains:判断这个集合中是否包含这个元素。
containsAll:A集合.containsAll(B集合)，B集合中的元素在A集合中都能找到,就返回true，否则返回false。

import java.util.ArrayList;
import java.util.Collection;
public class Mytest2 {
    public static void main(String[] args) {
        Collection collection = new ArrayList();
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("ddd");
        collection.add("eee");
        //contains:判断这个集合中是否包含此元素
        boolean b = collection.contains("ddd");
        System.out.println(b);
        System.out.println(collection);
        System.out.println("-------------------");
    Collection collection2 = new ArrayList();
        collection2.add("aaa");
        collection2.add("bbb");
        collection2.add("ccc");
        collection2.add("ddd");
        collection2.add("eee");
        collection2.add("fff");
        Collection collection3 = new ArrayList();
        collection3.add("aaa");
        collection3.add("bbb");
        collection3.add("ccc");
        collection3.add("ddd");
        collection3.add("eee");
        //collection3.add("hhh");
        //A集合.containsAll(B集合)：B集合中的元素在A集合中都能找到，就返回true，否则返回false。
        boolean b1 = collection2.containsAll(collection3);
 System.out.println(b1);
        System.out.println(collection2);
        System.out.println(collection3);
    }
}

（4）遍历：迭代器 Iterator iterator()
返回在此collection的元素上进行迭代的迭代器。
Iterator iterator = collection.iterator();
System.out.println(iterator);
//java.util.ArrayList$Itr 迭代器是ArrayList的内部类
通过迭代器来迭代集合中的元素
接口Iterator中的方法：
boolean hasNext();如果仍有元素可以迭代，返回true。
E next();返回迭代的下一个元素。

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

public class Mytest {
    public static void main(String[] args) {
        //遍历集合中的元素
        Collection collection =new ArrayList();
        collection.add("aaa");
        collection.add("bbb");
        collection.add("ccc");
        collection.add("ddd");
        collection.add("eee");
         /*
         * 迭代器：Iterator<E> iterator()
         * 返回在此collection的元素上进行迭代的迭代器
         */
        Iterator iterator = collection.iterator();
        System.out.println(iterator);
        //java.util.ArrayList$Itr@1540e19d,迭代器是ArrayList的内部类
        //通过迭代器来迭代集合中的元素
*/
   *接口Iterator中的方法：
         * (1)boolean hasnext();如果仍有元素可以迭代，返回true
         * (2)E next();返回迭代器的下一个元素
         */
        while (iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }
}

（5）retainAll:A集合.retainAll(B集合)，1）如果A集合是AB集合的交集，那么返回false，A集合中的元素没有发生变化。2）如果A集合中的元素除了AB集合的交集元素外，还有其他的元素，那么返回true，A集合中的元素发生变化，剩交集元素。3）如果A集合和B集合没有交集元素，那么A集合会被清空。
6）toArray:返回包含此数组的所有元素的数组。
把集合转换成数组：
Object[] objects=Collection.toArray();
System.out.println(Array.toString(objects));
ArrayList集合
1.ArrayList集合：
List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素
ArrayList:底层使用使用的是数组。查询快，增删慢 注意，此实现不是同步的 线程不安全 。 效率高
元素有序的（存取顺序一致），元素编有索引 允许元素重复
2.ArrayList集合特有的遍历方式：
void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常

ublic class MyTest1 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(100);
        list.add(100);
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(null);//允许置空
        //遍历方式:两种迭代器
        Iterator iterator = list.iterator();
        ListIterator listIterator = list.listIterator();
        //for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("==============================");
//JDK1.8 提供的一种迭代方法
        //void forEach(Consumer<? super E> action)
        //执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常
        list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                //o就是集合中的元素
                System.out.println(o);
            }
        });
    }
}
        

Vector集合
1.Vector集合：
Vector类概述: Vector 类可以实现可增长的对象数组 , Vector 是同步的。
2.Vector集合的特有功能：
public void addElement(E obj)
向Vector集合中添加元素
public E elementAt(int index)
向Vector集合中的指定索引处添加元素
public Enumeration elements()
Vector集合中特有的迭代器
E firstElement ()
返回此向量的第一个组件（位于索引 0)处的项）。
E lastElement ()
返回此向量的最后一个组件。

LinkedList集合
1,LinkedList集合：
底层数据结构是链表，查询慢，增删快，注意，此实现不是同步的。线程不安全，效率高
2。LinkedList类特有功能
public void addFirst(E e)及addLast(E e）
向LinkedList集合中开始位置和结束位置添加元素
public E getFirst()及getLast()
获取LinkedList集合中初始位置和结束位置的元素
public E removeFirst()及public E removeLast()
删除并返回LinkedList集合中开始位置和结束位置的元素
E poll ()
获取并移除此列表的头（第一个元素）
E pollFirst ()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast ()
获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
E pop ()
从此列表所表示的堆栈处弹出一个元素。
void push (E e)
将元素推入此列表所表示的堆栈。
泛型机制

1. 泛型机制：是一种将数据类型明确工作，推迟到创建对象或调用方法时才去明确的一种机制。
   泛型的好处，可以避免向下转型，也可以提高程序的扩展性。
   泛型的语法 <类型> <类型,类型2,。。。。> 类型指的是引用类型
   泛型可以定义在类上 接口上 方法上
   泛型只在编译期有效，在运行期就擦除了.
   泛型好处
   (1): 把运行时期的问题提前到了编译期间
   (2): 避免了强制类型转换
   (3):优化了程序设计，解决了黄色警告线
   2.泛型类的概述：把泛型定义在类上
   定义格式: public class 类名<泛型类型1,…>
   注意事项: 泛型类型必须是引用类型
   案例演示: 泛型类的使用

• 泛型的应用之泛型类: 就是把泛型定义在类上
• 格式: public class 类名<数据类型 , …> {}
• 3.泛型方法：
  A:泛型方法概述: 把泛型定义在方法上
  B:定义格式: public <泛型类型> 返回类型 方法名(泛型类型）
  4.泛型通配符：
  A:泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了
  B:? extends E: 向下限定，E及其子类
  C:? super E: 向上限定，E及其父类

增强for循环
A:增强for概述
简化数组和Collection集合的遍历
B:格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
注意增强for循环，在迭代集合的途中，不能增删元素，会报并发修改异常