2019-07-31 15:42 已编辑北京理工大学珠海学院 Java

关注

JavaSE部分——Java基础类库

Java基础类库

一、Scanner获取键盘输入

hasNextXxx()：是否还有下一个输入项
nextXxx()：获取下一个输入项

代码示例

import java.util.Scanner;

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

boolean hasNextLine()：返回输入源中是否还有下一行
String nextLine()：返回输入源中下一行的字符串

代码示例

import java.io.File;
import java.util.Scanner;

public class ScannerFileTest {
    public static void main(String[] args) throws Exception {
        // System.in代表标准输入，就是键盘输入
        Scanner sc = new Scanner(new File("D:\\eclipse-workspace\\JavaSE\\day07面向对象-1\\src\\ScannerFileTest.java"));
        System.out.println("ScannerFileTest.java文件内容如下: ");
        // 判断是否还有下一行
        while (sc.hasNextLine()) {
            // 输出文件中的下一行
            System.out.println(sc.nextLine());
        }
    }
}

二、系统相关

1、System类

标准输入、标准输出、错误输出

代码示例

import java.io.FileOutputStream;
import java.util.Map;
import java.util.Properties;

public class SystemTest {
    public static void main(String[] args) throws Exception {
        // 获取系统所有的环境变量
        Map<String, String> env = System.getenv();
        for (String name : env.keySet()) {
            System.out.println(name + "--->" + env.get(name));
        }
        System.out.println("---------------------------");
        // 获取指定环境变量的值
        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"));
    }
}

获取系统当前时间
- currentTimeMillis()和nanoTime()返回long型整数
identityHashCode(Object x)返回指定对象的精确的hashCode值，如果两个对象的identityHashCode值相同，则两个对象绝对是同一个对象

代码示例

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";
        // s1和s2是相同的字符串对象，所有它们的identityHashCode值相同
        System.out.println(System.identityHashCode(s3) + "----" + System.identityHashCode(s4));
    }
}

2、Runtime类与Java 9 的ProcessHandle

Runtime代码示例

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

ProcessHandle代码示例

import java.util.concurrent.CompletableFuture;

public class ProcessHandleTest {
    public static void main(String[] args) throws Exception {
        Runtime rt = Runtime.getRuntime();
        // 运行记事本程序
        Process p = rt.exec("notepad.exe");
        ProcessHandle ph = p.toHandle();
        System.out.println("进程是否运行: " + ph.isAlive());
        System.out.println("进程ID: " + ph.pid());
        System.out.println("父进程: " + ph.parent());
        // 获取ProcessHandle.Info信息
        ProcessHandle.Info info = ph.info();
        // 通过ProcessHandle.Info信息获取进程相关信息
        System.out.println("进程命令: " + info.command());
        System.out.println("进程参数: " + info.arguments());
        System.out.println("进程启动时间: " + info.startInstant());
        System.out.println("进程累计运行时间: " + info.totalCpuDuration());
        // 通过CompletableFuture在进程结束时运行某个任务
        CompletableFuture<ProcessHandle> cf = ph.onExit();
        cf.thenRunAsync(() -> {
            System.out.println("程序退出");
        });
        Thread.sleep(5000);
    }
}

三、常用类

1、Object类

boolean equals(Object obj)：判断指定对象与该对象是否相等。此处相等的标准是，两个对象是同一个对象，因此该equals()方法通常没有太大的实用价值
protected void finalize()：当系统中没有引用变量引用到该对象时，立即回收器调用此方法来清理该对象的资源
Class<?> getClass()：返回该对象的运行时类
int hashCode()：返回该对象的hashCode值
String toString()

自定义类实现“克隆”的步骤如下:

自定义类实现Cloneable接口
自定义类实现自己的clone()方法
实现clone()方法时通过super.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
    }
}

2、Java 7 新增的Objects类

工具类的用法

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!"));
    }
}

3、Java 9 改进的String、StringBuffer和StringBuilder类

String类是不可变类，即一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁
StringBuffer对象则代表一个字符序列可变的字符串，一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象，StringBuffer是线程安全的
StringBuilder代表可变字符串对象，StringBuilder则没有实现线程安全功能，所以性能略高。通常情况下，如果需要创建一个内容可变的字符串对象，则应该优先考虑使用StringBuilder类

详细见252页

4、Math类

详细见256页

5、Java 7 的ThreadLocalRandom与Random

在并发访问的环境下，使用ThreadLocalRandom来代替Random可以减少多线程资源竞争，最终保证系统具有更好的线程安全性
Random用法如下

import java.util.Arrays;
import java.util.Random;

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

如果这个类的两个实例是用同一个种子创建的，对它们以同样的顺序调用方法，则它们会产生相同的数字序列

import java.util.Random;

public class SeedTest {
    public static 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" + r1.nextInt());
        System.out.println("r1.nextDouble():\t" + r1.nextDouble());
        System.out.println("r1.nextGaussian():\t" + r1.nextGaussian());
        System.out.println("----------------------------");
        Random r2 = new Random(50);
        System.out.println("第二个种子为50的Random对象");
        System.out.println("r2.nextBoolean():\t" + r2.nextBoolean());
        System.out.println("r2.nextInt():\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("第一个种子为50的Random对象");
        System.out.println("r3.nextBoolean():\t" + r3.nextBoolean());
        System.out.println("r3.nextInt():\t" + r3.nextInt());
        System.out.println("r3.nextDouble():\t" + r3.nextDouble());
        System.out.println("r3.nextGaussian():\t" + r3.nextGaussian());
        System.out.println("----------------------------");
    }
}

ThreadLocalRandom代码示例

import java.util.concurrent.ThreadLocalRandom;

public class ThreadLocalRandomTest {
    public static void main(String[] args) {
        ThreadLocalRandom rand = ThreadLocalRandom.current();
        // 生成一个4~20之间的伪随机整数
        int val1 = rand.nextInt();
        System.out.println(val1);
        // 生成一个2.0~10.0之间的伪随机浮点数
        double val2 = rand.nextDouble(2.0, 10.0);
        System.out.println(val2);
    }
}

6、BigDecimal类

import java.math.BigDecimal;

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));
    }
}
使用String作为BigDecimal构造器参数: 
0.05 + 0.01 = 0.06
0.05 - 0.01 = 0.04
0.05 * 0.01 = 0.0005
0.05 / 0.01 = 5
使用double作为BigDecimal构造器参数: 
0.05 + 0.01 = 0.06000000000000000277555756156289135105907917022705078125
0.05 - 0.01 = 0.04000000000000000277555756156289135105907917022705078125
0.05 * 0.01 = 0.0005000000000000000277555756156289135105907917022705078125
0.05 / 0.01 = 5.000000000000000277555756156289135105907917022705078125

四、日期、时间类

1、Date类

Date()
Date(long date)
boolean after(Date when)
boolean before(Date when)
long getTime()
void setTime(long time)

代码示例

import java.util.Date;

public class DateTest {
    public static void main(String[] args) {
        Date d1 = new Date();
        // 获取当前时间之后100ms的时间
        Date d2 = new Date(System.currentTimeMillis() + 100);
        System.out.println(d2);
        System.out.println(d1.compareTo(d2));
        System.out.println(d1.before(d2));
    }
}

2、Calendar类

3、Java 8 新增的日期、时间包

五、正则表达式

String类里

boolean matches(String regex)
String replaceAll(String regex,String replacement)
String replaceFirst(String regex,String replacement)
String[] split(String regex)

1、创建正则表达式

2、使用正则表达式

Pattern对象是正则表达式编译后再内存中的表示形式，因此，正则表达式字符串必须先辈编译为Pattern对象，然后再利用该Pattern对象创建对应的Matcher对象。执行匹配所涉及的状态保留在Matcher对象中，多个Matcher对象可共享同一个Pattern对象。
如果某个正则表达式仅需一次使用，则可直接使用Pattern类的静态matches()方法，此方法自动把指定字符串编译成匿名的Pattern对象，并执行匹配

Matcher类里

find()：返回目标字符串中是否包含与Pattern匹配的子串
group()：返回上一次与Pattern匹配的子串
start()：返回上一次与Pattern匹配的子串在目标字符串中的开始位置
end()：返回上一次与Pattern匹配的子串在目标字符串中的结束位置加1
lookingAt()：返回目标字符串前面部分与Pattern是否匹配
matches()：返回整个目标字符串与Pattern是否匹配
reset()：将现有的Matcher对象应用于一个新的字符序列

代码示例

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class FindGroup {
    public static void main(String[] args) {
        // 使用字符串模拟从网络上得到的网页源码
        String str = "啊啊啊13500006666" + "人咯额13611125565" + "急急急15899903312";
        // 创建一个Pattern对象，并用它建立一个Matcher对象
        // 该正则表达式只抓取13X和15X段的手机号
        // 实际要抓取哪些电话号码，只要修改正则表达式即可
        Matcher m = Pattern.compile("((13\\d)|(15\\d))\\d{8}").matcher(str);
        // 将所有符合正则表达式的子串(电话号码)全部输出
        while (m.find()) {
            System.out.println(m.group());
        }
    }
}