Java 核心类API（上）：https://developer.aliyun.com/article/1491131
9.5 系统相关类
9.5.1 java.lang.System类
系统类中很多好用的方法，其中几个如下：
- static long currentTimeMillis() ：返回当前系统时间距离1970-1-1 0:0:0的毫秒值
- static void exit(int status) ：退出当前系统
- static void gc() ：运行垃圾回收器。
- static String getProperty(String key)：获取某个系统属性
- …
public class Test{ public static void main(String[] args){ long time = System.currentTimeMillis(); System.out.println("现在的系统时间距离1970年1月1日凌晨：" + time + "毫秒"); System.exit(0); System.out.println("over");//不会执行 } }
9.5.2 java.lang.Runtime类
每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。 应用程序不能创建自己的 Runtime 类实例。
public static Runtime getRuntime()： 返回与当前 Java 应用程序相关的运行时对象。
public long totalMemory()：返回 Java 虚拟机中的内存总量。此方法返回的值可能随时间的推移而变化，这取决于主机环境。
public long freeMemory()：回 Java 虚拟机中的空闲内存量。调用 gc 方法可能导致 freeMemory 返回值的增加。
public long maxMemory(): 返回 Java 虚拟机试图使用的最大内存量。
Process exec(String command):在单独的进程中执行指定的字符串命令。
9.6 数组工具类
java.util.Arrays数组工具类，提供了很多静态方法来对数组进行操作，而且如下每一个方法都有各种重载形式，以下只列出int[]类型的，其他类型的数组类推：
- static int binarySearch(int[] a, int key) ：要求数组有序，在数组中查找key是否存在，如果存在返回第一次找到的下标，不存在返回负数
- static int[] copyOf(int[] original, int newLength) ：根据original原数组复制一个长度为newLength的新数组，并返回新数组
- static int[] copyOfRange(int[] original, int from, int to) ：复制original原数组的[from,to)构成新数组，并返回新数组
- static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、元素是否完全相同
- static void fill(int[] a, int val) ：用val填充整个a数组
- static void fill(int[] a, int fromIndex, int toIndex, int val)：将a数组[fromIndex,toIndex)部分填充为val
- static void sort(int[] a) ：将a数组按照从小到大进行排序
- static void sort(int[] a, int fromIndex, int toIndex) ：将a数组的[fromIndex, toIndex)部分按照升序排列
- static String toString(int[] a) ：把a数组的元素，拼接为一个字符串，形式为：[元素1，元素2，元素3。。。]
示例代码：
import java.util.Arrays; import java.util.Random; public class Test{ public static void main(String[] args){ int[] arr = new int[5]; // 打印数组,输出地址值 System.out.println(arr); // [I@2ac1fdc4 // 数组内容转为字符串 System.out.println("arr数组初始状态："+ Arrays.toString(arr)); Arrays.fill(arr, 3); System.out.println("arr数组现在状态："+ Arrays.toString(arr)); Random rand = new Random(); for (int i = 0; i < arr.length; i++) { arr[i] = rand.nextInt(100);//赋值为100以内的随机整数 } System.out.println("arr数组现在状态："+ Arrays.toString(arr)); int[] arr2 = Arrays.copyOf(arr, 10); System.out.println("新数组：" + Arrays.toString(arr2)); System.out.println("两个数组的比较结果：" + Arrays.equals(arr, arr2)); Arrays.sort(arr); System.out.println("arr数组现在状态："+ Arrays.toString(arr)); } }
9.7 包装类
9.7.1 包装类
Java提供了两大类数据类型，基本类型与引用类型，使用基本类型在于效率，但是缺少像引用数据类型一样的丰富API，那么Java提供了针对基本数据类型的保证类，以提供更加便捷的操作功能，包装类就是把基本数据类型包装成对应的引用数据类型。
| 序号 | 基本数据类型 | 包装类（java.lang包） |
| 1 | byte | Byte |
| 2 | short | Short |
| 3 | int | Integer |
| 4 | long | Long |
| 5 | float | Float |
| 6 | double | Double |
| 7 | char | Character |
| 8 | boolean | Boolean |
| 9 | void | Void |
9.7.2 装箱与拆箱
装箱：把基本数据类型转为包装类对象。
转为包装类的对象，是为了使用专门为对象设计的API和特性
拆箱：把包装类对象拆为基本数据类型。
转为基本数据类型，一般是因为需要运算，Java中的大多数运算符是为基本数据类型设计的。比较、算术等
基本数值---->包装对象
Integer i1 = new Integer(4);//使用构造函数函数 Integer i2 = Integer.valueOf(4);//使用包装类中的valueOf方法
包装对象---->基本数值
Integer i1 = new Integer(4); int num1 = i1.intValue();
JDK1.5之后，可以自动装箱与拆箱。
注意：只能与自己对应的类型之间才能实现自动装箱与拆箱。
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4); i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5; //加法运算完成后，再次装箱，把基本数值转成对象。
Integer i = 1; Double d = 1;//错误的，1是int类型
总结：对象（引用数据类型）能用的运算符有哪些？
（1）instanceof
（2）=：赋值运算符
（3）==和!=：用于比较地址，但是要求左右两边对象的类型一致或者是有父子类继承关系。
（4）对于字符串这一种特殊的对象，支持“+”，表示拼接。
9.7.3 包装类的常用API
- 基本数据类型和字符串之间的转换（1）把基本数据类型转为字符串
int a = 10; //String str = a;//错误的 //方式一： String str = a + ""; //方式二： String str = String.valueOf(a); //方式三： Integer i=10; String str=i.toString();
（2）把字符串转为基本数据类型String转换成对应的基本类型 ，除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型，例如：
public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
或把字符串转为包装类，然后可以自动拆箱为基本数据类型
public static Integer valueOf(String s)：将字符串参数转换为对应的Integer包装类，然后可以自动拆箱为int基本类型public static Long valueOf(String s)：将字符串参数转换为对应的Long包装类，然后可以自动拆箱为long基本类型public static Double valueOf(String s)：将字符串参数转换为对应的Double包装类，然后可以自动拆箱为double基本类型
注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。
int a = Integer.parseInt("整数的字符串"); double d = Double.parseDouble("小数的字符串"); boolean b = Boolean.parseBoolean("true或false"); int a = Integer.valueOf("整数的字符串"); double d = Double.valueOf("小数的字符串"); boolean b = Boolean.valueOf("true或false");
Integer.MAX_VALUE和Integer.MIN_VALUE Long.MAX_VALUE和Long.MIN_VALUE Double.MAX_VALUE和Double.MIN_VALUE
Character.toUpperCase('x'); Character.toLowerCase('X');
Integer.toBinaryString(int i) Integer.toHexString(int i) Integer.toOctalString(int i)
9.7.4 包装类对象的缓存问题
包装类的数据在缓存数值范围内时，直接从内存中取出对象，超过范围会创建新的对象
| 包装类 | 缓存对象 |
| Byte | -128~127 |
| Short | -128~127 |
| Integer | -128~127 |
| Long | -128~127 |
| Float | 没有 |
| Double | 没有 |
| Character | 0~127 |
| Boolean | true和false |
示例代码：
Integer i = 1; Integer j = 1; System.out.println(i == j);//true Integer i = 128; Integer j = 128; System.out.println(i == j);//false Integer i = new Integer(1);//新new的在堆中 Integer j = 1;//这个用的是缓冲的常量对象，在方法区 System.out.println(i == j);//false Integer i = new Integer(1);//新new的在堆中 Integer j = new Integer(1);//另一个新new的在堆中 System.out.println(i == j);//false
@Test public void test3(){ Double d1 = 1.0; Double d2 = 1.0; System.out.println(d1==d2);//false 比较地址，没有缓存对象，每一个都是新new的 }
以上示例代码证明缓存的存在，源码中也有体现，
9.7.5 面试题
@Test public void test4(){ Double d1 = 1.0; double d2 = 1.0; System.out.println(d1==d2);//true 和基本数据类型比较会自动拆箱，比较数据值 } @Test public void test2(){ Integer i = 1000; double j = 1000; System.out.println(i==j);//true 会先将i自动拆箱为int，然后根据基本数据类型“自动类型转换”规则，转为double比较 } @Test public void test(){ Integer i = 1000; int j = 1000; System.out.println(i==j);//true 会自动拆箱，按照基本数据类型进行比较 }
public class TestExam { public static void main(String[] args) { int i = 1; Integer j = new Integer(2); Circle c = new Circle(); change(i,j,c); System.out.println("i = " + i);//1 System.out.println("j = " + j);//2 System.out.println("c.radius = " + c.radius);//10.0 } /* * 方法的参数传递机制： * （1）基本数据类型：形参的修改完全不影响实参 * （2）引用数据类型：通过形参修改对象的属性值，会影响实参的属性值 * 这类Integer等包装类对象是“不可变”对象，即一旦修改，就是新对象，和实参就无关了 */ public static void change(int a ,Integer b,Circle c ){ a += 10; // b += 10;//等价于 b = new Integer(b+10); c.radius += 10; /*c = new Circle(); c.radius+=10;*/ } } class Circle{ double radius; }
9.8 枚举Enum
9.8.1 概述
1、枚举的理解
某些类型的对象应该或者需要是有限的几个，这样的例子举不胜举：
- 星期：Monday(星期一)…Sunday(星期天)
- 性别：Man(男)、Woman(女)
- 月份：January(1月)…December(12月)
- 季节：Spring(春节)…Winter(冬天)
- 支付方式：Cash（现金）、WeChatPay（微信）、Alipay(支付宝)、BankCard(银行卡)、CreditCard(信用卡)
- 员工工作状态：Busy（忙）、Free（闲）、Vocation（休假）
- 订单状态：Nonpayment（未付款）、Paid（已付款）、Fulfilled（已配货）、Delivered（已发货）、Checked（已确认收货）、Return（退货）、Exchange（换货）、Cancel（取消）
如何实现一个类只有固定的几个对象，而且不能随意创建对象？
2、早期实现方式
在JDK1.5之前，需要程序员自己通过特殊的方式来定义枚举类型。
- 构造器加private私有化
- 本类内部创建一组常量对象，并添加public static修饰符，对外暴露这些常量对象
//只有固定4个对象的季节类 public class Season{ private String seasonName; public static final Season SPRING=new Season("春"); public static final Season SUMMER=new Season("夏"); public static final Season AUTUMN=new Season("秋"); public static final Season WINTER=new Season("冬"); private Season(String name){ this.seasonName = name; } @Override public String toString() { return seasonName; } }
//测试类 public class TestEnum { public static void main(String[] args) { Season spring = Season.SPRING; System.out.println(spring); } }
9.8.2 枚举类型
在JDK1.5之后，Java支持enum关键字来快速的定义枚举类型。
枚举类型本质上也是一种类，只不过是这个类的对象是固定的几个，而不能随意让用户创建。
1、枚举类型的定义
语法格式：
【修饰符】 enum 枚举类名{ 常量对象列表 } 【修饰符】 enum 枚举类名{ 常量对象列表; 其他成员列表; }
示例代码 1：
//定义枚举类型Season public enum Season{ SPRING, SUMMER, AUTUMN, WINTER }
//测试 public class TestEnum { public static void main(String[] args) { Season spring = Season.SPRING; System.out.println(spring); } }
2、 枚举类的要求和特点
- 枚举类的常量对象列表必须在枚举类的首行，因为是常量，所以建议大写。
- 如果常量对象列表后面没有其他代码，那么“；”可以省略，否则不可以省略“；”。
- 编译器给枚举类默认提供private的无参构造
- 如果需要也可以定义有参构造，默认也是private修饰，常量对象名后面加(实参列表)调用有参构造器。
- 枚举类默认继承自java.lang.Enum类，不能再继承其他的类型；枚举类默认是final修饰的也不能被继承。
- JDK1.5之后switch，提供支持枚举类型，case后面可以写枚举常量名。
- 枚举类型如有其它属性，建议这些属性也声明为final的，因为常量对象在逻辑意义上应该不可变。
public enum Week { MONDAY("星期一"), TUESDAY("星期二"), WEDNESDAY("星期三"), THURSDAY("星期四"), FRIDAY("星期五"), SATURDAY("星期六"), SUNDAY("星期日"); private final String description; Week(String description){ this.description = description; } @Override public String toString() { return super.toString() +":"+ description; } }
public class TestWeek { public static void main(String[] args) { Week week = Week.MONDAY; System.out.println(week); switch (week){//switch语句支持枚举类型 case MONDAY: System.out.println("怀念周末，困意很浓"); break; case TUESDAY: System.out.println("进入学习状态"); break; case WEDNESDAY: System.out.println("死撑"); break; case THURSDAY: System.out.println("小放松"); break; case FRIDAY: System.out.println("又信心满满"); break; case SATURDAY: System.out.println("开始盼周末，无心学习"); break; case SUNDAY: System.out.println("一觉到下午"); break; } } }
3、 枚举类型常用方法
- String toString(): 默认返回的是常量名（对象名），可以继续手动重写该方法！
- String name():返回的是常量名（对象名）
- int ordinal():返回常量的次序号，默认从0开始
- 枚举类型[] values():返回该枚举类的所有的常量对象，返回类型是当前枚举的数组类型，是一个静态方法
- 枚举类型 valueOf(String name)：静态方法，根据枚举常量对象名称获取枚举对象
示例代码：
public class TestEnumMethod { public static void main(String[] args) { Week[] values = Week.values(); for (int i = 0; i < values.length; i++) { System.out.println((values[i].ordinal()+1) + "->" + values[i].name()); } System.out.println("------------------------"); Scanner input = new Scanner(System.in); System.out.print("请输入星期值："); int weekValue = input.nextInt(); Week week = values[weekValue-1]; System.out.println(week); System.out.print("请输入星期名："); String weekName = input.next(); week = Week.valueOf(weekName); System.out.println(week); input.close(); } }
