1 字符串相关
1.1 String
所属包：java.lang
代表不可变的字符序列
注意：Java中，String是一个final类
1）创建字符串方式
java
String a = "hello";
// 开辟内存空间
String b = new String("hello");
String d = new String("hello");
// 通过+ 拼接 ，生成新的字符串
String str = "你好" + "世界";其他：
java
String(byte[] bytes)
String(char[] value)
//参数为字节数组
byte[] bytes = {97,98,99};
String str = new String(bytes);
System.out.println(str);
//参数为字符数组
char[] chars = {'a','b','c'};
String str = new String(chars);
System.out.println(str);
2）常用方法
字符串的长度
length()
字符串的比较
| 方法 | 说明 |
|---|---|
| boolean equals(String value) | 比较两个字符串内容是否相同，严格判等 |
| boolean equalsIgnoreCase(String s) | 比较两个字符串，忽略大小写 |
| int compareTo(String value) | 按字典顺序比较两个字符串。如果两个字符串相等，则返回 0；如果字符串在参数值之前，则返回值小于 0；如果字符串在参数值之后，则返回值大于 0 |
| int compareToIgnoreCase(String val) | 按字典顺序比较两个字符串，忽略大小写 |
| boolean isEmpty() | 判断是否是空字符串("") |
java
public class App2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s1 = "hello";
// 获取字符串内容的长度
int length = s1.length();
System.out.println(length);
String s2 = "hello";
String s3 = "world";
// 比较字符串的内容是否相同
boolean ret = s1.equals(s2);
System.out.println(ret);
System.out.println(s1.equals(s3));
String s4 = "Hello";
System.out.println(s1.equals(s4));
// 忽略大小写比较字符串内容
boolean ret2 = s1.equalsIgnoreCase(s4);
System.out.println(ret2);
String s6 = "HELLO";
// 比较大小
// 如果两个字符串一模一样，返回0
// 返回大于0的值，前面的字符串比后面的字符串大
// 返回小于0的值，前面的字符串比后面的字符串小
int ret3 = s1.compareTo(s6);
System.out.println(ret3);
// 忽略大小写，比较字符串的大小
System.out.println(s1.compareToIgnoreCase(s6));
// 内容是空
String s7 = "";
boolean ret4 = s7.isEmpty();
System.out.println(ret4);
System.out.println(s1.isEmpty());
// null表示没有引用对象
String s8 = null;
// s8.isEmpty(); // 报错
}
}注意：== 与 equals 的区别
java
public class App3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s1 = "hello";
String s2 = "hello";
// true
System.out.println(s1 == s2);
String s3 = new String("hello");
// 比较的是字符串的地址
// false
System.out.println(s1 == s3);
// 比较的是字符串的内容
System.out.println(s1.equals(s3));
}
}字符串的查找
| 方法 | 说明 |
|---|---|
| boolean contains(String str) | 判断字符串是否包含指定的字符串 |
| public boolean startsWith(String str) | 判断字符串是否以指定的前缀开始，是，返回true |
| public boolean endswith(String str) | 判断字符串是否以指定的后缀结束，是，返回true |
| public int indexOf(String str) | 返回指定子字符串str在此字符串中第一次出现的的索引值；如果未出现，则返回 -1。 |
| public int lastIndexOf(String str) | 返回指定子字符串str在此字符串中最后一次出现的索引值；如果未出现，则返回 -1。 |
| public char charAt(int index) | 指定索引index处的char值 |
java
public class App4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s1 = "give you color see see";
// 多态 方法的参数是接口或者实现类，传的实现类String的对象
// 是否包含指定的字符串
boolean ret = s1.contains("you");
System.out.println(ret);
System.out.println(s1.contains("abc"));
// 是否以指定的字符串开头
boolean ret2 = s1.startsWith("gi");
System.out.println(ret2);
System.out.println(s1.startsWith("g"));
System.out.println(s1.startsWith("abc"));
// 是否以指定的字符串结尾
System.out.println(s1.endsWith("see"));
System.out.println(s1.endsWith("abc"));
System.out.println(s1.endsWith("SEE"));
// 从前往后查找指定的字符串出现位置的索引 索引从0开始的, 返回-1 ，说明没有查找到
int index = s1.indexOf("see");
System.out.println(index);
System.out.println(s1.indexOf("abc"));
// 从后往前查找
System.out.println(s1.lastIndexOf("see"));
// 返回指定索引处的字符
char chars = s1.charAt(2);
System.out.println(chars);
// 运行报错
// System.out.println(s1.charAt(100));
}
}字符串的转换
| 方法 | 说明 |
|---|---|
| byte[] getBytes() | 将字符串转换为字节数组 |
| char[] toCharArray() | 将字符串转换为字符数组 |
| public String concat(String str) | 将指定字符串str连接到此字符串的结尾组成一个新字符串 |
| static String valueOf(int i) 等等 | 将指定类型的数据转换为字符串，静态方法 |
| public String toUpperCase(); | 将此字符串中的所有字符都转换为大写 |
| public String toLowerCase(); | 将此字符串中的所有字符都转换为小写 |
java
public class App6 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s1 = "hello";
// 根据字符串获取字节数组
byte[] bytes = s1.getBytes();
for(byte b : bytes) {
System.out.println(b);
}
// 根据字符串得到字符数组
char[] charArray = s1.toCharArray();
for(int i = 0; i < charArray.length; i++) {
System.out.println(charArray[i]);
}
// 字符串的连接（拼接） ，作用类似 "+"
String s2 = s1.concat("world");
System.out.println(s2);
System.out.println(s1);
// 执行的数据转为字符串形式
int i = 10;
String v1 = String.valueOf(10);
System.out.println(v1);
System.out.println(String.valueOf(12.3));
// 将字符串中所有字符转为大写
String upperCase = s1.toUpperCase();
System.out.println(upperCase);
// 转为小写
System.out.println(upperCase.toLowerCase());
}
}字符串的其他方法
| 方法 | 说明 |
|---|---|
| public String substring(int index) | 截取从索引index开始直到此字符串末尾的子字符串 |
| public String substring(int start, int end) | 截取指定开始索引和结束索引直接的字符串，不包括结束索引位置的字符 |
| public String[] split(String regex) | 根据匹配规则拆分此字符串，返回字符串数组，注意特殊字符如""，"." |
| static String join(CharSequence delimiter, CharSequence... elements) | 使用指定的分隔符，进行字符串的拼接 |
| public String replace(char oldChar, char newChar) | 返回用 newChar 替换此字符串中出现的所有 oldChar 而生成的新字符串 |
| String replace(CharSequence old,CharSequence new) | 使用新的字符串替换所有老的字符串，CharSequence是接口，String实现了该接口 |
| public String trim() | 去除字符串前后的空白字符 |
java
public class App7 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String info = "窗前明月光,地上鞋两双";
// 从指定的索引截取字符串，截取到末尾
String s1 = info.substring(2);
System.out.println(s1);
System.out.println(info);
// 截取","号后面的内容，不能数索引
int index = info.indexOf(",");
System.out.println(info.substring(index + 1));
// 根据开始和结束索引，截取字符串，注意，不包含结束索引处的元素
String s2 = info.substring(2, 5);
System.out.println(s2);
// 根据指定字符串进行拆分
String[] arr = info.split(",");
for(String s : arr) {
System.out.println(s);
}
String info2 = "let house come";
String[] arr2 = info2.split(" ");
System.out.println(arr2[0]);
// 根据指定字符串，进行其他字符串拼接
String joinStr = String.join("-", "Java", "iOS", "php");
System.out.println(joinStr);
// 可变参数，本质上就是数组
System.out.println(String.join(":", arr2));
System.out.println(String.join("", arr2));
// 使用新的字符替换字符串中所有旧的字符
String replace = info2.replace('o', 'O');
System.out.println(replace);
// 根据字符串进行替换
System.out.println(info2.replace("o", "O"));
System.out.println(info2.replace("house", "girl"));
// 去除字符串两端的空白字符，空格 制表符 都属于空白字符
String s = " hello ";
String trim = s.trim();
System.out.println(trim);
System.out.println(trim.length());
String aa = "hel lo";
String replace2 = aa.replace(" ", "");
System.out.println(replace2);
}
}1.2 StringBuffer
String对象的值是固定的，不能改变内容。虽然可以使用"+"来串联字符串达到附加新字符的目的，但"+"会产生一个新的String对象。
如果程序需要频繁连接字符串，生成的中间对象会非常多，带来内存消耗。此时，可以使用可变字符串类StringBuffer (线程安全的)，或StringBuilder
StringBuffer类代表可变的字符序列
StringBuffer称为字符串缓冲区。它的工作原理是：创建时，申请一块内存，存放字符序列，随着字符内容的不断扩大，如果缓冲区无法容纳增加的字符，再重新改变缓存区的大小（2倍+2），以容纳更多的字符序列
由于StringBuffer是可变对象，在频繁进行字符串修改添加删除时，首选StringBuffer，效率更高
两个常用的构造方法。
java
构造一个不带字符的字符串缓冲区，初始容量为 16 个字符
StringBuffer()
构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容
StringBuffer(String str)
public class App1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 创建空字符串
StringBuffer sb = new StringBuffer();
System.out.println(sb);
// 根据指定字符串创建StringBuffer对象
StringBuffer sb2 = new StringBuffer("hello");
System.out.println(sb2);
}
}常用方法
| 方法 | 说明 |
|---|---|
| StringBuffer append(String str)等 | 将指定的字符串追加到此字符序列 ，还支持其他类型参数 |
| StringBuffer insert(int offset, String str) | 将字符串str插入此字符序列指定位置中 |
| int length( ) | 返回StringBuffer对象的长度 |
| int indexOf(String str) | 返回指定子字符串在该字符串中第一次出现的位置索引 |
| String toString( ) | 将此StringBuffer对象转换为字符串形式 |
| StringBuffer reverse() | 反转字符串 |
| StringBuffer delete(int start, int end) | 删除此字符串从 start 位置开始到 end (不包含)位置结束的字符序列 |
| StringBuffer deleteCharAt(int pos) | 将删除 pos 索引处的字符 |
| StringBuffer replace(int start, int end, String s) | 用指定字符串s替换字符串从 start 位置开始到 end 位置结束的字符序列 |
java
public class App2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
StringBuffer sb = new StringBuffer();
// 追加
sb.append("hello");
sb.append(10);
sb.append("12.4");
System.out.println(sb);
// 指定索引处插入元素
sb.insert(2, "world");
System.out.println(sb);
// StringBuffer中字符串的实际长度
System.out.println(sb.length());
System.out.println(sb.capacity());
sb.insert(5, 45.6);
// 缓冲区的容量
System.out.println(sb.capacity());
System.out.println(sb);
// 根据指定索引范围进行删除，不包含结束索引处的元素
sb.delete(2, 5);
System.out.println(sb);
// 删除指定索引处的字符
sb.deleteCharAt(0);
System.out.println(sb);
// 替换指定索引范围的字符串为新的字符串，不包含结束位置的字符
sb.replace(2, 5, "new");
System.out.println(sb);
// 字符串的反转 abc -> cba
sb.reverse();
System.out.println(sb);
}
}1.3 StringBuilder
非线程安全的可变字符串类
用法同StringBuffer，但不保证线程的同步。如果对线程同步问题要求不是很高的话，建议优先采用该类，因为不用额外耗费性能维护线程的同步，比 StringBuffer要快。
2 包装类
Java是面向对象的编程语言，但Java中的基本数据类型并不是面向对象的，为了解决这个不足，Java为每个基本类型设计了一个对应的类，称为包装类。
包装类是将基本类型封装到一个类中，包含属性和方法，方便对其进行操作，位于java.lang包中
2.1 包装类介绍
| 基本类型 | 包装类 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| boolean | Boolean |
| float | Float |
| double | Double |
类关系图：
2.2 自动装拆箱
JDK5.0之后，Java为基本数据类型提供了自动装箱(boxing)、拆箱(unboxing)功能。
装箱：将基本数据类型包装为对应的包装类对象
拆箱：将包装类对象转换成对应的基本数据类型
java
// 装箱
Integer i = 10;
// 拆箱
int i = new Integer(10);
public class App1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int i = 10;
// 装箱, i2引用类型变量，存的都是地址，内容是20的Integer类型的对象的地址
Integer i2 = 20;
// 创建对象
Integer i3 = new Integer(30);
// 拆箱 ，只要new肯定会创建对象，将Integer对象的内容复制给int（基础类型）的变量
int i4 = new Integer(40);
System.out.println(i2);
System.out.println(i3);
System.out.println(i4);
Integer i5 = 20;
// 和String类似的
// true
System.out.println(i2 == i5);
// true 拆箱
System.out.println(i2 == 20);
// true 比较内容
System.out.println(i2.equals(i5));
Integer i6 = 1000;
Integer i7 = 1000;
// false
System.out.println(i6 == i7);
// true 拆箱
System.out.println(i6 == 1000);
// true
System.out.println(i6.equals(i7));
// -128-127 的数据 会放到常量区
// 有两个Integer类型的变量，能否通过== 比较值是否相同？
}
}2.3 包装类、基础数据、字符串之间转换
根据包装类获取基础类型：
Integer i = 10;
int j = i.intValue();
等等
把字符串值转换为包装类对象：
Integer.valueOf(String s)
Double.valueOf(String s)
等等
把包装类对象转换为字符串：
public String toString()
String转换为基本数据类型：
把字符串转换为double：Double.parseDouble(String s)
把字符串转换为int：Integer.parseInt(String s)
等等
java
public class App2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 拆箱也可以实现包装类到基础类型的转换
// 包装类->基础类型
Integer i = 10;
int i1 = i.intValue();
Double d = 12.3;
double d2 = d.doubleValue();
// 字符串->包装类型
String s = "10";
Integer i3 = Integer.valueOf(s);
System.out.println(i3);
Double d3 = Double.valueOf("12.3");
System.out.println(d3);
// 包装类 -> 字符串
String ss = i.toString();
System.out.println(ss);
// 字符串-> 基础类型
int parseInt = Integer.parseInt("100");
double parseDouble = Double.parseDouble("12.5");
System.out.println(parseInt);
System.out.println(parseDouble);
}
}2.4 部分包装类用法
1）Integer
java
// 转为二进制值 101
System.out.println(Integer.toBinaryString(5));
// 转为16进制值
System.out.println(Integer.toHexString(12));
// 转为8进制值
System.out.println(Integer.toOctalString(12));2）Character
java
char c1 = '9';
// 判断c1是否是数字
Character.isDigit(c1);
// 判断是否是字符(包括中文字符)
Character.isLetter(c1);
char c3 = 'A';
// 判断是否是小写字母
Character.isLowerCase(c3);
// 是否是大写字母
Character.isUpperCase(c3);
// 转换为小写字母
Character.toLowerCase(c3);
// 转换为大写字母
Character.toUpperCase(c3);3 日期与时间
3.1 Date
3.1.1 日期类
java.util.Date
java
// 获取当前时间
Date date = new Date();
// 根据时间对象获取时间戳
date.getTime();注：时间戳单位毫秒，表示1970-01-01 00:00:00到指定时间的毫秒数
3.1.2 日期对象与日期字符串转换
SimpleDateFormat类
方法：
String format(Date date) 日期对象转为字符串
Date parse(String str) 日期字符串转为日期对象
java
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 日期对象转为日期字符串
sdf.format(date);
// 日期字符串转为日期对象
sdf.parse(dateStr)日期格式字符串：
yyyy 年
MM 月
dd 日
HH 小时，24小时值
mm 分钟
ss 秒
SSS 毫秒
java
package com.renr;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 获取当前时间
Date date = new Date();
System.out.println(date);
// 获取时间对象的时间戳
System.out.println(date.getTime());
// 时间格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 日期类型对象转为时间字符串
String dateStr = sdf.format(date);
System.out.println(dateStr);
String dateStr2 = "2012-03-03 12:34:56";
try {
// 将日期字符串转为日期对象
Date date2 = sdf.parse(dateStr2);
System.out.println(date2);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}3.2 Calendar
日历类
3.2.1 基本用法
获取日历对象：Calendar.getInstance()
获取年月日等信息：get()
设置年月日等信息：set()
java
// 使用当前时区的日历对象
Calendar cal = Calendar.getInstance();
System.out.println("年:" + cal.get(Calendar.YEAR));
// 月份从0开始
System.out.println("月:" + (cal.get(Calendar.MONTH) + 1));
System.out.println("日:" + cal.get(Calendar.DAY_OF_MONTH));
System.out.println("时:" + cal.get(Calendar.HOUR_OF_DAY));
System.out.println("分:" + cal.get(Calendar.MINUTE));
System.out.println("秒:" + cal.get(Calendar.SECOND));
Calendar cal2 = Calendar.getInstance();
// 可以一次设置年月日时分秒，注意月份的值
// cal.set(year, month, date, hourOfDay, minute, second);
cal2.set(2020, 1, 15, 23, 59, 59);
System.out.println(cal2);
// 也可以分别设置
cal2.set(Calendar.YEAR, 2020);
cal2.set(Calendar.MONTH, Calendar.FEBRUARY);
cal2.set(Calendar.DAY_OF_MONTH, 12);
cal2.set(Calendar.HOUR_OF_DAY, 23);
cal2.set(Calendar.MINUTE, 59);
cal2.set(Calendar.SECOND, 59);3.2.2 Date和Calendar转换
java
// Calendar转化为Date
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
System.out.println(date);
// Date转化为Calendar
Date date2 = new Date(1647271837481L);
Calendar cal2 = Calendar.getInstance();
cal2.setTime(date2);
System.out.println(cal2);3.2.3 时间运算
add方法
java
Calendar cal = Calendar.getInstance();
System.out.println(cal.getTime());
// 日期的天 加减一个指定值
cal.add(Calendar.DAY_OF_MONTH, -1);
System.out.println(cal.getTime());
// 日期的月 加减一个指定值
cal.add(Calendar.MONTH, 1);
System.out.println(cal.getTime());3.3 JDK8的日期时间类
LocalDateTime 日期时间类
LocalDate 日期类
LocalTime 时间类
获取当前日期、时间
java
// 获取当前日期 年月日
LocalDate localDate = LocalDate.now();
// 获取当前时间 时分秒 毫秒
LocalTime localTime = LocalTime.now();
// 获取当前的日期和时间
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(localDate);
System.out.println(localTime);
System.out.println(localDateTime);根据指定日期/时间创建对象
java
// 指定年月日，创建LocalDate对象
LocalDate localDate = LocalDate.of(2022, 4, 13);
// 指定时分秒 创建LocalTime对象
LocalTime localTime = LocalTime.of(22, 43, 20);
// 指定年月日时分秒，创建LocalDateTime对象
LocalDateTime localDateTime = LocalDateTime.of(2022, 4, 13, 22, 43, 20);获取年月日时分秒
java
LocalDateTime localDateTime = LocalDateTime.now();
// 获取当前日期是当年的第几天
int dayOfYear = localDateTime.getDayOfYear();
// 获取当前日期是当月的第几天
int dayOfMonth = localDateTime.getDayOfMonth();
// 获取当前日期是本周的星期几，枚举类型
DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();
//获取当前日期的年月日时分秒
// 获取年
int year = localDateTime.getYear();
// 获取月
Month month = localDateTime.getMonth();
// 获取日
int day = localDateTime.getDayOfMonth();
// 获取时
int hour = localDateTime.getHour();
// 获取分钟
int minute = localDateTime.getMinute();
// 获取秒
int second = localDateTime.getSecond();日期时间的加减
java
LocalDateTime localDateTime = LocalDateTime.now();
// 指定日期添加指定的年数，负数表示减少的年数
LocalDateTime plusYearsResult = localDateTime.plusYears(2L);
// 指定日期添加指定的月数
LocalDateTime plusMonthsResult = localDateTime.plusMonths(3L);
// 指定日期添加指定的天数
LocalDateTime plusDaysResult = localDateTime.plusDays(7L);
// 指定日期添加指定的小时数
LocalDateTime plusHoursResult = localDateTime.plusHours(2L);
// 指定日期添加指定的分钟数
LocalDateTime plusMinutesResult = localDateTime.plusMinutes(10L);
// 指定日期添加指定的秒数
LocalDateTime plusSecondsResult = localDateTime.plusSeconds(10L);
// 另外的写法，了解一下
LocalDateTime nextMonth = localDateTime.plus(1, ChronoUnit.MONTHS);
LocalDateTime nextYear = localDateTime.plus(1, ChronoUnit.YEARS);
LocalDateTime nextWeek = localDateTime.plus(1, ChronoUnit.WEEKS);时间日期前后的比较与判断
java
LocalDateTime localDateTime1 = LocalDateTime.now();
LocalDateTime localDateTime2 = LocalDateTime.of(2022, 3, 4, 12, 34,45);
// 前面的日期是否在指定日期之前
boolean ret = localDateTime1.isBefore(localDateTime2);
// 前面的日期是否在指定日期之后
boolean ret2 = localDateTime2.isAfter(localDateTime2);
// 前面的日期是否和指定日期相同
boolean ret3 = localDateTime2.isEqual(localDateTime2);字符串与日期对象转换
java
// 转为日期字符串
LocalDateTime date1 = LocalDateTime.now();
// 指定日期格式
DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
// 转为指定格式的日期字符串
String date2Str = formatter2.format(date1);
// 转为日期对象
String datetime = "2022-04-13 21:47:30";
// 格式需要和日期字符串一致
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 日期字符串转为LocalDateTime对象
LocalDateTime ldt = LocalDateTime.parse(datetime, dtf);3.4 日期时间的工具类
4 其他
4.1 Math
Math类提供了一系列有关数学的基本运算和几何函数的方法，位于java.lang包下
Math类是final类，并且它的所有全局变量和方法都是静态的。
算数运算，方法比较多
| 方法 | 说明 |
|---|---|
| int abs (int a) | 返回 int 值的绝对值 |
| int max (int a, int b) | 返回两个 int 值中较大的一个 |
| int min (int a, int b) | 返回两个 int 值中较小的一个 |
| double sqrt (double a) | 返回 double 值的正平方根 |
| double pow(double a, double b) | 返回第一个参数的第二个参数次幂的值 |
| double floor (double a) | 向下取整 |
| double ceil(double a) | 向上取整 |
| long round(double b) | 四舍五入 |
| double random(); | 返回一个随机的double值，该值大于等于0.0小于1.0 |
java
// 平方根
System.out.println(Math.sqrt(16));
// 立方根
System.out.println(Math.cbrt(8.6));
// a的b次方
System.out.println(Math.pow(3, 2));
// 最大值
System.out.println(Math.max(4, 7));
// 最小值
System.out.println(Math.min(2.3, 4.5));
// 求绝对值
System.out.println(Math.abs(-10.7));
// 比指定数大的最小整数
System.out.println(Math.ceil(10.7));
System.out.println(Math.ceil(-1.7));
// 比指定数小的最大整数
System.out.println(Math.floor(10.7));
System.out.println(Math.floor(-10.7));
// 四舍五入为整数
System.out.println(Math.round(10.1));
System.out.println(Math.round(10.7));
System.out.println(Math.round(-10.7));
// [0,1)浮点数
System.out.println(Math.random());4.2 Random类
创建对象：
new Random()
| 方法 | 说明 |
|---|---|
| public double nextDouble() | 生成一个随机的double值，数值介于[0,1.0)之间 |
| public int nextInt() | 生成一个随机的int值 |
| public int nextInt(int n) | 是生成一个随机的int值，该值介于[0,n)的区间 |
4.3 System类
| 方法 | 说明 |
|---|---|
| static long currentTimeMillis(); | 返回当前的计算机时间的时间戳，单位毫秒 |
| static String getProperty(Stringkey) | 获取指定的属性 |
| static int exit(int status) | 终止正在运行的程序，status表示退出的状态码，非零表示异常终止 |
java
String jversion = System.getProperty("java.version");
String oName = System.getProperty("os.name");
String user = System.getProperty("user.name");
System.out.println("Java 运行时环境版本：" + jversion);
System.out.println("当前操作系统是：" + oName);
System.out.println("当前用户是：" + user);