java集合框架

集合：
我们学习的是面向对象语言，而面向对象语言是对事物的描述是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储，而要想存储对个对象，就不能是一个基本的变量，而应该是一个容器的变量，在目前所学的知识，容器类型的有：数组和StringBuffer,但是StringBuffer 的结果是个字符串，所以我们只能选择数组，这就是对象数组。而对象数组又不能适应变化的需求，因为数组的长度是固定的，这个时候，为了适应变化的需求，java就提供了集合类供我们使用。

数组和集合的区别：
1、长度区别：
数组长度固定
集合长度可变
2、内容不同：
数组存储的是同一类型的元素
集合存储的是不同类型的元素
3、元素的数据类型
数组可以存储基本类型，也可以存储引用类型
集合只能存储引用类型（只能用来装对象）

集合是存储多个元素的，存储多个元素会有不用的需求，比如：不能出现相同的元素，或者按照某一规则进行排序，针对不同的需求，java就提供了不同的集合类，这过个集合的数据结构不同。结构不同不重要，重要的是能够存储东西，并且还要能够使用；那么这多个集合使用共性的内容的，我们这这些集合类的共性不断向上提取，最终就能形成集合的继承体系结构。

java提供多种集合类，而他们的数据结构不同，但是肯定会有共性的内容（判断，获取，存储等）通过不断地向上提取，我们就可以得到一个集合的继承体系结构图：

Collection(集合)

分析：从具体到抽象
实现：从抽象到具体
使用：使用具体类

数据结构：数据的存储方式

Collection ：是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的有无序的，
1、添加
boolean add(Object obj) //添加一个元素
boolean addAll(Collection c) //添加一个集合的元素
2、删除
void clear（） //移除所有元素
boolean remove(Object obj) //移除一个元素
boolean remove(Collection c) //移除一个集合的元素
3、判断
boolean contains（Object o） //判断集合是否包含指定的元素
boolean contains(Collection c) //判断集合是否包含指定的集合元素
boolean isEmpty() //判断集合是否为空
4、获取（查找）
Iterator<E> iterator()

5、长度功能：
int size() //元素的个数
6、交集功能：
boolean retainAll(Collection c) //两个集合都有的元素
7、把集合转换为数组
Object [ ] toArray

package cn.Collection;
import java.util.ArrayList;
import java.util.Collection;
/**
 * Collection ：是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的有无序的，
 * 1、添加
         * boolean add(Object obj)        //添加一个元素
         * boolean addAll(Collection c)        //添加一个集合的元素
 * 2、删除
         * void clear（）        //移除所有元素
         * boolean remove(Object obj)               //移除一个元素
         * boolean remove(Collection c)        //移除一个集合的元素
 * 3、判断
         * boolean contains（Object o）        //判断集合是否包含指定的元素
         * boolean contains(Collection c)        //判断集合是否包含指定的集合元素
         * boolean isEmpty()        //判断集合是否为空
 * 4、获取（查找）
 *      Iterator<E> iterator()
 * 5、长度功能：
 *      int size()        //元素的个数
 * 6、交集功能：
 *      boolean retainAll(Collection c)         //两个集合都有的元素
 * 7、把集合转换为数组
 *      Object [ ] toArray
 *
 * */
public class CollectionDemo {
    public static void main(String[] args) {
        //测试不带All的方法
        //创建集合对象
        //Collection c = new Collection()       //这是错误的，接口不能实例化
        Collection c = new ArrayList();
        //boolean add(Object obj)       //添加一个元素
        //System.out.println("add= "+ c.add("hello"));
        c.add("hello");
        c.add("world");
        c.add("java");
        //void clear()      移除所有元素
        //c.clear();          //        c.clear();移除所有元素
//            System.out.println("remove= "+c.remove("hello"));      //c = [world, java]  移除hello
//            System.out.println("remove = "+ c.remove("hhhh"));      //判断不在给集合的元素，就false
        //boolean contains（Object o）        //判断集合是否包含指定的元素
//            System.out.println("contains = " + c.contains("hello"));
//            System.out.println("contains = "+ c.contains("heee"));      //false
        //boolean is Empty()        //判断集合是否为空
        //c.clear();//移除元素，       但是c = []，还有规则
        System.out.println("isEmpty= " + c.isEmpty());       //false
        //int size      长度
        System.out.println("size= " + c.size());
        System.out.println("c = " + c);
    }
}

package cn.Collection;
import java.util.ArrayList;
import java.util.Collection;
/**
 * Collection ：是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的有无序的，
 * 1、添加
         * boolean add(Object obj)        //添加一个元素
         * boolean addAll(Collection c)        //添加一个集合的元素
 * 2、删除
         * void clear（）        //移除所有元素
         * boolean remove(Object obj)               //移除一个元素
         * boolean removeAll(Collection c)        //移除一个集合的元素
 * 3、判断
         * boolean contains（Object o）        //判断集合是否包含指定的元素
         * boolean contains(Collection c)        //判断集合是否包含指定的集合元素
         * boolean isEmpty()        //判断集合是否为空
 * 4、获取（查找）
 *          Iterator<E> iterator()
 * 5、长度功能：
 *      int size()        //元素的个数
 * 6、交集功能：
 *      boolean retainAll(Collection c)         //两个集合都有的元素
 * 7、把集合转换为数组
 *      Object [ ] toArray
 *
 * */
public class CollectionDemo_02 {
    public static void main(String[] args) {
        //测试带All的对象
        //创建集合对象1
        Collection c1  = new ArrayList();
        c1.add("abc1");
        c1.add("abc2");
        c1.add("abc3");
        c1.add("abc4");
        //创建集合对象2
        Collection c2 = new ArrayList();
//        c2.add("abc1");
//        c2.add("abc2");
//        c2.add("abc3");
//        c2.add("abc4");
        //c2.add("abc4");       //可以重复，同样可以输出
        c2.add("abc5");
        c2.add("abc6");
        c2.add("abc7");
        //boolean addAll(Collection c)      //添加一个集合的元素
        //System.out.println("addAll= "+ c1.addAll(c2));     //在c1里面添加了c2 的集合元素
        //boolean removeAll(Collection c)       //移除一个集合的元素
        //System.out.println("removeAll= " + c1.removeAll(c2));       //只要移除一个元素，就返回true
        //boolean containsAll(Collection c)     判断集合中是否包含了指定元素的集合
        //System.out.println("containsAll = " + c1.containsAll(c2));      //只有包含所有的元素（只有包含所有的元素才叫包含），才会true
        //boolean retainAll(Collection c)       //两个集合都有的元素
        /**
         * 假设有两个集合与B
         * A对B做交集，最终的结果保存在A中，B不变，
         * 返回值表示的是A是否发生了改变
         * */
        System.out.println("retainAll = "+ c1.retainAll(c2));
        System.out.println("c1 = " + c1);
        System.out.println("c2 = " + c2);
    }
}

package cn.Collection;
import java.util.ArrayList;
import java.util.Collection;
/**
 * 集合的遍历：依次获取集合中的每一个元素
 * Object[] toArray   把集合转成数组
 *
 * */
public class CollectionDemo_03 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();
        //添加元素
        c.add("hello");     //Object obj = "hello";向上转型
        c.add("world");
        c.add("java");
        //遍历
        //Object [] toArray()
        Object[] obj = c.toArray();
        for (int x = 0; x < obj.length; x++) {
            //System.out.println(obj[x]);
            //如何获取元素的同时获取字符串的长度
           // System.out.println(obj[x] + "---" + obj[x].length);       //因为Object没有length方法
            //如果要获取长度就必须转为字符串
            //向下转型
            String s = (String )obj[x];
            System.out.println("s = " + s+"---"+s.length());
        }
    }
}

package Iterator;
import javax.naming.spi.ObjectFactoryBuilder;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 * Iterator iterator()   迭代器，集合专门用来遍历
 *
 * Object next()    获取元素，并移到下一个位置
 * boolean hasNext();       如果仍还有元素可以迭代，则返回true
 *
 *
 *
 * */
public class IteratorDemo_01 {
    public static void main(String[] args) {
        //创建结合对象
        Collection c = new ArrayList();
        //创建并添加元素
//        String s = "hello";
//        c.add(s);
        c.add("hello");
        c.add("world");
        c.add("java");
        //Iterator iterator()  迭代器
        Iterator it = c.iterator();         //返回的是子类对象，这里是多态
//        Object obj = it.next();
//        System.out.println("obj = " + obj);
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());
//        System.out.println(it.next());   //会报错
        //最后一个不应该写，在前面应该加一个判断，判断是否有下一个元素，
        /*
        if(it.hasNext()){
            System.out.println(it.next());
        }
        if(it.hasNext()){
            System.out.println(it.next());
        }
        if(it.hasNext()){
            System.out.println(it.next());
        }
        if(it.hasNext()){
            System.out.println(it.next());
        }
         */
        while(it.hasNext()){
            //System.out.println(it.next());
            String s = (String) it.next();      //因为next的返回Object
            System.out.println("s = " + s);
        }
    }
}

package Iterator;
import cn.CollectionTest.Student;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 * 使用集合存储5名学生对象，然后使用迭代器遍历
 *
 * */
public class IteratorTest {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();
        //创建学生对象
        Student s1 = new Student("小明", 27);
        Student s2 = new Student("小红", 30);
        Student s3 = new Student("小东", 33);
        Student s4 = new Student("小丽", 25);
        Student s5 = new Student("小王", 22);
        //把学生对象添加到集合：
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(s5);
        //遍历
        Iterator it = c.iterator();
        while(it.hasNext()){
            //System.out.println(it.next());      //如果重写了toString方法，这样就不会输出地址值
            //System.out.println("-----------------");
            Student s = (Student)it.next();       //如果没有重写toString方法，可以这样使用
            System.out.println(s.getName()+"---"+ s.getAge());
        }
    }
}

package Iterator;
import cn.CollectionTest.Student;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 * 使用集合存储5名学生对象，然后使用迭代器遍历
 *
 * */
public class IteratorTest_02 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();
        //创建学生对象
        Student s1 = new Student("小明", 27);
        Student s2 = new Student("小红", 30);
        Student s3 = new Student("小东", 33);
        Student s4 = new Student("小丽", 25);
        Student s5 = new Student("小王", 22);
        //把学生对象添加到集合：
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(s5);
        //遍历
        Iterator it = c.iterator();
        while(it.hasNext()){
            //System.out.println(it.next());      //如果重写了toString方法，这样就不会输出地址值
            //System.out.println("-----------------");
            Student s = (Student)it.next();       //如果没有重写toString方法，可以这样使用
            System.out.println(s.getName()+"---"+ s.getAge());
            //System.out.println(((Student)it.next()).getName()+"---"+((Student)it.next()).getAge());  //这样会报错
            //不要多次使用it.next()
        }
        //用for循环改进(这个效率高)
//        for(Iterator it = c.iterator(); it.hasNext();){
//            Student s = (Student)it.next();
//            System.out.println(s.getName()+ "---" +s.getAge());
//        }
//
    }
}

Iterator
迭代器：是集合遍历的一种方式
迭代器：是依赖于Collection而存在的

集合的使用步骤
1、创建集合对象：
Collection c = new ArrayList(）；

2、创建元素对象并添加：
Student s = new Student(“小明”,23);

3、把元素添加到集合中
c.add(s);

4、遍历
a、通过集合获取迭代器对象
Iterator it = c.iterator();
b、通过迭代器对象的hasNext()方法判断是否有元素
c、通过迭代器的next（）方法获取元素并移动到下一个位置

Iterator 的使用方法

        Iterator it = c.iterator();
        while(it.hasNext()){
            //System.out.println(it.next());      //如果重写了toString方法，这样就不会输出地址值
            //System.out.println("-----------------");
            Student s = (Student)it.next();       //如果没有重写toString方法，可以这样使用
            System.out.println(s.getName()+"---"+ s.getAge());
            //System.out.println(((Student)it.next()).getName()+"---"+((Student)it.next()).getAge());  //这样会报错
            //不要多次使用it.next()
        }
        //用for循环改进(这个效率高)
//        for(Iterator it = c.iterator(); it.hasNext();){
//            Student s = (Student)it.next();
//            System.out.println(s.getName()+ "---" +s.getAge());
//        }

package cn.Collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
 * 需求：储存自定义对象并遍历；String(name,age)
 *
 * 分析：
 *      1、创建学生类
 *      2、创建集合类
 *      3、创建学生对象
 *      4、把学生对象添加到集合对象中
 *      5、遍历
 *
 * */
public class CollectionTest {
    public static void main(String[] args) {
        //创建集合集合对象
        Collection c = new ArrayList();
        //创建学生对象
        Student s1 = new Student("貂蝉", 25);
        Student s2 = new Student("小婵", 16);
        Student s3 = new Student("黄月英", 20);
        Student s4  = new Student();
        s4.setName("大乔");
        s4.setAge(24);
        //把学生对象添加到集合中
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(new Student("孙尚香",19));           //匿名对象
        //遍历
//        Iterator it = c.iterator();
//        while(it.hasNext()){
//            //System.out.println(it.next());
//            Student s  = (Student )it.next();
//            System.out.println(s.getName()+"---"+ s.getAge());
        for(Iterator it = c.iterator();it.hasNext();){
            Student s = (Student)it.next();
            System.out.println(s.getName()+"---"+s.getAge());
        }
    }
}

• 分析：
  1、创建学生类
  2、创建集合类
  3、创建学生对象
  4、把学生对象添加到集合对象中
  * 5、遍历

List的特有功能：
a、添加功能：
void add(int index;Object element) //在指定位置添加元素
b、获取功能：
Object get(int index) //获取指定位置的元素
c、列表迭代器：
ListIterator listIterator() List集合特有的迭代器
d、删除功能：
Object remove(int index) //根据索引删除元素；返回被删除元素
e、修改功能：
Object set(int index,Object element) //根据索引修改元素，返回被修改的元素

package cn.List;
import java.util.ArrayList;
import java.util.List;
/**
 * List集合的特有功能：
 *  a、添加功能：
 *      void add(int index;Object element)      //在指定位置添加元素
 *  b、获取功能：
 *      Object get(int index)       //获取指定位置的元素
 *  c、列表迭代器：
 *      ListIterator listIterator()     List集合特有的迭代器
 *  d、删除功能：
 *      Object remove(int index)        //根据索引删除元素；返回被删除元素
 *  e、修改功能：
 *      Object set(int index,Object element)        //根据索引修改元素，返回被修改的元素
 *
 *
 * */
public class ListDemo_02 {
    public static void main(String[] args) {
        //创建集合对象
        List list = new ArrayList();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //调用方法
        //添加功能  void add(int index,Object element)      //在指定位置添加元素
       // list.add(1,"你好");
        //list.add(11,34);        //索引越界
        //list.add(3,"javaEE");       //没有问题
        //list.add(4,"javaEE");       //有问题
        //Object get(int index);    //获取制定位置的元素
        //System.out.println(list.get(1));
        //System.out.println(list.get(12));     //索引越界
        //Object remove(int index)      //根据索引删除元素，返回删除元素
        //System.out.println(list.remove(0));
        //Object set(int index,Object element)      //根据索引元素修改元素，返回被修改元素
        System.out.println(list.set(1,"WOTLD"));
        System.out.println("list = " + list);       //list = [hello, world, java]
    }
}

*  list 集合特有的遍历功能
 *  size和get功能的结合
 *  
 *      获取集合长度size
 *       for(int x = 0 ;x<list.size() ;x++){
 *          System.out.println("list = " + list.get(x));        //get 是获取每个元素
 *         }

package cn.List;
import java.util.ArrayList;
import java.util.List;
/**
 * list 集合特有的遍历功能
 * size和get功能的结合
 * <p>
 * 获取集合长度size
 * for(int x = 0 ;x<list.size() ;x++){
 * System.out.println("list = " + list.get(x));        //get 是获取每个元素
 * }
 */
public class LIstDemo_03 {
    public static void main(String[] args) {
        //创建集合对象
        List list = new ArrayList();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //获取元素
//        System.out.println("list = "+ list.get(0));
//        System.out.println("list = " +list.get(1));
//        System.out.println("list = "+ list.get(2));
//        for (int x = 0; x < 3; x++) {
//            System.out.println("list = " + list.get(x));
//        }
        //获取集合长度size
        for (int x = 0; x < list.size(); x++) {            //size可以获取集合长度
            System.out.println("list = " + list.get(x));        //get 是获取每个元素
        }
    }
}

ListIterator

package cn.ListIterator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
 * List集合的特点：
 *  有序 （存储和输出的元素一致） 可重复
 *      ListIterator listIterator()     列表迭代器
 *      该迭代器继承了Iterator迭代器，就可以直接使用hasNext()和next()方法
 *
 *      逆向遍历
 *      Object previous()       //获取列表的上一个元素
 *      判断
 *      boolean hasPrevious()判断列表上面是否还有元素
 *      
 *      注意：ListIterator 可以通过previous 进行逆向遍历，但是必须要先正向遍历，才能够逆向遍历(一般无意义，不使用)
 *      
 *
 * */
public class ListIteratorDemo {
    public static void main(String[] args) {
        //创建集合对象
        List list = new ArrayList();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //ListIterator listIteratorI()      //返回子类对象
        ListIterator lis = list.listIterator();
        while(lis.hasNext()){
            String s = (String)lis.next();
            System.out.println(s);
        }
        System.out.println("---------------");
//        System.out.println(lis.previous());
//        System.out.println(lis.previous());
//        System.out.println(lis.previous());
        while(lis.hasPrevious()){
            //System.out.println(lis.previous());
            String s = (String)lis.previous();
            System.out.println("s = " + s);
        }
        System.out.println("-------------------");
//        Iterator it = list.iterator();
//        while (it.hasNext()) {
//            String s = (String) it.next();
//            System.out.println(s);
//        }
//
//        System.out.println("-----------------------");
    }
}

package cn.ListIterator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
 *  问题：有一个集合，判断里面是否有“world，如果就添加”javaee
 *
 *      ConcurrentModificationException: 当方法及测到对象的并发修改，但不允许这种修改时，抛出此异常
 *      产生的原因：
 *          迭代器是依赖集合而存在的，在判断成功后，集合添加了新的元素，而迭代器不知道，所以就报错，这个错交并发修改异常
 *          其实这个问题的描述的是：迭代器遍历元素的时候，通过集合是不能修改元素的
 *
 *              解决方式：
 *                  1、迭代器迭代元素，迭代器修改元素
 *                          元素是在迭代元素之后，
 *                  2、集合遍历元素，集合修改元素（普通for）
 *                      元素是在集合的最后面
 *
 * */
public class ListIteratorDemo_02 {
    public static void main(String[] args) {
        //创建List对象
        List list = new ArrayList();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //迭代器遍历
        /*      错误的
        Iterator it = list.iterator();
        while(it.hasNext()){
            String s = (String)it.next();
            if("world".equals(s)){
                list.add("javaee");
            }
        }
         */
        /*
        //方式1：迭代器迭代元素，迭代器修改元素
        //Iterator 迭代器没有添加功能，所以只能使用子类接口ListIterator 中的添加功能
        ListIterator lit = list.listIterator();
        while(lit.hasNext()){
            String s  = (String)lit.next();
            if("world".equals(s)){
                lit.add("javaee");      //这里是通过迭代器添加元素
            }
        }
        System.out.println("list = " + list);
         */
        //方式2：集合遍历元素，集合修改元素（普通for）
        for (int x = 0; x < list.size(); x++) {
            String s = (String) list.get(x);
            if ("world".equals(s)) {
                list.add("javaee");
            }
        }
        System.out.println("list = " + list);
    }
}

数据结构：数据结构的组织方式。
面试题：常见的出具结构的优缺点？

栈：先进后出
入栈（压栈） A-B-C
出栈（弹栈） C-B-A
举例：
弹夹：存子弹，从上面压进，出去的的是从上面的先出

队列：先进先出
入栈（压栈） A-B-C
出栈（弹栈） A-B-C

举例：
买票，

数组：
存储同一类型的多个元素的容器，有索引，方便我们获取

链表：
由一个链子把多个节点连接起来的数据
节点：由数组和地址组成，（数据和指针域组成）
（数据就相当于数据，地址相当于指针域）

List的子类特点：
ArrayList:
底层数据结构是数组，查询快，增删慢
线程不安全，效率高
Vertor:
底层数据结构是数组，查询快，增删慢
线程安全，效率低
LinkedList:
底层数据结构是链表，查询慢，增删快
线程不安全，效率高

List怎么选择呢：
要安全吗？
要：vector（即是要安全也不使用）
不要:ArrayList 或者LinkedList
查询多：ArrayList:
增删多：LinkedList

如果什么都不会，那么就用ArrayList

//ClassCastException 类转换异常 这里要注意类型是否一致

package cn.Vector;
import javax.swing.text.Element;
import java.util.Enumeration;
import java.util.Vector;
/**
 * Vector的特有功能
 *      1、添加功能：
 *          public void addElement(Object obd)      ---add()
 *      2、获取功能：
 *          public Object element(int index)        ---get()
 *          public Enumeration element()            ---Iterator iterator
 *              boolean hasMoreElement()            ---haxNext()
 *              Object nextElement()                ---next()
 *              
 *       jdk 升级的原因
 *          1、安全
 *          2、效率
 *          3、简写化
 *
 * */
public class VectorDemo {
    public static void main(String[] args) {
        //创建集合对象
        Vector v = new Vector();
        //添加元素
        v.addElement("hello");
        v.addElement("world");
        v.addElement("java");
        //遍历
        for(int x = 0; x<v.size();x++){
            String s = (String)v.elementAt(x);
            System.out.println("s = " + s);
        }
        System.out.println("----------------");
//        Enumeration en = v.elements();
//        while(en.hasMoreElements()){
//            String s = (String)en.nextElement();
//            System.out.println(s);
//        }
        for(int x = 0 ; x< v.size(); x++){
            String s = (String)v.elementAt(x);
            System.out.println("s = " + s);
        }
    }
}

package cn.LinkedList;
import java.util.LinkedList;
/**
 * LinkedList的特有功能
 *      添加功能：
 *          public void addFirst(Object e)
 *          public void addLast(Object e)
 *
 *      获取功能：
 *          public Object getFirst()
 *          public Object getLast()
 *      删除功能：
 *          public Object removeFirst()
 *          public Object removeLast()
 *
 * */
public class LinkedListDemo {
    public static void main(String[] args) {
        //创建集合对象
        LinkedList link = new LinkedList();
        //添加元素
        link.add("hello");
        link.add("world");
        link.add("java");
        //添加功能：
        //link.addFirst("xixi");        //添加在第一个
        //link.addLast("haha");         //添加在最后一个
        //获取功能：
//        System.out.println(link.getFirst());
//        System.out.println(link.getLast());
        //删除功能：
        System.out.println(link.removeFirst());
        System.out.println(link.removeLast());
        //输出
        System.out.println("link = " + link);
    }
}

package cn.Test;
import java.util.ArrayList;
import java.util.Iterator;
/**
 * 去除集合中自定义对象对象的重复值（对象的成员变量值都想同）
 * contains()方法依赖的是equals ()方法，而学生类中没有equals()方法，默认使用的是父类的Object的equals()方法
 * 而Object()的equals()默认比较的是地址值，所以全部输出，因为全部 都是new出来的，地址值都不一样，所以全部不一样
 * 按照需求，比较成员变量，重写equals()方法。（自动生成）
 *
 *
 * */
public class ArrayListDemo_02 {
    public static void main(String[] args) {
        //创建集合对象：
        ArrayList array = new ArrayList();
        //创建学生对象：
        Student s1 = new Student("林青霞", 27);
        Student s2 = new Student("林志玲", 40);
        Student s3 = new Student("凤姐", 35);
        Student s4 = new Student("芙蓉姐姐", 18);
        Student s5 = new Student("翠花", 16);
        Student s6 = new Student("林青霞", 27);
        Student s7 = new Student("林青霞", 18);
        //添加元素
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        array.add(s5);
        array.add(s6);
        array.add(s7);
        //创建新集合，
        ArrayList newArray = new ArrayList();
        //遍历旧集合，得到每一个元素
        Iterator it = array.iterator();
        while(it.hasNext()){
            Student s = (Student)it.next();
            //拿那个元素到新集合里面找，
            if(!newArray.contains(s)){
                newArray.add(s);    //如果没有，就添加到新集合里面
            }
        }
        //遍历洗集合：
        for(int x = 0 ; x< newArray.size();x++){
            Student s = (Student)newArray.get(x);
            System.out.println(s.getName()+"---" +s.getAge());
        }
    }
}

MyStack

package cn.LinkedList;
import java.util.LinkedList;
/**
 * 自定义栈集合
 * @author dengtonghu
 * @version 1.0
 *
 * */
f
public class MyStack {
    private LinkedList link;
    //构造方法：
    public MyStack(){
        link = new LinkedList();
    }
    //添加功能：
    public void add(Object obj){
        link.addFirst(obj);
    }
    //获取功能
    public Object get(){
        //return link.getFirst();       //只能获取第一个
        return link.removeFirst();      //删除第一个并返回
    }
    //添加判断：
    public boolean isEmpty(){
        return link.isEmpty();
    }
}

泛型：
优点：
1、把运行周期出现的问题提前到了编译期间
2、避免了强制类型转换
3、优化了程序设计，避免了黄色警告线

使用场景：
看API,如果类、接口、抽象类后面跟着有,就说明要使用泛型，一般在集合中使用

package cn.Generic;
import java.util.ArrayList;
import java.util.Iterator;
/**
 * ArrayList存储字符串并遍历
 *
 *  程序出错：
 *      因为在存储的时候，储存了String类型和Integer 两种类型数据
 *      而在遍历的时候，我们都当做String 类型处理做转换，所以报错
 *      编译期间没有报错
 *
 *      数组：
 *      String[] strArray = new String[3];
 *      strArray[0] = "hello";
 *      strArray[1] = "world";
 *      strArray[2] = 10;       //这里就会报错，数据类型不一致，String 和int类型
 *
 *      集合模仿数组的做法，在创建对象的时候明确元素的数据类型，这样就不会出问题了
 *      而这种技术就是 泛型
 *
 *      泛型是一种特殊类型，是一种把类型明确的工作 推迟到创建对象或调用方法的时候 采取明确特殊的类型
 *      参数化类型把类型当做参数一样传递
 *      格式<数据类型>        //此处的数据类型只能是引用类型
 *
 *
 */
public class GenericDemo {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> array = new ArrayList<String>();
        //添加元素
        array.add("hello");
        array.add("world");
        array.add("java");
        //array.add(new Integer(10));
        //array.add(10);      //jdk5以后的自动装箱(自动装箱：把基本类型转为包装类类型.引用类型反之)           这里是引用类型，而其他是字符串类型
        //等价于：array.add(Integer.valueOf(10))
        //遍历
        Iterator<String> it = array.iterator();
        while(it.hasNext()){
            //String s =(String)it.next();
            String s =  it.next();      //明确了数据类型就不需要强转
            System.out.println("s = " + s);
        }
    }
}

//遍历的三种方式：

        //遍历：
        Iterator<Student>  it = array.iterator();        //迭代器
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+"---"+ s.getAge());
        }
        System.out.println("----------------------");
        for(Iterator<Student> IT = array.iterator();IT.hasNext();){
            Student s = IT.next();
            System.out.println(s.getName()+"---"+s.getAge());
        }
        System.out.println("--------------------");
        for(int x= 0; x<array.size(); x++){        //普通for（size和get）
            Student s = array.get(x);
            System.out.println(s.getName()+"---"+s.getAge());
        }

实现类在实现接口的两种情况：

package cn.Genericity.Genericty_04;
/**
 * 实现类在实现接口的时候有两种情况
 *      1、已经知道是什么类型
 *      2、不知道什么类型
 *
 * */
//public class InterImpl implements Inter<String>{
//
//
//    @Override     //不知道类型
//    public void show(String s) {
//        System.out.println("s = " + s);
//    }
//}
public class InterImpl<T> implements Inter<T>{
    @Override           //知道类型
    public void show(T t) {
        System.out.println("t = " + t);
    }
}

泛型高级之通配符

package cn.Genericity.Genericity_05;
import java.util.ArrayList;
import java.util.Collection;
/**
 * ? ：任意类型，如果没有明确，那么就是Object 以及任意java类
 * ? extends E :向下限定，E及其子类 ，不包括父类
 * ? super E    :向上限定，E及其父类，
 * 
 * */
public class GenericityDemo {
    public static void main(String [] args){
        Collection<Object> c1 = new ArrayList<Object>();
        //注意：泛型如果明确写的时候，前后必须一致
//        Collection<Object> c2 = new ArrayList<Animal>();
//        Collection<Object> c3 = new ArrayList<dog>();
//        Collection<Object> s4 = new ArrayList<cat>();
        //<?>表示任意类型都可以
        Collection<?> c5 = new ArrayList<Animal>();
        Collection<?> c6 = new ArrayList<dog>();
        Collection<?> c7 = new ArrayList<cat>();
        //? extends E  :向下限定，E及其子类，不包括父类
        //Collection<? extends Animal> c8 = new ArrayList<Object>();
        Collection<? extends Animal> c9 = new ArrayList<Animal>();
        Collection<? extends Animal> c10 = new ArrayList<dog>();
        Collection<? extends Animal> c11 = new ArrayList<cat>();
        //？super E:向上限定：E及其父类
        Collection<? super Animal> c12 = new ArrayList<Object>();
        Collection<? super Animal> c13 = new ArrayList<Animal>();
        //Collection<? super Animal> s14 = new ArrayList<dog>();
        //Collection<? super Animal> c15 = new ArrayList<cat>();
    }
    //定义一个类：
    class Animal{
    }
    class dog extends Animal{
    }
    class cat extends Animal{
    }
}

增强for

package cn.JDK5;
import java.util.ArrayList;
import java.util.List;
/**
 * JDK5的新特性：
 *      自动拆装箱：
 *          自动装箱：把基本类型转为包装类类型
 *          自动拆箱：把包装类类型转为基本类型
 *
 *      泛型：
 *          看API,如果类、接口、抽象类后面跟着有<E>,就说明要使用泛型，一般在集合中使用
 *
 *      增强for：
 *          是for循环的一种
 *              格式：
 *                  for(元素的数据类型 变量: 数组或者Collection 集合){
 *                      使用变量即可，给变量就是元素
 *                  }
 *            优点：简化了数组和集合的遍历
 *            弊端：增强for的目标不能我null
 *                  解决：对增强for的目标先进行一个不为null的判断然后使用
 *
 *      静态导入
 *      可变参数
 *      枚举
 *
 *
 *
 *
 * */
public class forDemo {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for(int x = 0 ; x<arr.length; x++){
            System.out.print(arr[x]+" ");
        }
        System.out.print("\n"+"--------------------------"+"\n");
        //增强for
        for(int x : arr){
            System.out.print(x+" ");
        }
        System.out.println("\n"+"---------------------------");
        //定义一个字符串数组
        String[] strArray = {"张三","李四","小明","小红"};
        for(String s : strArray){
            System.out.println(s);
        }
        //定义一个集合：
        ArrayList<String> array = new ArrayList<String>();
        array.add("hello");
        array.add("java");
        array.add("world");
        for(String s :array){
            System.out.println(s);
        }
        List<String> list = null;       //NullPointerException控制针异常
        if(list!= null) {
            for (String s : list) {
                //这个s是我从list里面获取的，在获取之前做了一个判断，其实就是迭代器功能
                System.out.println(s);
            }
        }
    }
}

package cn.JDK5;
import java.util.ArrayList;
import java.util.Iterator;
/**
 * ArrayList 存储字符串并遍历（三种方式：迭代器，普通for，增强for）
 */
public class ForDemo_02 {
    public static void main(String[] args) {
        //创建集合：
        ArrayList<String> array = new ArrayList<String>();
        //创建并添加元素
        array.add("hello");
        array.add("world");
        array.add("java");
        //遍历：
        Iterator<String> it = array.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("--------------------------");
        for (Iterator<String> IT = array.iterator(); IT.hasNext(); ) {
            String s = IT.next();
            System.out.println(s);
        }
        System.out.println("---------------------");
        //普通fo
        for (int x = 0; x < array.size(); x++) {
            String s = array.get(x);
            System.out.println(s);
        }
        System.out.println("---------------------------");
        //增强for：
        for (String s : array) {
            System.out.println(s);
        }
    }
}

增强for是用来替代迭代器