Collection接口之List、泛型

Collection接口

• List、Queue、Set的父接口
• 定义了可用于操作List、Set、Queue的方法——增删改查

List接口及其实现类：ArrayList

• List是元素有序且可重复的集合、被称为序列
• List可以精确的控制每个元素的插入位置、或删除指定位置的元素
• ArrayList——数组序列，是List接口的重要实现类
• ArrayList底层由数组实现

List的增加和遍历方法：

import java.util.*;
class ListDemo3 
{
    public static void main(String[] args) 
    {
        List list = new ArrayList();
        add(list);
        //select(list,0);
        testIterator(list);
    }
    //添加
    public static void add(List list)
    {
        course c1 = new course("1","离散数学");
        course c2 = new course("2","JDBC");
        course [] c3 = {new course("3","C语言"),new course("4","高等数学")};        

        list.add(c1);
        list.add(0,c2);//添加到指定位置
        //addAll要接收一个Collction的具体实例，通过Arrays的asList方法将course数组转为List
        list.addAll(Arrays.asList(c3));//添加数组
        list.addAll(0,Arrays.asList(c3));//添加到指定位置（list中的元素是可重复的）
        
    }

    //查找
    public static void select(List list,int a)
    {
        System.out.println("通过get方法访问:");
        //一个对象被添加到集合中去时会将其转为Object类型存储到集合中
        //所以需要将其强转。
        System.out.println(((course)list.get(a)).name);
        //通过for循环遍历list中的元素
        int size = list.size();
        for(int i=0; i<size; i++)
        {
            course c = (course)list.get(i);
            System.out.println(c.id+"..."+c.name);
        }
    }
    //通过迭代器访问
    //collection接口中定义了一个Iterator方法，可以返回一个当前
    //集合对象的迭代器，然后通过迭代器去遍历当前集合中的每一个元素
    //迭代器是用来遍历集合中元素的，本身不具备任何存储元素的功能
    //（迭代器依赖与集合存在本身不能独立存在）
    public static void testIterator(List list)
    {
        Iterator it = list.iterator();
        System.out.println("通过迭代器遍历List:");
        //Iterator是一个接口，其hasNext方法若还有元素则返回真
        while (it.hasNext())
        {
            //Iterator的next方法返回迭代的下一个元素
            course c = (course)it.next();
            System.out.println(c.id+"...."+c.name);
        }
    }
    //通过foreach迭代集合
    public static void testForEach(List list)
    {
        for (Object obj : list)
        {
            course c = (course)obj;
            System.out.println(c.id+"..."+c.name);
        }
    }
}

//课程类
class course
{
    String id;
    String name;
    course(String id, String name)
    {
        this.id = id;
        this.name = name;
    }
}

List的修改和删除方法：

import java.util.*;
class ListDemo4 
{
    public static void main(String[] args) 
    {
        List list = new ArrayList();
        add(list);
        change(list);
        testForeach(list);
        testRemove(list,1);
        testForeach(list);
    }

    public static void add(List list)
    {
        course [] arr =
            {new course("1","JDBC"),new course("2","MySQL"),new course("3","大神")};
        list.addAll(Arrays.asList(arr));
    }
    //List集合修改的方法
    public static void change(List list)
    {
        list.set(1,new course("3","首席技术官"));
    }
    //通过for each遍历集合
    public static void testForeach(List list)
    {
        for(Object obj : list)
        {
            course c = (course)obj;
            System.out.println(c.id+"..."+c.name);
        }
    }
    //List删除的方法
    public static void testRemove(List list,int id)
    {
        //删除单个
        list.remove(id);
        System.out.println("删除了课程");
        //删除单个
        course c1 = (course)list.get(0);
        list.remove(c1);
        //删除多个
        course [] c = {list.get(0),list.get(1)};
        list.removeAll(Arrays.asList(c));
    }

}
//课程类
class course
{
    String id;
    String name;
    course(String id, String name)
    {
        this.id = id;
        this.name = name;
    }
}

泛型：

• 集合中的元素，可以是任意类型的对象（对象的引用）如果把某个对象放入集合，则会忽略它的类型。而把他当做Object处理
• 泛型则是规定了某个集合只可以存放特定类型的对象。会在编译期间进行类型检查，可以直接按指定类型获取集合元素
• 泛型集合中不能添加泛型规定的类型及其子类型以外的对象。
• 泛型集合可以添加泛型的子类型的对象实例
• 泛型集合中的规定类型不能使用基本数据类型，但可以使用包装类

import java.util.*;
class GenericDemo
{
    public static void main(String[] args) 
    {
        //generic();
        generic_1();
    }
    public static void generic()
    {
        List<courses> list = new ArrayList<courses>();
        courses [] arr = {new courses("1","首席技术官"),
            new courses("2","首席架构师"),new courses("3","项目经理"),new courses("4","独当一面")};

        list.addAll(Arrays.asList(arr));
        //泛型能添加泛型规定类型的子类型。
        childCourses cc = new childCourses();
        cc.id="1";
        cc.name="时代的终结者";
        list.add(cc);
        //因为规定了泛型所以可以直接取出来而不用担心类型。
        //list.add("adfas");无法添加泛型规定以外的对象
        for (courses c : list)
        {
            System.out.println(c.id+"："+c.name);
        }
    }
    //基本类型必须使用包装类使用泛型
    public static void generic_1()
    {
        List<Integer> list = new ArrayList<Integer>();

        list.add(1);
        System.out.println("基本类型必须使用包装类作为泛型："+list.get(0));
    }

}
class courses
{
    String name;
    String id;
    courses(String name, String id)
    {
        this.name = name;
        this.id = id;
    }
    courses()
    {
    }
}
class childCourses extends courses
{
    
}

 自定义泛型：

 自定义泛型是一个数据类型的占位符（占着位置的符号）或者说是数据类型的变量

    //自定义泛型的语法规则： 修饰符  <自定义泛型的代表符号>返回值   函数名(使用自定义泛型){}
                          public <T>void reverss(T a){}

//在方法上自定义泛型，一般写T（type）或E（element）
    public static <T>T type(T t){
        return t;
    }

泛型类要注意的事项：

• 1. 在类上自定义泛型的具体数据类型是在使用该类的时候创建对象时候确定的。
• 2. 如果一个类在类上已经声明了自定义泛型，如果使用该类创建对象 的时候没有指定 泛型的具体数据类型，那么默认为Object类型
• 3.在类上自定义泛型不能作用于静态的方法，如果静态的方法需要使用自定义泛型，那么需要在方法上自己声明使用。