JAVA API

----API概念：

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

在Java中的API就是JDK中提供的各种功能。如CreateWindow就是一个API函数，在应用程序中如果要调用这个函数那么操作系统就会按该函数提供的参数信息产生一个相应的窗口

如何学习编程：

1. 必须先学习该语言的语法

2.我们要像学习汉语一样掌握成语一样掌握大量的API

3.也要学会分析与解决问题。养成良好的编程习惯与风格

 java工具软件的介绍与使用：

 sun公司没有提供图形化的开发环境，他把开发软件让给了合作伙伴。

Borland公司的Jbuilder        IBM 的 Visual Age  还有赛门铁克的Visual cafe 这几业是很给力的

String类和StringBuffer类：

一个字符串就是一边串的字符，java定义了String和StringBuffer两个类 来封装对字符串的各种操作，它们都被放到了java.lang包中，

不需要用import java.lang这个语句导入就可以直接使用他们了 

String类用于比较两个字符串，查找和抽取串中的字符或子串、【字符串与其他类型之间相互转换等 String类中的内容一旦被初始化就不能再改变。 

 StringBuffer类用于内容 可以改变的字符串，可以将其他各种类型的数据增加、插入到字符串中，也可以翻转字符串原来的内容。一旦通过StringBuffer生成最终想要的字符串，就应该使用StringBuffer.toString方法将其转换成String类，随后就可能 使用String类的各种方法操纵这个字符串

java为字符串提供了特别的连接操作符（+）可以把其他数据类型的数据转换成字串。并前后接成新的字符串。连接操作符的功能是通过StringBuffer类和它的append方法实现

String x="a"+"4"+"c";
编译时等效于
String x=new StringBuffer().append("a").append("4").toString();

这里是一个print键盘录入的 数据。

class readline
{
    public static void main(String[ ] args)
    {
        byte buf[ ]=new byte[1024];
            String strInfo=null;
           int pos=0;
            int ch=0;
        System.out.println("please enter info, input bye for exit:");
        while (true)
        {
            try
            {
                ch=System.in.read();
            }
            catch (Exception e)
            {
                System.out.println(e.getMessage());
            }
            switch (ch)
            {
            case '\r':
            break;
            case '\n':
                strInfo=new String(buf,0,pos);
            if(strInfo=="bye")//改为if(strInfo.equals("bye"))
            return;
            else
                System.out.println(strInfo);
              pos=0;
              break;
              default:
                  buf[pos++]=(byte)ch;
            }
        }
    }
}

 String类的构造方法String(buf,0,pos)这个方法把数组buf里面的值 从0到pos取出，用来创建一个新的String类对象。

String类有几个比较常用的函数，如equalsIgnoreCase、indexof、substring

equalsIgnoreCase(String anotherString)是在比较两个字符串时忽略大小写，将if(strInfo=="bye")改成 if(strInfo.equalsIgnoreCase("bye"))这样就会输出bye就退出程序

indexOf(int ch)方法是用来返回一个字符串中的首次出现的位置，如果没有这个字符则返回-1.

它的另一种形式indexOf(int ch, int fro,Index)返回 的是从fromIndex指定的数值开始ch字符首次出现的位置该方法可以应用于文件和数据库内容的查找等 功能。

String str="hello world";

System.out.println(str.indexof('o'));//打印结果是4

String str="hello world";
System.out.println(str.indexOf('o',6));//结果是7

indexOf还有其他几种形式

indexOf(String str)

indexOf(String str,int fromIndex)

subString(int beginIndex)方法返回的是一个字符串中从beginIndex指定数值到末尾的一个字符串，如果beginIndex指定的数值超过当前字符串的长度，则返回一个空字符串

这个方法也有另一种形式substring(int beginIndex,int endIndex)返回 的是当前字符串中从beginIndex开始 到endIndex-1结束的一个字符串

String类中的replace和toUpperCase方法不能改变字符串的内容？与String类对象的内容一旦被初始化就不能再改变不矛盾么？

它们返回类型都是String类，即生成一个新的字符串，而不是改变原来的字符串内容。

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

java对数据即提供基本数据的简单类型，也提供了相应的包装类使用基本简单数据类型，可以改善系统的性能。

java中很多类参数类型都是object即这些方法接收的参数都 是对象 ，同时，当要使用这些方法来处理基本功数据类型的数据，【这就是包装类

包装类对象在进行基本数据类型的类型转换时也特别有用。比如整数与字符串之间的转换

打印一个矩形

calss TestInteger
{
public static void main(String[] args)
{
int w=Integer.parseInt(arfs[0]);//第一种方法
int h=new Integer(args[1]).intValue();//第二种方法
//int h=Integer.valieof(args[1]).intValue();第三种方法
for(int i=0;i<h;i++)
{
sb.append('*');
}
System.out.println(sb.toString());
}
}
}

java中的八种基本数据类型与其对应的那个包装类
Boolean         Boolean
Byte              Byte
Char              Character
short             Short
int                Integer
long               Long
float               Float
double            Double

字符串转换成基本数据类型都是用     Xxx包装类.parseXxx方式 实现 （除了Boolean类用的是getBoolean方法）。要将包装类转换成基本数据

几乎都是Xxx包装类对象 xxxValue方式

集合类：

 在java编程中经常 用到Vector   Enumeration     ArrayList    Collection     Iterator   Set          List等 集合类

Vector类与Enumeration接口

Vector类是java语言提供的一种高级数据结构，可用于保存一系列对象，java不支持动态数组Vector类提供了一种 与动态 数组类似的功能。在我们不能预先确定要保存的对象 的数目或需要方便 获得某个对象 的存在位置时，Vector是一个不错的选择

import java.util.*;//Vector和Enumeration都在这个包中
public class void main(String[] args)
{
int b=0;
Vector v=new Vector();
System.out,println("Please Enter Number:");
while(true)
{
try
{
b=System.in.read();
}
chtch(Exception e)
{
System.out.println(e.getMessage());
}
if(b=='\r'|| b=='\n')
break;
else
{
int num=b-'0';
v.addElement(new Integer(num));//这里因为不能使用数组存储数据，所以只能取对象类型数据
}
}
int sum=0;
Enumeration e=v.elments();//访问这个对象里面的所有元素
while(e.hasMoreElements())
{
Integer intobj=(Integer)e.nextElment();//这里是对数据类型进行转换
sum+=intobj.intValue();//这里就是一个简单的求和的计数器。
}
System.out.println(sum);
}
}

Enumeration是一个接口类，它提供了一种访问各种数据结构（Vector类只是其中一种）中的所有数据的抽象机制，就是我们要访问各种数据结构对象 中所有的元素时都 可以使用同样的方式
2.Collection接口Iterator接口

我们要取出保存在实现 了Collection接口对象中的所有对象，我们也必须通过Coolection.iterator方法返回一个Iterator接口对象，Iterator接口的功能与使用同Enumeration接口非常相似，所以创建 了Iterator这个新接口，并缩短了方法名长度。

不能直接 用Collection接口类创建对象，而必须用实现 了Collection接口的类来创建对象，ArrayList类就是一个实现了Collection接口的类，我们将上面使用Vector和Enumeration的例子改为脾ArrayList和Iterator编写

import java.util.*;//ArrayList类和Iterator接口都在此包中
public class TestCollection
{
public static void main(String[] args)
{
int b=0;
ArrayList a1=new ArrayList();
System.out.println("Please Enter Number:");
while(true)
{
try
{
b=System.in.read();
}
catch(Exception e)
{
System.our,println(e.getMessage());
}
if(b=='\r'| b=='\n')
break;
else
{
int num=b-'0';
a1.add(new Integer(num));
}
}
int sum=0;
Iterator itr=a1.iterator();
while(itr.hasNext())
{
Integer intobj=(Integer)itr.next();
sum+=intobj.inValue();
}
}
System.out.println(sum);
}

与上面的一样都是保存产输入 的数据的和只是这里换成了Iteratora接口ArrayLIst类中的所有方法 是非同步的，所以没有多线程安全问题时，最好用的就是ArrayList

3.集合类接口的比较

另外 还有几个集合接口Set   List    Collection

Collection ——对象 之间没有指定 的顺序允许重复元素

Set——对象 之间没有的顺序，不允许 重复元素

List——对象之间有指定 的顺序允许 重复元素  
我们还 可以利用List接口中对象 之间有指定的顺序对List接口中的对象进行排序。

import java.util.*;
public
{
public static void main(String[] args)
ArrayList a1=new ArrayList();
a1.add(new Integer(1));
a1.add(new Integer(2));
a1.add(new Integer(2));
System.out,.println(a1.toString());//排序前
Collectlions.sort(a1);//排序方法
System.out.println(a1.toString());//排序后
}
}

Hashtable和Properties类

 Hasgutable是一种高级数据结构，用于快速检索数据，除了可以动态的存储对象 。而且 对每个存储对象都会安排另一个对象与之关联

向Hashtable中存储数据，使用的是Hashtable.put(Object key,Object value)方法从Hashtable中检索数据，

使用Hashtable.get(Object key)方法值和关键字都可以是任何类型的非空对象

Hashtable numbers=new Hashtable();
number.put("one",new Integer(1));
number.put("two",new Integer(2));
numbers.put("three"new Integer(3));
要检索其中的"two"关键字对应的数据
Integer  n=(Integer)numbers.get("two");
if(n!=null)
{
System.out,println("two=  "+n);
}

想要成功地从Hashtable中检索数据，用作关键字的对象必须正确覆盖Object.hashCode方法Object.equals方法。覆盖Object.equals检索数据时判断是否相等检索不可能正确。Object.hashCode会返回一个叫散列码的值。这个值是以对象的地址以某种方式转换来的，如果是两个内容想同的对象。地址值也不可能一样，所以Object.hashCode的返回值也不一样。想要让两个内容相同的Object返回一样的散列码那么子类必须覆盖Object.hashCode方法。用于关键字的类

StringBuffer类不会按照关键字类的要求覆盖hashCode方法，因为对象内容即使相等，但是地址值不等 ，所以我不能使用StringBuffer作为关键字类。
关于equals和hashCode两个方法 的实现

class MyKey
{
private String neme;
private int agep;
public MyKey(String name, int age)
{
this.name=name;
this.age=age;
}
publblic String toString()
{
return new String(name+","+age);
}
public boolean equals(Object obj)
{
if(name.equals(obj.name)&&age==obj.age)
return true;
else
return false;
}
public int hashCode()
{
return name.hashCode()+age;
}
}
//如果两个人年龄和姓名都相同那么我们就说他们是同一个人，。也可以再加上身高什么的

使用MyKey类做为关键字，取出所有关键字的集合和取出所有值的集合

Systrm类与Runtime类

System类：

 java不支持全局函数和变量。但是在设计 时候将一些系统相关的重要函数主变量收集到了一个统一 的类中这个类就是System类。

System类中的所有成员都是静态的，当我们需要引用 这些变量和方法时，直接使System类名作为前缀

System类中几个方法

exit(int status)方法，提前终止虚拟机运行对于在发生了异常的情况下想终止 虚拟机运行，只需要传递一个非零的值作为参数，对于正常情况下传递一个为0的参数终止

CurrenTimeMills方法返回自1970年1月1日0点0分0秒起至今的时候以毫秒为单位，这是一个long的最大值，其实在计算机内部只有数值，没有日期及其他各种类型也就是说

我们平常用到的日期本质上就是一个数值，但是通过这个数值，能够推算出具体的时间单位

平还可以用CurrentTimeMillis方法检测一段代码运行时所花的时间。

Long startTime=System.currentTimeMills();
...代码断
Long endTime=System.currentTimeMills();
System.out.println("tota1 time expended is"+(starttime-endTime)+"milliseconds");

getProperties方法与java的环境变量

getProperties方法获取当前虚拟机的环境变量，path和classpath就是其中的两个环境变量，第一个属性都 是变量与值 成对的形式出现的

同样的道理：java做为一个虚拟的操作系统，它也有自己的环境属性。Properties是Hashtable的子类，正好可以用于环境变量属性中的多个变量/值对格式 的数据，getProperties方法返回值是包含了当前虚拟机的所有环境属性的Properties类型的对象，

import java.util.*;
public class SystemInfo
{
public static void main(String[] args)
{
properties sp=System.getProperties();
Enumeration e=sp.propertyNames();
while(e.hasMoreElments())
{
String key=(String)e.nextElement();
System.out.println(key+"  ="+sp.getProperth(key));
}
}
}

 Runtime类

Runtime类封装了java命令本身的运行进程，其中很多方法 与System中方法 相重复，我们不能直接 创建Runtime实例，但是可以通过静态方法 Runtime.getRuntime获得正在运行Runtime对象引用。

Exce方法，java命令运行后，本身 是多途径操作系统 上的一个进程，在这个进程 中启动一个新的进程 ，即执行其他程序时使用exce方法 .exec方法返回 一个代表子进程 Process类对象 这个对象 java进程 可以与子进程交互

public class TestRuntime
{
public static void main(String[] args)
{
process p=null;
try
{
p=Runtime.getRuntime().exec("notepad.exe TestRuntime.java");
Thread.sleep(5000);
}
catch(Exception e)
{
Systrm.out,println(e.getMessage());
}
p.destroy();
}
}

程序是不能直接创建Runtime的实例。所以只会产生一个Runtime的实例 对象，而不能产生多个实例对象，这种情况就是单例设计模式

Date与Calendar、DateFformat类：

 Date类用于表示日期和时间。最为简单的构造函数就是Date()但是由于没有考虑到国际化所以又设计了两个新的类一个是Calendar类另一个是DateFormat类

Calendar类是一个抽象类，主要用于完成日期字段之间的相互操作的功能。如Calendar.add方法可以实现在某一日期的基础上增加若干天后的新日期

Calendar.get方法可以取出日期对象 中的日期字段的值，Calendar.set方法修改日期对象中的年月日日期字段的值。Calendar.getImstance方法可以返回 一个Calendar类型的对象 实例，GregorianCalendar类是JDK目前提供的唯一一个Calendar的子类

import java.util.*;
class TestCalendar
{
public static void main(String[]args)
{
Calendar c1=Calendar.getInstance();//下面打印当前时间
System.out,println()c1.get(c1.YEAR)+"年"+(c1.get(c1.MONTH)+1)+"月"+c1.get(c1.MINTH)+"日"+c1.get(c1.HOUR)+":"+c1.get(c1.MINUTE)+":"+get(c1.SECOND));
c1.add(c1.dDAY-OF-YEAR,315);//增加315天
//下面我们来打印的是315天后的时间
System.out,println()c1.get(c1.YEAR)+"年"+(c1.get(c1.MONTH)+1)+"月"+c1.get(c1.MINTH)+"日"+c1.get(c1.HOUR)+":"+c1.get(c1.MINUTE)+":"+get(c1.SECOND));
}
}

 java.text.DateFpr,at就是实现一个将Date对象表示 的日期用指定格式输出和将特定格式的日期字符串转换成Date对象这样一个功能的抽象基类

当我们要将一个字符串转换成Date类时，字符串中代表字符必须在模板中YYYY的位置 y的个数为指定了年的位数

Math与Random类：

Math类包含了所有用于几何和三角浮点运算函数，。这些都是静态的

Random类就是一个伪随机数产生器，随机数是按照某种算法产生的，一旦用一个初值创建Random对象就可以得到一系列的

随机数相同的初值创建的Random对象随机数序列是相同的，Random类的Random()构造方法中使用当前的时间 来初始化Random对象