Collection集合与泛型

• 集合：集合是java中提供的一种容器，可以用来存储多个数据。
  集合和数组既然都是容器，它们有啥区别呢？
• 数组的长度是固定的。集合的长度是可变的。
• 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。
  
  1. Collection 常用方法

import java.util.Collection;
import java.util.HashSet;
/*
 * `public boolean add(E e)`：  把给定的对象添加到当前集合中 。
 * `public void clear()` :清空集合中所有的元素。
 * `public boolean remove(E e)`: 把给定的对象在当前集合中删除。
 * `public boolean contains(E e)`: 判断当前集合中是否包含给定的对象。
 * `public boolean isEmpty()`: 判断当前集合是否为空。
 * `public int size()`: 返回集合中元素的个数。
 * `public Object[] toArray()`: 把集合中的元素，存储到数组中
*/
public class test {
    public static void main(String[] args) {
        Collection<String> coll=new HashSet<>();
        System.out.println(coll);
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        System.out.println(coll);
        coll.remove("张三");
        boolean r=coll.contains("王五");
        System.out.println(coll);
        boolean r1=coll.isEmpty();
        System.out.println(r1);
        int r2=coll.size();
        System.out.println(r2);
        Object[] arr = coll.toArray();
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }
        coll.clear();
        System.out.println(coll);
    }
}

运行结果

2. Iterator迭代器

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

/*
`public Iterator iterator()`: 获取集合对应的迭代器，用来遍历集合中的元素的。
 `public E next()`:返回迭代的下一个元素。
 `public boolean hasNext()`:如果仍有元素可以迭代，则返回 true。
*/
public class test {
    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        Iterator<String> it = coll.iterator();//获取迭代器的实现对象，并把指针指向-1索引
        while(it.hasNext()){//判断有没有下一个元素
            String name=it.next();//取出下一个元素，把指针向后移动一位
            System.out.println(name);
        }
    }
}

运行结果

增强for循环遍历

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

/*
增强for循环(也称for each循环)是**JDK1.5**以后出来的一个高级for循环，专门用来遍历数组和集合的。
它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
*/
public class test {
    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();
        coll.add("张三");
        coll.add("李四");
        coll.add("王五");
        for (String name:coll) {
            System.out.println(name);
        }
    }
}

3. 泛型
泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。
（1）泛型类修饰符 class 类名<代表泛型的变量> { }

public class GenericClass<D> {//D代表 未知的一种数据类型
    public D name;
    public D getName() {
        return name;
    }
    public void setName(D name) {
        this.name = name;
    }
}

public class test {
    public static void main(String[] args) {
        GenericClass<Integer> gc=new GenericClass<Integer>();//创建一个泛型为Integer的类
        gc.setName(99);
        Integer obj=gc.getName();
        System.out.println(obj);

        GenericClass<String> gc1 = new GenericClass<String>();//创建一个泛型为String的类
        gc1.setName("小廖");
        String obj1 = gc1.getName();
        System.out.println(obj1);
    }
}

（2）泛型方法修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }

public class GenericMethod {
    public <M> void method(M m){
        System.out.println(m);
    }
    public static <S> void method1(S s){
        System.out.println(s);
    }
}

public class test {
    public static void main(String[] args) {
        GenericMethod gm = new GenericMethod();
        gm.method(10);
        gm.method("Nihao");
        gm.method(8.9);
        gm.method(true);

        gm.method1(2222);
        GenericMethod.method1(2333);
    }
}

（3）泛型接口修饰符 interface 接口名<代表泛型的变量> { }

public interface GenericInterface<E> {
    public abstract void add(E e);
    public abstract E getE();
}
//泛型接口实现类第一种
public class GenericInterfaceIml<E> implements GenericInterface<E> {

    @Override
    public void add(E e) {

    }

    @Override
    public E getE() {
        return null;
    }
}
//泛型接口实现类第二种
public class GenericInterfaceIml2 implements GenericInterface<String > {

    @Override
    public void add(String s) {

    }

    @Override
    public String getE() {
        return null;
    }
}

（4）泛型通配符
不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

public class test {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("喜洋洋");
        list.add("灰太狼");

        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(1);
        list2.add(2);

        printArray(list);
        printArray(list2);
    }
    public static void printArray(ArrayList<?> list){//*************
        Iterator<?> it = list.iterator();
        while(it.hasNext()){
            Object o = it.next();
            System.out.println(o);
        }
    }
}

泛型的上限：

• 格式： 类型名称 <? extends 类 > 对象名称
• 意义： 只能接收该类型及其子类

泛型的下限：

• 格式： 类型名称 <? super 类 > 对象名称
• 意义： 只能接收该类型及其父类型

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//报错
    getElement(list3);
    getElement(list4);//报错
  
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}