JavaSE_第十二章:集合
作者：互联网
JavaSE学习历程
第一章:Java初识
第二章:Java语言基础
第三章:选择结构与分支结构
第四章:循环结构
第五章:方法/函数
第六章:数组
第七章:面向对象
第八章:三大特性
第九章:三个修饰符
第十章:接口
第十一章:常用类
第十二章:集合
1 集合的概念
什么是集合
- 概念:对象的容器,定义了对多个对象进行操作的常用方法.可实现数组的功能.
集合和数组区别
- 数组长度固定,集合长度不固定
- 数组可以存储基本类型和引用类型,集合只能存储引用类型
- 集合位置:java.util.*;
2 Collection体系集合
Collection父接口：
- 特点：代表一组任意类型的对象，无序、无下标。
常用方法：
| 方法 | 描述 |
|---|---|
| boolean add(Object obj) | 添加一个对象数据 |
| boolean addAll(Collection c) | 将一个集合中的所有对象添加到此集合中 |
| void clear() | 清空此集合中的所有对象 |
| boolean contains(Object o) | 检查此集合中是否包含o对象 |
| boolean equals(Object o) | 比较此集合是否与指定对象相等 |
| boolean isEmpty() | 判断此集合是否为空 |
| boolean remove(Object o) | 在此集合中移除o对象 |
| int size() | 返回此集合中的元素个数 |
| Object[] toArray() | 将此集合转换成数组 |
案例
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
/**
* @Classname Demo01
* @Description TODO:1、创建多个Student对象，使用集合Collection进行保存，使用Iterator和增强for进行遍历输出，并输出集合中有多少个值。
* @Date 2021/03/24 10:46
* @Created by xx
*/
public class Demo01 {
public static void main(String[] args) {
// 创建集合保存对象
Collection con = new ArrayList();
con.add(new Student("张三",20));
con.add(new Student("李四",23));
con.add(new Student("王五",25));
con.add(new Student("赵六",27));
//使用增强for遍历:name与age类型不一致--->obje
for (Object object:con) {
Student s = (Student)object;
//使用重写后的toString方法
// System.out.println(object);
System.out.println(s);
}
System.out.println("==================================");
//使用Iterator迭代器遍历
Iterator iterator = con.iterator();
while (iterator.hasNext()){
Student s = (Student) iterator.next();
System.out.println(s);
}
System.out.println("集合共"+con.size()+"个值");
System.out.println("========================================");
/**
* 2、创建多个Student对象，使用集合Collection进行保存，删除后遍历输出，在清空，后判断是否为空。
* */
//删除一个值
Iterator it = con.iterator();
while (it.hasNext()){
Student s = (Student)it.next();
if (s.getName().equals("王五")) {
it.remove();
}
}
for (Object obj:con) {
Student s = (Student)obj;
System.out.println(s);
}
System.out.println("================================");
//清空集合
// con.clear();
//移除本身--->清空集合
con.removeAll(con);
//判断是否为空
System.out.println("集合是否为空:"+(con.isEmpty()?"集合为空":"集合不为空"));
System.out.println("===================================================");
List list = new ArrayList();
list.add("zs");
list.add("ls");
list.add(7);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
/*
运行结果:
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='王五', age=25}
Student{name='赵六', age=27}
==================================
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='王五', age=25}
Student{name='赵六', age=27}
集合共4个值
========================================
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='赵六', age=27}
================================
集合是否为空:集合为空
===================================================
zs
ls
7
*/
/**
* @Classname Student
* @Description TODO:
* @Date 2021/03/24 12:54
* @Created by xx
*/
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object obj) {
//判断地址
if (this == obj) {
return true;
}
//判断类型
if (obj instanceof Student) {
Student s = (Student) obj;
if (this.name.equals(s.getName())&& this.age == s.getAge()) {
return true;
}
}
return false;
}
}
注:遍历的同时不能使用集合删除方法,否则会出现并发修改异常,可以使用迭代器的删除方法.
3 List接口与实现类
3.1 List接口
- 特点:有序、有下标、元素可重复。
- 继承Collection接口。
常用方法:
| 方法 | 描述 |
|---|---|
| void add(int index, Object o) | 在index位置插入对象o。 |
| boolean addAll(int index, Collection c) | 将一个集合中的元素添加到此集合中的index位置。 |
| Object get(int index) | 返回集合中指定位置的元素。 |
| List subList(int fromIndex, int toIndex) | 返回fromIndex和toIndex之间的集合元素。 |
案例:List集合保存对象
/**
* @Classname Demo3
* @Description TODO:3、创建多个Student对象，使用集合List集合保存，进行添加、以下标添加、以下标获取对象并输出，以下标删除，以下标修改值。add(int index, Object o)
* @Date 2021/03/24 12:54
* @Created by xx
*/
public class Demo3 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(0,new Student("张三",20));
list.add(1,new Student("李四",23));
list.add(2,new Student("王五",25));
list.add(3,new Student("赵六",27));
//下标获取对象并输出
for (int i = 0; i < list.size(); i++) {
Student s = (Student) list.get(i);
System.out.println(s);
}
System.out.println("==================================");
//通过下标删除对象
list.remove(1);
for (int i = 0; i < list.size(); i++) {
Student s = (Student) list.get(i);
System.out.println(s);
}
System.out.println("==================================");
//通过下标修改对象
list.set(2,new Student("孙七",18));
Iterator ite = list.iterator();
while (ite.hasNext()){
Student s = (Student) ite.next();
System.out.println(s);
}
System.out.println("==================================");
//判断是否存在
Student s1 = new Student("王五",25);
System.out.println("是否存在:"+(list.contains(s1)?"存在":"不存在"));
}
}
/*
运行结果:
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='王五', age=25}
Student{name='赵六', age=27}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='赵六', age=27}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='孙七', age=18}
==================================
是否存在:存在
Process finished with exit code 0
*/
3.2 List实现类
3.2.1 ArrayList
- 数组结构实现,查询快,增删慢.
- JDK1.2版本、线程不安全
案例:ArraysList集合保存对象
/**
* @Classname TestArrayList
* @Description TODO:4、创建多个Student对象，使用集合ArraysList集合保存，进行添加、以下标添加、以下标获取对象并输出，以下标删除，以下标修改值。
* @Date 2021/03/24 15:35
* @Created by xx
*/
public class TestArrayList {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
//以下标添加对象
arrayList.add(0,new Student("张三",20));
arrayList.add(1,new Student("李四",23));
arrayList.add(2,new Student("王五",25));
arrayList.add(3,new Student("赵六",27));
//以下标获取对象并输出
System.out.println(arrayList.get(1));
System.out.println("===================");
//以下标删除对象
arrayList.remove(2);
for (Object object:arrayList) {
Student s = (Student)object;
System.out.println(s);
}
System.out.println("===================");
//以下标修改对象
arrayList.set(0,new Student("孙七",18));
System.out.println(arrayList.get(0));
System.out.println("===================");
}
}
/*
运行结果:
Student{name='李四', age=23}
===================
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='赵六', age=27}
===================
Student{name='孙七', age=18}
===================
*/
3.2.2 LinkedList
- 链表结构实现,增删快,查询慢.
- JDK1.2版本,线程不安全.
案例:LinkedList保存对象数据。
/**
* @Classname TestLinkedList
* @Description TODO:5、创建多个Student对象，使用集合LinkedList集合保存，进行添加、以下标添加、以下标获取对象并输出，以下标删除，以下标修改值。使用addLast/addFirst/removeFirst/removeLast等方法
* @Date 2021/03/24 15:43
* @Created by xx
*/
public class TestLinkedList {
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
//以下标添加对象
linkedList.add(0,new Student("张三",20));
linkedList.add(1,new Student("李四",23));
linkedList.add(2,new Student("王五",25));
linkedList.add(3,new Student("赵六",27));
//以下标获取对象
System.out.println(linkedList.get(0));
System.out.println("==================================");
//以下标删除对象
linkedList.remove(1);
for (int i = 0; i < linkedList.size(); i++) {
Student s = (Student) linkedList.get(i);
System.out.println(s);
}
System.out.println("==================================");
//以下标修改对象
linkedList.set(2,new Student("孙七",18));
ListIterator ite = linkedList.listIterator();
while (ite.hasNext()){
Student s = (Student) ite.next();
System.out.println(s);
}
System.out.println("==================================");
//使用addLast/addFirst/removeFirst/removeLast等方法
linkedList.addFirst(new Student("周八",28));
linkedList.addLast(new Student("吴九",30));
for (Object obj:linkedList) {
Student s = (Student) obj;
System.out.println(s);
}
System.out.println("==================================");
//移除第一个与最后一个对象
linkedList.removeFirst();
linkedList.removeLast();
for (int i = 0; i < linkedList.size(); i++) {
Student s = (Student) linkedList.get(i);
System.out.println(s);
}
}
}
/*
运行结果:
Student{name='张三', age=20}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='赵六', age=27}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='孙七', age=18}
==================================
Student{name='周八', age=28}
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='孙七', age=18}
Student{name='吴九', age=30}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='孙七', age=18}
*/
ArrayList和LinkedList区别：
- ArrayList存储结构是数据，查找、遍历效率高。
- LinkedList存储结构是双向链表，删除、添加效率高。
3.2.3 Vector
数组结构实现,查询快,增删慢.
JDK1.0版本,线程安全,运行效率比ArrayList较慢.
案例:使用Vector保存数据
import java.util.ListIterator;
import java.util.Vector;
/**
* @Classname TestVector
* @Description TODO:LinkedList集合保存对象数据
* @Date 2021/03/26 17:52
* @Created by xx
*/
public class TestVector {
public static void main(String[] args) {
Vector vector = new Vector();
//以下标添加对象
vector.add(0, new Student("张三", 20));
vector.add(1, new Student("李四", 23));
vector.add(2, new Student("王五", 25));
vector.add(3, new Student("赵六", 27));
//以下标获取对象
System.out.println(vector.get(0));
System.out.println("==================================");
//以下标删除对象
vector.remove(1);
for (int i = 0; i < vector.size(); i++) {
Student s = (Student) vector.get(i);
System.out.println(s);
}
System.out.println("==================================");
//以下标修改对象
vector.set(2, new Student("孙七", 18));
ListIterator ite = vector.listIterator();
while (ite.hasNext()) {
Student s = (Student) ite.next();
System.out.println(s);
}
System.out.println("==================================");
}
}
/*
运行结果:
Student{name='张三', age=20}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='赵六', age=27}
==================================
Student{name='张三', age=20}
Student{name='王五', age=25}
Student{name='孙七', age=18}
==================================2
*/
4 Set接口与实现类
4.1Set接口
- 特点:无序,无下标,元素不可重复.
- 方法:全部继承自Collection中的方法.
- 使用foreach循环遍历:
for(数据类型 局部变量名:集合名){
//循环内部的局部变量,代表当次循环从集合中取出的对象.
}
案例:使用Set接口保存不重复数据.
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
/**
* @Classname TestSet
* @Description TODO:
* @Date 2021/03/25 09:48
* @Created by xx
*/
public class TestSet {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
Scanner input = new Scanner(System.in);
System.out.println("请输入需要存储的字符串");
String s = input.next();
//字符串转字符数组
char[] c = s.toCharArray();
//大写转小写
// char a= 'A';//65---a--->97
// int i =a;
// System.out.println(i);
//大写转小写;小写转大写
for (int i = 0; i < c.length-1; i++) {
if (c[i]>='A'&&c[i]<='Z'){
c[i] += 32;
}else if (c[i]>='a'&&c[i]<='z'){
c[i] -= 32;
}
}
for (Character ch:c) {
//字节转字符串
set.add(ch.toString());
}
//打印去除重复元素后的集合
System.out.println(set);
}
}
/*
运行结果:
请输入需要存储的字符串
jwspgjeoigjslanglkajg
[A, E, G, g, I, J, K, L, N, O, P, S, W]
*/
4.2 Set实现类
4.2.1 HashSet
- 基于HashCode实现元素步重复.
- 当存入元素的哈希码相同时,会调用==或equals进行确认,结果为tru,拒绝后者存入.
案例:HashSet实现不可插入重复的对象(对象属性相同为同一对象)
import java.util.HashSet;
/**
* @Classname TestHashSet
* @Description TODO:HashSet实现不可插入重复的对象(对象属性相同为同一对象)
* @Date 2021/03/25 11:25
* @Created by xx
*/
public class TestHashSet {
public static void main(String[] args) {
HashSet<Student> hashSet = new HashSet<Student>();
hashSet.add(new Student("张三",20));
hashSet.add(new Student("李四",23));
hashSet.add(new Student("王五",25));
hashSet.add(new Student("赵六",27));
System.out.println("插入重复值前:"+hashSet);
System.out.println("============");
hashSet.add(new Student("李四",23));
System.out.println("插入重复值后:"+hashSet);
}
}
/*
运行结果:
插入重复值前:[Student{name='张三', age=20}, Student{name='李四', age=23}, Student{name='赵六', age=27}, Student{name='王五', age=25}]
============
插入重复值后:[Student{name='张三', age=20}, Student{name='李四', age=23}, Student{name='赵六', age=27}, Student{name='王五', age=25}]
*/
注意:
- 根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步。
- 再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表。
- JDK1.8之后引入红黑树，提高效率。
4.2.2 LinkedHashSet
- 链表实现HashSet,按照链表存储,保留元素的插入顺序.
4.2.3 TreeSet
- 基于排列顺序实现元素不重复。
- 实现了SortedSet接口，对集合元素自动排序。
- 元素对象的类型必须实现Comparable接口，指定排序规则（自然排序）。
- 通过CompareTo方法确定是否为重复元素。
案例:treeSet集合实现有序插入
import java.util.Comparator;
import java.util.TreeSet;
/*
* @Classname TestTreeSet
* @Description TODO:treeSet集合实现有序插入
* @Date 2021/03/25 14:33
* @Created by xx
*/
public class TestTreeSet {
public static void main(String[] args) {
//使用comparator比较器实现比较
/*TreeSet<Student> treeSet = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int i = o1.getName().hashCode()- o2.getName().hashCode();
int i1 = o1.getAge().hashCode()- o2.getAge().hashCode();
return i != 0 ? i : i1;
}
});*/
//Student类实现comparable接口--->实现比较
TreeSet<Student> treeSet = new TreeSet<Student>();
treeSet.add(new Student("张三",20));
treeSet.add(new Student("赵六",28));
treeSet.add(new Student("李四",23));
treeSet.add(new Student("李四",23));
treeSet.add(new Student("王五",25));
treeSet.add(new Student("赵六",27));
for (Student stu:treeSet) {
System.out.println(stu);
}
}
}
/*
运行结果:
Student{name='张三', age=20}
Student{name='李四', age=23}
Student{name='王五', age=25}
Student{name='赵六', age=27}
Student{name='赵六', age=28}
*/
注：元素必须要实现Comparable接口,compareTo()方法返回值为0,认为是重复元素。
5 Map接口与实现类
5.1 Map接口的特点
- 用于存储任意键值对(key-Value).
- 键:无下标,不重复(唯一).
- 值:无下标,可以重复.
5.2 Map接口
特点: 称为“映射”存储一对数据(Key-Value)，键不可重复，值可以重复
常用方法:
| 方法名 | 描述 |
|---|---|
| V put(K key,V value) | 将对象存入到集合中，关联键值。key重复则覆盖原值。 |
| Object get(Object key) | 根据键获取对应的值。 |
| Set keySet() | 返回所有key。 |
| Collection values() | 返回包含所有值的Collection集合。 |
| Set<Map.Entry<K,V>> entrySet() | 键值匹配的Set集合。 |
案例:map实现增删改查功能
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @Classname TestMap
* @Description TODO:map实现增删改查功能
* @Date 2021/03/25 15:34
* @Created by xx
*/
public class TestMap {
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
//增
map.put("US", "美利坚合众国");
map.put("EN", "大不列颠及北爱尔兰联合王国");
map.put("JP", "日本国");
map.put("CN", "中华人民共和国");
//查
for (String key : map.keySet()) {
System.out.println(map.get(key));
}
System.out.println("=======================");
//删
map.remove("JP");
for (String key : map.keySet()) {
System.out.println(map.get(key));
}
System.out.println("=======================");
//改
map.put("EN", "英国");
Set<Map.Entry<String, String>> entries = map.entrySet();
System.out.println(entries);
/* for (Map.Entry<String, String> entry : map.entrySet()) {
System.out.println(entry.getKey()+"---------"+entry.getValue());
}*/
}
}
/*
运行结果:
日本国
大不列颠及北爱尔兰联合王国
中华人民共和国
美利坚合众国
=======================
大不列颠及北爱尔兰联合王国
中华人民共和国
美利坚合众国
=======================
[EN=英国, CN=中华人民共和国, US=美利坚合众国]
*/
5.3 Map实现类
5.3.1 HashMap(重点)
- JDK1.2版本，线程不安全，运行效率快。
- 允许用null 作为key或是value。
- 存储结构：哈希表。
案例:HashMap保存对象数据
public class TestHashMap {
public static void main(String[] args) {
//创建集合
HashMap<Student, String> students=new HashMap<Student,String>();
//刚创建hashmap之后没有添加元素 table=null size=0 目的节省空间
//1添加元素
Student s1=new Student("张三", 18);
Student s2=new Student("李四", 20);
Student s3=new Student("王五", 22);
students.put(s1, "北京");
students.put(s2, "上海");
students.put(s3, "杭州");
//students.put(s3, "南京");
students.put(new Student("王五", 22), "杭州");
System.out.println("元素个数:"+students.size());
System.out.println(students.toString());
//2删除
// students.remove(s1);
// System.out.println("删除之后"+students.size());
//3遍历
System.out.println("--------keySet---------");
//3.1使用keySet();
for (Student key : students.keySet()) {
System.out.println(key.toString()+"========="+students.get(key));
}
System.out.println("--------entrySet---------");
//3.2使用entrySet();
for (Map.Entry<Student, String> entry : students.entrySet()) {
System.out.println(entry.getKey()+"---------"+entry.getValue());
}
//4判断
System.out.println(students.containsKey(new Student("张三", 18)));
System.out.println(students.containsValue("杭州"));
}
}
5.3.2 TreeMap
实现了SortedMap接口(Map的子接口)，可以对key自动排序，Key需实现Comparable接口。
案例演示：使用TreeMap保存数据。
public class TestTreeMap {
public static void main(String[] args) {
//新建集合(定制比较)
TreeMap<Student, String> treeMap=new TreeMap<Student,String>();
//1添加元素
Student s1=new Student("张三", 18);
Student s2=new Student("李四", 20);
Student s3=new Student("王五", 22);
treeMap.put(s1, "北京");
treeMap.put(s2, "上海");
treeMap.put(s3, "深圳");
treeMap.put(new Student("王五", 22), "南京");
System.out.println("元素个数:"+treeMap.size());
System.out.println(treeMap.toString());
//2删除
// treeMap.remove(new Student("李四", 20));
// System.out.println(treeMap.size());
//3遍历
//3.1使用keySet
System.out.println("-----keySet()-------");
for (Student key : treeMap.keySet()) {
System.out.println(key+"-------"+treeMap.get(key));
}
System.out.println("------entrySet()--------");
for(Map.Entry<Student, String> entry : treeMap.entrySet()) {
System.out.println(entry.getKey()+"--------"+entry.getValue());
}
//4判断
System.out.println(treeMap.containsKey(new Student("王五", 22)));
}
}
5.3.3 其他实现类
Hashtable:
- jdk1.0版本,线程安全,运行效率慢,不允许`null作为键值.
Properties:- Hashtable的子类,要求key与value都是String.通常用于配置文件的读取.
6 泛型集合
6.1 泛型概念
概念:
- Java泛型是JDK1.5中引入的一个新特性,其本质是参数化类型,把类型作为参数传递.
- 常见形式有泛型类,泛型接口,泛型方法.
语法:
- <T,…> T称为类型占位符,表示一种引用类型.
优点:
- 提高代码的重用性.
- 防止类型转换异常,提高代码的安全性.
案例:
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
/**
* @Classname TestList01
* @Description TODO:
* @Date 2021/03/24 08:36
* @Created by xx
*/
public class TestList01 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
list.add("Hello");
list.add("Learn");
list.remove("Hello");
list.remove(0);
// for (int i = 0; i < list.size(); i++) {
// System.out.println(list.get(i));
// }
// for (String string:list) {
// System.out.println(string);
// }
//for循环
for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
String string = (String) iterator.next();
System.out.println(string);
}
}
}
/*
运行结果:
Hello
Learn
*/
1.泛型只能使用引用类型.2.不同泛型类型对象之间不能相互赋值.
6.2 泛型集合
- 参数化类型,类型安全的集合,强制集合元素的类型必须一致.
- 特点:
- 编译时检查,而非运行时抛出异常.
- 访问时,不必类型转换(拆箱).
- 不同泛型之间引用不能相互赋值,泛型不存在多态.
案例:
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
/**
* @Classname TestList01
* @Description TODO:
* @Date 2021/03/24 08:36
* @Created by xx
*/
public class TestList01 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
list.add("Hello");
list.add("Learn");
list.remove("Hello");
list.remove(0);
// for (int i = 0; i < list.size(); i++) {
// System.out.println(list.get(i));
// }
// for (String string:list) {
// System.out.println(string);
// }
//for循环
for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
String string = (String) iterator.next();
System.out.println(string);
}
}
}
/*
运行结果:
zs
ls
==================
12
18
*/
7 Collections工具类
集合工具类,定义了除了存取之外的集合常用方法.
常用方法:
| 方法 | 描述 |
|---|---|
| public static void reverse(List<?> list) | 反转集合中元素的顺序 |
| public static void shuffle(List<?> list) | 随机重置集合元素的顺序 |
| public static void sort(List<T> list) | 升序排序（元素类型必须实现Comparable接口) |
| public static <T> int binarySearch( list, T key) | 二分查找 |
案例:
import java.util.HashSet;
import java.util.Set;
/**
* @Classname TestSetCollection
* @Description TODO:hashSet实现交集并集差集
* @Date 2021/03/25 10:47
* @Created by xx
*/
public class TestSetCollection {
public static void main(String[] args) {
Set<String> hs = new HashSet<String>();
Set<String> hs2 = new HashSet<String>();
hs.add("java");
hs.add("c");
hs.add("c++");
hs.add("html");
hs.add("css");
hs2.add("css");
hs2.add("html");
hs2.add("js");
hs2.add("layUi");
//交集--->留下两个集合共有的值
hs.retainAll(hs2);
System.out.println(hs);
//添加数据还原初始集合--->方便测试并集与差集
hs.add("java");
hs.add("c");
hs.add("c++");
//差集--->留下比较集合不含的值
hs.removeAll(hs2);
System.out.println(hs);
//添加数据还原初始集合--->方便测试并集
hs.add("html");
hs.add("css");
//并集--->合并两个集合
hs.addAll(hs2);
System.out.println(hs);
}
}
8 复习回顾
map
map不属于Collection体系,为单独的集合体系.
标签：name,age,第十二章,System,println,Student,集合,JavaSE,out 来源： https://blog.csdn.net/YX_SYXS/article/details/115442399