day02-Collection、泛型

标签的使用

格式：
​ 名字：

名字自己写

必须放在循环语句前面

Collection集合

就是一个“容器”，能够装很多的“引用”

java内部提供了很多的“集合类”，每种集合类对元素的存储采用了不同的“数据结构”–集合存储数据的方式

ArrayList集合用于获取元素比较快，增删较慢

常见的数据结构：
1，数组：ArrayList

​ 2，链表：LinkedList

​ 3，哈希表：HashSet 增删改查都快，但是都要先生成一个哈希值

​ 4， 栈：

​ 5，队列：

​ 6，树：

​ 7，图：

集合体系图：

Collection常用功能

1，添加

​ 1).public boolean add（E e）：把给定的对象添加到集合中

​ 对于ArrayList永远返回true,但是对于set当储存重复的元素时会返回false

2，删除

​ 2).public void clear():清空集合中所有元素

​ 3).public void remove(E e):把给定的对象在当前集合中删除

​ 如果有多个相同的 元素，只移除一个

3.判断

​ 4).public boolean contains(E e):判断当前集合中是否包含给定的对象

​ 5).public boolean isEmpty();判断当前集合是否为空

4，获取

​ 6).public int size();返回集合中元素的个数

​ 7).public Object [] toArray():把集合中的元素，存储到数组中

5.遍历

​ 8).public Iterator iteartor();获取一个迭代器；

迭代器_Iteartor接口的使用

ArrayList<String> list = new ArrayList<>();

    list.add("黄磊");
    list.add("黄晓明");
    list.add("黄宏");
    list.add("黄渤");

    System.out.println(list);

    //获取迭代器
    Iterator<String> it = list.iterator();
    while (it.hasNext()) {
        System.out.println(it.next());
    }
}

迭代器实现原理

个人理解：从集合中拿出元素到迭代器对象中，然后游标往下走，拿出一个元素执行hasNext()–为true就继续游标往下走next()，要是为false就不往下走，结束

迭代器_增强for：

也叫foreach循环，是一种for循环的新写法；

使用它增强for可以遍历数组，集合

1).数组：
        int[] arr = {1,4,234,325,32};
        for(int i = 0;i < arr.length ; i++):
            int n = arr[i];
            System.out.println(n);
        }
        增强for
        for(int n : arr){//底层编译为：普通for循环
            Sytsem.out.println(n);
        }
    2).集合：
        ArrayList<String> list = new ArrayList<>();
        //增强for
        for(String s : list){//底层编译为：迭代器
            System.out.println(s);

泛型

泛型的好处：让编译器为我们代码监督，只能向集合中添加指定类型的数据；如果添加了其它类型数据，编译器会立即编译报错

泛型定义和使用

1).class Student<E>{
            public void add(E e){
            }
            public E get(){
                return null;
            }
       }

中E：可以是大写，小写，也可以是一个字符，多个字符；

类中的方法可以使用这个类型名；

含有泛型的方法

//定义一个方法，可以接收5个相同类型的值
public <T> void sum(T t1,T t2,T t3,T t4,T t5){
    System.out.println("t1 = " + t1);
    System.out.println("t2 = " + t2);
    System.out.println("t3 = " + t3);
    System.out.println("t4 = " + t4);
    System.out.println("t5 = " + t5);
}

public static void main(String[] args) {
    Student stu = new Student();

    stu.<Integer>sum(10,20,30,40,50);
    stu.<String>sum("a", "b", "c", "d", "e");

}

含有泛型的接口

    同泛型类：
        public interface IA<E>{
            public void add(E e);
        }

泛型通配符

需求：定义一个方法，方法的形参：可以接受具有任何泛型的集合

class Demo{
            public static void main(String[] args){
                ArrayList<String> list1 = new ArrayList<>();
                ArrayList<Integer> list2 = new ArrayList<>();
                ArrayList<Student> list3 = new ArrayList<>();
                p1(list1);//OK的
                p1(list2);//OK的
                p1(list3);//OK的
                p1("呵呵");//错误
            }
            public static void p1(ArrayList<?> list){
            }
        }
    2).需求：class Person{}
           class Student extends Person{}
           class JavaStudent extends Student{}

           请定义方法，参数可以接收具有：Student或者JavaStudent泛型的集合：上限
        class Demo{
            public static void main(String[] args){
                ArrayList<Person> list1 = new ArrayList<>();
                ArrayList<Student> list2 = new ArrayList<>();
                ArrayList<JavaStudent> list3 = new ArrayList<>();
                p1(list1);//错误
                p1(list2);//OK的
                p1(list3);//OK的
            }
            public static void p1(ArrayList<? extends Student> list){
            }
        }
    3).需求：定义方法，参数可以接收具有：Person或者Student泛型的集合：下限
        class Demo{
            public static void main(String[] args){
                ArrayList<Person> list1 = new ArrayList<>();
                ArrayList<Student> list2 = new ArrayList<>();
                ArrayList<JavaStudent> list3 = new ArrayList<>();
                p1(list1);//OK的
                p1(list2);//OK的
                p1(list3);//错误
            }
            public static void p1(ArrayList<? super Student> list){
            }
        }