Transcript 第7章Java的工具类

第5章 Java的工具类
5.1 Java语言基础类库
5.2 Applet类与Applet小程序
5.3 Java的数组
5.4 集合类
5.5 Java的字符串
5.6日期和时间类
淮海工学院 计算机课程
学习提要
1. 掌握Java语言的Object类、Math 类、数据类型类、
System类；
2.掌握Applet的工作原理和Applet类的使用；
3. 掌握Java语言的集合框架类、String类及
StringBuffer类、Date类及Calendar类的用法；
淮海工学院 计算机课程
5.1 Java语言基础类库
5.1.1 Object类
Object类是Java程序中所有类的直接或间接父类，也
是类库中所有类的父类。Object类包含了所有Java类的公共
属性，其中的主要方法有：
（1）protected Object clone（）
生成当前对象的一个拷贝，并返回这个复制对象。
（2）public boolean equals（Object obj）
比较两个对象是否相同，是则返回true。
（3）public final Class getClass（）
获取当前对象所属的类信息，返回Class对象。
淮海工学院 计算机课程
（4） protected void finalize（）
定义回收当前对象时所需要完成的清理工作。
（5） public String toString（）
返回当前对象本身的有关信息，按字符串对象返回。
5.1.2
数据类型类
数据类型类
基本数据类型
名称
Boolean
Character
Double
Float
boolean
char
double
float
逻辑型
字符型
双精度型
浮点型
Integer
Long
int
long
整型
长整型
淮海工学院 计算机课程
Integer类的使用
（1）最大值和最小值的限定：
通过 MAX_VALUE域 和 MIN_VALUE域来设定
（2）生成Integer对象的构造函数：
public Integer（int value）：通过int数据生成
public Integer（String s）：通过字符串生成
（3）数据类型转换方法：
将当前对象所对应的int量转换成其他基本数据类型的量，
并返回转换后的值。
public double doubleValue( )
public int intValue( )
public long longValue( )
淮海工学院 计算机课程
(4) 字符串与int量相互转化的方法
1）public String toString（）方法 将当前Integer对象
对应的int量转换成字符串；
2）public static int parseInt（String s）是类的方法，
直接将字符串转化成int量。
例： int i= Integer.parseInt（”345”）；
3） public static Integer valueOf（String s）也是类的
方法，可以将一个字符串转化成一个Integer对象。这个对
象对应的int数值与字符串表示的数值一致。
int i= Integer.valueOf(”345”).intValue（）;
对其他数据类型：
float f= Float. valueOf(”345”).floatValue（）；
淮海工学院 计算机课程
5.1.3 Math类
Math类用来完成一些常用的数学运算,提供了一些static方法,
使用时用类名做前缀就可以直接使用。如：
k=Math.max(9,6);
Math类的主要属性和方法：
public final static double E;
public final static double PI;
//数学常数e
//圆周率常量π
public static double abs(double a);
//绝对值
public static double exp(double a);
//e的a幂
public static double floor(double a); //不大于a的最大整数
public static double log(double a);
//自然对数
淮海工学院 计算机课程
public static double sqrt(double a);
//开平方
public static double random(); //产生0到1之间的随机数
public static double pow(double a, double b ); //乘方
public static double rint(double a);
//四舍五入
public static double IEEEremainder(double a, double b);
数 (取模运算)
public static float min(float a, float b);
//求最小值
public static double max(double a, double b); //求最大值
淮海工学院 计算机课程
// 求余
例 TestMath.java
//Math类与数据类型类的使用示例
import java.awt.Graphics;
import java.applet.Applet;
public class TestMath extends Applet
{
public void paint(Graphics g)
{
double a=Math.sqrt(4),d=Math.rint(3.5);
double p=Math.pow(a,d),r=Math.random(),r1=Math.rint(r*10);
double m=Math.min(4.6,7),n=Math.max(5.5,10.3), n1=Math.min(m,n);
double mod=Math.IEEEremainder(12,5);
// 取余数
int b=Float.valueOf("34.5").intValue(); //字符串转化成整数
float c=Float.valueOf("34.5").floatValue(); //字符串转化成浮点数
String s1=Integer.toString(b);
//整数转化成字符串
String s2=Float.toString(c);
//浮点数转化成字符串
String s3=Double.toString(a);
//双精度数转化成字符串
String s4=Double.toString(p);
String s5=Double.toString(r);
String s6=Double.toString(r1);
String s7=Double.toString(n1);
String s8=Double.toString(mod);
g.drawString("计算结果:",10,20);
g.drawString(s1,10,40);
g.drawString(s2,10,60);
}
}
淮海工学院 计算机课程
5.1.4 System类
(1) 用System类获取标准输入/输出
标准输入 public static InputStream in;
System的属性 标准输出 public static PrintStream out;
标准错误 public static PrintStream err;
例: char c;
try
{
System.out.println("input a character:");
c=(char)System.in.read();
System.out.println("you have inputed: "+c);
}
catch(IOException e)
{
System.err.println(e.toString());
}
淮海工学院 计算机课程
(2) 用System类的方法获取系统信息及完成系统操作
1）public static long currentTimeMillis( )
获取自1970年1月1日零时至当前系统时刻的毫秒数,通
常用来比较两事件发生的先后时间差。
2） public static void exit (int status)
在程序的用户线程执行完之前，强制java虚拟机退出
运行状态，并把状态信息status返回给虚拟机的操作系统，
如：System.exit（0）；//非0为不正常退出
3)
public static void gc( )
强制调用Java虚拟机的垃圾回收功能，收集内存中丢
失的垃圾对象所占用的空间，使其可以被重新加以利用。
淮海工学院 计算机课程
5.2
Applet类与Applet小程序
5.2.1 Applet的基本工作原理
Java Applet是通过兼容Java的Internet浏览器来解释执
行的。
编译好的Java字节码文件保存在特定的WWW服务器上，当
浏览器遇到网页中嵌入的<applet>标记时，就会根据该
Applet的名字和位置自动把字节码从服务器上下载到本地，
并利用浏览器本身拥有的Java解释器直接执行该字节码。
由于有浏览器的支持，Applet不需要建立自己的主流程
框架，也不需要有专门的图形界面。Applet需要做的是接收
和响应浏览器发来的消息或事件。
淮海工学院 计算机课程
5.2.2 Applet类
（1）Applet类简介
它是Java类库中一个重要的系统类，存在于
java.applet包中。Applet类是Java的系统类
java.awt.Panel的子类。
Panel属于一种容器，作用是：
 包容和排列其他的界面元素，如按钮、对话框等
 响应它所包容范围之内的事件，或把事件向更高层次传递。
Applet在此基础上，还具有一些与浏览器和Applet生
命周期有关的专门方法。
淮海工学院 计算机课程
（2）Applet类的主要方法
1）init（）方法
用来完成主类实例的初始化工作。如：创建和初始化程
序运行所需要的对象实例，把图形或字体加载入内存，设置
各种参数，加载图形和声音并播放等。
2）start（）方法
用来启动浏览器运行Applet的主线程。浏览器在调用init
（）方法初始化Applet类的实例之后，接着会自动调用
start（）方法，除此之外，start（）方法在Applet被重新
启动时也会被系统自动调用。
3）stop（）方法
类似于start（）方法的逆操作，当用户浏览其它页面，
或切换到其他系统应用时，浏览器将自动调用stop（）方法
暂停执行Applet的主线程。
淮海工学院 计算机课程
4）paint（）方法
主要用来在Applet的界面中显示文字、图形和其他界面
元素，也是浏览器自动调用的方法。导致浏览器调用paint
（）方法的事件主要有三种：
 Applet被启动后，自动调用paint（）来重新描绘自己的界
面；
 Applet所在的浏览器窗口改变时，要求自动调用paint（）
来重画界面；
 Applet的其他方法被调用时，系统也会调用此方法。
paint（）方法有一个固定的参数——Graphics类的对象g。
Graphics类是用来完成一些较低级的图形用户界面操作的类，
其中包括画圆、点、线、多边形及显示简单文本。
淮海工学院 计算机课程
5）destroy（）方法
当用户退出浏览器时，浏览器自动调用Applet 实例的
destroy（）方法完成释放资源、关闭连接之类的操作。
Applet的生命周期与主要方法
下载并
实例化
Applet
init（）初始化
start（）启动
启动Applet
Applet转入后台
重新激活
Applet
stop（）中止
destroy( )消亡
退出浏览器
淮海工学院 计算机课程
例 LifeCycle.java
import java.applet.*;
import java.awt.*;
public class LifeCycle extends Applet
//定义主类是Applet的子类
{
//定义各计数器
private int InitCnt;
private int StartCnt;
private int StopCnt;
private int DestroyCnt;
private int PaintCnt;
public LifeCycle()
//构造函数
{
//各计数器初始化
InitCnt = 0; StartCnt = 0;
StopCnt = 0;DestroyCnt = 0;PaintCnt = 0;
}
public void init()
{
InitCnt++;
// init()方法执行次数加一
}
public void destroy()
{
DestroyCnt++;
// destroy ()方法执行次数加一
}
public void start()
{
StartCnt++;
// start()方法执行次数加一
}
public void stop()
{
StopCnt++;
// stop()方法执行次数加一
}
淮海工学院 计算机课程
public void paint(Graphics g)
{
PaintCnt++;
// paint()方法执行次数加一，画出坐标轴和标尺
g.drawLine(20,200,300,200);
g.drawLine(20,200,20,20);
g.drawLine(20,170,15,170);
g.drawLine(20,140,15,140);
g.drawLine(20,110,15,110);
g.drawLine(20,80,15,80);
g.drawLine(20,50,15,50);
g.drawString("Init()",25,213);
g.drawString("Start()",75,213);
g.drawString("Stop()",125,213);
g.drawString("Destroy()",175,213);
g.drawString("paint()",235,213); //用矩形块高度显示各种方法被调用次数
g.fillRect(25,200-InitCnt*30,40,InitCnt*30);
g.fillRect(75,200-StartCnt*30,40,StartCnt*30);
g.fillRect(125,200-StopCnt*30,40,StopCnt*30);
g.fillRect(175,200-DestroyCnt*30,40,DestroyCnt*30);
g.fillRect(235,200-PaintCnt*30,40,PaintCnt*30);
}
}
淮海工学院 计算机课程
5.2.3 HTML文件参数传递
Applet通过标记<APPLET> </APPLET>嵌入在HTML文件中，
<APPLET> 至少需要包括三个参数：code、height、width。
其它可选参数如下：
（1）codebase
当Applet字节码文件的保存位置与所嵌入的HTML文档不
同时，需要用此参数指明字节码文件的位置，该位置用URL
格式表示。
（2）alt
如果浏览器不包含Java解释器，则不能执行字节码文件，
此时可用alt参数告诉用户此浏览器不支持Java。
（3）align
表示Applet界面区域在浏览器窗口中的对齐方式。
淮海工学院 计算机课程
HTML文件可以通过标记<PARAM>向它所嵌入的Applet传递参
数，使Applet的运行更加灵活。
格式为：
<PARAM name=x
value=“这是一个字符串参数”>
<PARAM>标记只能传递一个字符串类型的参数。
Applet利用getParamter（）方法来获取HTML传递来的参数，
方法中用name指定的参数名。
格式： getParamter（” x ”）
淮海工学院 计算机课程
例：MyApplet_param.java
import java.applet.Applet ;
import java.awt.Graphics ;
public class MyApplet_param extends Applet
//定义主类
{
private String s = "" ;
//用于接收HTML参数的程序变量
private int x ;
private int y ;
public void init ( )
{
s = getParameter ( "vstring" ) ;
//接收HMTL中传递的参数
x = Integer.parseInt ( getParameter ( "x" ) ) ;
y = Integer.parseInt ( getParameter ( "y" ) ) ;
}
public void paint ( Graphics g )
{
if(s != null)
g.drawString (s,x,y);
}
}
************************
<HTML> <BODY>
<APPLET code = "MyApplet_param.class" height=200 width = 300>
<PARAM name = vstring value = "我是来自HTML的参数">
<PARAM name = x
value = 50>
<PARAM name = y
value = 100>
</APPLET>
</BODY></HTML>
淮海工学院 计算机课程
5.3 Java的数组
5.3.1 声明数组
作用：声明数组的名称和数组所包含的元素的数据类型。
语法：
格式1： 数组元素类型
数组名[ ]；
格式2： 数组元素类型[ ] 数组名；
方括号[ ]是数组的标志，推荐采用格式2。
如：一维数组：int[] MyArray；
D200_Card[ ] ArrayOf200Card;
二维数组：
int[][] MyArray=new int[4][5]；
淮海工学院 计算机课程
5.3.2 创建数组空间
定义好的数组必须创建数组空间后才可以使用。Java不支持
变长的数组，所以在创建数组空间时必须指明数组的长度，
以确定所开辟内存空间的大小。
语法格式：
数组名= new 数组元素类型[数组元素的个数]
例：MyArray=new int[10]；
ArrayOf200Card=new D200_Card[15];
 数组声明可以和创建数组空间同时完成，如：
int[ ] MyArray=new int[10]；
D200_Card [ ] ArrayOf200Card=new D200_Card[15];
如果数组元素类型是基本数据类型，可以在创建数组空间的
同时赋初值，如：
int[ ] MyArray={1,2,3,4,5,6,7,8,9,10 }
淮海工学院 计算机课程
5.3.3 创建数组元素并初始化
若数组元素类型为基本数据类型,本步骤可以省略.
对于以某一类对象为数组元素的数组，则必须创建并利用
构造函数来初始化每个数组元素，一般用循环结构来完成。
例：for ( int i=0; i<ArrayOf200Card . length;i++)
{
ArrayOf200Card[i]= new
D200_Card(200180000+i, 1111, 50.0, ”200”, 0.10);
}
淮海工学院 计算机课程
Java中数组使用注意事项：
（1）数组元素的下标从0开始，至数组元素个数-1个为止；
下标必须是整型数或是可以转化成整型的量。
（2）所有数组都有一个属性length，存储的是数组元素的个
数；
（3）Java系统能自动检查数组下标是否越界。利用length-1
作为下标的上界可以避免越界。
（4）Java中的数组实际上是一种隐含的“数组类”的实例，
每个数组名是对该实例的一个引用，而数组的每个元素是
对数组元素类实例的引用，所以新建数组时要有创建数组
和创建数组元素两个步骤。
淮海工学院 计算机课程
例：UseArray.java
//使用数组显示图片：
import java.applet.Applet;
import java.awt.*;
public class UseArray extends Applet
{ Image[] m_Images; //定义元素类型为Image的数组,保存图片
int totalImages=10;
int currentImage=0;
Label child;
public void init()
{
child=new Label("还记得自己天真浪漫的童年吗？");
add(child);
m_Images=new Image[totalImages]; //创建数组,分配内存空间
for(int i=0;i<totalImages;i++)
m_Images[i]=getImage(getDocumentBase(),
“images\\baby”+(i+1)+“.jpg”); //数组元素赋值
}
淮海工学院 计算机课程
public void start()
{
currentImage=0;
}
public void paint(Graphics g)
{
g.drawImage(m_Images[currentImage],50,50,this);
currentImage=++currentImage%totalImages;
try{
Thread.sleep(1000); //图片显示的时间间隔
}
catch(InterruptedException e)
{ showStatus(e.toString());
}
repaint();
}
}
淮海工学院 计算机课程
5.4 集合(Collections)类
5.4.1 集合类概述
集合(Collections)是能够存储其它对象的对象，所以也
称容器。集合中只能存储对象，不能存储基本类型的数据。
集合中的对象也称为元素;
 集合都能自动扩容,而且通过其上的迭代器(Iterator)可方
便地对集合中包含的元素进行遍历。
 Java的Collections API包括Set、List、Queue集合接口，
并且支持泛型操作。另外，Map是一类特殊的集合，与一般
的集合不同，它包含的是Key-Value对。
对象1 对象2 对象3 对象4 …….. 对象n
Iterator
淮海工学院 计算机课程
Java Collections API中的核心集合接口
《接口》
Iterator
+hasNext()
+next()
+remove()
《接口》
Iterable
+itarator()
《接口》
Map
+clear()
+put()
+remove()
+containsKey()
+containsValue()
+get()
+keyset()
…..
《接口》
Collection
+add()
+remove()
+clear()
+isEmpty()
+size()
+contains()
《接口》
List
+get()
+set()
+remove()
《接口》
Set
《接口》
Queue
+element()
+offer()
+peek()
+poll()
《接口》
SortedMap
+comparator()
+firstKey()
+lastKey()
…..
《接口》
SortedSet
+compartor()
+first()
+last()
………………
淮海工学院 计算机课程
注意:
Map接口
和Collection
接口的不同
之处!!
5.4.2 Collection接口
Collection接口是集合接口树的根，它定义
了集合操作的通用API。对Collection接口的某
些实现类允许有重复元素，而另一些不允许有重
复元素；某些是有序的而另一些是无序的。JDK中
没有提供这个接口的实现，而是提供了它的子接
口如Set和List的实现。
淮海工学院 计算机课程
5.4.3 Set接口
Set中不能包含重复的元素。它是数学中
“集合”概念的抽象，可以用来表示类似于
学生选修的课程集合或机器中运行的进程集
合等。
淮海工学院 计算机课程
5.4.4 List接口
List是一个有序的集合，称为列表或序列。
List中可以包含重复的元素,可以通过元素
在List中的索引序号访问相应的元素。
List接口的实现类有：
ArrayList、LinkedList、Ｖector等。
实验3的例题3-4和3-5中用LinkedList对象来保存图
书信息,且使用了泛型机制,请认真理解!!
淮海工学院 计算机课程
5.4.5 Ｍap接口
Map实现键（key）到值(value)的映射。Map中不能包含
重复的键值，每个键值最多只能映射到一个值。
HashTable就是一种常用的Map。
5.4.6 Queue接口
Queue（队列）中的元素采用FIFO的顺序进行入队、
出队操作。
5.4.7 SortedSet和SortedMap接口
SortedSet和SortedMap分别是具有排序性能的Set和
Map。
淮海工学院 计算机课程
Set接口的实现类--Hashset
HashSet类是Set接口的实现类，它不保存元素的加入顺序，
不含重复元素。
import java.util.*;
class HashSetDemo
{ public static void main(String[] args)
{ HashSet hs = new HashSet(); //创建HashSet对象并向其中加入对象元素
hs.add("1"); hs.add("2"); hs.add("3");
hs.add("4"); hs.add("5"); hs.add("5");
Iterator it=hs.iterator(); //在HashSet上创建迭代器
while(it.hasNext()) //利用迭代器依次访问HashSet中的各个元素
{
System.out.println(it.next()); }
hs.remove("5");
System.out.println(hs);
}
}
淮海工学院 计算机课程
运行结果如下：
3
5
2
4
1
[3，2，4，1]
从运行结果可以看出，
(1)HashSet添加的顺序与
迭代显示的结果顺序并不
一致，这也验证了
HashSet不保存元素加入
顺序的特征。
(2)不包含重复元素
淮海工学院 计算机课程
List接口的实现类--ArrayList
(1) ArrayList类支持可随需要而增长的动态数
组，它能够动态地增加或减小其大小。
(2)ArrayList以一个原始大小被创建，当超过
了它的大小，将自动增大，当其中所包含的对
象被删除后，就自动缩小。
(3)ArrayList类对于使用索引取出元素有较高的
效率，它可以使用索引来快速定位对象。但元
素做删除或插入速度较慢。
淮海工学院 计算机课程
ArrayListDemo.java
import java.util.*;
public class ArrayListDemo
{
public static void main(…)
{
Collection c1=new ArrayList();
for(int i=0;i<5;i++)
{
c1.add(new Integer(i));
}
System.out.println("c1:"+c1);
Collection c2=new ArrayList();
c2.addAll(c1);
c2.remove(new Integer(3));
c2.add("The End");
System.out.println("c2:"+c2);
Iterator it=c2.iterator(); //创建迭代器
while(it.hasNext()) //遍历操作
{
Object obj=it.next();
System.out.println
("Iterator遍历c2 "+obj+"\t");
}
}
}
淮海工学院 计算机课程
运行结果如下：
C1:[0，1，2，3，4]
C2:[0，1，2，4，The End]
Iterator遍历C2 0
Iterator遍历C2 1
Iterator遍历C2 2
Iterator遍历C2 4
Iterator遍历C2 The End
淮海工学院 计算机课程
List的实现类--LinkedList
(1)LinkedList提供了一个链接列表数据结构，通过连
接指针来关联前后两个元素。对于那些需要做频繁
插入或删除元素操作的应用来说，使用LinkedList
类效率较高。
(2) LinkedList类定义了一些有用的方法用于访问和操
作列表。
如：调用addFirst()方法可以在表头增加元素；
调用addLast()方法可以在表尾增加元素；调用
getFirst()方法可以获得第一个元素；调用getLast()
方法可以得到最后一个元素；调用removeFirst()方
法可以删除第一个元素；调用removeLast()方法可
以删除最后一个元素。
淮海工学院 计算机课程
LinkedListDemo.java
import java.util.*;
class LinkedListDemo
{
public static void main(String args[])
{
LinkedList ll=new LinkedList();
ll.add("F");
ll.add("B");
ll.add("D");
ll.add("E");
ll.add("C");
System.out.println
("初始化后ll的内容:"+ll);
ll.addLast("Z");
ll.addFirst("A0");
ll.add(1,"A1");
System.out.println
("添加操作后ll的内容:"+ll);
ll.remove("F");
ll.remove(2);
System.out.println
("删除操作后ll的内容:"+ll);
ll.removeFirst();
ll.removeLast();
System.out.println
("删除操作后ll的内容:"+ll);
Object val=ll.get(2);
ll.set(2,(String)val+ " Changed");
System.out.println
("修改操作后ll的内容:"+ll);
}
}
淮海工学院 计算机课程
运行结果为：
初始化后ll的内容：[F，B，D，E，C]
添加操作后ll的内容：[A0，A1，F，B，D，E，C，Z]
删除操作后ll的内容：[A0，A1，D，E，C，Z]
删除操作后ll的内容：[A1，D，E，C]
修改操作后ll的内容：[A1，D，E Changed，C]
淮海工学院 计算机课程
List的实现类--Vector
(1) Vector类提供了实现可增长数组的功能，它提供的访
问方法支持类似数组运算和与Vector大小相关的运算。
(2)允许向量中增加、删除和插入元素，也允许测试向量
的内容和检索指定的元素。
(3)Vector的常用方法包括:
addElement(Object obj);
insertElementAt(Object obj,int index);
setElementAt(Object obj,int index);
removeElement(Object obj);
removeAllElements();
淮海工学院 计算机课程
VectorDemo.java
import java.util.*;
class VectorDemo
{
@SuppressWarnings("unchecked")
public static void main(String[] args)
{
Vector v = new Vector();
v.addElement("one");
v.addElement("two");
v.addElement("three");
System.out.println
("向量初始值:"+v.toString());
v.insertElementAt("zero",0);
v.insertElementAt("oop",3);
System.out.println
("插入元素后的向量值:"+
v.toString());
v.setElementAt("three",3);
v.setElementAt("four",4);
System.out.println
("修改元素后的向量值:"+
v.toString());
v.removeAllElements();
System.out.println
("全部删除后的向量值:"+
v.toString());
}
}
淮海工学院 计算机课程
运行结果为：
向量初始值：[one，two，three]
插入元素后的向量值:[zero，one，two，oop，three]
修改元素后的向量值:[zero，one，two，three，four]
全部删除后的向量值:[ ]
淮海工学院 计算机课程
Map的实现类--HashMap
HashMap是基于哈希表的Map接口的
实现，它是使用频率最高的一个容器，
它内部对“键”用Set进行散列存放，所
以根据“键”去取“值”的效率很高.
它不保证映射的顺序，特别是它不保
证该顺序是恒久不变的。
淮海工学院 计算机课程
HashMapDemo.java
import java.util.*;
class HashMapDemo
{
public static void main(String
args[])
{
HashMap hashmap=new
HashMap();
hashmap.put("0","c");
//用put方法向HashMap中以“键//值”对的形式加入元素
hashmap.put("1","a");
hashmap.put("2","b");
hashmap.put("3","a");
System.out.println("HashMap:");
System.out.println(hashmap);
//该容器有其内部的排序方式，事实上是
//依据哈希算法来排的
Set set=hashmap.keySet();
//获取全部键，它的返回类型是Set
Iterator iterator=set.iterator();
while(iterator.hasNext())
{ System.out.print
(hashmap.get(iterator.next())+";");
} }
}
运行结果如下:
HashMap:
{3=a，2=b，0=c，1=a}
a;b;c;a;
淮海工学院 计算机课程
Map的实现类--TreeMap
TreeMap容器类比较特殊，
它对“键”进行排序存放，所以
放入TreeMap中的“键-值”对中
的“键”必须是可“排序”的。
淮海工学院 计算机课程
TreeMapDemo.java
import java.util.*;
public class TreeMapDemo
{
public static void main(String args[])
{
TreeMap treemap=new TreeMap();
treemap.put("0","d");
treemap.put("2","a");
treemap.put("1","b");
treemap.put("3","c");
System.out.println("TreeMap:");
System.out.println(treemap); //可以
对键排序
System.out.println(treemap.firstKey());
//返回第一个键
Set set=treemap.keySet();
Iterator iterator=set.iterator();
while(iterator.hasNext())
{
System.out.print(treemap.get(iterator.
next())+";");
}
}
}
运行结果如下所示。
TreeMap:
{0=d，1=b，2=a，3=c}
0
d;b;a;c;
淮海工学院 计算机课程
List的实现类--Stack
import java.util.*;
class StackDemo
{ public static void main(String[] args)
{ Stack myStack = new Stack();
for(int i = 0; i < 10 ; i ++ )
{
myStack.push(String.valueOf(i));
}
//查看目前堆栈中的元素
System.out.println( myStack );
//依次出栈
System.out.println("现在依次出栈");
while (!myStack.empty())
{
System.out.println(myStack.pop());
} } }
输出结果为：
[0，1，2，3，4，5，6，7，8，9]
现在依次出栈
9
8
7
6
5
4
3
2
1
0
淮海工学院 计算机课程
Java泛型初步
(1)所谓泛型，就是在对类、方法等进行定义时，
指定它为通用类型，也就是数据类型是任意的
类型.
如:List<T> list=null.
(2)具体调用时，要将通用类型转换成指定的类
型来使用。
(3)泛型为提高大型程序的类型安全和可维护性
带来了很大的潜力。
(4) 泛型语言特性只在JDK5.0及以后版本中可用。
淮海工学院 计算机课程
以下程序片段中同时使用泛型和非泛型机制，从中可
以感受到泛型所带来的便利。
//不用泛型
List list=new ArrayList();
list.add(‘jzh”);
//取出的元素为Object类型，需做强制类型转换
String name=(String)list.get(0);
System.out.println(“取出的元素为:”+name);
//采用泛型
List<String> lst=new ArrayList<String>();
lst.add(‘jzh”);
//取出的元素为String类型，不需做类型转换
String rname=lst.get(0);
System.out.println(“取出的元素为:”+rname);
淮海工学院 计算机课程
1.泛型的声明
在定义一个泛型类的时候，在“<>”之间定
义形式类型参数.
例如:
class TestGen<K,V>
其中”K”、”V”不代表值，而是表示类型。
实例化泛型对象的时候，一定要在类名后面
指定具体的类型参数.
如：List<String> lst=
new ArrayList<String>();
淮海工学院 计算机课程
2.泛型的使用
学时 所限，仅以一个程序示例，介绍泛
型机制的初步用法.
具体使用时，请参阅相关书籍或网上资源。
淮海工学院 计算机课程
TestGenerics.java
import java.util.*;
public class TestGenerics
{
public static void main(String args[])
{
List<String> lst=new ArrayList<String>();
lst.add("ABC");
lst.add("DEF");
//错误操作，试图将Integer和Double类型
//的对象放入List<String>中
//lst.add(1);
//lst.add(2.0);
String str=lst.get(0);
//使用泛型后，获得对象时不用进行
//强制类型转换
for(String s:lst)
{
System.out.println(s);
}
Map<Integer,String> map=
new HashMap<Integer,String>();
map.put(1,"Shi Jun");
map.put(2,"Ji Zhao-hui");
map.put(3,"Huang Xia");
Set<Integer> keys=map.keySet();
for(Integer i:keys)
{
String value=map.get(i);
System.out.println
(i+"--"+value);
}
}
}
淮海工学院 计算机课程
运行结果
淮海工学院 计算机课程
5.5 Java的字符串
5.5.1
String类
Java中字符串常量用String类的对象表示，对所有用
双引号括起的字符串常量，系统都会创建一个无名的
String类。
（1）创建字符串常量String对象
创建String对象时，通常需要向String类的构造函数传
递参数来指定所创建的字符串的内容。
String类的构造函数：
1）public String（）——创建一个空的字符串常量
2）public String(String value)——利用一个已经存在
的字符串常量创建一个新的String对象，该对象的内容与
给出的字符串常量一致。
淮海工学院 计算机课程
3）public String(StringBuffer buffer)——利用一个
已经存在的StringBuffer对象为新建的对象String初
始化。
4）public String(char value[ ])——利用已经存在的
字符数组的内容初始化新建的String对象。
创建实例：
①String s;
//声明一个对象s
s=new String(“ABC”);
//为s赋值
②String s=new String(“ABC”); //声明的同时赋值
③String s= “ABC”;
//简化的直接赋值方法
淮海工学院 计算机课程
（2）字符串常量的操作
求字符串的长度的方法： public int length（）；
例： String
s=“Study”,s1=“学习”；
System.out.println(s.length( ))；//显示5
System.out.println(s1.length( ))；//显示2
注意:在java中,每个字符(不论中文还是西文)都是占用16个
比特的Unicode字符，故都只要一个字符表示。
（3）判断字符串的前缀和后缀
public boolean startsWith(String prefix);
public boolean endsWith(String suffix);
这两个方法分别用来判断当前字符串的前缀和后缀是否为
指定的字符子串。
淮海工学院 计算机课程
例：String s=User.getID（）；
if （s.startsWith（”320705”））
{ System.out.println(“此人是连云港的”);
}
（4）字符串中单个字符的查找
public int indexOf(int ch);
从前往后查找字符ch在当前字符串中第一次出现的位置，
并返回字符ch出现的位置，若找不到返回-1。
public int indexOf(int ch，int fromIndex);
在当前字符串中自fromIndex位置的字符之后向后查找，并
返回该字符首次出现的位置。
与上面对应的从后往前找的方法：
public int lastindexOf(int ch);
public int lastindexOf(int ch，int fromIndex);
淮海工学院 计算机课程
（5）字符串中子串的查找
public int indexOf(String str);
public int indexOf(String str，int fromIndex)；
例:
String s="How do you do";
System.out.println(s.indexOf("do")); //4
System.out.println(s.lastIndexOf("do")); //11
System.out.println(s.indexOf("o",2)); //5
System.out.println(s.indexOf("t",2)); //-1
System.out.println(s.lastIndexOf("o",4)); //1
System.out.println(s.lastIndexOf("o",10)); //8
淮海工学院 计算机课程
获取字符串中某个(index表示位置)字符的方法：
public char charAt(int index);
String s1="兔年快乐!";
String s2="Hello,world!";
System.out.println(s1.charAt(1)); //年
System.out.println(s2.charAt(1)); //e
（6）连接字符子串
public String concat(String str);
将参数字符串连接在当前字符串的尾部。
例：String s=“早上好，”；
System.out.println（s.concat（”同学们”））；
System.out.println（s);
淮海工学院 计算机课程
（7）比较两个字符串
public int compareTo(String anotherString);
若当前字符串与参数字符串完全相同/大于/小于时，则返回
0/正值/负值。
public boolean equals(Object anObject);
比较两个字符串，区分大小写，相同时返回真值，否则为假。
public boolean equalsIgnoreCase(String anotherString);
比较两个字符串，忽略大小写，相同时返回真值，否则为假。
例：String s1=“Hello”, s2=“hello”;
boolean b1=s1.equals(s2); //返回假
boolean b2=s1.equalsIgnoreCase(s2); //返回真
淮海工学院 计算机课程
例:
String s="abcde";
System.out.println(s.compareTo("boy")); //-1
System.out.println(s.compareTo("ababoy")); //2
System.out.println(s.compareTo("abcde")); //0
System.out.println(s.compareTo("Abcde")); //32
System.out.println(s.compareToIgnoreCase("Abc
de")); //0
淮海工学院 计算机课程
(8) 求子串方法substring
substring方法用来从当前字符串中获
得一个子串，示例如下:
String s="Hello world";
System.out.println(s.substring(0,5));//Hello
System.out.println(s.substring(6)); //world
String s1=“20110426”;
int year=Integer.parseInt(s1.substring(0,4));
int month=Integer.parseInt(s1.substring(4,6));
int day=Integer.parseInt(s1.substring(6,8));
淮海工学院 计算机课程
(9) trim方法
一个字符串s调用trim()方法得到一个字符
串对象，该字符串对象是s去掉前后空格后得
到的字符串。一般对于用户从文本框中所键入
的数据，都需要用trim()方法去除前后多余的
空格，然后再进行其它运算处理。
示例代码如下:
String userName=tf_Name.getText().trim();
String userPwd=tf_Pwd.getText().trim();
淮海工学院 计算机课程
(10)replace方法
replace(char oldChar,char newChar)方法返回一个新的字符
串，它是通过用newChar替换此字符串中出现的所有oldChar
得到的。
如果oldChar在此String对象表示的字符序列中没有出现，
则直接返回对此String对象的引用，否则创建一个新的String对
象。
示例如下:
String s1="mesquite in your cellar";
String s2="the war of baronets";
System.out.println(s1.replace('e','o')); // mosquito in your collar
System.out.println(s1); // mesquite in your cellar
System.out.println(s2.replace('r','y')); // the way of bayonets
System.out.println(s2); // the war of baronets
淮海工学院 计算机课程
(11)matches方法
字符串对象调用public boolean matches(String regex)方
法可以判断当前字符串对象是否和参数regex指定的正则表
达式匹配。
正则表达式是含有一些具有特殊意义字符的字符串，这
些特殊字符称为正则表达式中的元字符。比如,”\\dhello”中
的”\\d”就是有特殊意义的元字符，代表0-9中的任何一个数
字。字符串”9hello”和”1hello”都能和正则表达
式”\\dhello”相匹配。有关正则表达式的详细内容请阅Java
的API文档。
matches方法最常见的用途就是用来判断一个字符串是否
符合某个特定的格式，这个特定的格式就是用正则表达式给
出的。如可以将有效的身份证格式、email格式、日期格式
等信息用正则表达式进行约束。然后对一个字符串对象应用
matches方法，判断其是否是有效的格式。
淮海工学院 计算机课程
例：
public class matchesDemo
{
public static void main(String args[])
{
String s1="32070519710630005X";
//通过正则表达式限制身份证的格式
String regex="[0-9]{18}|[0-9]{17}X";
if(s1.matches(regex))
System.out.println(s1+"是有效的身份证号码");
else
System.out.println(s1+"不是有效的身份证号码");
}
}
淮海工学院 计算机课程
（11）split方法
该方法根据与给定的正则表达式的匹配情况对字符
串进行拆分，拆分的结果以字符串数组的形式返回。
例:用split方法对文本进行拆分，提取其中的单词。
public class splitDemo
{ public static void main(String args[])
{ String[] ss=new String[5];
String s = “Huai hai Institute of Technology";
//在每个空格字符处进行分解
ss = s.split(" ");
for(int i=0;i<ss.length;i++)
System.out.println(ss[i]);
}
}
淮海工学院 计算机课程
5.5.2 StringBuffer类
用来存放字符串变量的对象属于StringBuffer类。
（1）创建字符串变量——StringBuffer对象
构造函数：
public StringBuffer( );
创建一个空StringBuffer对象，需要扩充后才可以使用。
public StringBuffer(int length);
创建一个长度为length的StringBuffer对象。
public StringBuffer(String str);
利用一个已存在的字符串String对象来初始化
StringBuffer对象。
淮海工学院 计算机课程
（2）字符串变量的扩充、修改与操作
• 追加的方法：
public StringBuffer append(参数对象类型 参数对象
名);
将指定的参数对象转化成字符串，附加在原
StringBuffer字符串对象之后。
• 插入的方法：
public StringBuffer insert(int 插入位置，参数对
象类型 参数对象名);
在指定位置插入给出的参数对象所转化而得的字符串。
淮海工学院 计算机课程
•
修改的方法：
public void setCharAt(int index, char ch);
将指定位置处的字符用给定的另一个字符来替换。
其它方法:
StringBuffer reverse()
反转字符串
StringBuffer delete(int start,int end)
删除指定对象中从start位置开始
到end-1位置的字符序列
StringBuffer deleteCharAt(int pos)
此方法将删除pos指定位置处的
字符
淮海工学院 计算机课程
Java为字符串提供了特别的连接操作符”+”，可以把
其他各种类型的数据转换成字符串，并前后连接成新的字
符串。连接操作符”+”的功能是通过StringBuffer类和它的
append方法实现的。
例如：
String x=”a”+4+”c”;
编译时等效于：
String x=new
StringBuffer().append(“a”).append(4).append(“c”).toString();
在实际开发中，如果需要频繁改变字符串的内容，就需
要考虑用StringBuffer类实现。因为其内容可以改变，所以
执行性能会比String类更高。
淮海工学院 计算机课程
String类与StringBuffer类的使用示例
import java.awt.Graphics;
import java.applet.Applet;
public class TestString extends Applet
{
public void paint(Graphics g)
{
String s1="大学生";
String s2="淮海工学院";
String s3="计算机系";
String s4="Student",s6="student";
String s5;
StringBuffer s7=new StringBuffer("Hello,boys!"),
s8=new StringBuffer();
int L=s1.length();
//求字符串长度
int i=0,j=0,k=2;
boolean b1,b2;
淮海工学院 计算机课程
if (s2.startsWith("海")|| s1.endsWith("学生")) //判断字符串的前缀 、后缀
s5=s2+s1;
else
s5=s1.concat(s2);
//连接字符子串
i=s5.indexOf((int)‘学’);
//查找单个字符
j=s5.indexOf(“学生”,2);
//查找子串字符
b1=s6.equals(s4);
//比较两个字符串
b2=s6.equalsIgnoreCase(s4);
//比较两个字符串,忽略大小写
s8.append("Hello,girls!");
//字符串扩充
s7.insert(6,"girls");
//字符串插入
s8.setCharAt(6,'G');
g.drawString("****操作结果**** ",10,20);
g.drawString(s1,10,40);
g.drawString(s2,10,60);
g.drawString(s3,10,80);
g.drawString(s4,10,100);
g.drawString(s5,10,120);
g.drawString(Integer.toString(L),10,140);
g.drawString(Integer.toString(i),10,160);
g.drawString(Integer.toString(j),10,180);
g.drawString(Integer.toString(k),10,200);
g.drawString(s7.toString(),10,220);
g.drawString(s8.toString(),10,240);
g.drawString(Boolean.toString(b1)+" "+Boolean.toString(b2),10,280);
}
}
淮海工学院 计算机课程
5.5.3 StringTokenizer类
有时需要分析字符串并将字符串分解成可被独立使用
的单词，这些单词称为语言符号。例如，对于字符串”We
are students”，如果把空格作为该字符串的分隔符，那么该
字符串有3个单词。而对于字符串”We,are,students”，如果
把逗号作为该字符串的分隔符，那么该字符串有3个单词。
当分析一个字符串并将字符串分解成可被独立使用的单
词时，可以使用java.util包中的StringTokenizer类。该类有两
个常用的构造方法
(1)StringTokenizer(String s):为字符串s构造一个分析器。使用默
认的分隔符集合，即空格符（若干个空格被看作一个空
格）、换行符、回车符、Tab符等。
(2)StringTokenizer(String s,String delim):为字符串s构造一个分
析器，参数delim中的字符被作为分隔符。
淮海工学院 计算机课程
例：
(1)StringTokenizer fenxi=new
StringTokenizer(“We are students”);
(2)StringTokenizer fenxi=new
StringTokenizer(“We,are;students”, ”,;”);
把一个StringTokenizer对象称为一个字符串分析器，一
个分析器可以使用nextToken()方法逐个获取字符串中的语言
符号(单词)，每当调用nextToken()时，都将在字符串中获得
下1个语言符号，每当获取到一个语言符号，字符串分析器
中的负责计数的变量的值就自动减1，该计数变量的初始值
等于字符串中的单词数目。通常用while循环来逐步获取语
言符号，为了控制循环，可以使用StringTokenizer类中的
hasMoreTokens方法，只要字符串中还有语言符号，即计数
变量的值大于0，该方法就返回true，否则返回false。
另外还可以随时让分析器调用countTokens方法得到分
析器中计数变量的值。
淮海工学院 计算机课程
例:利用StringTokenizer对字符串文本进行分析
import java.util.*;
public class StringTokenizerDemo
{
public static void main(String[] args)
{
String str1 = "Hello world!This is Java code,stringTokenizer Demo.";
String str2 = "How to use StringTokenizer?StringTokenizer?";
StringTokenizer strT1 = new StringTokenizer(str1,“ .!");
//创建StringTokenizer类的对象strT1,并构造字符串str1的分析器
//以空格符、"."及"!"作为分隔符
StringTokenizer strT2 = new StringTokenizer(str2,“ ?");
//创建StringTokenizer类的对象strT2,并构造字符串str2的分析器
//以空格符及"?"作为分隔符
淮海工学院 计算机课程
int num1 = strT1.countTokens();
//获取字符串str1中语言符号的个数
int num2 = strT2.countTokens();
//获取字符串str2中语言符号的个数
System.out.println("str1 has "+num1+" words.They
are:");
while(strT1.hasMoreTokens())
{
//利用循环来获取字符串str1中下一个
//语言符号,并输出
String str = strT1.nextToken();
System.out.print("\""+str+"\" ");
}
淮海工学院 计算机课程
System.out.println("\nstr2 has "+num2+" words.They
are:");
while(strT2.hasMoreTokens())
{ //利用循环来获取字符串str2中
//下一个语言符号,并输出
String str = strT2.nextToken();
System.out.print("\""+str+"\" ");
}
}
}
图6-7 例6-8的运行结果
淮海工学院 计算机课程
5.6 日期和时间类
1） Date类
• Date类封装了日期和时间信息,一般需要结合使用
DateFormat的子类SimpleDateFormat来实现日期的格式化
输出,其构造函数是：
public SimpleDateFormat(String pattern)
该构造函数可以用参数pattern指定的格式创建一个对
象，该对象调用format(Date date)方法来对Date对象进
行格式化.
• 系统中计算机的起始时间是公元1970年1月1日0时(格林威
治时间)，如果是北京时间为8时。
淮海工学院 计算机课程
Pattern中可以有的元字符
表示的内容
年
月
日
时
分
秒
星期
y
M
d
H
m
s
E
格式
yy
MM
dd
HH
mm
ss
用系统当前时间创建日期对象的方法：
Date nowTime=new Date( );
淮海工学院 计算机课程
yyyy
import java.util.Date;
import java.text.SimpleDateFormat;
class testDate
//系统时间使用示例
{
public static void main(String args[])
{
Date nowTime=new Date();
Date pastTime=new Date(2000); //该数字为毫秒
System.out.println(nowTime);
System.out.println(pastTime);
SimpleDateFormat testformat1=new SimpleDateFormat("'现在时间
是'：yyyy年MM月dd日E");
System.out.println(testformat1.format(nowTime));
SimpleDateFormat testformat2=new SimpleDateFormat("'过去时间
是'：yyyy年MM月dd日HH 时mm分ss秒");
System.out.println(testformat2.format(pastTime));
System.out.println(new Date(System.currentTimeMillis()));
}
}
淮海工学院 计算机课程
2) Calendar(日历)类
• 使用Calendar类的static方法getInstance( )可以
初始化一个日历对象
Calendar myCalendar=
Calendar.getInstance( );
• Calendar对象可以调用set方法来设置时间：
public final void set(int year,int month,int date)
public final void set(int year,int month,int date,int
hour,int minute)
public final void set(int year,int month,int date,int
hour,int minute,int second)
淮海工学院 计算机课程
import java.util.*;
class testCalendar
{
public static void main(String args[])
{
Calendar myCalendar=Calendar.getInstance();
myCalendar.setTime(new Date());
String 年=String.valueOf(myCalendar.get(Calendar.YEAR)),
月=String.valueOf(myCalendar.get(Calendar.MONTH)+1),
日=String.valueOf(myCalendar.get(Calendar.DAY_OF_MONTH)),
星期=String.valueOf(myCalendar.get(Calendar.DAY_OF_WEEK)-1);
int hour=myCalendar.get(Calendar.HOUR_OF_DAY),
minute=myCalendar.get(Calendar.MINUTE),
second=myCalendar.get(Calendar.SECOND);
System.out.println("现在时间是："+年+"年"+月+"月"+日+"日"+
"星期"+ 星期);
System.out.println(""+hour+"时"+minute+"分"+second+"秒");
}
}
淮海工学院 计算机课程