java中集合的结构list类型

collection  集合

Collection接口 是List Set和Queue接口的父接口 定义了可用于操作List,Set和Queue的方法---增删改查

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

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() {
    
    }
    //重新equals函数,这个写了一部分不再写了
    /*@Override
    public boolean equals(Object obj) {
       if(this == obj) {
          return true;
       }
       if(obj == null) 
           return false;
       return true;
    }
    */
}

ListTest.java代码(基本的List类型)如下所示：
import java.util.List;
import java.util.ArrayList; //需要引用这个
import java.util.Arrays; //需要引用这个
import java.util.Iterator; //通过迭代器访问
/**
* 备选课程类
*/
public class ListTest
{
    /**
    * 用于存放备选课程的List
    */
    public List coursesToSelect;
    public ListTest(){
      this.coursesToSelect = new ArrayList();
    }
    /**
    * 用于往coursesToSelect中添加备选课程
    */
    public void testAdd() {
      //创建一个课程对象，并通过调用add方法，添加到备选课程List中
      Course cr1 = new Course("1","数据结构");
      coursesToSelect.add(cr1);
      Course temp = (Course)coursesToSelect.get(0);
      System.out.println("添加了课程："+temp.id+":"+temp.name);

      Course cr2 = new Course("2","C语言");
      coursesToSelect.add(0,cr2);
      Course temp2 = (Course)coursesToSelect.get(0);
      System.out.println("添加了课程："+temp2.id+":"+temp2.name);

      coursesToSelect.add(cr1);
      Course temp0 = (Course)coursesToSelect.get(2);
      System.out.println("添加了课程："+temp0.id+":"+temp0.name);
      
      //以下方法会抛出数组下标越界异常
      //Course cr3 = new Course("3","test");
      //coursesToSelect.add(4,cr3);
      Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};
      coursesToSelect.addAll(Arrays.asList(course));
      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));
      Course temp5 = (Course)coursesToSelect.get(2);
      Course temp6 = (Course)coursesToSelect.get(3);
      System.out.println("添加了两门课程："+temp5.id+":"+temp5.name+";"+temp6.id+":"+temp6.name);
    }
    /*
     * 取得List中元素的方法
     * @param args
    */
    public void testGet() {
       int size = coursesToSelect.size();//size()表示取得元素的长度
       for(int i=0;i<size;i++) {
         Course cr = (Course)coursesToSelect.get(i);
         System.out.println("课程："+cr.id+":"+cr.name);
       }
    }
    /*
     * 通过迭代器来遍历List
     * @param args
    */
    public void testIterator() {
       //通过集合的iterator方法，取得迭代器的实例
       Iterator it = coursesToSelect.iterator();
       System.out.println("有如下课程待选(通过迭代器访问):");
       while(it.hasNext()) {
         Course cr = (Course)it.next();
         System.out.println("课程:"+cr.id+":"+cr.name);
       }
    }
    /*
     * 通过for each方法访问集合元素
     * @param args
    */
    public void testForEach() {
       System.out.println("有如下课程待选(通过for each访问):");
       for(Object obj:coursesToSelect) {
          Course cr = (Course)obj;
          System.out.println("课程:"+cr.id+":"+cr.name);
       }
    }
    /*
     * 修改list中的元素
     * @param args
    */
    public void testModify() {
       coursesToSelect.set(4,new Course("7","毛概"));
    }
    /*
     * 删除list中的元素
     * @param args
    */
    public void testRemove() {
       Course cr = (Course)coursesToSelect.get(4);
       System.out.println("我是课程:"+cr.id+":"+cr.name+",我即将被删除");
       coursesToSelect.remove(cr);
       System.out.println("成功删除课程!");
       testForEach();
    }

    /*
     * 往list中添加一些奇怪的东西
     * @param args
    */
    public void testType() {
       System.out.println("能否往List中添加一些奇怪的东西呢!?");
       coursesToSelect.add("我不是课程，我只是一个无辜的字符串!!");
    }
    public static void main(String[] args){
      /*ListTest lt = new ListTest();
      lt.testAdd();
      lt.testGet();
      lt.testIterator();
      lt.testForEach();
      lt.testModify();
      lt.testForEach();
      lt.testRemove();*/
      /*
        D:\javacode>javac ListTest.java
        注: ListTest.java使用了未经检查或不安全的操作。
        注: 有关详细信息, 请使用 -Xlint:unchecked 重新编译。

        D:\javacode>java ListTest
        添加了课程：1:数据结构
      */
      /*
        D:\javacode>java ListTest
        添加了课程：1:数据结构
        添加了课程：2:C语言
        添加了两门课程：3:离散数学;4:汇编语言
        添加了两门课程：5:高等数学;6:大学英语
      */
      ListTest lt = new ListTest();
      lt.testAdd();
      lt.testType();
      lt.testForEach();
    }//main end
}//ListTest end

获取元素可以用get，get的时候可能需要类型转换，尤其是对象的存储写入的时候，因为对象存入集合都变成Object类型了，
取出来时需要类型转换。

带有泛型---Course,的List类型属性

TestGeneric.java代码如下所示：

import java.util.ArrayList;
import java.util.List;

public class TestGeneric
{
   /**
   * 带有泛型---Course,的List类型属性
   */
   public List<Course> courses;
   public TestGeneric() {
      this.courses = new ArrayList<Course>();
   }
   /**
   * 测试添加
   */
   public void testAdd() {
      Course cr1 = new Course("1","大学语文");
      courses.add(cr1);
      //泛型集合中，不能添加泛型规定的类型及其子类型以外的对象，否则会报错
      //courses.add("能否添加一些奇怪的东西呢");
      Course cr2 = new Course("2","Java基础");
      courses.add(cr2);
   }

   /*
     * 测试循环遍历
     * @param args
    */
    public void testForEach() {
       for(Course cr : courses) {
          System.out.println(cr.id+":"+cr.name);
       }
    }

    /*
     * 泛型结合可以添加泛型的子类型的对象实例
     * 这个也把父类Course添加的元素给打印出来了
     * @param args
    */
    public void testChild() {
       ChildCourse ccr = new ChildCourse();
       ccr.id = "3";
       ccr.name = "我是子类型的课程对象实例~~";
       courses.add(ccr);
    }
   /**
   * 泛型不能使用基本类型
   */
   public void testBasicType() {
      List <Integer> list = new ArrayList<Integer>();
      list.add(1);
      System.out.println("基本类型必须使用包装类作为泛型!"+list.get(0));
   }
   /**
   * @param args
   */
    public static void main(String[] args) {
      //System.out.println("都是好的");
      TestGeneric tg = new TestGeneric();
      tg.testAdd();
      tg.testForEach();
      /*
      D:\javacode\code>java TestGeneric
      1:大学语文
      2:Java基础
      */
      tg.testChild();
      tg.testForEach();
      /*
      //这个也把父类Course添加的元素给打印出来了
      1:大学语文
      2:Java基础
      3:我是子类型的课程对象实例~~
      */
      tg.testBasicType();
      //res:基本类型必须使用包装类作为泛型!1
    }//main end
}//TestGeneric end

ChildCourse.java代码如下所示：
public class ChildCourse extends Course
{
}