类库是Java应用程序接口(Application Programming Interface，API)，是系统提供的已实现的标准类的集合。
Java类库中的类和接口封装在特定的包里，每个包有自己的功能。
除了java.lang之外，其它包的内容需要经过import语句引用，方便在程序中使用。所有这些类的介绍和使用方法，Java都提供了极其完善的技术文档，这种机制在极大程度上释放了程序员，让他们何以把更多的时间放在对象的设计上，而不是语法和一些局部算法上。

包名	内容介绍
java.lang.*	Java编程语言的基本类库
java.util.*	包括集合类、事件处理模式、日期时间工具等各类常用工具包
java.math	提供了简明的整数算术以及十进制算数的基本函数
java.io	提供了通过数据流、对象序列以及文件系统实现的系统输入、输出
java.awt.*	提供了创建用户界面以及绘制、管理图形、图像的类
javax.swing.*	提供了一系列轻量级的用户界面组件,是目前Java用户界面常用的包
java.text	提供了一些类和接口用于处理文本、日期、数字以及语法独立于首然语言之外格式的消息
java.applet	提供了创建applet需要的类,包括帮助applet访间其内容的通讯类
java.net	提供了用于实现网络通讯应用的所有类
java.sql	提供了访回和处理来自于Java标准数据源数据的类
java.beans.*	提供开发Java Beans需要的类
java.security.*	提供了设计网络安全方案需要的类
javax.accessibility	定义了用户界面组件之间相互访间的一种机制
javax.naming.*	未命名服务提供了一系列类和接口
javax.rmi.*	为用户提供了远程方法调用的应用程序接口
javax.sound.*	提供了MIDI输入、输出以及合成需要的类和接口

Object类

Object类定义在Object.java文件中，属于java.lang包。
Object类是一种特殊类，Java中所有的类包括用户自定义的类都默认继承该类，或者说Object类是Java所有类的超类，所有对象（包括数组）都实现这个类的方法。

（1）equals()方法

声明格式：public boolean equals(Object obj)
指示其他某个对象是否与此对象“相等”。注意equals()方法判断相同的情况是两个对象指向同一块内存。

Object obj1=new Object();
Object obj2=new Object();
System.out.println(obj1.equals(obj2));
obj2=obj1;
System.out.println(obj1.equals(obj2));

任何Object对象的非空引用值obj1和obj2，当且仅当obj1和obj2引用同一个对象时，此方法才返回true。

（2）clone()方法

声明格式：protected Object clone()
创建并返回此对象的一个副本。此方法返回的对象应该独立于该对象（正被复制的对象）。

（3）getClass()方法

声明格式：public final Class<?> getClass()
返回此 Object 的运行时类。返回的 Class 对象是由所表示类的 static synchronized 方法锁定的对象。
getClass.getName()：返回对象所属类的名称。

（4）toString()方法

声明格式：public String toString()
返回该对象的字符串表示。通常，toString()方法会返回一个“以文本方式”表示此对象的字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成,它的值等于：getClass().getName() + '@' + Integer.toHexString(hashCode())
getClass()返回对象执行时的Class实例，然后使用此实例调用getName()方法可以取得类的名称。

Object obj1=new Object();       
System.out.println(obj1);//java.lang.object@1b48197
System.out.println(obj1.toString());//java.lang.object@1b48197

哈希码：hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值。Object类的hashCode.返回对象的内存地址经过处理后的结构，由于每个对象的内存地址都不一样，所以哈希码也不一样。

（5）hashCode()方法

声明格式：public int hashCode()
返回该对象的哈希码值。通常将对象的内存地址进行哈希运算，返回一个int类型的哈希值。

（6）finalize ()方法

声明格式：protected void finalize() throws Throwable
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。

（7）notify()方法

声明格式：public final void notify()
唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

（8）notifyAll()方法

声明格式：public final void notifyAll()
唤醒在此对象监视器上等待的所有线程。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

（9）wait()方法

声明格式：
public final void wait() throws InterruptedException;—— 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
public final void wait(long timeout,int nanos) throws InterruptedException;——在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。
public final void wait(long timeout) throws InterruptedException;——在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。

System类

java.lang.System类，其声明格式为：
public final class System extends Object
System类是一个特殊类，它是一个公共最终类，不能被继承，也不能被实例化（System类的构造方法是私有的private)，即不能创建System类的对象。
System的成员变量和成员方法都是static。使用时以System作为前缀，即形如“System.变量名”和“System.方法名”。

System类的公共数据流

标准输入流：public static final InputStream in，此流已打开并准备提供输入数据。通常，此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。
标准输出流：public static final PrintStream out，此流已打开并准备接受输出数据。通常，此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标。
标准错误输出流：public static final PrintStream err，此流已打开并准备接受输出数据。通常，此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标。按照惯例，此输出流用于显示错误消息，或者显示那些即使用户输出流（变量 out 的值）已经重定向到通常不被连续监视的某一文件或其他目标，也应该立刻引起用户注意的其他信息。

System类的常用方法

（1）arraycopy()方法：

从指定源数组的指定位置开始复制若干个数组元素到目标数组的指定位置。
声明格式：

public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)

src：源数组
srcPos：源数组中的起始位置
dest：目标数组
destPos：目标数组中的起始位置
length：要复制的数组元素的数量

arraycopy()举例：

public class Test {
    public static void main(String[] args) {
        int a[]={1,2,3,4,5};
        int b[]=new int[5];
        int c[]=new int[3];
        System.arraycopy(a,0,b,0,5);
        System.arraycopy(a,2,c,1,2);
        for(int i=0;i<5;i++)
            System.out.print(a[i]); //12345
        System.out.print('\n'); 
        for(int i=0;i<b.length;i++)
            System.out.print(b[i]);//12345
        System.out.print('\n'); 
        for(int i=0;i<c.length;i++)
            System.out.print(c[i]);//034
        System.out.print('\n'); 
    }
}

（2）getProperties ()方法

声明格式：public static Properties getProperties(argument);
返回系统环境信息：Java虚拟机维护了一系列系统环境信息，它们都是以“键名／值”对的形式出现的，一旦Java虚拟机启动之后，系统就自动将这些变量初始化，其中包含了与运行环境相关的很多信息。

（3）setProperty ()方法

声明格式：public static String setProperty(String key,String value)
设置系统变量的值，key为键名，value为键值。

（4）currentimeMillis ()方法

声明格式：public static long currentimeMillis()
返回系统时间，单位毫秒。

（5）exit()方法

声明格式：public static void exit(int status)
在用户的程序还未执行完之前，强制关闭Java虚拟机，并把状态信息status传递给操作系统，status非零时，表示非正常退出

（6）gc()方法

声明格式：public static void gc()
运行垃圾收集器

字符串类

Java提供了丰富的标准类，这些标准类被组织成类包，其中java.lang包中定义了String、StringBuffer、StringBuilder三个类，用于创建和处理字符串。Java将字符串作为这些类的对象来处理。

Java的字符串分为两种类型：

不可变字符串(字符串常量)：创建以后不能改变其内容的字符串，用String类创建和处理字符串常量；
可变字符串(字符串变量) ：创建以后可以改变其内容的字符串，StringBuffer和StringBuilder类用于创建和操作字符串变量。

String类

（1）声明字符串

字符串必须包含在一对双引号“”之内。
声明格式：String str=[null];
[null]若省略，表示str变量是未初始化的状态，否则表示声明的字符串的值等于null。

（2）创建字符串

格式一： String str=new String(参数列表);

String类的常用构造方法：

• public String()：初始化一个新创建的String对象，使其表示一个空字符序列。
• public String(String value)：初始化一个新创建的字符串对象，使其表示一个与参数相同的字符序列，或者说，新创建的字符串是该参数字符串的副本。
• public String(char value[])：分配一个新的字符串，使其表示字符数组参数中当前包含的字符序列。该字符数组的内容已被复制，后续对字符数组的修改不会影响新创建的字符串。
• public String(char a[],int startIndex, int numChars)：提取一个已经存在的字符数组a中的一部分创建一个新字符串，startIndex表示开始截取字符串的位置，numChars表示截取的字符个数，即字符串长度。该子串的内容已被复制，后续对字符数组a的修改不会影响新创建的字符串。
  String类构造方法的使用：

public class Test {
    public static void main(String[] args) {
        String s1=new String();
        char c[]={'s','t','u','d','e','n','t'};         
        String s2=new String(c);
        String s3=new String(c,2,3);
        String s4=new String(s3);
        System.out.println(s1);// 
        System.out.println(s2);//student
        System.out.println(s3);//ude
        System.out.println(s4);//ude    
        }
}

格式二： String str=字符串常量;
字符串常量即字符串的字面值。
字符串常量被存入一个字符数组，然后封装在String对象中。
第一次用到一个字面值时，在字符串常量池中新建对象。
再次用到相同字面值时，访问“常量池”中存在的对象，而不会新建。
创建字符串举例：

public class Test {
    public static void main(String[] args) {
        char[] a={'h','e','l','l','o'};
        String s1=new String(a);//新分配内存
        String s2="hello";//常量池新分配内存
        String s3="hello";//访问常量池存在的对象
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s1==s2);//比较s1和s2的内存地址
        System.out.println(s2==s3); //比较s1和s2的内存地址，s2和s3引用的是同一个内存地址
        System.out.println(s1.equals(s2));//比较字符串内容
    }
}

本程序的运行结果是：

hello
hello
hello
false
true
true

String类创建的字符串对象是不可修改的，因为其内部封装的数组是私有隐藏的，且没有提供公开的方法修改数组也就是说，String字符串不能修改、删除或替换字符串中的某个字符，即String对象一旦创建，那么实体是不可以再发生变化的。

String类的常用方法

charAt()方法

格式：public char charAt(int index)
功能：返回指定索引处的char值。索引范围为从0开始，到length() -1。序列的第一个char值位于索引0处，第二个位于索引1处，依此类推，这类似于数组下标。

compareTo()方法

格式：public int compareTo(String anotherString)
功能：按字典顺序比较两个字符串。如果按字典顺序此字符串对象位于参数字符串anotherString之前，则比较结果为一个负整数，即两个字符串的Unicode值之差。如果按字典顺序此字符串对象位于参数字符串之后，则比较结果为一个正整数，即两个字符串的Unicode值之差。如果这两个字符串相等，则结果为 0。
String类compareTo()方法的使用：

public class Test {
    public static void main(String[] args) {
        String s1="abc";
        String s2="abc";
        String s3="abcde";
        String s4="123";
        System.out.println(s1.compareTo(s2));//0
        System.out.println(s1.compareTo(s3));//-2
        System.out.println(s1.compareTo(s4));//48   
    }
}

endsWith()方法

格式：public boolean endsWith(String suffix)
功能：测试此字符串是否以指定字符串suffix为后缀结束。

startsWith()方法

格式：public boolean startsWith(String prefix)
功能：测试此字符串是否以指定的字符串prefix为前缀开始。

String s1="I am a student"; 
System.out.println(s1.endsWith("ent"));//true
System.out.println(s1.startsWith("a"));//false

equals()方法

格式：public boolean equals(Object anObject)
功能：此字符串与指定的对象比较。当且仅当该参数不为null，并且是与此对象表示相同字符序列的字符串对象时，结果才为“true”。

public class Test {
    public static void main(String[] args) {
        String aa="123";
        String bb="123";
        String a=new String("123");
        String b=new String("123");
        System.out.println(a.equals(b));//true
        System.out.println(a==b);//false    
        System.out.println(aa.equals(bb));//true
        System.out.println(aa==bb);//true   
    }
}

getChars()方法

格式：public void getChars(int srcBegin, int srcEnd, char dst[],int dstBegin)
功能：从该字符串中拷贝字符到目的字符数组中。
参数srcBegin表示要复制的字符串中第一个字符的索引。
参数srcEnd表示要复制的字符串中最后一个字符之后的索引。
参数dst表示目标数组。
参数dstBegin表示目标数组中的开始偏移量。
String类getChars()方法的使用:

public class Test {
    public static void main(String[] args) {
        String s="I am a student";
        int i=5;
        int j=14;
        char chars[]=new char[10];
        s.getChars(i,j,chars,0);
        System.out.println(chars);//a student
    }
}

indexOf()方法

格式：public int indexOf(int ch)
功能：返回指定字符在此字符串中第一次出现处的索引。如果未出现该字符，则返回-1。

String s="I am a student";
System.out.println(s.indexOf('a')); //2

length()方法

格式：public int length()
功能：返回此字符串的长度。

isEmpty()方法

格式：public boolean isEmpty()
功能：当且仅当length()为0时返回“true”。

String s="I am a student";
System.out.println(s.isEmpty());//false

replace()方法

格式：public String replace(char oldChar,char newChar)
功能：返回一个新的字符串，它是通过用newChar字符替换此字符串中出现的所有oldChar字符而生成的。

String s="I am a student";
System.out.println(s.replace('a','A'));//I Am A student

replaceAll()方法

格式：public String replaceAll(String old,String new)
功能：字符串对象s调用该方法可以获得一个字符串对象，这个字符串对象是通过用参数new字符串替换所有的old字符串而得到的字符串。

String s="I am a student";
System.out.println(s.replaceAll("am","AM"));//I AM a student

substring()方法

格式：
public String substring(int beginIndex)
public String substring(int beginIndex,int endIndex)
功能：返回一个新的字符串，它是此字符串的一个子字符串。当方法只有一个参数beginIndex时，该子字符串始于指定索引处的字符，一直到此字符串末尾；当方法有两个参数时，该子字符串从指定的beginIndex处开始，直到索引endIndex-1处的字符。

public class Test {
    public static void main(String[] args) {
        String s="I am a student";
        System.out.println(s.substring(5));//a student
        System.out.println(s.substring(2,8));//am a s
    }
}

trim()方法

格式：public String trim()
功能：返回字符串的副本，忽略前导空格和尾部空格。

String s="  I am a student  ";
System.out.println(s.trim());//I am a student

其他方法

toUpperCase()：所有字符都转换为大写

toLowerCase()：所有字符都转换为小写

compareToIgnorCase(String str)：忽略大小写比较，与另一个字符串按编码顺序比较大小

StringBuffer类

（1）StringBuffer类的声明

StringBuffer类能创建可修改的字符串序列，即该类的对象实体的内存空间可以自动改变大小，便于存放一个可变的字符串。
声明格式：StringBuffer str;

（2）StringBuffer类的创建

格式：str=new StringBuffer(参数列表);

StringBuffer类的常用构造方法：

StringBuffer()：创建一个空的StringBuffer对象,默认容量为16个字符
StringBuffer(int len)：构造一个空的字符串缓冲区，其初始容量由参数len设定
StringBuffer(String s)：创建一个StringBuffer对象，利用一个已经存在的字符串 。String的对象str来初始化该对象，其容量是String对象的长度加16个字符
例如：

StringBuffer s0=new StringBuffer();     
//分配了长16个字符的字符缓冲区
StringBuffer s1=new StringBuffer(512);
 //分配了512个字符的字符缓冲区
StringBuffer s2=new StringBuffer(“You are good!”); 
 //在字符缓冲区中存放字符串“Happy new year！”，另外，后面又留了16个字符的空缓冲区。

说明：每个StringBuffer对象都有一个容量，只要其字符序列的长度不超过其容量，就无需分配新的内部缓冲数组；如果内部缓冲数组溢出，StringBuffer对象的容量将自动增大。

（3）StringBuffer类的常用方法

StringBuffer类提供很多对字符串变量进行访问的方法，在这些方法中绝大部分与String类中的方法相同。同时，StringBuffer类还提供了用于字符串变量修改和扩充的方法。

字符串的访问

• public int length()：返回当前StringBuffer对象的长度（字符串的字符个数）
• public int capacity()：返回当前StringBuffer对象的容量，即总的可供分配的字符存储单元。

字符串的修改

• public void setCharAt (int index , char ch)：将指定的字符ch放到index指定的位置上。
• public char charAt(int n)：返回字符串中n位置上的字符， n的范围为0~length()-1。
• StringBuffer replace( int start ,int end, String str)：将start到end-1之间的子字符串用str替换。
• public StringBuffer append(String str)：将给定的字符串，追加到当前字符串变量的末尾。
• StringBuffer deleteCharAt(int a)：用于删除指定索引位置处的字符
• StringBuffer delete(int start, int end)：删除从start到end-1的子字符串。
• public StringBuffer reverse()：StringBuffer对象使用reverse()方法将该对象实体中的字符翻转，并返回当前对象的引用。
• public StringBuffer insert(int index, Object obj)：将指定的对象转换为字符串，插入指定的位置。
  StringBuffer类常用方法的使用：

public class Test {
    public static void main(String[] args) {
         StringBuffer s1=new StringBuffer("It is wild.");
         System.out.println(s1.capacity( ));
         System.out.println(s1.length( ));
         s1. setCharAt(6,'m');
         System.out.println(s1);
         StringBuffer s2=new StringBuffer("Good morning!");
         s2. replace(5,12, "afternoon "); 
         System.out.println(s2);
         StringBuffer s3=new StringBuffer("Hello");
         s3.append(" students.");
         s3.insert(6,"all ");
         System.out.println(s3);
         StringBuffer s4=new StringBuffer("Hello all students.");
         s4.delete(6,10);   
         System.out.println(s4);    
    }
}

本程序的运行结果是：

27
11
It is mild.
Good afternoon !
Hello all students.
Hello students.

String类由于使用频繁，有时也被视为基本类型
遇到双引号自动创建String类的对象
提供字符串运算符，字符串的连接：+
比较：
不可变字符串：String类（效率较高），不能更改
可变字符串：StringBuffer类(使用灵活），可追加、插入、修改，但内存管理复杂

创建字符串

StringBuffer   dest = new  StringBuffer(len);
String   s = new  String("abc");
String   s = "abc";

修改可变字符串(StringBuffer类的方法)

append(字符)：在字符串的最后追加一个字符
insert(位置，子串)：在字符串某位置插入子串
setCharAt(位置，替代字符)：将字符串指定位置处的字符置换成指定字符