API总笔记

Java API

●理解API辅助开放工具的使用

●String类与StringBuffer类

●基本数据类型的对象包装类

●集合类

●Hastable与Properties类

●System类与Runtime类

●Date、Calendar与DateFormat类

●Timer与TimerTask类

●Math与Random类

●学习API的方法

API的概念

API（Application Programming Interface）：应用程序的接口。

01-03

String类和StringBuffer类

●位于https://www.360docs.net/doc/9c8339638.html,ng包中。

●String类对象中的内容一旦被初始化就不能再改变。

●StringBuffer类用于封装内容可以改变的字符串。

用toString方法转换成String类型

Sring x=”a”+4+”c”,编译时等效于：String x=neStringBuffer().append(“a”).append(4).append(“c”);

●字符串常量（如”hello”）实际上是一种特殊的匿名String对象。比较下面两种情况的差异：

String s1=”hello”; String s2=”hello”;

String s1=new String(“hello”); String s2=new String(“hello”);

编程实例：逐行读取键盘输入，直到输入内容为”bye”时，结束程序。

当String s1=”hello”, String s2=”hello”; 那么s1==s2成立；他们都是应用同一个内存空间，

以节省内存资源，这是由String类的特殊性来决定的。当String s1=new String(“hello”); String

s2=new String(“hello”);的时候，因为他们已经各自创建了一个自己的内存空间，所以s1≠s2

的，内存地址不一样！

String类的常用成员方法

●构造方法：

String（byte[] bytes,int offset,int length）

●equalslgnorgCase方法

●indexOf(int ch)方法

●substring(int beginIndex)方法

substring(int beginIndex,int endIndex)

public String(byte[] bytes,

int offset,

int length)

通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的

String。新 String 的长度是字符集的函数，因此可能不等于该子数组的

长度。

当给定 byte 在给定字符集中无效的情况下，此构造方法的行为没有指

定。如果需要对解码过程进行更多控制，则应该使用CharsetDecoder类。

参数：

bytes - 要解码为字符的 byte

offset - 要解码的第一个 byte 的索引

length - 要解码的 byte 数

抛出：

IndexOutOfBoundsException - 如果 offset 和 length 参数索引字符

超出 bytes 数组的范围

将字节数组的的内容转换成字符串，从字节数组中的第offset个元素节

开始，到length个数的元素的内容作为新的字符串对象。

例子：

class ReadLine {

public static void main(String args[])

{

//定义一个不能超过1024个字节的内容的数组，此数组来吸收字符。

byte[] buf=new byte[1024];

//字符串对象

String strInfo=null;

int pos=0;

int ch=0;

System.out.println("请输入内容：");

while(true)

{

try{

//读取一个字节的数据（ch为什么是int类型？）

/*这里的System.in.read()方式是运用了java.io.InputStream类中的read()方法。

read()方法从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。

以整数形式返回实际读取的字节数。在输入数据可用、检测到文件末尾或者抛出异常前，

此方法一直阻塞。

如果 b 的长度为 0，则不读取任何字节并返回 0；否则，尝试读取至少一个字节。

如果因为流位于文件末尾而没有可用的字节，则返回值 -1；否则，至少读取一个字节

并将其存储在 b 中。

将读取的第一个字节存储在元素 b[0] 中，下一个存储在 b[1] 中，依次类推。读取的字节数

最多等于 b 的长度。设 k 为实际读取的字节数；这些字节将存储在 b[0] 到

b[k-1] 的元素中，

不影响 b[k] 到 b[b.length-1] 的元素。

类 InputStream 的 read(b) 方法的效果等同于：

read(b, 0, b.length)

参数：

b - 存储读入数据的缓冲区。

返回：

读入缓冲区的总字节数；如果因为已经到达流末尾而不再有数据可用，则返回-1。

抛出：

IOException - 如果不是因为流位于文件末尾而无法读取第一个字节；如果输入流已关闭；

如果发生其他 I/O 错误。

NullPointerException - 如果 b 为 null。*/

ch=System.in.read();

}

catch(Exception e)

{

e.printStackTrace();

}

switch(ch)

{

case'\r': //当回车的时候,\r 表示回车

break;

case'\n': // \n表示换行；

/*这个字符串是从字符数组内容中读取来的, 下句的意思是：将字符数组buf 中

从第0个位置开始读取，到pos这个位置的字符为止的字符转换为字符串。*/

strInfo=new String(buf,0,pos);

/*String类型的字符串要与别的字符串的内容对比，

*必须用到equalsIgnorCase方法来对比，如果是

* 等号来对比，则对比的是字符串内存~！内存是不相等的所以切记！！！ equalsIgnoreCase()方法是将此 String 与另一个 String 比较，不考虑大小写。

如果两个字符串的长度相同，并且其中的相应字符都相等（忽略大小写），

则认为这两个字符串是相等的。 */

if(strInfo.equals("bye"))

{

return;

}

else

{

System.out.println(strInfo);

pos=0; //当打印完一个字符串之后，字符串的位置要回到0这个位置！以便下一行输入！

break;

}

default:

buf[pos++]=(byte)ch;

}

}

// System.out.println("hello".indexOf('o'));

}

}

equalsIgnoreCase

public boolean equalsIgnoreCase(String anotherString)

将此 String 与另一个 String 比较，不考虑大小写。如果两个字符串的长度相同，并且其中的相应字符都相等（忽略大小写），则认为这两个字符串是相等的。

在忽略大小写的情况下，如果下列至少一项为 true，则认为 c1 和 c2 这两个字符相同。

?这两个字符相同（使用 == 运算符进行比较）。

?对每个字符应用方法Character.toUpperCase(char)生成相同的结果。

对每个字符应用方法Character.toLowerCase(char)生成相同的结果。

参数：

anotherString - 与此 String 进行比较的 String。

返回：

如果参数不为 null，且这两个 String 相等（忽略大小写），则返回 true；

否则返回 false。

indexOf

public int indexOf(int ch)

返回指定字符在此字符串中第一次出现处的索引。如果在此 String 对象表示的字符序列中出现值为 ch 的字符，则返回第一次出现该字符的索引（以 Unicode 代码单元表示）。对于 0 到 0xFFFF（包括 0 和 0xFFFF）范围内的 ch 的值，返回值是

this.charAt(k) == ch

为 true 的最小k值。对于其他 ch 值，返回值是

this.codePointAt(k) == ch

为 true 最小k值。无论哪种情况，如果此字符串中没有这样的字符，

则返回 -1。

参数：

ch - 一个字符（Unicode 代码点）。

返回：

在此对象表示的字符序列中第一次出现该字符的索引；如果未出现该字

符，则返回 -1。

substring

public String substring(int beginIndex)

返回一个新的字符串，它是此字符串的一个子字符串。该子字符串从指定

索引处的字符开始，直到此字符串末尾。

示例：

"unhappy".substring(2) returns "happy"

"Harbison".substring(3) returns "bison"

"emptiness".substring(9) returns "" (an empty string)

参数：

beginIndex - 起始索引（包括）。

返回：

指定的子字符串。

抛出：

IndexOutOfBoundsException - 如果 beginIndex 为负或大于此 String 对象的长度。

substring

public String substring(int beginIndex,

int endIndex)

返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。

示例：

"hamburger".substring(4, 8) returns "urge"

"smiles".substring(1, 5) returns "mile"

参数：

beginIndex - 起始索引（包括）。

endIndex - 结束索引（不包括）。

返回：

指定的子字符串。

抛出：

IndexOutOfBoundsException- 如果 beginIndex 为负，或 endIndex 大于此 String 对象的长度，或 beginIndex 大于 endIndex。

01_04

因为API接口中很多引用的参数都是（object类型）对象！所以我们要用到包装类把基本数据类型转换成对象！

前面的代码在每次运行的时候，会先将sb转换成stringBuffer对象，然后加上后面的星号，然后生成一个新的sb对象，然后如此循环不断生成新的对象浪费资源。而后边的那个就不会，只创建一个sb对象，然后就不断的在sb对象后面追加星号。public class TestInteger {

public static void main(String[] args) {

/*以下三种办法都是将字符串转换成整数的三种办法！*/

// int intValue() 以 int 类型返回该 Integer 的值。

int w=new Integer(args[0]).intValue();

/*static int parseInt(String s)

* 将字符串参数作为有符号的十进制整数进行解析。 */

int h=Integer.parseInt(args[1]);

/*static Integer valueOf(String s)

返回保存指定的 String 的值的 Integer 对象。下面那句因为

返回的是Integer对象，所以要用intValue()方法转换成int类型的 */

// int h=Integer.valueOf(args[1]).intValue();

for(int i=0;i

{

StringBuffer sb=new StringBuffer();

for(int j=0;j

{

sb.append("*");

}

System.out.println(sb.toString());

}

}

}

01-05

Vector使用的时候有考虑到线程同步的问题，即使有一个线程，它也会有监视器去监视，所以会出现大的开销！ArrayList使用时是没有考虑到线程同步的问题的，所以编写程序时要使用这个类就要考虑是否有线程同步的问题了！就因为这个类没有线程同步问题考虑，所以运行时的效率快些。

Collection接口是Set和List这两个接口的父类。

import java.io.IOException;

import java.util.*;

//要使用到Vector和Enumeratrion类，这两个类都在java.until.*的包里

public class TestVector {

public static void main(String[] args) {

// System.out.println("please enter number:");

int b=0;

/*Vector 类可以实现可增长的对象数组。与数组一样， * 它包含可以使用整数索引进行访问的组件。

* 但是，Vector 的大小可以根据需要增大或缩小，

* 以适应创建 Vector 后进行添加或移除项的操作。即创建了一个可伸缩的空间！*/

Vector v=new Vector ();

System.out.println("please enter number:");

while(true)

{

try {

b = System.in.read();

} catch (IOException e) {

e.printStackTrace();

}

if(b=='\r'||b=='\n')

break;

else

{

// 注意：输入的数据都是ASIC II码表中对应的数字！所以要减字符0

int num=b-'0';

/* addElement方法是将指定的组件添加到此向量的末尾，将其大小增加 1。

* 如果向量的大小比容量大，则增大其容量。此方法的功能与 add(E)

* 方法的功能完全相同（后者是 List 接口的一个方法)因为传入的是组件，

* 所以num必须要转换成Integer对象类型！*/

v.addElement(new Integer(num));

}

}

int sum=0;

/*Enumeration是一个接口，elements()方法是返回此向量的组件的枚举。

* 返回的 Enumeration 对象将生成此向量中的所有项。

* 生成的第一项为索引 0 处的项，然后是索引 1 处的项，依此类推。 */

Enumeration e=v.elements();

/*boolean hasMoreElements()测试此枚举是否包含更多的元素。

* 测试此枚举是否包含更多的元素。

返回：

当且仅当此枚举对象至少还包含一个可提供的元素时，才返回 true；否则返回 false。*/

while(e.hasMoreElements())

{

/*nextElement

E nextElement()如果此枚举对象至少还有一个可提供的元素，则返回此枚举的

下一个元素。

返回：

此枚举的下一个元素。

抛出：

NoSuchElementException - 如果没有更多的元素存在。*/

Integer intObj=(Integer)e.nextElement();

// intValue()：将传入的对象以int类型的方式传入

sum+=intObj.intValue();

}

System.out.println("sum="+sum);

}

}

import java.util.*;

public class TestSort

{

public static void main(String args[])

/*ArrayList() 构造一个初始容量为 10 的空列表。*/

ArrayList al=new ArrayList();

al.add(new Integer(1));

al.add(new Integer(4));

al.add(new Integer(3));

/* public String toString()返回此 collection 的字符串表示形式。

* 该字符串表示形式由 collection 元素的列表组成，

* 这些元素按其迭代器返回的顺序排列，并用方括号 ("[]") 括起来。

* 相邻元素由字符 ", "（逗号加空格）分隔。通过 String.valueOf(Object) * 可以将元素转换成字符串。

覆盖：

类 Object 中的 toString

返回：

此 collection 的字符串表示形式*/

System.out.println(al.toString());

/* Collections 类中的方法都是静态的

sort(List list, Comparator c)

根据指定比较器产生的顺序对指定列表进行排序。可以用来排序，但是返回的类型是静

态的！*/

Collections.sort(al);

System.out.println(al.toString());

}

}

上段程序运行结果是：[1, 4, 3]

[1, 3, 4]

01_06

Hashtable类可以起到搜索的作用！

public class MyKey

{

private String name=null;

private int age=0;

private String sex=null;

public MyKey(String name, int age,String sex) //构造函数没有返回类型 {

https://www.360docs.net/doc/9c8339638.html, = name;

this.age = age;

this.sex=sex;

}

public String toString()

{

return name+","+sex+","+age;

}

/* Object类中的equals(Object obj)方法

* public boolean equals(Object obj)

指示其他某个对象是否与此对象“相等”。 */

public boolean equals(Object obj)

{

// instanceof 用于比较两个对象是否相同,这里面用的是对象的比较~

if(obj instanceof MyKey)

{

MyKey objTem=(MyKey)obj;

if(name.equals(https://www.360docs.net/doc/9c8339638.html,)&&age==objTem.age&&sex.equals(objTem.sex)) {

return true;

}

else

{

return false;

}

}

else

{

return false;

}

}

}

import java.util.*;

public class HashtableTest {

public static void main(String[] args)

{

Hashtable numbers=new Hashtable();

/*public V put(K key,V value)将指定 key 映射到此哈希表中的指定 value。

键和值都不可以为 null。

通过使用与原来的键相同的键调用 get 方法，可以获取相应的值。

参数：

key - 哈希表的键

value - 值

返回：

此哈希表中指定键的以前的值；如果不存在该值，则返回 null

抛出：

NullPointerException - 如果键或值为 null*/

numbers.put(new MyKey("zhangsan",18,"boy"),new Integer(1));

numbers.put(new MyKey("lisi",18,"boy"),new Integer(2));

numbers.put(new MyKey("wangwu",15,"girl"),new Integer(3));

numbers.put(new MyKey("zhangsan",17,"boy"),new Integer(4));

/*HashTable类中的keys方法

public Enumeration keys()返回此哈希表中的键的枚举。

返回：

此哈希表中的键的枚举。*/

Enumeration e=numbers.keys();

/*Enumeration接口中的hasMoreElements抽象方法

boolean hasMoreElements()测试此枚举是否包含更多的元素。

返回：

当且仅当此枚举对象至少还包含一个可提供的元素时，才返回 true；否则返回false。*/

while(e.hasMoreElements())

{

/*Enumeration接口的nextElement（）方法

E nextElement()如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

返回：

此枚举的下一个元素。

抛出：

NoSuchElementException - 如果没有更多的元素存在。*/

MyKey key=(MyKey)e.nextElement();

/*public V get(Object key)返回指定键所映射到的值，如果此映射不包含此键的映射，则返回 null.

更正式地说，如果此映射包含满足 (key.equals(k)) 的从键 k 到值 v 的映射，则此方法返回 v；

否则，返回 null。（最多只能有一个这样的映射。）

参数：

key - 要返回其相关值的键

返回：

指定键映射到的值，如果此映射不包含到键的映射，则返回 null。

抛出：

NullPointerException - 如果指定键为 null*/

System.out.println(key+"="+numbers.get(key));

System.gc();

}

}

}

01_07

import java.util.Properties;

import java.io.*;

public class PropertiesFile {

public static void main(String[] args) {

/*

public static long currentTimeMillis()返回以毫秒为单位的当前时间。

注意，当返回值的时间单位是毫秒时，值的粒度取决于底层操作系统，并

且粒度可能更大。

例如，许多操作系统以几十毫秒为单位测量时间。

返回：

当前时间与协调世界时 1970 年 1 月 1 日午夜之间的时间差（以毫秒为单位测量）。*/ long startTimes=System.currentTimeMillis();

/* Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中

加载。

属性列表中每个键及其对应值都是一个字符串。

一个属性列表可包含另一个属性列表作为它的“默认值”；如果

未能在原有的属性

列表中搜索到属性键，则搜索第二个属性列表。

因为 Properties 继承于 Hashtable，所以可对

Properties 对象应用 put

和 putAll 方法。但不建议使用这两个方法，因为它们允许调用者插入其键或值

不是 String 的项。相反，应该使用 setProperty 方法。如果在“不安全”的

Properties 对象（即包含非 String 的键或值）上调用 store 或 save 方法，

则该调用将失败。类似地，如果在“不安全”的 Properties 对象（即包含非 String

的键）上调用 propertyNames 或 list 方法，则该调用将失败。 */

Properties settings=new Properties();

try {

/* FileInputStream类从文件系统中的某个文件中获得输入字节。

哪些文件可用取决于主机环境。

FileInputStream类用于读取诸如图像数据之类的原始字节流。

要读取字符流，请考虑使用 FileReader。

FileInputStream(String name)构造方法

通过打开一个到实际文件的连接来创建一个FileInputStream，

该文件通过文件系统中的路径名 name 指定。

void load(InputStream inStream)

从输入流中读取属性列表（键和元素对）。*/ settings.load(new FileInputStream("count.txt"));

}

catch (Exception e)

{

/*public Object setProperty(String key,String value)

调用 Hashtable 的方法 put。使用 getProperty 方法提供并行性。

强制要求为属性的键和值使用字符串。返回值是 Hashtable 调用 put 的结果。

参数：

key - 要置于属性列表中的键。

value - 对应于 key 的值。

返回：

属性列表中指定键的旧值，如果没有值，则为null。

String.valueof(0)方法返回 int 参数的字符串表示形式。*/

settings.setProperty("count", String.valueOf(0));

}

/*public String getProperty(String key)

用指定的键在此属性列表中搜索属性。如果在此属性列表中未找到该键，

则接着递归检查默认属性列表及其默认值。如果未找到属性，则此方法返回 null。

参数：

key - 属性键。

返回：

属性列表中具有指定键值的值。

Integer.parseInt()将字符串参数作为有符号的十进制整数进行解析。*/

int c=Integer.parseInt(settings.getProperty("count"))+1;

System.out.println("这是第"+ c+"次运行");

settings.setProperty("count", new Integer(c).toString());

try {

settings.store(new FileOutputStream("count.txt"),"Program is using");

} catch (Exception e) {

e.printStackTrace();

}

long endTimes=System.currentTimeMillis();

System.out.println(endTimes-startTimes);

}

}

System与Runtime类

import java.util.*;

public class TestProperties {

public static void main(String[] args) {

// System.setProperties();

Properties sp=System.getProperties();

Enumeration e=sp.propertyNames();

while(e.hasMoreElements())

{

String key=(String)e.nextElement();

System.out.println(key+"="+sp.getProperty(key));

}

Process p=null;

try {

p=Runtime.getRuntime().exec("notepad.exe TestProperties.java");

Thread.sleep(5000);

p.destroy();

} catch (Exception e1) {

e1.printStackTrace();

}

}

}

01_08

import java.util.*;

import java.text.SimpleDateFormat;

public class TestCalendar {

public static void main(String[] args) {

/*Calendar 类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，

并为操作日历字段（例如获得下星期的日期）提供了一些方法。

瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间1970 年1 月1 日的

00:00:00.000，格里高利历）的偏移量。

该类还为实现包范围外的具体日历系统提供了其他字段和方法。

这些字段和方法被定义为protected。

与其他语言环境敏感类一样，Calendar 提供了一个类方法getInstance，

以获得此类型的一个通用的对象。Calendar 的getInstance 方法

返回一个Calendar 对象，其日历字段已由当前日期和时间初始化：Calendar rightNow = Calendar.getInstance();

public static Calendar getInstance()

使用默认时区和语言环境获得一个日历。返回的Calendar 基于当前时间，

使用了默认时区和默认语言环境。

返回：

一个Calendar。*/

Calendar c1=Calendar.getInstance();

System.out.println(c1.get(Calendar.YEAR)+"年"+

c1.get(c1.MONTH)+"月"+c1.get(c1.DAY_OF_MONTH)+"日"

+c1.get(c1.HOUR_OF_DAY)+":"+c1.get(c1.MINUTE)+":"+c1.get(c1.SECOND));

/*public abstract void add(int field,int amount)根据日历的规则，

为给定的日历字段添加或减去指定的时间量。例如，要从当前日历时间减去5 天，可以通过调用以下方法做到这一点：

add(Calendar.DAY_OF_MONTH, -5)。

参数：

field - 日历字段。

amount - 为字段添加的日期或时间量。*/

c1.add(c1.DAY_OF_YEAR,300);

System.out.println(c1.get(Calendar.YEAR)+"年"+

c1.get(c1.MONTH)+"月"+c1.get(c1.DAY_OF_MONTH)+"日"

+c1.get(c1.HOUR_OF_DAY)+":"+c1.get(c1.MINUTE)+":"+c1.get(c1.SECOND));

/* SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。

* public SimpleDateFormat(String pattern)用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。注：此构造方法可能不支持所有语言环境。要覆盖所有语言环境，请使用DateFormat 类中的工厂方法。

参数：

pattern - 描述日期和时间格式的模式

抛出：

NullPointerException - 如果给定的模式为null

IllegalArgumentException - 如果给定的模式无效*/

SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd");

SimpleDateFormat sdf2=new SimpleDateFormat("yyyy年MM月dd日");

try{