第六讲 Java API
● 理解API的概念
● java辅助工具的使用
● String类和StringBuffer类
● 基本数据类型的对象包装类
● 集合类
● Hashtable与Properties类
● System类与Runtime类
● Date、Calendar与DateFormat类
● Timer与TimerTask类
● Math与Random类
● 学习API的方法
理解API的概念
● API的概念
(Application Programming Interface)
● Window API
就是Windows操作系统提供的各种函数，例如，CreatWindow。
● Java API
就是JDK中提供的各种Java类，例如，System类。
Java工具软件
● Borland公司的Jbuilder
● IBM公司的Visual Age
● Sun公司的Sun ONE Studio
● 塞六铁克的Visual cafe
● Jcreator
● Jcreator Pro
● 下载地址：http://www.Jcreator.com
● 工作区(jcw)与工程(jcp)
● 使用类向导创建新类
● 使用动态随笔功能和自动输入功能
● 指定Jcreator所有使用的JDK
● 设置第三方提供的Jar包
● 指定启动运行类及参数
● 设置多个运行配置环境
String类和StringBuffer类
● 位于java.lang包中。
● String类对象中的内容一旦被初始化就不能再改变。
● StringBuffer类用于封闭内容可以改变的字符串。
用toString方法转换成String类型
String x=”a”+4+”c”,编译时等效于：
String x=new StringBuffer().append(“a”).append(4).append(“c”).toString();
● 字符串常量（如”hello”）实际上是一种特殊的匿名String对象。比较下面两种情况的差异：
● String s1=”hello”; String s2=”hello”;
● String s1=new String(“hello”); String s2=new String(“hello”);
编程实例：逐行读取键盘输入，直到输入内容为”bye”时，结束程序。
public class ReadLine
{
public static void main(String[] args)
{
int pos=0;
int ch=0;
byte []buf=new byte [1024];
String strInfo=null;
System.out.println("请输入内容：");
while(true)
{
try{ch=System.in.read();}catch(Exception e){e.printStackTrace();}
switch(ch)
{
case '\r':
break;
case '\n':
strInfo=new String(buf,0,pos);
if(strInfo.equals("bye"))
//if(strInfo.equalsIgnoreCase("bye"))忽略大小写。
{
return;
}
else
{
System.out.println(strInfo);
pos=0;
break;
}
default:
buf[pos++]=(byte)ch;
}
}
}
}
String类的常用成员方法
● 构造方法：
● String(byte[] bytes, int offset, int length)
构造一个新的 String，方法是使用指定的字符集解码字节的指定子数组。
● charAt(int index)
返回指定索引处的 char 值
● compareTo(String anotherString)
按字典顺序比较两个字符串。
● indexOf(int ch)
返回指定字符在此字符串中第一次出现处的索引。如果不存在这样的值，则返回 -1。
例：strName.indexOf(‘a’);
● indexOf(int ch, int fromIndex)
从指定的索引开始搜索，返回在此字符串中第一次出现指定字符处的索引。
● indexOf(String str)
返回第一次出现的指定子字符串在此字符串中的索引。
● indexOf(String str, int fromIndex)
从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。
● length()
返回此字符串的长度。
● substring(int beginIndex)
返回一个新的字符串，它是此字符串的一个子字符串。
● substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。
● toLowerCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
● toUpperCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
● valueOf(int i)
返回 int 参数的字符串表示形式。
● ………………………………………………………..
●
基本数据类型的对象包装类
● 基本数据类型包装类的作用
|
基本数据类型
|
包装类
|
|
boolean
|
Boolean
|
|
byte
|
Byte
|
|
char
|
Character
|
|
short
|
Short
|
|
Int
|
Integer
|
|
Long
|
Long
|
|
float
|
Float
|
|
double
|
Double
|
编程实例：将字符串转换成整数的编程举例
在屏幕上打印出一个星号(*)组成的矩形，矩形的宽度和高度通过启动程序时传递给main方法的参数指定，并比较下面两段代码的运行效率：
String sb=new String(); StringBuffer sb=new StringBuffer();
for(int j=0;j<w;j++) for(int j=0;j<w;j++)
{ {
sb=sb+*; sb.append(*);
} }
以下黑粗体部分是“字符串转换成整数”的3种方法。
public class lesson64
{
public static void main(String[] args)
{
int h=new Integer(args[0]).intValue();
int w=Integer.parseInt(args[1]);
/*int w=Integer.valueOf(args[1]).intValue();*/
//StringBuffer sb=new StringBuffer();
for(int i=0;i<h;i++)
{
//sb定义在这里，可以省略下面用“//”注释的语句。
StringBuffer sb=new StringBuffer();
for(int j=0;j<w;j++)
{
sb.append('*');
}
System.out.println(sb.toString());
//sb.delete(0,h+1);
}
}
}
集合类
集合类用于存储一组对象，其中的每个对象称之为元素，经常会用到的有Vector、Enumeration、ArrayList、Collection、Iterator、Set、List等集合类和接口。
● Vector类与Enumeration接口。
编程举例：将键盘上输入的数字序列中的每位数字存储在Vector对象中，然后在屏幕上打印出每位数字相加的结果，例如，输入32，打印出5;输入1234，打印出10。
import java.util.*;
public class TestVector
{
public static void main(String[] args)
{
int sum=0;
Vector v=new Vector();
System.out.println("请输入数字：");
while(true)
{
int b=0;
try{b=System.in.read();}catch(Exception ex){ex.printStackTrace();}
if(b=='\r'||b=='\n')
break;
else
{
int num=b-'0';
v.addElement(new Integer(num));
}
}
Enumeration e=v.elements();
while(e.hasMoreElements())
{
Integer intObj=(Integer)e.nextElement();
sum+=intObj.intValue();
//sum+=((Integer)e.nextElement()).intValue();
}
System.out.println(sum);
}
}
● Collection接口与Iterator接口
编程举例：用ArrayList和Iterator改写上面的例子程序。
import java.util.*;
public class TestCollection
{
public static void main(String[] args)
{
int sum=0;
ArrayList al=new ArrayList();
System.out.println("请输入数字：");
while(true)
{
int b=0;
try{b=System.in.read();}catch(Exception e){e.printStackTrace();}
if(b=='\r'||b=='\n')
{
break;
}
else
{
int num=b-'0';
al.add(new Integer(num));
}
}
Iterator it=al.iterator();
while(it.hasNext())
{
sum+=((Integer)it.next()).intValue();
}
System.out.println(sum);
}
}
注意：在何种情况下使用Vector和ArrayList?
Vcetor类中的所有方法都是线程同步的，如果有两个线程并发的访问同一个Vector对象，这是安全的。即使有一个线程访问Vector对象时，同步监视器也是的运行的，这样程序的运行效率就会降低。ArrayList类中的所有方法都不是线程同步的，如果程序中不存在多线程安全问题，使用ArrayList会比使用Vector效率高些;如果程序中存在多线程安全问题，使用ArrayList则需要用户自己对访问ArrayList对象的程序代码进行同步处理，使用Vector则不需要这样做。
● Collection、Set、List的区别如下：
Collection是Set和List的父类，
Collection各元素对象之间没有指定的顺序，允许有重复元素和多个null元素对象
Set各元素对象之间没有指定的顺序，不允许有重复元素和最多允许有一个null元素对象
List各元素对象之间有指定的顺序，允许有重复元素和多个null元素对象
import java.util.*;
public class TestSort
{
public static void main(String[] args)
{
ArrayList al=new ArrayList();
al.add(new Integer(2));
al.add(new Integer(5));
al.add(new Integer(1));
System.out.println(al.toString());
Collections.sort(al);
System.out.println(al.toString());
}
}
Hashtable类
Hashtable不仅可以像Vector一样动态存储一系列的对象，而且对存储的每一个对象（称为值）都要安排另一个对象（称为关键字）与之相关联。
例：
创建了一个数字的哈希表
Hashtable numbers=new Hashtable();
numbers.put(“one”,new Integer(1));
numbers.put(“two”,new Integer(2));
numbers.put(“three”,new Integer(3));
注：如存在相同关键字，则修改原来的关键字所对应的值。
要检索一个数字
Integer n=(Integer)numbers.get(“two”);
If(n!=null)
{
System.out.println(“tow=’+n);
}
用作关键字的类必须覆盖Object.hashCode方法和Object.equals方法。
编程举例：使用自定义类作为Hashtable的关键字类
HashTableTest类：
import java.util.*;
public class HashTableTest
{
public static void main(String[] args)
{
Hashtable numbers=new Hashtable();
numbers.put(new MyKey("zhangsan",18),new Integer(1));
numbers.put(new MyKey("lisi",15),new Integer(2));
numbers.put(new MyKey("wangwu",20),new Integer(3));
Enumeration e=numbers.keys();
while(e.hasMoreElements())
{
MyKey key=(MyKey)e.nextElement();
System.out.print(key.toString()+"=");
System.out.println(numbers.get(key));
}
System.out.println(numbers.get(new MyKey("zhangsan",18)));
}
}
MyKey类
public class MyKey
{
private String name = null;
private int age = 0;
public MyKey(String name,int age)
{
this.name=name;
this.age=age;
}
public boolean equals(Object obj)
{
if(obj instanceof MyKey)
{
MyKey key=(MyKey)obj;
if(name.equals(key.name)&&age==key.age)
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
public int hashCode()
{
return name.hashCode()+age;
}
public String toString()
{
return name+","+age;
}
}
Properties类
● Properties类是Hashtable的子类
● 增加了将Hashtable对象中的关键字和值保存到文件和从文件中读取关键字和值到Hashtable对象中的方法。
● 如果要用Properties.store方法存储Properties对象中的内容，每个属性的关键字和值都必须是String类型
编程举例：使用Prperties把程序的启动运行记录在某个文件中，每次运行时打印出它的运行次数。
import java.util.Properties;
import java.io.*;
public class PropertiesFile
{
public static void main(String[] args)
{
// TODO: Add your code here
Properties setting=new Properties();
try
{
setting.load(new FileInputStream("count.txt"));
}
catch(Exception e)
{
setting.setProperty("count",String.valueOf(0));
}
int n=Integer.parseInt(setting.getProperty("count"))+1;
System.out.println("Times:"+n);
setting.setProperty("count",String.valueOf(n));
try
{
setting.store(new FileOutputStream("count.txt"),"Program used:");
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
System与Runtime类
● System类
n Exit方法
public static void exit(int status)
终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非零的状态码表示异常终止，零为正常终止。
该方法调用 Runtime 类中的 exit 方法。该方法永远不会正常返回。
调用 System.exit(n) 实际上等效于调用：
Runtime.getRuntime().exit(n)
public static long currentTimeMillis()
返回以毫秒为单位的当前时间。注意，当返回值的时间单位是毫秒时，值的粒度取决于基础操作系统，并且粒度可能更大。例如，许多操作系统以几十毫秒为单位测量时间。
返回：
当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）。
- Java虚拟机的系统属性
- GetProperties和setProperties方法
getProperties
public static Properties getProperties()
确定当前的系统属性。
setProperties
public static void setProperties(Properties props)
将系统属性设置为 Properties 参数。
getProperty
public static String getProperty(String key)
获得指定键指示的系统属性
setProperty
public static String setProperty(String key,String value)
设置指定键指示的系统属性。
参数：
key - 系统属性的名称。
value - 系统属性的值。
返回：
系统属性以前的值，如果没有以前的值，则返回 null。
编程实例：列出Java虚拟机的系统属性
import java.util.*;
public class TestProperties
{
public static void main(String[] args)
{
long startTime=System.currentTimeMillis();
Properties pp=System.getProperties();
pp.setProperty("name","jianke");
System.setProperties(pp);
Enumeration e=pp.propertyNames();
while(e.hasMoreElements())
{
String key=(String)e.nextElement();
System.out.println(key+System.getProperty(key));
}
long endTime=System.currentTimeMillis();
System.out.println("此程序启动运行时间："+(endTime-startTime)+"ms");
}
}
● Runtime类
在单独的进程中执行指定的字符串命令。
- public void exit(int status)
通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机。此方法从不正常返回。可以将变量作为一个状态码；根据惯例，非零的状态码表示非正常终止。
返回与当前 Java 应用程序相关的运行时对象。Runtime 类的大多数方法是实例方法，并且必须根据当前的运行时对象对其进行调用。
编程实例：在Java程序中启动一个Windows记事本程序运行实例，并在该运行实例中打开这个Java程序的源文件，启动的记事本程序5秒钟后被关闭。
public class TestRunTime
{
public static void main(String[] args)
{
Process p=null;
try
{
p=Runtime.getRuntime().exec("notepad.exe TestRunTime.java");
Thread.sleep(5000);
p.destroy();
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
Destroy（Process方法）
public abstract void destroy()
杀掉子进程。强制终止此 Process 对象表示的子进程。
与日期和时间有关的类
● 最常用几个类：Date、DateFormat和Calendar
● Calendar类
Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。Calendar 的 getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化：
Calendar rightNow = Calendar.getInstance();
◆ public abstract void add(int field, int amount)
根据日历的规则，为给定的日历字段添加或减去指定的时间量。例如，要从当前日历时间减去 5 天，可以通过调用以下方法做到这一点：
add(Calendar.DAY_OF_MONTH, -5)。
参数：
field - 日历字段。
amount - 为字段添加的日期或时间量
◆ public int get(int field)
返回给定日历字段的值。
◆ public void set(int field,int value)
将给定的日历字段设置为给定值
参数：
field - 给定的日历字段。
value - 给定日历字段所要设置的值。
◆ GrlendarCalendar子类
编程实例：计算出距当前日期时间315天后的日期，并用“XXXX年XX月XX日XX小时：XX分：XX秒”的格式输出。
import java.util.Calendar;
public class TestCalendar
{
public static void main(String[] args)
{
Calendar c=Calendar.getInstance();
System.out.println(c.get(c.YEAR)+"年"+
c.get(c.MONTH) +"月"+c.get(c.DAY_OF_MONTH)+"日"+
c.get(c.HOUR_OF_DAY)+":"+c.get(c.MINUTE)+":"+c.get(c.SECOND));
c.add(c.DAY_OF_YEAR,315);
System.out.println(c.get(c.YEAR)+"年"+
c.get(c.MONTH) +"月"+c.get(c.DAY_OF_MONTH)+"日"+ c.get(c.HOUR_OF_DAY)+":"+c.get(c.MINUTE)+":"+c.get(c.SECOND));
}
}
● Date类
● Java.text.DateFormatg与java.text.SimpleDateFormat子类
public abstract class DateFormat extends Format
DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并分析日期或时间。日期/时间格式化子类（如 SimpleDateFormat）允许进行格式化（也就是日期 -> 文本）、分析（文本-> 日期）和标准化。将日期表示为 Date 对象，或者表示为从 GMT（格林尼治标准时间）1970 年，1 月 1 日 00:00:00 这一刻开始的毫秒数。
public class SimpleDateFormat extends DateFormat
SimpleDateFormat 是一个以与语言环境相关的方式来格式化和分析日期的具体类。它允许进行格式化（日期 -> 文本）、分析（文本 -> 日期）和规范化。
SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。但是，仍然建议通过 DateFormat 中的 getTimeInstance、getDateInstance 或 getDateTimeInstance 来新的创建日期-时间格式化程序
编程实例：将“2002-03-15”格式的日期字符串转换成“2002年03月15日”的格式。
import java.util.*;
import java.text.*;
public class TestCalendar
{
public static void main(String[] args)
{
SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat sdf2=new SimpleDateFormat("yyyy年MM月dd日");
try
{
Date d=sdf1.parse("2002-03-15");
System.out.println(sdf2.format(d));
}
catch(Exception e)
{
e.printStackTrace();
}
System.out.println(new Date());
}
}
Timer与TimerTask类
|
构造方法摘要
|
|
Timer()
创建一个新计时器。
|
|
|
Timer(boolean isDaemon)
创建一个新计时器，可以指定其相关的线程作为守护程序运行。
|
|
|
Timer(String name)
创建一个新计时器，其相关的线程具有指定的名称。
|
|
|
Timer(String name, boolean isDaemon)
创建一个新计时器，其相关的线程具有指定的名称，并且可以指定作为守护程序运行。
|
|
● Schedule方法主要有如下几种重载形式：
方法摘要
|
void
|
schedule(TimerTask task, Date time)
安排在指定的时间执行指定的任务。
task - 所要安排的任务。
time - 执行任务的时间。
|
|
void
|
schedule(TimerTask task, Date firstTime, long period)
安排指定的任务在指定的时间开始进行重复的固定延迟执行。
task - 所要安排的任务。
firstTime - 首次执行任务的时间。
period - 执行各后续任务之间的时间间隔，单位是毫秒。
|
|
void
|
schedule(TimerTask task, long delay)
安排在指定延迟后执行指定的任务。
task - 所要安排的任务。
delay - 执行任务前的延迟时间，单位是毫秒。
|
|
void
|
schedule(TimerTask task, long delay, long period)
安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
task - 所要安排的任务。
delay - 执行任务前的延迟时间，单位是毫秒。
period - 执行各后续任务之间的时间间隔，单位是毫秒。
|
● TimerTask类实例了Runnable接口，要执行的任务由它里面实现的run方法来完成。
编程实例：程序启动运行30秒启动Windows自带的计算器程序。
import java.util.*;
public class TestTimer
{
public static void main(String[] args)
{
Timer tm=new Timer();
tm.schedule(new MyTimerTask(tm),30000);
}
}
class MyTimerTask extends TimerTask
{
private Timer tm=null;
public MyTimerTask(Timer tm)
{
this.tm=tm;
}
public void run()
{
try
{
Runtime.getRuntime().exec("calc.exe");
}
catch(Exception e)
{
e.printStackTrace();
}
//结束任务的线程代码
tm.cancel();
}
}
Math与Random类
● Math类包含了所有用于几何和三角运算的方法
● Random类是一个伪随机数产生器
|
int
|
nextInt()
返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
|
|
int
|
nextInt(int n)
返回一个伪随机数，它是从此随机数生成器的序列中取出的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。
|
例：
public static void main(String[] args)
{
Random rd=new Random();
System.out.println(rd.nextInt(100));
}