java的基础类库称为,6. Java基础类库

以下是《疯狂Java讲义》中的一些知识，如有错误，烦请指正。

与用户互动

Java程序的参数

如果运行Java程序时在类名后紧跟一个或多个字符串(多个字符串之间以空格隔开)，JVM就会把这些字符串依次赋给args数组元素。

如果某参数本身包含了空格，则应该将该参数用双引号(")括起来，否则JVM会把这个空格当成参数分隔符，而不是当成参数本身。

使用Scanner获取键盘输入

使用Scanner类可以很方面地获取用户的键盘输入，Scanner是一个基于正则表达式的文本扫描器，它可以从文件、输入流、字符串中解析出基本类型值和字符串值。Scanner类提供了多个构造器，不同的构造器可接受文件、输入流、字符串作为数据源，用于从文件、输入流、字符串中解析数据。

Scanner主要提供了两个方法来扫描输入：

hasNextXxx()：是否还有下一个输入项，其中Xxx可以是Int、Long等代表基本数据类型的字符串。如果需要判断是否包含下一个字符串，则可以省略Xxx。

nextXxx()：获取下一个输入项。Xxx的含义与前一个方法中Xxx相同。

import java.util.*;

public class ScannerKeyBoardTest

{

public static void main(String[] args)

{

// System.in代表标准输入，就是键盘输入

Scanner sc = new Scanner(System.in);

// 增加下面一行将只把回车作为分隔符

// sc.useDelimiter("\n");

// 判断是否还有下一个输入项

while(sc.hasNext())

{

// 输出输入项

System.out.println("键盘输入的内容是："

+ sc.next());

}

}

}

获取任意类型的输入项

import java.util.*;

public class ScannerLongTest

{

public static void main(String[] args)

{

// System.in代表标准输入，就是键盘输入

Scanner sc = new Scanner(System.in);

// 判断是否还有下一个long型整数

while(sc.hasNextLong())

{

// 输出输入项

System.out.println("键盘输入的内容是："

+ sc.nextLong());

}

}

}

文件读取

import java.util.*;

import java.io.*;

public class ScannerFileTest

{

public static void main(String[] args)

throws Exception

{

// 将一个File对象作为Scanner的构造器参数，Scanner读取文件内容

Scanner sc = new Scanner(new File("ScannerFileTest.java"));

System.out.println("ScannerFileTest.java文件内容如下：");

// 判断是否还有下一行

while(sc.hasNextLine())

{

// 输出文件中的下一行

System.out.println(sc.nextLine());

}

}

}

系统相关

System类

System类提供了代表标准输入、标准输出和错误输出的类属性；并提供了一些静态方法用于访问环境变量、系统属性的方法；还提供了加载文件和动态链接库的方法。下面程序通过System类来访问操作的环境变量和系统属性。

import java.io.*;

import java.util.*;

public class SystemTest

{

public static void main(String[] args) throws Exception

{

// 获取系统所有的环境变量

Map env = System.getenv();

for (String name : env.keySet())

{

System.out.println(name + " ---> " + env.get(name));

}

// 获取指定环境变量的值

System.out.println(System.getenv("JAVA_HOME"));

// 获取所有的系统属性

Properties props = System.getProperties();

// 将所有系统属性保存到props.txt文件中

props.store(new FileOutputStream("props.txt")

, "System Properties");

// 输出特定的系统属性

System.out.println(System.getProperty("os.name"));

}

}

如果两个对象的相同，一定是同一个对象。

public class IdentityHashCodeTest

{

public static void main(String[] args)

{

// 下面程序中s1和s2是两个不同对象

String s1 = new String("Hello");

String s2 = new String("Hello");

// String重写了hashCode()方法——改为根据字符序列计算hashCode值，

// 因为s1和s2的字符序列相同，所以它们的hashCode方法返回值相同

System.out.println(s1.hashCode()

+ "----" + s2.hashCode());

// s1和s2是不同的字符串对象，所以它们的identityHashCode值不同

System.out.println(System.identityHashCode(s1)

+ "----" + System.identityHashCode(s2));

String s3 = "Java";

String s4 = "Java";

// s3和s4是相同的字符串对象，所以它们的identityHashCode值相同

System.out.println(System.identityHashCode(s3)

+ "----" + System.identityHashCode(s4));

}

}

Runtime类

Runtime类代表Java程序的运行时环境，每个Java程序都有一个与之对应的Runtime实例，应用程序通过该对象与其运行时环境相连。

应用程序不能创建自己的Runtime实例，但可以通过getRuntime()方法获取与之关联的Runtime对象。

Runtime类代表Java程序的运行时环境，可以访问JVM的相关信息，如处理器数量，内存信息等。

public class RuntimeTest

{

public static void main(String[] args)

{

// 获取Java程序关联的运行时对象

Runtime rt = Runtime.getRuntime();

System.out.println("处理器数量："

+ rt.availableProcessors());

System.out.println("空闲内存数："

+ rt.freeMemory());

System.out.println("总内存数："

+ rt.totalMemory());

System.out.println("可用最大内存数："

+ rt.maxMemory());

}

}

除此之外，Runtime还有一个功能：它可以直接单独启动一条进程来运行操作系统的命令。

public class ExecTest

{

public static void main(String[] args)

throws Exception

{

Runtime rt = Runtime.getRuntime();

// 运行记事本程序

rt.exec("notepad.exe");

}

}

常用类

Object类

Object类是所有类、数组、枚举类的父类，也就是说，Java允许把所有任何类型的对象赋给Object类型的变量。当定义一个类时没有使用extends关键字为它显式指定父类，则该类默认继承Object父类。

Object还提供了一个protected修饰的clone()方法，程序员可重写该方法来实现“浅克隆”。

自定义类实现“浅克隆”的步骤：

自定义类实现Cloneable接口。

自定义类实现clone()方法。

在clone()方法中通过super.clone()调用Object的clone()方法来实现“浅克隆”。

class Address

{

String detail;

public Address(String detail)

{

this.detail = detail;

}

}

// 实现Cloneable接口

class User implements Cloneable

{

int age;

Address address;

public User(int age)

{

this.age = age;

address = new Address("广州天河");

}

// 通过调用super.clone()来实现clone()方法

public User clone()

throws CloneNotSupportedException

{

return (User)super.clone();

}

}

public class CloneTest

{

public static void main(String[] args)

throws CloneNotSupportedException

{

User u1 = new User(29);

// clone得到u1对象的副本。

User u2 = u1.clone();

// 判断u1、u2是否相同

System.out.println(u1 == u2); //false

// 判断u1、u2的address是否相同

//不会对引用类型的成员变量值所引用的对象进行深克隆

System.out.println(u1.address == u2.address); //true

}

}

复制出来的只是原有对象的副本，只是一种浅克隆，只克隆该对象的所有成员变量值，不会对引用类型的成员变量值所引用的对象进行深克隆。深克隆需要开发者子集进行递归克隆。

Objects类

题外话：工具类命名习惯是添加s，如Arrays、Collections。

hashCode()：返回指定对象的hashCode值。

toString：返回指定对象的“描述性”字符串。

requiredNonNull：检查对象是否为null。主要用于对方法形参进行输入校验。

import java.util.Objects;

public class ObjectsTest

{

// 定义一个obj变量，它的默认值是null

static ObjectsTest obj;

public static void main(String[] args)

{

// 输出一个null对象的hashCode值，输出0

System.out.println(Objects.hashCode(obj));

// 输出一个null对象的toString，输出null

System.out.println(Objects.toString(obj));

// 要求obj不能为null，如果obj为null则引发异常

System.out.println(Objects.requireNonNull(obj

, "obj参数不能是null！"));

}

}

String、StringBuffer和StringBuilder

字符串就是一连串的字符序列，Java提供了String和StringBuffer两个类来封装对字符串，并提供了系列方法来操作字符串对象。

String类是不可变类的，

StringBuffer对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append、insert、reverse、setCharAt、setLength等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString方法将其转换为一个String对象。

JDK1.5又新增了一个StringBuilder类，它也代表了字符串对象。StringBuilder是线程不安全的。

public class StringBuilderTest

{

public static void main(String[] args)

{

StringBuilder sb = new StringBuilder();

// 追加字符串

sb.append("java");//sb = "java"

// 插入

sb.insert(0 , "hello "); // sb="hello java"

// 替换

sb.replace(5, 6, ","); // sb="hello, java"

// 删除

sb.delete(5, 6); // sb="hellojava"

System.out.println(sb);

// 反转

sb.reverse(); // sb="avajolleh"

System.out.println(sb);

System.out.println(sb.length()); // 输出9

System.out.println(sb.capacity()); // 输出16

// 改变StringBuilder的长度，将只保留前面部分

sb.setLength(5); // sb="avajo"

System.out.println(sb);

}

}

Math 类

Math类是一个工具类，它的构造器被定义成private的，因此无法创建Math类的对象；Math类中所有方法都是类方法，可以直接通过类名来调用它们。

Random与ThreadLocalRandom

Random类专门用于生成一个伪随机数，它有两个构造器：一个构造器使用默认的种子，另一个构造器需要程序员显式传入一个long型整数的种子。

相对于Math的random()方法而言，Random类的提供了更多方法来生成各种伪随机数，它不仅可以生成浮点类型的伪随机数，也可以生成整数类型的伪随机数，还可以指定生成随机数的范围。

ThreadLocalRandom是Java7新增的，它可以在多线程环境下代替Random减少多线程资源竞争，从而提供更好的线程安全。

import java.util.*;

public class RandomTest

{

public static void main(String[] args)

{

Random rand = new Random();

System.out.println("rand.nextBoolean()："

+ rand.nextBoolean());

byte[] buffer = new byte[16];

rand.nextBytes(buffer);

System.out.println(Arrays.toString(buffer));

// 生成0.0~1.0之间的伪随机double数

System.out.println("rand.nextDouble()："

+ rand.nextDouble());

// 生成0.0~1.0之间的伪随机float数

System.out.println("rand.nextFloat()："

+ rand.nextFloat());

// 生成平均值是 0.0，标准差是 1.0的伪高斯数

System.out.println("rand.nextGaussian()："

+ rand.nextGaussian());

// 生成一个处于int整数取值范围的伪随机整数

System.out.println("rand.nextInt()：" + rand.nextInt());

// 生成0~26之间的伪随机整数

System.out.println("rand.nextInt(26)：" + rand.nextInt(26));

// 生成一个处于long整数取值范围的伪随机整数

System.out.println("rand.nextLong()：" + rand.nextLong());

}

}

BigDecimal

float、double两种基本浮点类型的浮点数容易引起精度丢失。

程序中需要对double浮点数进行加、减、乘、除基本运算，则需要先将double类型数值包装成BigDecimal对象，调用BigDecimal对象的方法执行运算后再将结果转换成double型变量。

public class BigDecimalTest

{

public static void main(String[] args)

{

BigDecimal f1 = new BigDecimal("0.05");

BigDecimal f2 = BigDecimal.valueOf(0.01);

BigDecimal f3 = new BigDecimal(0.05);

System.out.println("使用String作为BigDecimal构造器参数：");

System.out.println("0.05 + 0.01 = " + f1.add(f2));

System.out.println("0.05 - 0.01 = " + f1.subtract(f2));

System.out.println("0.05 * 0.01 = " + f1.multiply(f2));

System.out.println("0.05 / 0.01 = " + f1.divide(f2));

System.out.println("使用double作为BigDecimal构造器参数：");

System.out.println("0.05 + 0.01 = " + f3.add(f2));

System.out.println("0.05 - 0.01 = " + f3.subtract(f2));

System.out.println("0.05 * 0.01 = " + f3.multiply(f2));

System.out.println("0.05 / 0.01 = " + f3.divide(f2));

}

}

注意：创建BigDecimal对象时，不要直接使用double浮点数作为构造器参数调用BigDecimal构造器

。否则会有精度损失。

日期时间类

Date类

Date类从JDK1.0起就开始存在了。但正因为它历史悠久，所以它的大部分构造器、方法都已经过时，不再推荐使用了

Calender类

因为Date类的设计上存在一些缺陷，Java提供了Calendar类来更好地处理日期和时间。Calendar是一个抽象类，它用于表示日历。

Calendar本身是一个抽象类，它是所有日历类的模板，并提供了一些所有日历通用的方法，但它本身不能直接实例化。程序只能创建Calendar子类的实例，Java本身提供了一个GregorianCalendar类，一个代表Gregorian Calendar的子类，它代表了我们通常所说的公历。

开发者可以开发自己的Calendar子类。

import java.util.*;

public class CalendarTest

{

public static void main(String[] args)

{

Calendar c = Calendar.getInstance();

// 取出年

System.out.println(c.get(YEAR));

// 取出月份

System.out.println(c.get(MONTH));

// 取出日

System.out.println(c.get(DATE));

// 分别设置年、月、日、小时、分钟、秒

c.set(2003 , 10 , 23 , 12, 32, 23); //2003-11-23 12:32:23

System.out.println(c.getTime());

// 将Calendar的年前推1年

c.add(YEAR , -1); //2002-11-23 12:32:23

System.out.println(c.getTime());

// 将Calendar的月前推8个月

c.roll(MONTH , -8); //2002-03-23 12:32:23

System.out.println(c.getTime());

Calendar cal1 = Calendar.getInstance();

cal1.set(2003, 7, 23, 0, 0 , 0); // 2003-8-23

cal1.add(MONTH, 6); //2003-8-23 => 2004-2-23

System.out.println(cal1.getTime());

Calendar cal2 = Calendar.getInstance();

cal2.set(2003, 7, 31, 0, 0 , 0); // 2003-8-31

// 因为进位到后月份改为2月，2月没有31日，自动变成29日

cal2.add(MONTH, 6); // 2003-8-31 => 2004-2-29

System.out.println(cal2.getTime());

Calendar cal3 = Calendar.getInstance();

cal3.set(2003, 7, 23, 0, 0 , 0); //2003-8-23

// MONTH字段“进位”，但YEAR字段并不增加

cal3.roll(MONTH, 6); //2003-8-23 => 2003-2-23

System.out.println(cal3.getTime());

Calendar cal4 = Calendar.getInstance();

cal4.set(2003, 7, 31, 0, 0 , 0); //2003-8-31

// MONTH字段“进位”后变成2，2月没有31日，

// YEAR字段不会改变，2003年2月只有28天

cal4.roll(MONTH, 6); //2003-8-31 => 2003-2-28

System.out.println(cal4.getTime());

}

}