java API学习记录

 

API(Application Programming Interface)

JAVA   API就是JDK中提供的各种类

1. String和StringBuffer类位于java.lang中

toString方法可以把StringBuffer转换为String

String x = "a"+4+"c";

String x = new StringBuffer().append("a").append(4).append("c").toString();

字符串常量实际上就是一种特殊的匿名String对象

Equals可以用来比较是否是同一个对象，==如果两个字符串一样的话就相等了

System.in.read();可以从键盘读取一个字节，需要捕捉IOException异常

参考类：

public class ReadLine {

public static void main(String[] args) {

byte [] buf = new byte[1024];

String strInfo = null;

int pos = 0;

int ch = 0;

while(true){

try {

ch = System.in.read();

} catch (IOException e) {

e.printStackTrace();

}

switch(ch){

case '/r':

break;

case '/n':

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

if(strInfo.equals("bye")){

return;

}

else{

System.out.println(strInfo);

pos = 0;

break;

}

default:

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

break;

}

}

}

}

String类

构造方法：String(byte[]bytes,int offset,int length)

equlaslgnoreCase方法：可以忽略大小写

indexOf(int ch)方法：用于返回字符在字符串首次出现的位置，没有返回-1

substring(int beginIndex)方法:字符开始位置,返回字符

Substring(int beginIndex,int endIndex)：返回其间的字符

StringBuffer类

toString():返回一个String类型对象

Append():把一个字符串连接到StringBuffer中

2.基本数据类型的对象包装类

boolean-->Boolean,char-->Character,int-->Integer...

许多方法中都使用了Object对象，如果需要使用这样的方法就必须使用包装类

把一个字符串转换成int类型可以有三种方法： intValue(),Integer.parseInt(),valueOf()

第三种方法与前两种不同的是第三种方法转换之后是一个Integer类型

3.集合类

    集合类用于存储一组对象，其中每个对象称之为元素，经常会用到的       Vector,Enumeration,ArrayList,Collection,lterator,Set,List等

 (1).Vector类与Enumeration接口

  如果不能预先确定预先要保存的对象的数目，或者需要方便获得某个对象的存放   位置时，可以选择Vector类

public class TestVector {

@SuppressWarnings("unchecked")

public static void main(String args[]){

Vector v = new Vector();

int b = 0;

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{

int num = b - '0';

v.addElement(new Integer(num));

//向Vector对象中加入这个整数对象

}

}

int sum = 0;

Enumeration e = v.elements();

//v.elements()返回一个Enumeration接口对象

while(e.hasMoreElements()){//如果还有元素，指示器将返回true

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

//nextElement()返回的是一个对象

//返回指示器正在指向的那个对象,并将指示器指向下一个对象

sum +=intObj.intValue();

//intValue可以把Integer对象转换为int类型

}

System.out.println(sum);

}

}

(2).Collection接口与Iterator接口

 ArrayList类实现了Collection接口

import java.io.IOException;

import java.util.ArrayList;

import java.util.Iterator;

 

public class TestCollection {

@SuppressWarnings("unchecked")

public static void main(String args[]){

ArrayList v = new ArrayList();

int b = 0;

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{

int num = b - '0';

v.add(new Integer(num));

//向ArrayList对象中加入这个整数对象

}

}

int sum = 0;

Iterator e = v.iterator();

//v.iterator()返回一个Enumeration接口对象

while(e.hasNext()){//如果还有元素，指示器将返回true

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

//next()返回的是一个对象

//返回指示器正在指向的那个对象,并将指示器指向下一个对象

sum +=intObj.intValue();

//intValue可以把Integer对象转换为int类型

}

System.out.println(sum);

}

}

ArrayList类中所有方法都是非同步的，在没有线程安全时候ArrayList效率较高

以下是JDK文档中的提示：

注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须 保持外部同步。（结构上的修改是指任何添加或删除一个或多个元素的操作，或者显式调整底层数组的大小；仅仅设置元素的值不是结构上的修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法将该列表“包装”起来。这最好在创建时完成，以防止意外对列表进行不同步的访问。

（3）.Collection,Set,List区别:

  Set,List是Collection的子类

  Collection各对象之间没有指定的顺序，允许有重复元素和多个null元素对象

  Set各对象没有指定顺序，不允许有重复元素，最多允许有一个null元素对象

  List各元素对象之间有指定顺序，允许重复对象，和多个null元素对象

import java.util.ArrayList;

import java.util.Collections;

public class TestSort {

@SuppressWarnings("unchecked")

public static void main(String []args){

ArrayList al = new ArrayList();

al.add(new Integer(1));

al.add(new Integer(3));

al.add(new Integer(2));

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

Collections.sort(al);//用来操作集合类对象

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

}

}

(4).Hashtable类

此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。

 代码如下：

import java.util.Enumeration;

import java.util.Hashtable;

 

public class HashtableTest {

@SuppressWarnings("unchecked")

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();

//取出所有关键字的集合(Integer)

while(e.hasMoreElements()){

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

System.out.print(key.toString()+"=");

//key隐式的调用toString方法,可以直接写成key...

System.out.println(numbers.get(key));

//这里的key是直接从hastable里面取出来的,不用再比较了

//key是hastable的一部分,这样检索比较方便

}

System.out.println(numbers.get(new  MyKey("zhangsan",18))); }

}

public class MyKey {

private String name = null;

private int age = 0;

public MyKey(String string, int i) {

this.name = string;

this.age = i;

}

public String toString(){

return name+","+age;

}

//equals方法，hashCode方法并不是被程序调用的，而是被get方法调用

//numbers.get(key)

public boolean equals(Object obj){

if(obj instanceof MyKey){

MyKey objTemp = (MyKey)obj;

if(name.equals(objTemp.name) && age==objTemp.age){

return true;

}

else{

return false;

}

}

else{

return false;

}

}

public int hashCode(){

return name.hashCode()+age;

}

}

  （5）.Properties类是Hashtable的子类

   Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加 载。属性列表中每个键及其对应值都是一个字符串。

示例代码：

新建一个count.txt文件内容为：

#Program is used:

#Thu Apr 14 15:03:46 CST 2011

count=0

import java.util.Properties;

import java.io.*;

 

public class PropertiesFile {

public static void main(String args[]){

Properties settings = new Properties();

try {

settings.load(new FileInputStream("C://Users//姜康 //Desktop//java//count.txt"));

} catch (IOException e) {

e.printStackTrace();

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

System.out.println("!!");

}

//settings.get("count");需要转换成字符串

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

//getProperty直接得到一个字符串

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

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

//Integer(c).toString()把整数类型转换为string类型

//put方法可以接收非字符串对象做参数,setProperty只能是字符串

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

try {

settings.store(new FileOutputStream("C://Users//姜康 //Desktop//java//count.txt"), "Program is used:");

} catch (IOException e) {

System.out.println(e.getMessage());

}

//把properties属性列表加入到输出流中，第二个参数是设置标题

}

}

（6）.System与Runtime类

Exit方法，currentTimeMillis方法

JVM的系统属性

getProperties和setProperties方法可以设置JVM的系统属性

Runtime类

它封装了java命令的运行进程，不能直接创建Runtime实例，可以通过静态方法 Runtime.getRuntime获得正在运行的Runtime对象的引用。

不能通过new来创建Runtime

设置JVM属性：java -DAAA=aaa TestProperties

实例程序：

import java.util.*;

public class TestProperties {

@SuppressWarnings("unchecked")

public static void main(String []args){

Properties sp= System.getProperties();

Enumeration e = sp.propertyNames();

while(e.hasMoreElements()){

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

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

}

}

}

下面一个例子是打开一个文件，然后几秒钟后关闭

package api.test;

import java.io.IOException;

import java.util.*;

 

public class TestProperties {

@SuppressWarnings("unchecked")

public static void main(String []args){

//Process为一个类，代表JVM启动的一个子线程

Process p = null;

try {

p = Runtime.getRuntime().exec("notepad.exe C://Users// 姜康//Desktop//java//Test.java");

} catch (IOException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

}

try {

Thread.sleep(5000);

} catch (InterruptedException e1) {

// TODO Auto-generated catch block

e1.printStackTrace();

}

p.destroy();

}

}

  (7). 与日期和时间有关的类

Date，DateFormat，Calendar

Calendar类：add()方法

get()方法获得年月日，小时分秒

Set()方法修改年月日...

getInstance静态方法

GregorianCalendar子类

   import java.util.Calendar;

 

public class TestCalendar {

@SuppressWarnings("static-access")

public static void main(String[] args) {

Calendar c1 = Calendar.getInstance();

//得到Calendar类的实例对象，也可以用new来产生

System.out.print(c1.get(c1.YEAR)+"年"+c1.get(c1.MONTH)+"月"+c1.get(Calendar.DAY_OF_MONTH)+"日");

System.out.println(c1.get(c1.HOUR)+":"+c1.get(c1.MINUTE)+":"+c1.get(c1.SECOND));

c1.add(c1.DAY_OF_YEAR, 315);

System.out.print(c1.get(c1.YEAR)+"年"+c1.get(c1.MONTH)+"月"+c1.get(Calendar.DAY_OF_MONTH)+"日");

System.out.println(c1.get(c1.HOUR)+":"+c1.get(c1.MINUTE)+":"+c1.get(c1.SECOND));

}

}

java.text.DateFormat与java.text.Simple.DateFormat子类

 

import java.util.Date;

import java.text.ParseException;

import java.text.SimpleDateFormat;

public class TestCalendar {

public static void main(String[] args) {

SimpleDateFormat sdf1 = new     

SimpleDateFormat("yyyy-mm-dd");

SimpleDateFormat sdf2 = new

SimpleDateFormat("yyyy年mm月dd");

Date d = null;

try {

d = sdf1.parse("2003-03-15");

} catch (ParseException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(sdf2.format(d));

//用于把指定对象的值输出

    }

   }

（8）.Timer/TimerTask类

Timer一种线程设施，用于安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。

与每个 Timer 对象相对应的是单个后台线程，用于顺序地执行所有计时器任务。计时器任务应该迅速完成。如果完成某个计时器任务的时间太长，那么它会“独占”计时器的任务执行线程。因此，这就可能延迟后续任务的执行，而这些任务就可能“堆在一起”，并且在上述令人讨厌的任务最终完成时才能够被快速连续地执行。

TimerTask由 Timer 安排为一次执行或重复执行的任务。

Schedule(TimerTask task,long delay)

Schedule(TimerTask task,Date time)

TimerTask实现Runable接口,要执行的任务由它里面实现的run方法完成

import java.util.Timer;

import java.util.TimerTask;

public class TestTimer {

public static void main(String args[]){

//使用匿名对象来完成,无法访问到Timer对象

/*new Timer().schedule({

//需要覆盖子类的run方法

public void run(){

try{

Runtime.getRuntime().exec("calc.exe");

}catch(Exception e){

e.printStackTrace();

}

}

},1000);*/

//结束任务线程的代码

Timer tm = new Timer();

tm.schedule(new MyTimerTask(tm), 3000);

}

}

class MyTimerTask extends TimerTask{

@SuppressWarnings("unused")

private Timer tm = null;

//传递过来的是tm对象

public MyTimerTask(Timer tm){

this.tm = tm;

}

public void run(){

try{

Runtime.getRuntime().exec("calc.exe");

}catch(Exception e){

e.printStackTrace();

}

tm.cancel();

//可以结束线程

}

}

(9) .Math与Random类

Math类包含了所有用于几何和三角运算的方法

Random类是一个伪随机数产生器