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());
}
}
}
投递米哈游等公司8个岗位
小红书一面176人在聊
，太棒啦！！！