浅入深出之Java集合框架（上）

Java中的集合框架（上）

由于Java中的集合框架的内容比较多，在这里分为三个部分介绍Java的集合框架，内容是从浅到深，如果已经有java基础的小伙伴可以直接跳到浅入深出之Java集合框架（下）。

目录

浅入深出之Java集合框架（上）

浅入深出之Java集合框架（中）  

浅入深出之Java集合框架（下）

Java集合框架编程练习小程序——扑克牌小游戏

一、集合概述

1）集合的概念

现实生活中的集合：很多事物凑在一起。

数学中的集合：具有共同属性的事物的总体。

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

2）集合的作用

如果一个类的内部有多相同类型的属性，并且它们的作用和意义是一样的。比如说，一个学生可以选多个课程，对于一个学生类来说，XX课程就是他的一个属性，而xx课程通常不只有一个。对于像这种情况，如果把每一个课程都定一个属性就太繁琐了，这里我们就要用到集合的概念。

    

综上所述，集合的作用有以下几点：

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

3)集合和数组的对比

可以看出集合和数组的功能类似，都是把一系列的数据放入到一个容器中，但是在类的内部我们为什么要用集合而不是数组呢？

1. 数组的长度固定，集合长度可变。集合的优势就在于，集合的长度是随着里面的内容而扩充的，而数组的长度是已经定义好的。
2. 数组只能通过下标访问元素，类型固定（数组下标只能是整形的），而有的集合可以通过任意类型查找所映射的具体对象（key关键字可以是任意类型）。

二、Java集合框架体系结构

我们来简单看一下java集合框架：(还有很多接口和类没有列出，这里只列出常用的接口和类)

如图所示，JAVA集合框架体系结构：Collection与Map是两个根接口。

Collection接口：内部存储的是一个个独立的对象。包含：

1、List接口：序列，存储元素排列有序且可重复。实现类:ArrayList，数组序列；实现类：LinkedList，链表。

2、Queue接口：队列，存储元素排列有序且可重复。实现类：LinkedList，链表。

3、Set接口：集，存储元素无序且不可重复。实现类：HashSet，哈希集。

Map接口：内部以<Key,Value>（任意类型）的一个映射去存储数据，这一个映射就是Entry类（Map的内部类）的实例。包括：实现类：HashMap，哈希表。

Collection接口是List、Set、Queue接口的父接口，Collection接口定义了可用于操作List、Set和Queue的方法--增删改查。（具体的Collection接口的方法可以通过查API，这里就不列举了。）

其中，ArrayList、HashSet和HashMap是使用最多的三个实现类，这里我们将逐个介绍这三个实现类。

在这篇文章中将先介绍ArrayList的用法。

三、ArrayList实现类

List接口及其实现类--ArrayList

List可以精确的控制每个元素的插入位置，或删除某个位置元素；

List有add()插入方法和get()获取方法；

ArrayList--数组序列，是List的一个重要实现类

ArrayList底层是由数组实现的，这也是其名字的由来。

那么如何使用这些集合呢？我们来通过一个小例子，写一个小程序来更直观的学习集合的使用方法。（之后的文章的例子也是基于此的）

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

程序功能——模拟学生选课功能

1. 选择课程（往集合添加课程）
2. 删除所选的某门课程（删除集合中的元素）
3. 查看所选课程
4. 修改所选课程

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

以下是该程序的代码片段，因为是用于测试来介绍集合的使用，所以请不要在意细节，代码会一步步改进的。

1)创建学生类和课程类

 /**
  * 学生类
  * @author hysum
  *
  */
 public class Student implements {
     private String name;//学生姓名
     private String id;//学生id
     private Set courses;//所选课程的set集合

     public Student(){}
     public Student(String id,String name){
         this.id=id;
         this.name=name;
         this.courses=new HashSet();//初始化集合
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public String getId() {
         return id;
     }
     public void setId(String id) {
         this.id = id;
     }
     public Set getCourses() {
         return courses;
     }
     public void setCourses(Set courses) {
         this.courses = courses;
     }

 /**
  * 课程类
  * @author hysum
  *
  */
 public class Course {
 private String id;//课程id
     private String name;//课程名称

     public Course(){

     }
     public Course(String name){
         this.name=name;
     }
     public String getId() {
         return id;
     }
     public void setId(String id) {
         this.id = id;
     }
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public Course(String id,String name){
         this.id=id;
         this.name=name;
     }
 }

2）创建备选课程类

 /**
  * 备选课程类
  *
  * @author hysum
  *
  */
 public class ListCourse {
 private List CoresesToSelect;// 备选课程
     private Student stu;
     private static Scanner in;
     {
         in = new Scanner(System.in);
     }
     public ListCourse() {
         this.CoresesToSelect = new ArrayList();// 初始化List集合
     }
        public List getCoresesToSelect() {
         return CoresesToSelect;
     }

     public void setCoresesToSelect(List coresesToSelect) {
         CoresesToSelect = coresesToSelect;
     }    }

注意：

List是接口，所以在构造方法中不能直接实例化，而通过ArrayList()实例化！！！

例：public List coursesToSelect = new ArrayList();

Set、Map都类似，不可以直接对他实例化，要借助相应的实例化类如HashSet(),HashMap();

3）在备选课程里添加课程

(添加元素)List下总共有4个为List插入元素的方法 ：

1.add(element);

2.add(index,element);

3.addAll(Arrays.asList(对象数组名));

4.addAll(index,Arrays.asList(对象数组名));

以下用代码示例：

 /*
  * 添加备选课程
  */
 public void AddCourse() {
         Course cr1=new Course("1","数据结构");//创建课程对象
     this.CoresesToSelect.add(cr1);//用add(element)添加
         Course temp=(Course)this.CoresesToSelect.get(0);//用get方法取出，注意类型转换
     System.out.println("添加了课程："+temp.getId()+" "+temp.getName());

         Course cr2=new Course("2","C语言");//创建课程对象
     this.CoresesToSelect.add(0,cr2);//用add(index,element)添加
     temp=(Course)this.CoresesToSelect.get(0);
         System.out.println("添加了课程："+temp.getId()+" "+temp.getName());
 }      

 Course[] course = { new Course("1", "数据结构"), new Course("2", "C语言"), new Course("3", "汇编语言"),
                 new Course("4", "离散数学") };
         this.CoresesToSelect.addAll(Arrays.asList(course));//用addAll(Arrays.asList(对象数组名))添加

注意：

1.对象被存入集合都变成object类型了 取出时需要类型强转。（之后会用泛型来解决这个问题）

例：Course temp = (Course)coursesToSelect.get(0);

2.添加进list中的位置（index）介于[0，length]之间；0代表插到队头，length代表插到队尾。

3.如果添加到List中的长度大于他目前的长度，则系统会出现异常，即数组下表越界异常,如：

 Course cr2=new Course("2","C语言");//创建课程对象
 this.CoresesToSelect.add(2,cr2);//用add方法添加,超出集合现有长度 temp=(Course)

4）备选课程取出打印

以下三种方法都是用来取出List中元素的方法：

-----for循环-----

 public void testGet(){
 int size=CoursesToSelect.size();
 for(int i=0;i<size;i++){
 Course cr=(Course) CoursesToSelect.get(i);
 System.out.println("取出的课程："+cr.getId()+":"+cr.getName());
 }
 }

-----迭代器-----

Iterator是一个接口,依赖于集合存在的。

 Iterator it=CourseToSelect.iterator();
 while(it.hasNext()){
 Course cr=(Course) it.next();
 System.out.println("课程:" + cr.id + ":" + cr.name);
 }

-----for each(推荐使用)-----

 for(Object obj:CoursesToSelect){//遍历集合中的每一个元素，作为每一个Object变量
 Course cr=(Course) obj;
 System.out.println("课程:" + cr.id + ":" + cr.name);
 }

5）备选课程修改

使用set（index,Object element）修改元素，index表示索引位置，element表示新对象。

     /*
      * 修改备选课程
      */
     public void Modify(int index, Course c) {// 传入要修改的参数
         this.CoresesToSelect.set(index, c);
     }

6）删除备选课程元素

List中有remove(index),remove(对象值)和removeAll(Arrays.asList(对象数组名))方法来删除容器中元素的值(用法和add类似)。

Course是信息课程类，有id和name属性；courseToSelect是list的序列容器对象。

     /*
      * 删除备选课程，跟添加方法类似
      */
     public void Remove(int index) {// 通过索引位置删除
         this.CoresesToSelect.remove(index);
     }

     public void Remove(Course c) {// 通过课程对象删除
         this.CoresesToSelect.remove(c);

     }

     public void Remove(Course[] c) {// 通过集合对象删除
         this.CoresesToSelect.removeAll(Arrays.asList(c));

     }

注意：

1.remove(index);删除位置要大于0并且小于List(序列容器)的长度。如果要删除全部可以用for循环嵌套此方法。

2.remove(object);先要获得删除的值，用法是先定义一个信息变量通过get()来存放要删除的值,然后用remove(删除的对象值);

3.removeAll(Arrays.asList());要删除指定的多个位置  Arrays.asLIst(对象数组名);作用是把数组转换为集合。用法是先创建信息对象数组存放删除元素的值，然后再用removeAll(Arrays.asList(对象数组名))方法,删除集合数组的元素。

四、应用泛型管理课程

在上面的几个例子中，小伙伴是否发现对于集合的取出和遍历都要将Object对象进行强制转换后才能使用，每次这样做不仅增加了编程难度还使代码特别繁琐，这里我们可以利用泛型来帮助我们更加方便地使用java集合。

首先，我们要知道没有使用泛型的话，集合中的元素,可以是任意类型的对象(对象的引用)，如果把某个对象放入集合,则会忽略他的类型把他当做Object处理。

那么我们就在刚才的例子里往备选课程类里的CoresesToSelect的List集合添加一些奇怪的东西会发什么有趣的事呢？

 　　　/*
      * 往List中添加一些奇怪的东西
      */
      public void testType(){
      System.out.println("能否往List中添加一些奇怪的东西呢?");
      this.CoresesToSelect.add("我不是课程，我是字符串！");
      }

当调用取出课程方法取出该元素时，运行时出错：

这是因为取出该元素时String类型不能强制转换为Course类型，那有什么办法来避免集合中被添加不希望添加的类型呢？

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

泛型：指规定了某个集合只能存放特定类型的对象。

语法：ArrayList<String> array=new ArrayList<String>();  //规定array中只能存放String类型的对象

那么，了解了泛型之后，上面的例子里都可以加上泛型了，修改如下（只列出修改的部分）：（自行对比）

 private Set<Course> courses;//所选课程的set集合
 this.courses=new HashSet<Course>();//初始化集合
 public Set<Course> getCourses() {
         return courses;
     }
     public void setCourses(Set<Course> courses) {
         this.courses = courses;
     }

 private List<Course> CoresesToSelect;// 备选课程
 public ListCourse() {
         this.CoresesToSelect = new ArrayList<Course>();// 初始化List集合
     }
 public List<Course> getCoresesToSelect() {
         return CoresesToSelect;
     }

     public void setCoresesToSelect(List<Course> coresesToSelect) {
         CoresesToSelect = coresesToSelect;
     }

foreach循环的修改：

 for (Course obj : CoresesToSelect) {
     System.out.println("添加了课程：" + obj.getId() + " " + obj.getName());
 }

运用了泛型的话，用foreach语句时 存储变量应该为泛型的类型。for(Course a:courseToSelect),不必再用Object取出再强转，因为已经规定容器里装的都是Course类型。

使用泛型要注意：

1.泛型集合中，不能添加泛型规定的类型和其子类以外的对象，否则会报错！

2.泛型中可以添加规定的类型的子类型的对象。如：

 public void testChild() {
         ChildCourse ccr = new ChildCourse();
         ccr.id = "3";
         ccr.name = "我是子类型的课程对象实例~~";
         courses.add(ccr);
 }

3.不能直接添加基本类型（int,float等）的对象，如果要添加，需要使用其包装类。如：

 public void testBasicType() {
 List<Integer> list = new ArrayList<Integer>();
 list.add(1);
 System.out.println("基本类型必须使用包装类作为泛型！" + list.get(0));
 }

五、通过Set集合管理课程

Set集合和List一样是Collection接口的子接口。它的方法跟List类似，但有稍许不同，因为Set集合是无序且不重复的。

1）添加学生选课的课程

add方法跟ArrayList一样

 li.stu=new Student("1","小明");
         System.out.println("欢迎"+li.stu.getName()+"同学选择课程");
         for(int i=0;i<3;i++){//循环三次添加选课
             System.out.println("请选第"+(i+1)+"门课程：");
             String Id=in.next();
             for(Course c:li.getCoresesToSelect()){
                 if(c.getId().equals(Id)){
                     li.stu.getCourses().add(c);
                 }
             }

         }

注意：Set 中添加某个对象，无论添加多少次，最终只会保留一个该对象（的引用）。同时，保留的是第一次添加的那一个。Set集合是无序的不可重复的。

2）打印输出学生选的课程

 //输出学生选的课程
         for(Course c:li.stu.getCourses()){
             System.out.println(c.getId()+" "+c.getName());

         }

注意：循环遍历Set中的每一个元素只能用foreach或iterator，不能像List一样用get()方法。因为是无序的每次的输出结果都有些差别。

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

总结：

1、Set没有像List中set()方法一样就修改，因为List是有序的，可以指定位置，而Set是无序的，可以用循环遍历方式修改。

2、查询遍历时，Set不能用get()方法去获取，因为无序没有指定索引ID，但可以使用foreach和iterator来遍历，但是每次遍历出来可能顺序都不一样，还是因为无序造成的。

3、Set中的size(),add(),addAll(),remove(),removeAll()与List类似。

4、Set还可以添加null(但只能添加一个null，因为不重复)；

---

本篇主要讲述了List和Set的基本操作：增删改查，下一篇我将介绍Map接口的基本操作，有兴趣的小伙伴可以加一下方的"关注"哦！