ArrayList、Vector、LinkedList、泛型(Generic)、可变参数、增强for循环

、目录：

ArrayList
Vector
LinkedList
泛型(Generic)
可变参数
增强for循环

ArrayList存储字符串并遍历

​ JDK1.8新增的一个方法也能遍历集合
​ void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常
​

A:案例演示:	ArrayList存储字符串并遍历
		迭代器
		普通for
        ArrayList list = new ArrayList();

        list.add(100);
        list.add(200);
        list.add(300);

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        Iterator it=list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

16.02_集合框架(ArrayList存储自定义对象并遍历)(掌握)

A:案例演示:	ArrayList存储自定义对象并遍历
		迭代器
		普通for
        ArrayList list = new ArrayList();

        list.add(new Shouji("华为"));
        list.add(new Shouji("苹果"));
        list.add(new Shouji("小米"));

        for (int i = 0; i < list.size(); i++) {
            Shouji str=(Shouji)list.get(i);
            System.out.println(str);
        }
        Iterator it=list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

16.03_集合框架(Vector的特有功能)(掌握)

A:Vector类概述:	Vector 类可以实现可增长的对象数组 , Vector 是同步的。 
B:Vector类特有功能
	public void addElement(E obj)
	public E elementAt(int index)
	public Enumeration elements()
C:案例演示:	Vector的特有功能演示
        Vector vector = new Vector();
        vector.add("你好");
        vector.addElement("我不好");

        Object o = vector.get(0);
        Object o1 = vector.elementAt(0);
        System.out.println(o);

        System.out.println(o1);

        Object o2 = vector.firstElement();
        Object o3 = vector.get(vector.size() - 1);
        Object o4 = vector.lastElement();
        System.out.println(o2);
        System.out.println(o3);
        System.out.println(o4);

LinkedList的特有功能

A:LinkedList类概述:  List 接口的链接列表实现 , 此实现不是同步的
B:LinkedList类特有功能
	public void addFirst(E e)及addLast(E e)
	public E getFirst()及getLast()
	public E removeFirst()及public E removeLast()
C:案例演示	
	LinkedList的特有功能演示

用LinkedList模拟栈数据结构的集合并测试

A:案例演示:	需求：请用LinkedList模拟栈数据结构的集合，并测试
        MyList myList = new MyList();

        myList.addEle("aaa");
        myList.addEle("bbb");
        myList.addEle("ccc");

        Object ele = myList.getEle();
        System.out.println(ele);
        Object ele1 = myList.getEle();
        System.out.println(ele1);
        Object ele2 = myList.getEle();
        System.out.println(ele2);

去除ArrayList中重复字符串元素方式

A:案例演示
	需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
	思路：创建新集合方式
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("bbb");
        list.add("bbb");
        list.add("bbb");
        list.add("ccc");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        //采用创建新集合的方式来做
        ArrayList newList = new ArrayList();

        for (int i = 0; i < list.size(); i++) {
            Object obj = list.get(i);
            //去重装到新集合
            String ele= (String) obj;
            if(!newList.contains(ele)){
                newList.add(ele);
            }
        }

        System.out.println(newList);

16.07_集合框架(去除ArrayList中重复自定义对象元素)(掌握)

A:案例演示
	需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)
B:注意事项
	重写equals()方法
	        ArrayList list = new ArrayList();
        list.add(new Student("张三", 23));
        list.add(new Student("张三", 23));
        list.add(new Student("张三", 24));
        list.add(new Student("王五", 25));
        list.add(new Student("王五", 26));
        list.add(new Student("王五", 25));
        list.add(new Student("赵六", 26));

        ArrayList newList = new ArrayList();

        for (int i = 0; i < list.size(); i++) {
           Student stu = (Student) list.get(i);
           if(!newList.contains(stu)){
               newList.add(stu);
           }
        }

        //遍历新集合
        for (int i = 0; i < newList.size(); i++) {
            System.out.println(newList.get(i));
        }

泛型概述和基本使用

A:泛型概述:是一种把类型明确的工作
推迟到创建对象
或者调用方法的时候才去明确的特殊的类型。
参数化类型，把类型当作参数一样的传递。
B:泛型的格式	:	<数据类型>	这里的数据类型只能是引用数据类型
C:泛型好处
	(1): 把运行时期的问题提前到了编译期间
	(2): 避免了强制类型转换
	(3):优化了程序设计，解决了黄色警告线
	注意：泛型只在编译期有效  但在运行期就擦除了
D:泛型基本使用

ArrayList存储字符串并遍历泛型版

A:案例演示:	ArrayList存储字符串并遍历泛型版
        ArrayList<String> list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("bbb");
        list.add("bbb");
        list.add("bbb");
        list.add("ccc");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        //采用创建新集合的方式来做
        ArrayList newList = new ArrayList();

        for (int i = 0; i < list.size(); i++) {
            if(!newList.contains(list.get(i))){
                newList.add(list.get(i));
            }
        }

        System.out.println(newList);

ArrayList存储自定义对象并遍历泛型版)

A:案例演示:	ArrayList存储自定义对象并遍历泛型版
        ArrayList<Student> list = new ArrayList();
        list.add(new Student("张三", 23));
        list.add(new Student("张三", 23));
        list.add(new Student("张三", 24));
        list.add(new Student("王五", 25));
        list.add(new Student("王五", 26));
        list.add(new Student("王五", 25));
        list.add(new Student("赵六", 26));

        Student student = list.get(0);
        System.out.println(student.getName()+"==="+student.getAge());

泛型的由来

	ObjectTool
	泛型的由来:通过Object转型问题引入
	早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。
	也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

泛型类的概述及使用

A:泛型类概述:	        把泛型定义在类上
B:定义格式:		public class 类名<泛型类型1,…>
C:注意事项:		泛型类型必须是引用类型
D:案例演示:		泛型类的使用
- 泛型的应用之泛型类: 就是把泛型定义在类上
- 格式:		public class 类名<数据类型 , ....> {}
public class MyClass<T> { //泛型<T>  我把泛型加在类上
    T t;
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}

泛型方法的概述和使用

A:泛型方法概述:	把泛型定义在方法上
B:定义格式:		public <泛型类型> 返回类型 方法名(泛型类型 变量名)
C:案例演示:		泛型方法的使用
public class MyDemo2<T, U, R> implements MyInterface<T, U, R>{
    @Override
    public R show(T t, U u) {
        return null;
    }
}

}

泛型接口的概述和使用

A:泛型接口概述:	把泛型定义在接口上
B:定义格式:		public interface 接口名<泛型类型>
C:案例演示:		泛型接口的使用
public interface MyInterface<T,U,R> { //泛型接口
    public R show(T t,U u);
}

泛型高级之通配符

A:泛型通配符<?>:		任意类型，如果没有明确，那么就是Object以及任意的Java类了
B:? extends E:			向下限定，E及其子类
C:? super E:			向上限定，E及其父类
D:案例演示:			泛型高级之通配符的基本使用
	/**
	 * 泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致
	 */
	Collection<Object> col1 = new ArrayList<Object>() ;
	Collection<Object> col2 = new ArrayList<Animal>() ;//报错

	// ? 表示任意的数据类型
	Collection<?> col5 = new ArrayList<Object>() ;
	Collection<?> col6 = new ArrayList<Animal>() ;

	// ? extends E : 向下限定	, ? 表示的是E或者E的子类

// Collection<? extends Animal> col9 = new ArrayList() ;//报错
Collection<? extends Animal> col10 = new ArrayList() ;
Collection<? extends Animal> col11 = new ArrayList() ;

	// ? super E:  向上限定 , ? 表示的是E或者E的父类
	Collection<? super Animal> col13 = new ArrayList<Object>() ;
	Collection<? super Animal> col14 = new ArrayList<Animal>() ;

// Collection<? super Animal> col15 = new ArrayList() ;//报错

增强for的概述和使用

A:增强for概述
	简化数组和Collection集合的遍历
B:格式：
	for(元素数据类型 变量 : 数组或者Collection集合) {
		使用变量即可，该变量就是元素
	}
C:案例演示
	数组，集合存储元素用增强for遍历
        int[] arr={20,40,50,60};
        for(int ele:arr){
            System.out.println(ele);
        }
D:好处和注意事项
	简化遍历
	注意事项：增强for的目标要判断是否为null

ArrayList存储字符串并遍历增强for版

A:案例演示:	ArrayList存储字符串并遍历增强for版
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);


        for(Integer ele:list){
            System.out.println(ele);
        }

16.18_集合框架(ArrayList存储自定义对象并遍历增强for版)(掌握)

A:案例演示:	ArrayList存储自定义对象并遍历增强for版
        ArrayList<Student> list = new ArrayList();
        list.add(new Student("张三", 23));
        list.add(new Student("张三", 23));
        list.add(new Student("张三", 24));
        list.add(new Student("王五", 25));
        list.add(new Student("王五", 26));
        list.add(new Student("王五", 25));
        list.add(new Student("赵六", 26));

        for(Student ele:list){
            System.out.println(ele);
        }

可变参数的概述和使用

A:可变参数概述:	定义方法的时候不知道该定义多少个参数
B:格式:			修饰符 返回值类型 方法名(数据类型…  变量名){}
C:注意事项：
	a:	这里的变量其实是一个数组
	b:	如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

	// 可变参数
public static int add(int... a){
	
	// 定义一个累加变量
	int sum = 0 ;
	
	for(int s : a ){
		sum += s ;
	}
	
	return sum;
}

Arrays工具类的asList()方法的使用

A:案例演示:		Arrays工具类的asList(T... t)方法的使用:		将数组转换成集合
	注意事项:	得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)
			只能获取元素(get)
        int[] arr2 = {20, 40, 50, 60};
        //把数组转换成集合
        List<int[]> ints = Arrays.asList(arr2);

集合嵌套之ArrayList嵌套ArrayList

A:需求：
	我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student>
	但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList<Student>。	
	而我现在有多个ArrayList<Student>。也要用集合存储，怎么办呢?
	集合嵌套之ArrayList嵌套ArrayList

	// 定义大的集合
	ArrayList<ArrayList<Student>> allClassList = new  ArrayList<ArrayList<Student>>() ;
	
	// 创建每一个班的集合
	ArrayList<Student> jcClassList = new  ArrayList<Student>() ;