java.

util 包
回顾

每个 Java 程序，都将默认导入 java.lang 包；

对于每个原始数据类型，都有一个与其相对应的包装
类；
使用 String 类和 StringBuffer 类中的常用方法，并区
分 String 类和 StringBuffer 类的不同之处；
Math 类不可以实例化，并且不可继承，其中的方法全
部都是静态方法， 直接通过类名调用；
Object 类是所有的类的最终父类，其中的
equals 、 toString 等方法可以视具体情况决定是否重
写；
通过 Class 类的实例可以检索到有关对象的类描述信
息。
本章相关词汇

单 词 说 明
utility 有用的，实用的
date 日期
calendar 日历，历法
random 随意，任意，胡乱的
list 列表
link 链条，链状物
hash 散乱的，一般指散列码
map 地图
vector 向量，矢量
本章目标

了解 java.util 包
运用如下类进行 Java 编程：
– Date 类
– Calendar 类
– Random 类
使用 Collection 接口及其实现类：
– ArrayList 类
– LinkedList 类
– Vector 类
掌握 HashMap 类
java.util 包简介

java.util 包是 Java 内置的一个工具包，其

中包含一系列常用的工具类；
如处理日期和日历的类以及一些集合类；
java.util 包不会默认导入，如果要使用到
该包中的类，则必须在程序的开始部分显
式地声明如下语句：
import java.util.*;
Date 类

Date 类对象用来表示时间和日期；
该类提供一系列操纵日期和时间各组成部
分的方法；
Date 类最多的用途是获取系统当前的日期
和时间。
Date 类的构造方法

Date 类的构造方法有 6 种重载方式，以下是比

较常用的几种。
构 造 方 法 说 明

Date() 使用系统当前时间创建日期对象

使用自 1970 年 1 月 1 日以后的指定毫秒

Date(long date)
数创建日期对象

Date(int year, int month, int date) 创建指定年、月、日的日期对象 ( 过时 )

Date(int year, int month, int date, 创建指定年、月、日、时、分、秒的日

int hrs, int min, int sec) 期对象 ( 过时 )
Date 类的常用方法

方 法 原 型 说 明

如果当前日期对象在 when 指定的日期对象

boolean after(Date when)
之后，返回 true ，否则返回 false

如果当前日期对象在 when 指定的日期对象

boolean before(Date when)
之前，返回 true ，否则返回 false

设置日期对象，以表示自 1970 年 1 月 1 日
void setTime(long time)
起的指定毫秒数

如果两个日期对象完全相同，返回 true ，
boolean equals(Object obj)
否则返回 false

String toString() 返回日期的格式化字符串，包括星期几

 Date 类示例

public class DateDemo {

public static void main(String[] args) {

Date date = new Date(); // 获得当前的系统日期和时间

System.out.println(" 今天的日期是： " + date);

long time = date.getTime(); // 获得毫秒数

System.out.println(" 自 1970 年 1 月 1 日起以毫秒为单位的时间 (GMT):" + time);

// 截取字符串中表示时间的部分
String strDate = date.toString();
String strTime = strDate.substring(11, (strDate.length() - 4));
System.out.println(strTime);
strTime = strTime.substring(0, 8);
System.out.println(strTime);
}
}
Calendar 类

Calendar 类也是用来操作日期和时间的类，但
它可以以整数形式检索类似于年、月、日之类的
信息；
Calendar 类是抽象类，无法实例化，要得到该
类对象只能通过调用 getInstance 方法来获得；
Calendar 对象提供为特定语言或日历样式实现
日期格式化所需的所有时间字段。
Calendar 类的常用方法

方 法 原 型 说 明
Calendar getInstance() 返回默认地区和时区的 Calendar 对象 (static)

int get(int fields) 返回调用对象中 fields 指定部分的值

void set(int fields, int value) 将 value 中指定的值设置到 fields 指定的部分

将 amount 值添加到 fields 指定的时间或日期部
void add(int fields, int amount)
分
Date getTime() 返回与调用对象具有相同时间的 Date 对象

Object clone() 返回调用对象的副本

void clear() 清除当前对象中所有的时间组成部分

boolean after(Object obj) 如果调用对象时间在 obj 之后，返回 true

boolean before(Object obj) 如果调用对象时间在 obj 之前，返回 true

boolean equals(Object obj) 判断调用对象与 obj 是否相等

Calendar 类示例
public class CalendarDemo {
public static void main(String[] args) {
// 创建包含有当前系统时间的 Calendar 对象
Calendar cal = Calendar.getInstance();

// 打印 Calendar 对象的各个组成部分的值
System.out.print(" 当前系统时间： ");
System.out.print(cal.get(Calendar.YEAR) + " 年 ");
System.out.print((cal.get(Calendar.MONTH) + 1) + " 月 ");
System.out.print(cal.get(Calendar.DATE) + " 日 ");
System.out.print(cal.get(Calendar.HOUR) + ":");
System.out.print(cal.get(Calendar.MINUTE) + ":");
System.out.println(cal.get(Calendar.SECOND));

// 将当前时间添加 30 分钟，然后显示日期和时间
cal.add(Calendar.MINUTE, 30);
Date date = cal.getTime();
System.out.println(" 将当前时间添加 30 分钟后的时间： " + date);
}
}
Random 类

Random 类专门用来生成随机数；
该类的构造方法有 2 种重载方式。

构 造 方 法 说 明

Random() 直接创建一个 Random 类对象

使用 seed 作为随机种子创建一个
Random(long seed)
Random 类对象
Random 类的常用方法

方 法 原 型 说 明

int nextInt() 从随机数生成器返回下一个整型值

long nextLong() 从随机数生成器返回下一个长整型值

从随机数生成器返回 0.0 到 1.0 之间的下一个

float nextFloat()
浮点值

从随机数生成器返回 0.0 到 1.0 之间的下一个

double nextDouble()
双精度值

从随机数生成器返回下一个高斯分布的双精度
double nextGaussian()
值。中间值为 0.0 ，而标准差为 1.0
 Random 类示例

public class RandomDemo {

public static void main(String[] args) {
// 创建一个 Random 类对象
Random rand = new Random();

// 随机生成 20 个随机整数，并将其显示出来
for (int i = 0; i < 20; i++) {
int num = rand.nextInt();
System.out.println(" 第 " + (i + 1) + " 个随机数是： " + num);
}
}
}
集合

集合是将多个元素组成一个单元的对象；
类似于数组，但数组最大的缺点是：长度受到限制（一经
创建，就不可再改变），并且只能存放相同数据类型的元
素；
集合的长度没有限制，可以存放任意多的元素，而且元素
的数据类型也可以不同；
集合还提供一系列操纵数据的方法，如存储、检索等等。
集合框架的优点

提供有用的数据结构和算法，从而减少编
程工作；
提高了程序速度和质量 , 因为它提供了高
性能的数据结构和算法；
允许不同 API 之间的相互操作， API 之
间可以来回传递集合；
可以方便地扩展或改写集合。
java.util 包中的集合类

为了满足不同场合的需要， java.util 包中
包含有一系列集合类；
如： ArrayList 类、 LinkedList
类、 Vector 类、 HashMap 类等等，接下
来将逐一进行介绍；
集合类中只能存放对象，而不能存放原始
数据类型的元素，所以当有原始数据类型
需要存放时，只能将其转换成相应的包装
类对象。
ArrayList 类

ArrayList 是长度可变的对象引用数组，称为动
态数组；
随着元素的添加，元素数目的增大，数组容量也
会随之自动扩展；
访问和遍历数组元素时， ArrayList 的性能优越
；
ArrayList 类继承了 AbstractList 类并实现了 List
接口。
ArrayList 类的构造方法

ArrayList 类的构造方法有 3 种重载方式。

构 造 方 法 说 明

ArrayList() 创建一个空的 ArrayList 对象

ArrayList(Collection c) 根据指定的集合创建 ArrayList 对象

ArrayList(int initialCapacity ) 使用给定的大小创建 ArrayList 对象

ArrayList 类的常用方法

方 法 原 型 说 明
int size() 返回 ArraList 对象的大小，即元素的数量

判断 ArrayList 对象是否为空，为空返回 true ，

boolean isEmpty()
否则返回 false

void clear() 清空 ArrayList 对象中的所有元素

向 ArrayList 对象中添加一个元素，该元素可
boolean add(Object element)
以是任何类的对象

Object remove(int index) 从 ArrayList 对象中删除指定索引位置的元素

Object get(int index) 返回指定索引位置的元素

将元素 elem 存放到由 index 指定的索引位置

Object set(int index, Object elem)
上
判断 element 在 ArrayList 对象中是否存在，
int indexOf(Object element)
存在返回对应的索引，否则返回 -1
ArrayList 类示例 1

public class ArrayListDemo1 {

public static void main(String[] args) {
ArrayList al = new ArrayList(); // 创建一个空 ArrayList 对象
for (int i = 0; i < 10; i++) {
Integer num = new Integer(i); // 创建整型包装类对象
al.add(num); // 将该对象存放到 ArrayList 中
}
System.out.println(" 数组中的元素： ");
for (int i = 0; i < al.size(); i++) {
Integer temp = (Integer)(al.get(i)); // 获得 ArrayList 中索引为 i 的元素
System.out.println(temp);
}
System.out.println("*********************************");
al.clear(); // 清空
System.out.println(" 数组被清空后的情况： ");
System.out.println(" 数组长度为： " + al.size());
if (al.isEmpty()) { // 判断是否为空
System.out.println(" 数组现在为空。 ");
}
else {
System.out.println(" 数组现在不为空。 ");
}
}
}
ArrayList 类示例 2

public class ArrayListDemo2 {

public static void main(String[] args) {
ArrayList al = new ArrayList(); // 创建一个空的 ArrayList 对象
// 往动态数组中添加元素
al.add(" 苹果 "); al.add(" 梨子 "); al.add(" 香蕉 ");
al.add(" 西瓜 "); al.add(" 榴莲 ");
System.out.println(" 目前数组的长度： " + al.size());
for (int i = 0; i < al.size(); i++) {
System.out.println((String)(al.get(i)));
}
String str = new String(" 西瓜 ");
int index = al.indexOf(str); // 判断某个元素是否存在
if (index < 0) {
System.out.println(str + " 在数组中不存在。 ");
} else {
System.out.println(str + " 存在，索引为： " + index);
}
al.remove(3); // 删除某个索引位置的元素
System.out.println(" 删除索引为 3 的元素后的情况： ");
for (int i = 0; i < al.size(); i++) {
System.out.println((String)(al.get(i)));
}
}
}
LinkedList 类

LinkedList 类用于创建链表数据结构；
链表中元素的数量不受任何限制，可以随
意地添加和删除；
与 ArrayList 相比，如果需要频繁地添加和
删除元素， LinkedList 的性能更加优越；
LinkedList 类继承了
AbstractSequentialList 类，并实现了 List
接口；
LinkedList 类的构造方法

LinkedList 类的构造方法有 2 种重载方式。

构 造 方 法 说 明

LinkedList() 创建一个空链表

LinkedList(Collection c) 根据指定的集合创建链表
LinkedList 类的常用方法

方 法 原 型 说 明
int size() 返回链表的大小，即元素的数量

判断链表是否为空，为空返回 true ，否则返

boolean isEmpty()
回 false

void clear() 清空链表中的所有元素，使其成为空链表

向链表中添加一个元素，该元素可以是任何类
boolean add(Object element)
的对象

Object remove(int index) 从链表中删除指定索引位置的元素

Object get(int index) 返回指定索引位置的元素

将元素 elem 存放到由 index 指定的索引位置

Object set(int index, Object elem)
上
判断 element 在链表中是否存在，存在返回对
int indexOf(Object element)
应的索引，否则返回 -1
LinkedList 类的常用方法（续）

方 法 原 型 说 明

void addFirst(Object element) 将指定元素添加到链表的开始处

void addLast(Object element) 将指定元素添加到链表的结尾处

Object removeFirst() 删除链表中的第一个元素

Object removeLast() 删除链表中的最后一个元素

Object getFirst() 返回链表中的第一个元素

Object getLast() 返回链表中的最后一个元素

LinkedList 类示例

public class LinkedListDemo {

public static void main(String[] args) {
LinkedList ll = new LinkedList(); // 创建空的链表
for (int i = 1; i <= 10; i++) {
Double temp = new Double(Math.sqrt(i)); // 创建包装类对象
ll.add(temp); // 将包装类对象添加到链表中
}
System.out.println(" 链表中的元素： ");
// 循环打印链表中的元素
for (int i = 0; i < ll.size(); i++) {
System.out.println(ll.get(i));
}
System.out.println("*********************************");
ll.removeFirst(); // 删除第一个元素
ll.removeLast(); // 删除最后一个元素
System.out.println(" 删除第一个元素和最后一个元素后的链表： ");
for (int i = 0; i < ll.size(); i++) {
System.out.println(ll.get(i));
}
}
}
Vector 类

Vector 类与 ArrayList 类和 LinkedList 类很

相似，最大的区别在于 Vector 是线程同步
的；
如果在多线程的程序中要使用到集合框架
，并且不希望线程与线程之间相互干扰，
那么 Vector 是不错的选择；
Vector 类继承于 AbstractList 类，并实现了
List 接口。
Vector 类的构造方法

Vector 类的构造方法有 4 种重载方式。

构 造 方 法 说 明

创建一个空的 Vector 对象。初始容量为 10 ，

Vector()
容量增量为 0

Vector(Collection c) 根据指定的集合创建 Vector 对象

创建一个 Vector 对象，初始容量由

Vector(int initialCapacity) initialCapacity 指定，容量增量为 0

Vector(int initialCapacity, 创建一个 Vector 对象，初始容量由

initialCapacity 指定，容量增量由
int capacityIncrement) capacityIncrement 指定
Vector 类的常用方法

方 法 原 型 说 明
int size() 返回 Vector 对象的大小，即元素的数量

判断 Vector 对象是否为空，为空返回 true ，

boolean isEmpty()
否则返回 false

void clear() 清空 Vector 对象中的所有元素

向 Vector 对象中添加一个元素，该元素可以
boolean add(Object element)
是任何类的对象

Object remove(int index) 从 Vector 对象中删除指定索引位置的元素

Object get(int index) 返回指定索引位置的元素

将元素 elem 存放到由 index 指定的索引位置

Object set(int index, Object elem)
上
判断 element 在 Vector 对象中是否存在，存
int indexOf(Object element)
在返回对应的索引，否则返回 -1
Vector 类的常用方法（续）

方 法 原 型 说 明
int capacity() 返回 Vector 对象的容量，即元素的个数

void addElement(Object element) 将指定元素插入到 Vector 对象的末尾处

void insertElementAt(Object elem, int index) 将指定元素插入到指定索引位置

void setElementAt(Object elem, int index) 将指定对象替换位于指定索引处的对象

Object ElementAt(int index) 检索位于指定索引处的元素

boolean contains(Object elem) 如果 Vector 对象包含指定元素，返回 true

Object firstElement() 返回 Vector 对象中的第一个元素

Object lastElement() 返回 Vector 对象中的最后一个元素

void removeAllElements() 删除 Vector 对象中的所有元素

void copyInto(Object[] anArray) 将 Vector 对象中的元素复制到指定数组中

void setSize(int newSize) 根据 newSize 的值设置 Vector 对象的容量

Vector 类示例

public class VectorDemo {

public static void main(String[] args) {
Vector vec = new Vector(); // 创建空的 Vector

// 往 Vector 中添加元素
vec.addElement("Java");
vec.addElement("C#");
vec.addElement("Oracle");
vec.addElement("C++");
vec.addElement("HTML");

System.out.println(vec.toString()); // 打印 Vector 中的元素

vec.removeElement("C++"); // 删除其中的元素
System.out.println(vec.toString());
}
}
HashMap 类

HashMap 以键值对的形式存储元素；
对于 HashMap 来说，不存在索引，也就
是说不可以通过索引来访问元素，只能通
过键去访问值，如要快速检索元素的
话， HashMap 性能优越；
由于没有索引，所以 HashMap 中元素的
存放是没有顺序的；
HashMap 类继承了 AbstractMap 类，并
实现了 Map 接口。
HashMap 类的构造方法

HashMap 类的构造方法有 4 种重载方式。

构 造 方 法 说 明

HashMap() 创建一个空的 HashMap 对象

根据指定的 Map 集合创建 HashMap 对

HashMap(Map m)
象

创建一个指定容量和默认负载系数的
HashMap(int initialCapacity)
HashMap 对象

HashMap(int initialCapacity, 创建一个指定容量和指定负载系数的

float loadFactor) HashMap 对象
HashMap 类的常用方法

方 法 原 型 说 明
int size() 返回 HashMap 对象的大小，即元素的个数

判断 HashMap 对象是否为空，为空返回 true ，

boolean isEmpty() 否则返回 false

void clear() 清空 HashMap 对象中的所有元素

向 HashMap 对象中添加一个元素，必须指定
Object put(Object key, Object value) 该元素的键和值

Object remove(Object key) 通过键对象删除相对应的值对象

Object get(Object key) 通过键对象查找相对应的值对象

查找指定的键对象在 HashMap 对象中是否存

boolean containsKey(Object key) 在
查找指定的值对象在 HashMap 对象中是否存
boolean containsValue(Object value) 在
 HashMap 示例

public class HashDemo {

public static void main(String[] args) {
HashMap hm = new HashMap(); // 创建空的 HashMap
// 往 HashMap 中添加元素
hm.put("93-07", " 张三 ");
hm.put("84-12", " 李四 ");
hm.put("102-20", " 王五 ");
hm.put("91-04", " 郑六 ");
hm.put("111-17", " 田七 ");

// 打印出 HashMap 中的元素

System.out.println(hm.toString());
// 通过键对象查找值对象
System.out.println(" 学号 91-04 的学生是 " + hm.get("91-04"));
System.out.println(" 学号 84-12 的学生是 " + hm.get("84-12"));
hm.remove("93-07"); // 通过键对象删除元素
System.out.println(hm.toString());
}
}
总结

java.util 包中包含一系列常用的工具类和集合框
架类；
Date 类和 Calendar 类用来操作日期和时间；
可以使用 Random 类的对象来生成随机数；
集合框架提供了一系列复杂的数据结构和优越的
算法；
ArrayList 类可以创建动态数组；
LinkedList 类可以创建链表结构；
Vector 类可以创建线程同步的动态数组；
HashMap 类可以创建键值对集合。