JAVA学习之路 （十）集合

集合

java中的集合： 是一种工具类，就像是容器，存储任意数量的具有共同属性的对象

集合的作用

1. 在类的内部，对数据进行组织
2. 简单而快速的搜索大量数目的条目
3. 有的集合接口，提供了一系列排列有序的元素，并且可以在序列中进行快速的插入和删除
4. 有些集合接口，提供了映射关系，可以通过关键字key去快速的查找到对应的唯一对象

集合和数组的区别

1. 数组的长度是固定的，但是集合可变
2. 数组只能通过数组下标查找，类型固定，而有的集合可以通过任意类型查找所映射的对象

java集合的框架

Collection 接口

Collection接口 是List、Set、Queue的父接口，

List接口之ArrayList

1. List是元素有序并且可重复的集合，被称为是序列
2. List可以精准控制每个元素的插入和删除
3. ArrayList --数组序列，是一个重要实现类
4. ArrayList底层是数组实现的

ArrayList的增删改查

package com.collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * 备选课程类
 * @author zjj
 * ArrayList的增删改查
 *
 */
public class ListTest {
    private List coursesList; // 备选课程列表
    
    
    public ListTest() {
        this.coursesList = new ArrayList();
    }


    public List getCoursesList() {
        return coursesList;
    }


    public void setCoursesList(List coursesList) {
        this.coursesList = coursesList;
    }
    // 添加课程
    public void listAdd() {
        // 添加一个课程
        course c1 = new course("1", "c语言");
        coursesList.add(c1);
        course temp = (course)coursesList.get(0);
        System.out.println("添加了课程:"+temp.getId()+";"+temp.getName());
        
        
        course cr2=new course("2","数据结构");
        coursesList.add(0,cr2);
        course temp2=(course)coursesList.get(1);
        System.out.println("添加了课程:"+temp2.getId()+";"+temp2.getName());
        /**course cr2=new course("2","C语言");
        coursesList.add(4,cr2);
        报错，数组下标越界*/ 
        
        // 添加一个数组进去
        course [] course = {new course("3","离散"), new course("4","毛概")};
        coursesList.addAll(Arrays.asList(course)); 
        course temp3 = (course) coursesList.get(2);
        course temp4 = (course) coursesList.get(3);
        System.out.println("添加了课程:"+temp3.getId()+";"+temp3.getName());
        System.out.println("添加了课程:"+temp4.getId()+";"+temp4.getName());
        
        course [] course1 = {new course("5","网络"), new course("6","信息")};
        coursesList.addAll(2,Arrays.asList(course1)); 
        course temp5 = (course) coursesList.get(2);
        course temp6 = (course) coursesList.get(3);
        System.out.println("添加了课程:"+temp5.getId()+";"+temp5.getName());
        System.out.println("添加了课程:"+temp6.getId()+";"+temp6.getName());
        
    }
    
    /**
     * for循环遍历List
     */
    public void testGet() {
        int len = coursesList.size(); // 获取到ArrayList的长度
        System.out.println("=========================");
        for(int i = 0; i < len; i++) {
            course temp = (course) coursesList.get(i);
            System.out.println("添加了课程:"+temp.getId()+";"+temp.getName());
        }
        
    }
    /**
     * 通过迭代器来遍历List
     */
    public void Listget() {
        Iterator it = coursesList.iterator(); // 迭代器方法
        System.out.println("==========迭代器===============");
        while(it.hasNext()) {
            course lt = (course) it.next();
            System.out.println("添加了课程:"+lt.getId()+";"+lt.getName());
        }
    }
    
    /**
     * 通过foreach遍历
     */
    
    public void testForEach() {
        System.out.println("==========forEach循环===============");
        for(Object obj :coursesList) {
            course cr = (course) obj;
            System.out.println("添加了课程:"+cr.getId()+";"+cr.getName());
        }
    }
    
    /**
     * 修改课程
     */
    public void modify() {
        coursesList.set(2, new course("10", "修改的name"));
        
    }
    /**
     * 删除课程
     */
    
    public void delete() {
        course cr = (course) coursesList.get(4);
        coursesList.remove(cr);
//        coursesList.remove(4); 效果同上
        
        // 同时删除多个
        course [] courses = {(course) coursesList.get(1), (course) coursesList.get(2)};
        coursesList.removeAll(Arrays.asList(courses));
        
    }
    
}

泛型管理

1.集合中的元素是可以是任意类型的对象，如果把这个对象放入集合，则会忽略它的类别，而把他当作是一个Object来处理，这也就是我们为什么需要进行强制类型转换为course的原因了

2.泛型则是规定了某一个集合中只能存放某些特定类型的对象，会在编译期间进行类型检查，可以直接按照指定的类型获取元素

package com.collection;

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

/**
 * 测试泛型
 * @author zjj
 *
 */
public class testGeneric {
    // 泛型就是在<>中写明规定的类型
    public List<course> courseList;
    
    public testGeneric() {
        this.courseList = new ArrayList<course>();
    }
    
    public void add () {
        course c = new course("1","语文");
        courseList.add(c);
    }
    
    public void forEach() {
        // 注意这里，我们可以直接使用course，不需要先写成Object，再强转
        for(course c: courseList) {
            System.out.println("课程:" +c.getId()+";"+c.getName());
        }
    }
    
    public static void main(String [] args) {
        testGeneric d = new testGeneric();
        d.add();
        d.forEach();
    }
}