Java集合框架中List接口的简单使用

　　Java集合框架可以简单的理解为一种放置对象的容器，和数学中的集合概念类似，Java中的集合可以存放一系列对象的引用，也可以看做是数组的提升，Java集合类是一种工具类，只有相同类型的对象引用才可以放到同一个集合中，否则是不能放进去的；

　　集合可以对元素进行简单快速的查找、插入、删除操作

　　某些集合可以有<key value>映射的关系

　　数组的长度是固定的，而集合的长度是跟随元素的个数动态变化的，灵活性和扩展性都比数组更加优越

　　数组只能存放基本类型的数据，而集合存放的是对象引用类型的

　　数组只能通过索引来访问，但是集合的访问则可以通过任意类型查找元素

　　

　　Java中提供了一些接口用于构建集合，根接口主要有：Collection和Map接口

　　Collection接口常用的是3个子接口：List(序列)、Queue(队列)、Set(数据集)；对于这个子接口各有自己的实现方法，来创建引用，常用的：List实现方法是ArrayList方法，Queue实现方法是LinkedList，Set实现方法是HashSet

　　Map接口则可以由HashMap方法直接实现

　　

　　以上是集合的基本概念和Java中常用的集合框架接口，下面来看一个学生选课的简单示例，代码如下：

　　课程类，Course.java

/*
 * 课程类，规定课程结构，用于向集合中传入此类型的元素
 */

public class Course {
    public String id;
    public String name;
    public Course(String id,String name){
        //含参构造方法
        this.id = id;
        this.name = name;
    }
    
    public Course(){
        //无参构造器，为了子类初始化隐式构造方法
    }
}

　　集合操作类，ListTest.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/*
 * 操作课程测试类
 */

public class ListTest {
    public List coursesToSelect;    //定义List接口类型的属性，存放课程
    
    public ListTest(){
        this.coursesToSelect = new ArrayList();    //初始化构造器，通过ArrayList方法实现List接口类型属性初始化
    }
    /*
     * 用于添加课程的方法
     */
    public void testAdd(){
        Course cr1 = new Course("1","数据结构");    //不一个类中，必须实例化课程对象，传入初始值
        coursesToSelect.add(cr1);    //添加属性到List中，位置0
        Course temp1 = (Course) coursesToSelect.get(0);    //取出对应位置的属性，因为取出时全部为Object类型的所以需要转成Course类型的
        System.out.println("添加了课程：" + temp1.id + ":" + temp1.name);
        
        Course cr2 = new Course("2","C语言");
        coursesToSelect.add(0,cr2);    //通过重载的add指定添加位置，会把刚才添加的0位置挤到1位置
        Course temp2 = (Course) coursesToSelect.get(0);    //取出对应位置的属性，因为取出时全部为Object类型的所以需要转成Course类型的
        System.out.println("添加了课程：" + temp2.id + ":" + temp2.name);
        
        //List中元素允许重复，重新添加一次
        coursesToSelect.add(cr1);    //重新添加课程1，索引继续往后排
        Course temp0 = (Course) coursesToSelect.get(2);
        System.out.println("添加了课程：" + temp0.id + ":" + temp0.name);
        
//        Course cr3 = new Course("3","Test");
//        coursesToSelect.add(4,cr3);    //添加索引不能大于当前元素个数，所以最大应该是2，否则会抛出数组下标越界异常
        
        Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};    //创建一个课程类数组，存放多个对象
        coursesToSelect.addAll(Arrays.asList(course));    //把数组转成List传递到courseToSelect属性中
        Course temp3 = (Course) coursesToSelect.get(3);
        Course temp4 = (Course) coursesToSelect.get(4);
        System.out.println("添加了两门课程：" + temp3.id + ":" + temp3.name + "  " + temp4.id + ":" + temp4.name);
        
        Course[] course2 = {new Course("5","高等数学"),new Course("6","算法分析")};
        coursesToSelect.addAll(2,Arrays.asList(course2));    //通过重载的addAll指定添加位置，只是放置多个对象，原有的将会被挤出
        Course temp5 = (Course) coursesToSelect.get(2);
        Course temp6 = (Course) coursesToSelect.get(3);
        System.out.println("添加了两门课程：" + temp5.id + ":" + temp5.name + "  " + temp6.id + ":" + temp6.name);
    }
    
    /*
     * 遍历List中元素的方法
     */
    public void testGet(){
        int size = coursesToSelect.size();    //取得List中的元素个数
        System.out.println("有如下课程：");
        for(int i = 0;i < size;i++){
            Course cr = (Course) coursesToSelect.get(i);
            System.out.println("课程：" + cr.id + ":" + cr.name);
        }
    }
    
    /*
     * 通过迭代器来遍历List中的元素
     */
    public void testIterator(){
        Iterator it = coursesToSelect.iterator();    //通过iterator实现Iterator接口
        System.out.println("有以下课程：");
        //如果下一个元素存在，循环
        while(it.hasNext()){
            Course cr = (Course) it.next();
            System.out.println("课程：" + cr.id + ":" + cr.name);
        }
    }
    
    /*
     * 通过foreach方法遍历List中的元素
     */
    public void testForeach(){
        System.out.println("有以下课程：");
        //因为coursesToSelect中元素都为Object所以foreach循环元素为：Object obj
        for(Object obj:coursesToSelect){
            Course cr = (Course) obj;
            System.out.println("课程：" + cr.id + ":" + cr.name);
        }
    }
    
    /*
     * 修改List中的元素
     */
    public void testModify(){
        coursesToSelect.set(4,new Course("7","操作系统"));    //通过set方法修改相应位置的元素
    }
    
    /*
     * 删除List中的元素
     */
    public void testRemove(){
//        Course cr = (Course) coursesToSelect.get(4);
//        System.out.println("将要删除课程：" + cr.id + ":" + cr.name);
//        //coursesToSelect.remove(4);    //按照索引删除课程
//        coursesToSelect.remove(cr);    //按照传入对象删除课程
//        testForeach();
        System.out.println("将同时要删除索引4和5上的元素：");
        Course[] course = {(Course) coursesToSelect.get(4),(Course) coursesToSelect.get(5)};
        coursesToSelect.removeAll(Arrays.asList(course));    //把对象数组转成List类型，然后批量删除
        testForeach();
        
    }
    
    /*
     * 往List中添加其他类型的时候会出现异常
     */
    public void testType(){
        System.out.println("往List添加其他类型的元素：");
        coursesToSelect.add("string");
        //会报出异常，String类型无法转换成Course类型
    }
    
    public static void main(String[] args){
        ListTest lt = new ListTest();    //实例化对象，并调用构造器初始化
        lt.testAdd();
//        lt.testType();
//        lt.testForeach();
        lt.testGet();
        lt.testIterator();
        lt.testForeach();
        lt.testModify();
        lt.testForeach();
        
        lt.testRemove();
    }
    
}

　　代码比较乱，主要就是体现了怎么定义List引用，通过构造方法初始化List引用，通过add、addAll、get、set、remove、removeAll这些方法来操作List中的元素，同时有一些常见的错误注释中都有说明，然后就是通过3中遍历方式遍历出List中所有元素，值得注意的一点是把属性放入List的引用coursesToSelect属性中时全部会被转换成Object类型，然后取出时也是Object类型的，不是Course类型的，所以每次取出时都要用一次类型强制转换，下一篇文章会解决这种问题，就是使用泛型来解决

　　以上就是List接口的简单使用，另外还有很多方法，这里只是最基本的操作，只要对集合的本质有个明确的理解和认识，其他的具体方法经常去查Java API文档就可以了