1.1. java.util包中提供了一些集合类,这些集合类又被称为容器。
1.2. 关于容器,集合类与数组的不同之处:
固定
的,集合的长度是可变
的;基本类型的数据
,集合用来存放对象的引用
。1.3. 常用的集合有List集合、Set集合和Map集合;
List与Set继承了Collection接口
,各接口
还提供了不同的实现类
。
常用集合类的继承关系如下:
元素
;添加元素、删除元素、管理数据
的方法。下面是一个综合实例,把表中的方法都用一遍:
(Ps:
package com.lzw;
import java.util.*;
public class Muster { // 创建类Muster
public static void main(String args[]) {
Collection<String> list = new ArrayList<>(); // 实例化集合类对象
list.add("a"); // 向集合添加数据
list.add("b");
list.add("c");
list.add("d");
list.add("e");
System.out.println("Now add a&b&c&d&e to the list , its size is:"+list.size());
System.out.println("Print out all element of the list:");
Iterator<String> it = list.iterator(); // 创建迭代器
while (it.hasNext()) { // 判断是否有下一个元素
String str = (String) it.next(); // 获取集合中元素
System.out.println(str);
}
System.out.println("------------------------------------------------");
list.remove("a");
list.remove("b");
list.remove("c");
System.out.println("Now remove a&b&c of the list , its size is:"+list.size());
System.out.println("Print out all element of the list:");
Iterator<String> it1 = list.iterator();
while(it1.hasNext()){
String str = (String)it1.next();
System.out.println(str);
}
System.out.println("Now is the list Empty? "+list.isEmpty());
System.out.println("------------------------------------------------");
list.remove("d");
list.remove("e");
System.out.println("Now remove d&e of the list , its size is:"+list.size());
System.out.println("Now is the list Empty? "+list.isEmpty());
}
}
输出结果:
Now add a&b&c&d&e to the list , its size is:5
Print out all element of the list:
a
b
c
d
e
------------------------------------------------
Now remove a&b&c of the list , its size is:2
Print out all element of the list:
d
e
Now is the list Empty? false
------------------------------------------------
Now remove d&e of the list , its size is:0
Now is the list Empty? true
接口
的所有实现类
。允许重复
,各元素的顺序
就是对象插入的顺序
。索引(元素在集合中的位置)
来访问集合中的元素。List接口继承了Collection接口
,因此包含Collection中的所有方法。
此外,List接口还定义了以下两个非常重要的方法:
get(int index)
:获得指定索引位置的元素;
set(int index,Object obj)
:将集合中指定索引位置的对象修改为指定的对象。
List接口的常用实现类有ArrayList
与LinkedList
.
ArrayList
类
a. 实现了可变的数组
,允许保存所有元素
,包括null
,并可以根据索引位置对集合进行快速的随机访问;
b. 缺点是向指定的索引位置插入对象或删除对象的速度较慢。
LinkedList
类
a.采用链表结构
保存对象。
b.优点是便于向集合中插入和删除对象,需要向集合中插入、删除对象
时,使用LinkedList类实现的List集合的效率较高:
c. 但对于随机访问集合中的对象
,使用LinkedList类实现List集合的效率较低。
使用List集合时通常声明
为List类型,可通过不同的实现类
来实例化
集合。
分别通过ArrayList
、LinkedList
类实例化List集合
,代码如下:
List<E> list = new ArrayList<>();
List<E> list2 = new LinkedList<>();
在上面的代码中,E
可以是合法的Java数据类型
。
例如,如果集合中的元素为字符串类型
,那么E
可以修改为String
。
下面是一个综合实例:
import java.util.*;
public class Gather { // 创建类Gather
public static void main(String[] args) { // 主方法
List<String> list = new ArrayList<>(); // 创建集合对象
list.add("a"); // 向集合添加元素
list.add("b");
list.add("c");
list.add("d");
list.add("e");
int i = (int) (Math.random() * (list.size())); // 获得0~4之间的随机数
System.out.println("随机获取数组中的元素:" + list.get(i));
list.remove(2); // 将指定索引位置的元素从集合中移除
System.out.println("将索引是'2'的元素从数组移除后,数组中的元素是:");
for (int j = 0; j < list.size(); j++) { // 循环遍历集合
System.out.println(list.get(j));
}
}
}
输出结果:
随机获取数组中的元素:c
将索引是'2'的元素从数组移除后,数组中的元素是:
a
b
d
e
不按特定的方式排序
,只是简单地把对象加入集合中
;不能包含重复对象
;Set接口
和Set接口的实现类
组成。Collection接口
,因此包含Collection接口的所有方法
。Set接口常用的实现类有HashSet类
与TreeSet类
。
HashSet
类
a. 实现Set接口
,由哈希表(实际上是一个HashMap实例)
支持。
b. 它不保证Set的迭代顺序
,特别是它不保证该顺序恒久不变
。
c .此类允许使用null元素
。
TreeSet
类
a. 不仅实现了Set接口
,还实现了java.util.SortedSet接口
,
b. 因此,TreeSet类实现的Set集合在遍历集合时
按照自然顺序递增排序
;*********%%%%%%%%%%***********
c. 也可以按照指定比较器
递增排序;
d. 即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。
TreeSet类新增的方法如下表:
几个需要注意的地方:
compareTo()
方法中书写的内容正是TreeSet类实现的Set集合在遍历集合时
那自然顺序递增排序
的依据;compareTo()
方法的前提是要让使用的类实现Comparable接口
;compareTo()
方法中书写的规则进行自然顺序递增排序
,而非add()
的顺序;自然顺序递增排序
之的Set结合,而非add()
的顺序;包含
和不包含
的运用;
(可参考下面实例加深了解)
下面是一个综合实例:
import java.util.*;
public class UpdateStu implements Comparable<Object> {
String name;
long id;
//构造方法
public UpdateStu(String name, long id) {
this.id = id;
this.name = name;
}
//定义排序规则
public int compareTo(Object o) {
UpdateStu upstu = (UpdateStu) o;
int result = id > upstu.id ? 1 : (id == upstu.id ? 0 : -1);
return result;
}
//getter & setter
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public static void main(String[] args) {
UpdateStu stu1 = new UpdateStu("李同学", 01011);//呐!01011是八进制!!!!!!!!!!!!!!!!!
UpdateStu stu2 = new UpdateStu("陈同学", 01021);
UpdateStu stu3 = new UpdateStu("王同学", 01051);
UpdateStu stu4 = new UpdateStu("马同学", 01012);
TreeSet<UpdateStu> tree = new TreeSet<>();
tree.add(stu1);
tree.add(stu2);
tree.add(stu3);
tree.add(stu4);
Iterator<UpdateStu> it = tree.iterator();
System.out.println("Set集合中的所有元素:");
while (it.hasNext()) {
UpdateStu stu = (UpdateStu) it.next();
System.out.println(stu.getId() + " " + stu.getName());
}
System.out.println("李马陈王是自然排序,其对应的对象名顺序是:");
System.out.println("stu1");
System.out.println("stu4");
System.out.println("stu2");
System.out.println("stu3");
System.out.println(" ");
System.out.println("tree.first().getName():" + tree.first().getName());
System.out.println("tree.last().getName():" + tree.last().getName());
System.out.println("------------------------------------------------");
it = tree.headSet(stu3).iterator();
System.out.println("截取stu3前面部分的集合:");
while (it.hasNext()) {
UpdateStu stu = (UpdateStu) it.next();
System.out.println(stu.getId() + " " + stu.getName());
}
System.out.println("------------------------------------------------");
it = tree.subSet(stu2, stu3).iterator();
System.out.println("截取stu2&stu3中间部分的集合");
while (it.hasNext()) {
UpdateStu stu = (UpdateStu) it.next();
System.out.println(stu.getId() + " " + stu.getName());
}
System.out.println("------------------------------------------------");
it = tree.tailSet(stu1).iterator();
System.out.println("截取stu1后面部分的集合");
while (it.hasNext()) {
UpdateStu stu = (UpdateStu) it.next();
System.out.println(stu.getId() + " " + stu.getName());
}
}
}
输出结果:
Set集合中的所有元素:
521 李同学
522 马同学
529 陈同学
553 王同学
李马陈王是自然排序,其对应的对象名顺序是:
stu1
stu4
stu2
stu3
tree.first().getName():李同学
tree.last().getName():王同学
------------------------------------------------
截取stu3前面部分的集合:
521 李同学
522 马同学
529 陈同学
------------------------------------------------
截取stu2&stu3中间部分的集合
529 陈同学
------------------------------------------------
截取stu1后面部分的集合
521 李同学
522 马同学
529 陈同学
553 王同学
最后强调:
TreeSet类
实现的set集合
必须实现Comparable接口
,该接口中的compareTo(Object o)
方法
比较此对象(this/实现本接口的类的实例化对象)
与指定对象(传进来的作为参数的对象)
的顺序;Collection
接口,其提供的是key到value的映射
;key
,每个key
只能映射一个value
;存储对象在映射中的存储位置
,但不是由key对象本身
决定的,而是通过一种“散列技术”
进行处理,产生一个散列码的整数值
;散列码
通常用作一个偏移量
,该偏移量对应分配给映射的内存区域的起始位置
,从而确定存储对象在映射中的存储位置
;下面是一个综合实例:
import java.util.*;
public class UpdateStu {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>(); // 创建Map实例
map.put("01", "李同学"); // 向集合中添加对象
map.put("02", "魏同学");
map.put("03", "王同学");
map.put("04", "陈同学");
map.put("05", "张同学");
map.put("06", "赵同学");
Set<String> set = map.keySet(); // 构建Map集合中所有key对象的集合
Iterator<String> it = set.iterator(); // 创建集合迭代器
System.out.println("key集合中的元素(map.keySet() + iterator()):");
while (it.hasNext()) { // 遍历集合
System.out.println(it.next());
}
System.out.println("------------------------------------------------");
Collection<String> coll = map.values(); // 构建Map集合中所有values值集合
it = coll.iterator();
System.out.println("values集合中的元素(map.values() + iterator()):");
while (it.hasNext()) { // 遍历集合
System.out.println(it.next());
}
System.out.println("------------------------------------------------");
System.out.println("map.get(\"01\")" + map.get("01"));
System.out.println("map.get(\"02\")" + map.get("02"));
System.out.println("map.get(\"03\")" + map.get("03"));
System.out.println("------------------------------------------------");
System.out.println("map.containsKey(\"01\")" + map.containsKey("01"));
System.out.println("map.containsKey(\"10\")" + map.containsKey("10"));
System.out.println("map.containsValue(\"李同学\")" + map.containsValue("李同学"));
System.out.println("map.containsValue(\"许同学\")" + map.containsValue("许同学"));
}
}
输出结果:
key集合中的元素(map.keySet() + iterator()):
01
02
03
04
05
06
------------------------------------------------
values集合中的元素(map.values() + iterator()):
李同学
魏同学
王同学
陈同学
张同学
赵同学
------------------------------------------------
map.get("01")李同学
map.get("02")魏同学
map.get("03")王同学
------------------------------------------------
map.containsKey("01")true
map.containsKey("10")false
map.containsValue("李同学")true
map.containsValue("许同学")false
注意:Map集合中允许值对象是null,而且没有个数限制,例如,可通过“map.put("05",null)”语句向集合中添加对象。
HashMap
和TreeMap
;HashMap类
实现Map集合;HashMap类
实现的Map集合添加和删除映射关系效率更高
;哈希表
的Map接口
的实现;哈希码
对其内部的映射关系进行快速查找
;
TreeMap
中的映射关系存在一定的顺序
;HashMap
类
a .是基于哈希表的Map接口的实现;
b. 此实现提供所有可选的映射操作
,并允许使用null值和null键
,但必须保证键的唯一性
。
c .HashMap通过哈希表对其内部的映射关系进行快速查找
。
d. 此类不保证
映射的顺序,特别是它不保证该顺序恒久不变。
TreeMap
类
a. 不仅实现了Map接口,还实现了java.util.SortedMap接囗,因此,集合中的映射关系具有一定的顺序。
b. 但在添加、删除和定位映射关系
时,TreeMap类比HashMap类性能稍差
。
c. 由于TreeMap类实现的Map集合中的映射关系是根据键对象按照一定的顺序排列
的,因此不允许键对象是null
。
可以通过HashMap类创建Map集合, 当需要顺序输出时,再创建一个完成相同映射关系的TreeMap类实例。如下的综合实例:
首先是一个Emp类文件:
public class Emp {
private String e_id;
private String e_name;
public Emp( String e_id,String e_name) {
this.e_id = e_id;
this.e_name = e_name;
}
public String getE_id() {
return e_id;
}
public void setE_id(String e_id) {
this.e_id = e_id;
}
public String getE_name() {
return e_name;
}
public void setE_name(String e_name) {
this.e_name = e_name;
}
}
测试用主类:
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class MapText { // 创建类MapText
public static void main(String[] args) { // 主方法
Map<String, String> map = new HashMap<>(); // 由HashMap实现的Map对象
Emp emp = new Emp("351", "张三"); // 创建Emp对象
Emp emp2 = new Emp("512", "李四");
Emp emp3 = new Emp("853", "王一");
Emp emp4 = new Emp("125", "赵六");
Emp emp5 = new Emp("341", "黄七");
map.put(emp4.getE_id(), emp4.getE_name()); // 将对象添加到集合中
map.put(emp5.getE_id(), emp5.getE_name());
map.put(emp.getE_id(), emp.getE_name());
map.put(emp2.getE_id(), emp2.getE_name());
map.put(emp3.getE_id(), emp3.getE_name());
// Set<String> set = map.keySet(); // 获取Map集合中的key对象集合
Iterator<String> it = map.keySet().iterator();
System.out.println("HashMap类实现的Map集合,无序:");
while (it.hasNext()) { // 遍历Map集合
String str = (String) it.next();
String name = (String) map.get(str);
System.out.println(str + " " + name);
}
System.out.println( );
TreeMap<String, String> treemap = new TreeMap<>(); // 创建TreeMap集合对象
treemap.putAll(map); // 向集合添加对象
Iterator<String> iter = treemap.keySet().iterator();
System.out.println("TreeMap类实现的Map集合,键对象升序:");
while (iter.hasNext()) { // 遍历TreeMap集合对象
String str = (String) iter.next(); // 获取集合中的所有key对象
String name = (String) treemap.get(str); // 获取集合中的所有values值
System.out.println(str + " " + name);
}
}
}
输出结果:
HashMap类实现的Map集合,无序:
341 黄七
125 赵六
512 李四
853 王一
351 张三
TreeMap类实现的Map集合,键对象升序:
125 赵六
341 黄七
351 张三
512 李四
853 王一
import java.util.*;
public class Text {
public static void main(String[] args) {
List<Integer> list = new LinkedList<>();
for(int i = 1 ;i<=100;i++){
list.add(new Integer(i));
}
list.remove(list.get(10));
System.out.println("ok");
}
}
输出结果:
ok
import java.util.*;
public class Text {
public static void main(String[] args) {
Set<String> set = new HashSet<>(); //HashSet是Set的子接口
set.add("a");
set.add("c");
set.add("A");
set.add("a");
set.add("C");
List<String> list = new ArrayList<>();
list.add("a");
list.add("c");
list.add("A");
list.add("a");
list.add("C");
System.out.println(set);
System.out.println(list);
}
}
输出结果:
[a, A, c, C]
[a, c, A, a, C]
首先是Emp.java:
public class Emp {
private String e_id;
private String e_name;
public Emp( String e_id,String e_name) {
this.e_id = e_id;
this.e_name = e_name;
}
public String getE_id() {
return e_id;
}
public void setE_id(String e_id) {
this.e_id = e_id;
}
public String getE_name() {
return e_name;
}
public void setE_name(String e_name) {
this.e_name = e_name;
}
}
然后是主类:
import java.util.*;
public class Text {
public static void main(String[] args) {
Map<String, String> map = new TreeMap<>();
Emp emp = new Emp("001", "张三");
Emp emp2 = new Emp("005", "李四");
Emp emp3 = new Emp("004", "王五");
Emp emp4 = new Emp("010", "赵六");
Emp emp5 = new Emp("015", "魏七");
map.put(emp.getE_id(), emp.getE_name());
map.put(emp2.getE_id(), emp2.getE_name());
map.put(emp3.getE_id(), emp3.getE_name());
map.put(emp4.getE_id(), emp4.getE_name());
map.put(emp5.getE_id(), emp5.getE_name());
map.remove("015");
for (String string : map.keySet()) {
System.out.println(map.get(string));
}
}
}
输出结果:
张三
王五
李四
赵六
参考资料:《Java从入门到精通》