翔奕时代

A year's plan starts with spring.

0%

Java学习-part.06（集合框架collection-ArrayList、HashSet）

发表于 更新于 分类于 6.5k 6 分钟

集合概述及作用

概念：

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

集合是重点。

集合的作用：

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

Java集合框架体系结构

java

Collection接口、子接口以及实现类

Collection接口

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

List接口以及实现类 – ArrayList （有点类似PHP的索引数组）

  • List是元素有序并且可以重复的集合，被称为序列
  • List可以精确的控制每个元素的插入的位置，或删除某个位置元素
  • ArrayList–数组序列，是List的一个重要实现类 ** (使用频率最高)
  • ArrayList底层是由数组实现的

下面是一个课程类

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.collection;

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

在List集合中加入课程类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.collection;
import java.util.List;

// 往课程类里面添加课程
public class ListCourse {
    //添加课程
    public void addCourse() {
        List list  = new ArrayList();
        Course sc1 = new Course("1","大学英语");
        list.add(sc1);   //添加在第一个位置，下标0处
        Course tmp = (Course)list.get(0);
        System.out.println("加入的课程为：" + tmp.id + ":" + tmp.name);
        
        
        Course sc2 = new Course("2","线性代数");
        list.add(1, sc2);    //根据下标准确插入
        Course tmp1 = (Course)list.get(1);
        System.out.println("加入的课程为：" + tmp1.id + ":" + tmp1.name);
        
        
         //这里会抛出数组下标越界的异常 ***
        //Course str3 = new Course("2","电子商务概论");
        //this.courseToSelect.add(5, str3);
        
         //批量加入
        Course[] courses = {new Course("4","毛概论"),new Course("5","电子商务概论")};
        list.addAll(Arrays.asList(courses)); //批量加入，一定要用数组转成list
        Course tmp3 = (Course)list.get(2);
        Course tmp4 = (Course)list.get(3);900
        
        System.out.println("加入的课程为：" + tmp3.id + ":" + tmp3.name);
        System.out.println("加入的课程为：" + tmp4.id + ":" + tmp4.name);
        
    }
}

//执行结果 

加入的课程为：1:大学英语
加入的课程为：2:线性代数
加入的课程为：4:毛概论
加入的课程为：5:电子商务概论

** list集合泛型的指定：（如果不指定类型，在取出数据的时候，需要按需进行类型强转）

List list = new ArrayList(); //放入的是课程对象
List list = new ArrayList(); //总类Object类，指定里面按只能放入对象
List list = new ArrayList(); //指定里面只能放入字符串

常用的list方法：

1
2
3
4
5
6
7
8
9
10
11
12
List list = new ArrayList();

list.add("test");   //按序添加进集合
list.add(0,"test"); //在指定位置添加进集合
list.addAll(list);  //向集合追加一个collection，只可追加collection，由于java不提供collection的实现，由它的下级list来实现接口
list.addAll(4,list); //与上述含义相同， “4”意为追加元素所放的位置
list.contains("test"); //判断集合里面是否包含某个元素，返回值boolean
list.remove("test"); //删除集合中的某一个元素，参数可以是集合元素，也可以是元素下标
list.set(int index,Object obj); //将集合中指定的索引位置的对象修改为指定的对象
list.get(int index); //获得集合中指定位置的对象
list.size();         //获得集合的长度
list.isEmpty();      //判断集合是否为空，返回值boolean

(更多方法参考java api文档)

List集合的遍历方式

1、for循环遍历

1
2
3
4
5
6
7
8
9
10
11
12
/**
     * for循环遍历
     * @param list
     */
    public void getListValue(List<Course> list) {
    		int size = list.size();
    		System.out.println("课程列表为");
    		for(int i=0;i<size;i++) {
    			Course tmp = list.get(i);
    			System.out.println("课程：" + "下标为：" + i +"->" + tmp.id + ":" + tmp.name);
    		}
    }

2、迭代器方式遍历

1
2
3
4
5
6
7
8
9
10
11
12
/**
    * 迭代器的方式遍历
    * @param list
    */
   public void getList(List<Course> list) {
   		Iterator<Course> it = list.iterator();
   		System.out.println("迭代器的方式课程列表为");
   		while(it.hasNext()) {
   			Course tmp = it.next();
   			System.out.println("课程：" + "下标为："  + tmp.id + ":" + tmp.name);
   		}
   }

3、for each的方式遍历

1
2
3
4
5
6
7
8
9
10
/**
     * for each的方式遍历
     * @param list
     */
    public void getForEach(List<Course> list) {
    		System.out.println("for each的方式课程列表为");
    		for(Course lt : list) {
    			System.out.println("课程：" + "下标为："  + lt.id + ":" + lt.name);
    		}
    }

泛型

集合中的元素，可以使任意类型的对象（对象的引用）

  • 如果把某个对象放入集合，则会忽略他的类型
  • 而把他当做Object来处理

泛型则是规定了某个集合只可以存放特定类型的对象

  • 会在编译期间进行类型检查
  • 可以直接按指定类型获取集合元素
  • ** 泛型集合中，不能添加泛型规定的类型及其子类型以外的对象，否则会报错！
1
2
3
4
5
6
//只可以存放指定的类型
List<String> list = new ArrayList<String>();

List<Course> courses = new ArrayList<Course>();

List<Object> obj = new ArrayList<Object>();

泛型不能使用基本类型，如果必须要用基本类型，请使用包装类

1
2
3
4
5
6
  //泛型不能使用基本类型，如果必须要用基本类型，请使用`包装类`
List<Integer> list = new ArrayList<Integer>();
list.add(12);
int tmp = list.get(0);
	
System.out.println(tmp);

Set接口及其实现类 – HashSet

  • Set是元素无序并且不可以重复的集合，被称为集
  • HashSet–哈希集，是Set的一个重要实现类

下面展示的是一个学生选课的实例：

Course.java

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.collection;

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

Student.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.collection;
import java.util.Set;
import java.util.HashSet;

// 学生类
public class Student {

	public String id;   //学生id
	
	public String name; //学生name
	
	public Set<Course> courses; //学生选课集合
	
	public Student(String id, String name) {
		this.id = id;
		this.name = name;
		this.courses = new HashSet<Course>();
	}
}

StudentSelect.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
package com.collection;

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

public class StudentSelect {
	
	public List<Course> courseToSelect;    //备选课程     
	final int SELECT_NUM = 3;    	      //选课门数

/**
 * main
 * @param args
 */
public static void main(String[] args) {
    StudentSelect ss = new StudentSelect();
    ss.addCourse();
    Student st = new Student("1","小明");
    System.out.println("欢迎学生" + st.name + "选课！");
    //每个学生选三门
    for(int i = 0;i< ss.SELECT_NUM;i++) {  
        System.out.println("请选择第"+ (i+1) +"门课程的ID：");
        
        Scanner input = new Scanner(System.in);
        String inputNum = input.next();
        for(Course tmp : ss.courseToSelect) {
            //备选课程的id与输入的id一致就加入到学生的课程里面
            if(tmp.id.equals(inputNum)) {
                st.courses.add(tmp);
            }
        }
    }
    //遍历已选课程列表
    System.out.println("已选课程为：");
    for(Course kc : st.courses) {
        System.out.println(kc.id + ":" + kc.name);
    }
}
	
/**
 * 添加课程并输出备选课程
 */
public void addCourse() {
        this.courseToSelect = new ArrayList<Course>();
    Course sc1 = new Course("1","大学英语");
    courseToSelect.add(sc1);
    Course sc2 = new Course("2","线性代数");
    courseToSelect.add(1, sc2);
    //批量加入
    Course[] courses = {new Course("4","毛概论"),new Course("5","电子商务概论")};
    courseToSelect.addAll(Arrays.asList(courses));  //不指定下标的addAll
    //批量添加
    Course[] tmps = {new Course("6","统计学"),new Course("7","计算机科学与技术"),new Course("8","C语言")};
    courseToSelect.addAll(Arrays.asList(tmps));
   //输出备选课程
    System.out.println("备选课程为：");
    for(Course cr : courseToSelect) {
            System.out.println(cr.id + ":" + cr.name);
    }
}
}


运行结果：

备选课程为：
1:大学英语
2:线性代数
4:毛概论
5:电子商务概论
6:统计学
7:计算机科学与技术
8:C语言
欢迎学生小明选课！
请选择第1门课程的ID：
1
请选择第2门课程的ID：
7
请选择第3门课程的ID：
8
已选课程为：
1:大学英语
8:C语言
7:计算机科学与技术