Java有一系列功能强大的可重用类，分别在不同的包中，这些包按功能可划分为：语言包java.lang(language)、输入/输出包java.io、实用程序包java.util(utility)、小应用程序包java.applet、图形用户接口包java.swing、java.awt和网络包java.net等。有时人们称前三种包为java的基础包。
Java常用包的简单介绍如下：
1）java.lang包 主要含有与语言相关的类，如Math类，System类。java.lang包由解释程序自动加载，不需显式说明，
2）java.io包 主要含有与输入/ 输出相关的类，这些类提供了对不同的输入和输出设备读写数据的支持，这些输入和输出设备包括键盘、显示器、打印机、磁盘文件和网络等。
3）java.util包 包括许多具有特定功能的类，有日期、向量、哈希表、列表和堆栈等。
4）java.swing包和java.awt包 提供了创建图形用户界面元素的类。通过这些元素，编程者可以控制所写Applet或程序的外观界面。该包中包含定义窗口、对话框、按钮、复选框、列表、菜单、滚动条及文本域的类。
5）java.net包 含有与网络操作相关的类，如TCP sockets、URL以及二进制码向ASCII码转换的工具。
6）java.applet包 含有控制Hotjava浏览器的类，这些类可以控制HTML文档格式、应用程序中的声音资源等，其中Applet类是用来创建包含于HTML页内的applet必不可少的类。
Java语言的核心部分就是java.lang包, 它定义了Java中的大多数基本的类。每个java程序都自动导入java.lang包，由此可见该包的重要性。
java.lang 包中包含了Object类，java.lang.Object类是Java中整个类层次结构的根结点，这个软件包还定义了基本数据类型的类：String、Boolean、Character、Byte、Integer、Short、Long、Float和Double等。这些类支持数字类型的转换操作。java.lang包中的其他类还有：
Class:为运行时搜集的信息，如对instanceof操作符提供支持。
Math:提供像PI 和E 这样的数学常数及各种函数。
System:提供对操作系统的访问，包括默认的I/O流、环境变量、自动垃圾收集、系统时间和系统属性，许多System方法可访问Runtime类的方法。
Runtime:提供对操作系统的访问，使用java.lang.Runtime 可以使应用程序容易与它所运行的环境协调。
Thread:Thread和java.lang.Runnable接口协同作用提供对Java中多线程的支持。
Throwable:它是Java中所有异常（Exception）的基类，是java.lang.Exception、java.lang.Error和java.lang.RuntimeException的父类。应用程序运行发生意外时，异常和错误类就抛出对象。
Integer 类是基本类型 int类型的包装类。该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他方法。
1）属性：
static int MAX_VALUE：返回最大的整型数；
static int MIN_VALUE：返回最小的整型数；
static Class TYPE：返回当前类型。
例：
System.out.println('Integer.MAX_VALUE: ' Integer.MAX_VALUE );
结果为：Integer.MAX_VALUE: 2147483647
2）构造方法：
Integer(int value) ：通过一个int类型的变量构造对象；
Integer(String s) ：通过一个String的类型构造对象；
例：
Integer i = new Integer('1234');
生成了一个值为1234的Integer对象。
3）常用方法：
1’byteValue()：取得用byte类型表示的整数；
2’int compareTo(Integer anotherInteger) ：比较两个整数。相等时返回０；小于时返回负数；大于时返回正数。
例：
Integer i = new Integer(1234);
System.out.println('i.compareTo: ' i.compareTo(new Integer(123)) );
结果为：i.compareTo: 1
3’int compareTo(Object o) ：将该整数与其他类进行比较。如果o也为Integer类，进行方法2 的操作；否则，抛出ClassCastException异常。
4’int intValue() ： 返回该整型数所表示的整数。
5’long longValue() ：返回该整型数所表示的长整数。
6’static int parseInt(String s) ：将字符串转换成整数。s必须是时进制数组成，否则抛出NumberFormatException异常。
7’ static int parseInt(String s, int radix) ：以radix为基数radix返回s的十进制数。所谓的基数，就是“几进制”。
8’short shortValue() ：返回该整型数所表示的短整数。
9’static String toBinaryString(int i) ：将整数转为二进制数的字符串。
10’static String toHexString(int i) ：将整数转为十六进制数的字符串。
11’static String toOctalString(int i) ：将整数转为八进制数的字符串。
12’String toString() ：将该整数类型转换为字符串。
13’static String toString(int i) ：将该整数类型转换为字符串。不同的是，此为类方法。
14’static String toString(int i, int radix) ：将整数i以基数radix的形式转换成字符串。
例：
int i1 = 54321;
System.out.println('Integer.toString(int i,int radix): ' Integer.toString(i1,16) );
结果为：Integer.toString(int i, int radix): d431
Float、Double、Character等基本类型的类使用方法基本类似，这里就不再详述，用到时查阅API即可。
在实际应用中，经常会遇到对字符串进行动态修改。StringBuffer类可以完成字符串的动态添加、插入和替换等操作。
1）构造方法：
StringBuffer() ：构造一个没有任何字符的StringBuffer类。
StringBuffer(int length) ： ：构造一个没有任何字符的StringBuffer类，并且，其长度为length。
StringBuffer(String str) ：以str为初始值构造一个StringBuffer类。
2）常用方法：
1’StringBuffer append(元素类型)
向字符串缓冲区“追加”元素，这个“元素”参数可以是布尔量、字符、字符数组、双精度数、浮点数、整型数、长整型数对象类型的字符串、字符串和StringBuffer类等。如果添加的字符超出了字符串缓冲区的长度，Java将自动进行扩充。
2’int capacity() ：返回当前StringBuffer对象（字符串缓冲区）的总空间，而非字符号串的长度。
3’char charAt(int index) ：在当前StringBuffer对象中取索引号为index的字符。第一个字符的索引为“0”
4’StringBuffer delete(int start, int end) ：删除当前StringBuffer对象中以索引号start开始，到end结束的子串。
5’ StringBuffer deleteCharAt(int index) ：删除当前StringBuffer对象中索引号为index的字符。
6’StringBuffer insert(int offset, 类型名 参数名)
在当前StringBuffer对象中插入一个元素，在索引号offset处插入相应的值。
7’StringBuffer reverse() ：将字符串翻转。
StringBuffer sb = newStringBuffer('0123456789');
System.out.println( 'sb.reverse(): ' sb.reverse() );
结果为：sb.reverse(): 9876543210
8’void setLength(int newLength) ：重新设置字符串缓冲区中字符串的长度，如果newLength小于当前的字符串长度，将截去多余的字符。
StringBuffer sb = newStringBuffer('0123456789');
sb.setLength(5);
System.out.println( 'sb: ' sb );
结果为：sb: 01234
9’String substring(int start) ：取当前StringBuffer对象中，从start开始到结尾的子串。
10’String substring(int start, int end) ：取当前StringBuffer对象中，从start开始到end的子串。
11’String toString() ：将当前StringBuffer对象转换成String对象。
java.lang.Math类是标准的数学类，封装了一些数学函数和常量。
1）三角函数
下面的三个方法接受一个double类型的且以弧度为单位的角度值，并返回相应的运算结果。
1’sin(double a) 返回角度a的sin值；
2’cos(doublea) 返回角度a的cos值；
3’tan(doublea) 返回角度a的tan值；
下面的方法是反三角函数：
4’asin(double r) 返回 sin值为r的角度值；
5’acos(double r) 返回 cos值为r的角度值；
6’atan(double r) 返回 tan值为r的角度值。
2）乘方
1’pow(double y,double x) 返回y的x次方，例如，Math.pow(2.0,3.0)返回结果为8.0；
2’exp(double x) 返回ex ；
3’log(double x) 返回x的自然对数；
4’sqrt(double x) 返回x的平方根。
3）舍入
1’ceil(double a) 返回大于或等于a的最小整数值；
2’floor(double a)返回小于或等于a的最大整数值；
3’rint(double a) 返回舍入尾数后接近a的整型值；
4’round(float a) 返回舍入尾数后最接近a的整型值；
5’round(double a)返回舍入尾数后最接近a的长整型值。
4）其他
下面是几个应用于int、long、float和double类型的方法：
1’abs(a) 返回a的绝对值；
2’max(a,b)返回a和b的最大值；
3’min(a,b)返回a和b的最小值。
在 System 类中，有标准输入、标准输出和错误输出流；可以实现对外部定义的属性和环境变量的访问、加载文件和库的方法以及快速复制数组的方法等等。
System类不能被实例化。它有三个非常有用的对象：
static PrintStream err “标准”错误输出流。
static InputStream in “标准”输入流。
static PrintStream out “标准”输出流。
常用的方法有：
static void arraycopy(Object src, int srcPos,Object dest, int destPos, int length) 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
static long currentTimeMillis() 返回以毫秒为单位的当前时间。
static void exit(int status) 终止当前正在运行的 Java 虚拟机。按照惯例，非零的状态码表明非正常终止。
static void gc() 运行垃圾回收器。
每个 Java 应用程序都对应一个 Runtime 类实例，应用程序不能创建自己的 Runtime 类实例，但可以通过 getRuntime 方法获取当前运行时。
Runtime 类提供了很多方法，请阅读JDK的相关文档。
Java程序运行时，本身启动了一个进程，在这个进程中如何启动一个新进程呢？在Runtime中提供了一个exec方法，可以实现该功能。
java.util包提供了许多实用的类，如：日期、向量、哈希表、列表和堆栈等。
日期时间类是一个相对简单、但又使用频繁的类。利用日期时间类提供的方法，可以获取当前日期和时间，计算某年或某月的天数，或者对当前日期进行比较等。
1）构造方法：
1’public Date()
这个构造方法将把当前日期和时间保存到所创建的Date实例中。
2’public Date(int year, int month, int date)
根据所给定的year、month、date参数创建一个Date 实例。利用此构造方法，所创建的Date实例表示的日期与年（year）、月(month)、日(day)参数表示的日期等同。
3’public Date(int year, int month, int date, int hours, int minutes)
这个构造方法类似于第2个方法，只不过这里还提供了具体的小时（hours）和分钟（minutes）参数，因而时间要更为精确。
4’public Date(int year, int month, int date, int hours,int minutes,intseconds)
这个构造方法类似于第3个方法，所不同的是这里还提供了具体的秒（seconds）参数，时间又精确了一些。
一旦创建了日期时间类的一个实例，就可以用它的方法来检索有关日期和时间的信息。
2）方法：
1’public int getYear() 返回当前日期中的年份。
2’public int getMonth() 返回当前日期中的月份。
3’public int getDate() 返回当前日期在月份中的日期值（1-31）。
4’public int getDay() 返回某天是星期几。
5’public int getHours() 返回当前日期中的小时数。
6’public int getMinutes() 返回当前日期中的分钟数。
7’public int getSeconds() 返回当前日期中的秒数。
8’public boolean befor(Date when) 对日期实例所代表的时间和when进行比较。若比when早，返回true; 否则返回false
9’public boolean after(Date when) 对日期实例所代表的时间和when进行比较。若比when晚，返回true;否则返回false。
10’public boolean equal(Object obj) 比较两个日期对象。若相等,则返回true;否则返回false。
11’public String toString() 返回当前日期参数的字符串表示形式。注意：不同主机系统的日期表示形式不尽相同。
日期时间类的使用非常简单，只需要不带任何参数创建一个类实例，就可以生成一个代表当前日期的类。如下所示：
Date today = new Date();
System.out.println(today.toString());
或者也可用一个更为简单的方式：
System.out. println(today);
后一种方式中，println将自动调用toString方法，因而无需显式调用。
1)构造方法：
StringTokenizer(String str) ：构造一个用来解析str的StringTokenizer对象。java默认的分隔符是“空格”、“制表符(‘\t’)”、“换行符(‘\n’)”、“回车符(‘\r’)”。
StringTokenizer(String str, String delim) ：构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符。
StringTokenizer(String str, String delim, booleanreturnDelims) ：构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符，同时，指定是否返回分隔符。
2）常用方法：
1’int countTokens() ：返回nextToken方法被调用的次数。
2’boolean hasMoreTokens() ：返回是否还有分隔符。
3’boolean hasMoreElements() ：结果同2’。
4’String nextToken() ：返回从当前位置到下一个分隔符的字符串。
5’Object nextElement() ：结果同4’。
6’String nextToken(String delim) ：与4’类似，以指定的分隔符返回结果。
Random类的对象用于生成伪随机数流
1）构造方法：
Random()：创建一个新的随机数发生器。
Random(long seed) ：用一个种子（长整型）创建一个随机数发生器。
2）常用方法：
1’protected int next(int bits) ：产生下一个伪随机数。
2’boolean nextBoolean() ：返回下一个从随机发生器的系列中得到的均匀分布的布尔值。
3’void nextBytes(byte[] bytes) ：产生随机字节数组放到指定的数组中。
4’double nextDouble() ：返回下一个从随机发生器的系列中得到的均匀分布的0.0到1.0的双精度类型值。
5’float nextFloat() ：返回下一个从随机发生器的系列中得到的均匀分布的0.0到1.0的浮点类型值。
6’double nextGaussian() ：返回下一个从随机发生器的系列中得到的符合均匀分布的0.0的平均数到1.0方差的高斯分布双精度类型值。
7’int nextInt() ：返回下一个从随机发生器的系列中得到的均匀分布的整型值。
8’int nextInt(int n) ：返回下一个从随机发生器的系列中得到的均匀分布的0到指定整型数（n）之间的整型值。
9’long nextLong() ：返回下一个从随机发生器的系列中得到的均匀分布的长整型值。
10’void setSeed(long seed) ：设置随机数发生器的种子为一个长整型数。
这个类的对象使用一个48位的种子，如果这个类的两个实例是用同一个种子创建的，并且，各自对它们以同样的顺序调用方法，则它们会产生相同的数字序列。
下面就对上面的介绍做一个实验，尤其注意相同种子时的结果，如果用默认的构造方法构造对象，他们是属于同一个种子的。
例：Random类
import java.util.Random;
public class TestRandom{
publicstatic void main(String[] args){
Random r1 = new Random(50);
System.out.println('第一个种子为50的Random对象');
System.out.println('r1.nextBoolean():\t' r1.nextBoolean());
System.out.println('r1.nextInt():\t\t' r1.nextInt());
System.out.println('r1.nextDouble():\t' r1.nextDouble());
System.out.println('r1.nextGaussian():\t' r1.nextGaussian());
System.out.println('______________________________');
Randomr2 = new Random(50);
System.out.println('第二个种子为50的Random对象');
System.out.println('r2.nextBoolean():\t' r2.nextBoolean());
System.out.println('r2.nextInt():\t\t' r2.nextInt());
System.out.println('r2.nextDouble():\t' r2.nextDouble());
System.out.println('r2.nextGaussian():\t' r2.nextGaussian());
System.out.println('______________________________');
Random r3 = new Random(100);
System.out.println('种子为100的Random对象');
System.out.println('r3.nextBoolean():\t' r3.nextBoolean());
System.out.println('r3.nextInt():\t\t' r3.nextInt());
System.out.println('r3.nextDouble():\t' r3.nextDouble());
System.out.println('r3.nextGaussian():\t' r3.nextGaussian());
System.out.println('结果一目了然！');
}
}
结果：
第一个种子为50的Random对象
r1.nextBoolean(): true
r1.nextInt(): -1727040520
r1.nextDouble(): 0.6141579720626675
r1.nextGaussian(): 2.377650302287946
______________________________
第二个种子为50的Random对象
r2.nextBoolean(): true
r2.nextInt(): -1727040520
r2.nextDouble(): 0.6141579720626675
r2.nextGaussian(): 2.377650302287946
______________________________
种子为100的Random对象
r3.nextBoolean(): true
r3.nextInt(): -1139614796
r3.nextDouble(): 0.19497605734770518
r3.nextGaussian(): 0.6762208162903859
该类实现了List接口,用户可以对List中每个元素的插入位置进行精确地控制。也可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
与 set 不同，Vector通常允许重复的元素。
Vector 类可以实现可增长的对象数组。它的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。
1）构造方法：
Vector()构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
Vector(Collection<? extends E> c) 构造一个包含指定集合中的元素的向量，这些元素按其集合的迭代器返回元素的顺序排列。
Vector(int initialCapacity)使用指定的初始容量和等于零的容量增量构造一个空向量。
Vector(int initialCapacity, int capacityIncrement)使用指定的初始容量和容量增量构造一个空的向量。
2）方法：
1’public void setSize(int newSize)设置此向量的大小。如果新大小大于当前大小，则会在向量的末尾添加相应数量的 null 项。如果新大小小于当前大小，则丢弃索引 newSize 处及其之后的所有项。
2’public int capacity()返回此向量的当前容量。
3’public int size()返回此向量中的组件数。
4’public boolean isEmpty()测试此向量是否不包含组件。
5’public int indexOf(Object elem)搜索给定参数的第一个匹配项，使用 equals 方法测试相等性。
6’public E elementAt(int index)返回指定索引处的组件。
7’public E firstElement()返回此向量的第一个组件（位于索引 0 处的项）。
8’public E lastElement()返回此向量的最后一个组件。
9’public void setElementAt(E obj, int index)将此向量指定 index 处的组件设置为指定的对象。丢弃该位置以前的组件。索引必须为一个大于或等于0 且小于向量当前大小的值。此方法的功能与 set 方法的功能完全相同（后者是 List 接口的一部分）。请注意，set 方法将反转参数的顺序，与数组用法更为匹配。另外还要注意，set 方法将返回以前存储在指定位置的旧值。
10’public void removeElementAt(int index)删除指定索引处的组件。此向量中的每个索引大于或等于指定 index 的组件都将下移，使其索引值变成比以前小 1 的值。此向量的大小将减 1。
索引必须为一个大于或等于 0 且小于向量当前大小的值。
11’public void insertElementAt(E obj,int index)将指定对象作为此向量中的组件插入到指定的 index 处。此向量中的每个索引大于或等于指定 index 的组件都将向上移位，使其索引值变成比以前大 1 的值。索引必须为一个大于或等于 0 且小于或等于向量当前大小的值（如果索引等于向量的当前大小，则将新元素追加到向量）。
12’public void addElement(E obj)将指定的组件添加到此向量的末尾，将其大小增加 1。如果向量的大小比容量大，则增大其容量。
此方法的功能与 add(Object) 方法的功能完全相同（后者是 List 接口的一部分）。
13’public boolean removeElement(Object obj)从此向量中移除变量的第一个（索引最小的）匹配项。如果在此向量中找到该对象，那么向量中索引大于或等于该对象索引的每个组件都会下移，使其索引值变成比以前小 1 的值。
此方法的功能与 remove(Object) 方法的功能完全相同（后者是 List 接口的一部分）。
14’public void removeAllElements()从此向量中移除全部组件，并将其大小设置为零。
此方法的功能与 clear 方法的功能完全相同（后者是List 接口的一部分）。
15’public E get(int index)返回向量中指定位置的元素。
16’public boolean add(E o)将指定元素追加到此向量的末尾。
17’public boolean remove(Object o)移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。
18’public void add(int index,E element)在此向量的指定位置插入指定的元素。将当前位于该位置的元素（如果有）及所有后续元素右移（将其索引加 1）。
19’public void clear()从此向量中移除所有元素。此调用返回后，向量将为空（除非抛出了异常）。
例：输入一串数字，求每位的和
import java.util.*;
classTestVector{
public static void main(String args[]){
intb=0,sum=0;
Vector<Integer> v=new Vector<Integer>();//<>括号内指明该集合存储元素的类型
System.out.println('please inputnumber:');
while(true){
try{
b=System.in.read();
}
catch(Exception e){
}
if(b=='\r'||b=='\n')break;
else {
int num=b-'0';
v.addElement(new Integer(num));
}
}
for(int i=0;i<v.size();i ){
sum =((Integer)(v.elementAt(i))).intValue();
}
System.out.println('totalis:' sum);
}
}
ArrayList类大致上等同于 Vector 类，也实现了List接口，但是此类是不同步的，而Vector类是同步的，每个 ArrayList 实例都有一个容量。该容量是指用来存储列表元素的数组的大小，随着向ArrayList 中不断添加元素，其容量也自动增长。
1）构造方法：
ArrayList()构造一个初始容量为 10 的空列表。
ArrayList(Collection<? extends E> c)构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
ArrayList(int initialCapacity)构造一个具有指定初始容量的空列表。
2）常用方法：
boolean add(E o) 将指定的元素追加到此列表的尾部。
void add(int index, E element)将指定的元素插入此列表中的指定位置。
boolean addAll(Collection<? extends E> c)按照指定 Collection 的迭代器所返回的元素顺序，将该 Collection 中的所有元素追加到此列表的尾部。
boolean addAll(int index, Collection<? extendsE> c) 从指定的位置开始，将指定 Collection 中的所有元素插入到此列表中。
void clear()移除此列表中的所有元素。
int indexOf(Object elem)搜索给定参数第一次出现的位置，使用 equals 方法进行相等性测试。
boolean isEmpty()测试此列表中是否没有元素。
int lastIndexOf(Object elem)返回指定的对象在列表中最后一次出现的位置索引。
E remove(int index)移除此列表中指定位置上的元素。
int size()返回此列表中的元素数。
Object[] toArray() 返回一个按照正确的顺序包含此列表中所有元素的数组。
例：ArrayList类
import java.util.*;
class ArrayListDemo{
publicstatic void main(String[] argas){
ArrayList<String> al=newArrayList<String>();//JDK1.5后在集合类中建议指定集合存放的类型。
al.add('zhangsan');
al.add('lisi');
al.add('wangwu');
System.out.println(al);
}
}
HashSet类实现 Set 接口，由哈希表支持。它不保证集合的迭代顺序；特别是它不保证该顺序恒久不变。HashSet类允许使用 null 元素。实现是不同步的。
Set集合中元素是无序的，不允许有重复的元素。
例8-8：
import java.util.*;
public class HashSetDemo {
publicstatic void main(String[] args) {
HashSet<Student> hs=newHashSet<Student>();
hs.add( newStudent(1001,'liping'));
hs.add(newStudent(1002,'lisi'));
hs.add(newStudent(1003,'wanglili'));
Iterator it=hs.iterator();
while(it.hasNext()){
Studentstu=(Student)it.next();
stu.showInfo();
}
}
}
class Student{
private final int 学号;
privateString 姓名;
publicStudent(int no,String s){
学号=no;
姓名=s;
}
publicvoid setName(String s){
姓名=s;
}
publicString getName(){
return 姓名;
}
publicint getId(){
return 学号;
}
publicvoid showInfo(){
System.out.println('学号:' 学号 '\n姓名:' 姓名);
}
}
Iterator是对集合进行迭代的迭代器。迭代器代替了 Java Collections Framework 中的 Enumeration。迭代器允许在迭代期间从迭代器所指向的集合中移除元素。
常用方法如下：
boolean hasNext()
如果仍有元素可以迭代，则返回 true。
E next()
返回迭代的下一个元素。
void remove()
从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操作）。
联系客服
