1 public static void main(String args[]) { 2 BigDecimal bd1 = new BigDecimal("123456789.0123456890"); 3 BigDecimal bd2 = BigDecimal.valueOf(123L); 4 bd1 = bd1.add(bd2); 5 System.out.println(bd2.toPlainString()); 6 BigDecimal bd3 = new BigDecimal(bd2.toPlainString()); 7 if (bd3.equals(bd2)) 8 System.out.println("bd2 is equal to bd3"); 9 if (bd3.intValue() == 123) 10 System.out.println("bd3 is equal to 123."); 11 } 12 /* 输出结果如下： 13 123 14 bd2 is equal to bd3 15 bd2 is equal to 123. 16 */
由上例的输出结果可见，BigDecimal中提供了各种类型之间的可传递性转换，既上例中的bd2对象，源于123L，然后再将该对象转换会原始类型时，得到的值和之前初始化该对象的值仍然是相等的。上例中还用将bd2转换为字符串，并用该结果构造了另外一个BigDecimal对象，在比较这个两个对象的值时，发现他们是相等的。这种可传递性的类型之间的转换，Effective Java的作者是比较推崇的。 2) 基本的数学运算和数学函数应用：
1 public static void main(String args[]) { 2 BigDecimal bd1 = new BigDecimal("123456789.0123456890"); 3 BigDecimal bd2 = BigDecimal.valueOf(123L); 4 bd1 = bd1.add(bd2); 5 System.out.printf("bd1 = %s after add.\n",bd1.toPlainString()); 6 bd1 = bd1.multiply(bd2); 7 System.out.printf("bd1 = %s after multiply.\n",bd1.toPlainString()); 8 bd1 = bd1.subtract(bd2); 9 System.out.printf("bd1 = %s after subtract.\n",bd1.toPlainString()); 10 bd1 = bd1.divide(bd2, BigDecimal.ROUND_UP); 11 System.out.printf("bd1 = %s after divide.\n",bd1.toPlainString()); 12 bd1 = bd1.negate(); 13 System.out.printf("bd1 = %s after negate.\n",bd1.toPlainString()); 14 System.out.println("The power of db2(123) is " + bd2.pow(2).toPlainString()); 15 } 16 /* 输出结果如下： 17 bd1 = 123456912.0123456890 after add. 18 bd1 = 15185200177.5185197470 after multiply. 19 bd1 = 15185200054.5185197470 after subtract. 20 bd1 = 123456911.0123456890 after divide. 21 bd1 = -123456911.0123456890 after negate. 22 The power of db2(123) is 15129 23 */
从结果中可以看出没有丢失精度。 3) 基于刻度的进位：
1 public static void main(String args[]) { 2 int decimalPlaces = 2; 3 BigDecimal bd = new BigDecimal("123456789.0123456890"); 4 //始终向下舍位 5 BigDecimal bd1 = bd.setScale(decimalPlaces, BigDecimal.ROUND_DOWN); 6 System.out.println(bd1.toString()); 7 //始终向上进位 8 BigDecimal bd2 = bd.setScale(decimalPlaces, BigDecimal.ROUND_UP); 9 System.out.println(bd2.toString()); 10 BigDecimal bd3 = new BigDecimal(3.14159); 11 //四舍五入 12 bd3 = bd3.setScale(3, BigDecimal.ROUND_HALF_UP); 13 System.out.println(bd3.toString()); 14 } 15 /* 输出结果如下： 16 123456789.01 17 123456789.02 18 3.142 19 */
2. 大整型对象(BigInteger): BigInteger和BigDecimal相比，大部分的功能是相同的，主要的差异为BigInteger仅仅表示大整数的封装，而不能表示浮点数，与此同时，BigInteger还提供了大量的位操作运算，这个和C++中的BitSet非常类似。如果我们的在应用中只是需要大整数，那么应该首先该类，而不是BigDecimal，如果我们的应用逻辑中有多于64种状态(long表示64bits)的情况，可以考虑用BigInteger的位操作功能。 1) 基本的数学运算和数学函数应用：
1 public static void main(String args[]) { 2 BigInteger bi1 = new BigInteger("1234567890123456890"); 3 BigInteger bi2 = BigInteger.valueOf(123L); 4 System.out.printf("bi1 = %s after added\n",bi1.add(bi2)); 5 System.out.printf("bi1 = %s after multiply\n",bi1.multiply(bi2)); 6 System.out.printf("bi1 = %s after subtract\n",bi1.subtract(bi2)); 7 System.out.printf("bi1 = %s after divide\n",bi1.divide(bi2)); 8 System.out.printf("bi1 = %s after negate\n",bi1.negate()); 9 int exponent = 2; 10 System.out.printf("bi1 = %s after pow\n",bi1.pow(exponent)); 11 } 12 /* 输出结果如下： 13 bi1 = 1234567890123457013 after added 14 bi1 = 151851850485185197470 after multiply 15 bi1 = 1234567890123456767 after subtract 16 bi1 = 10037137318076885 after divide 17 bi1 = -1234567890123456890 after negate 18 bi1 = 1524157875323883924401765803688472100 after pow 19 */
2) 将BigInteger的值转换为各种进制的字符串表示：
1 public static void main(String args[]) { 2 BigInteger number = new BigInteger("2008"); 3 System.out.println("Number = " + number); 4 System.out.println("Binary = " + number.toString(2)); 5 System.out.println("Octal = " + number.toString(8)); 6 System.out.println("Hexadecimal = " + number.toString(16)); 7 number = new BigInteger("FF", 16); 8 System.out.println("Number = " + number); 9 System.out.println("Number = " + number.toString(16)); 10 } 11 /* 输出结果如下： 12 Number = 2008 13 Binary = 11111011000 14 Octal = 3730 15 Hexadecimal = 7d8 16 Number = 255 17 Number = ff 18 */
3) 从字符串构造各种进制的BigInteger对象：
1 public static void main(String args[]) { 2 BigInteger bi = new BigInteger("120ff0", 16); 3 Integer ii = Integer.valueOf("120ff0", 16); 4 if (bi.intValue() == ii.intValue()) 5 System.out.println("bi.intValue == ii.intValue"); 6 System.out.println("int i = " + bi.intValue()); 7 8 BigInteger bi2 = new BigInteger("100100100111111110000", 2); 9 System.out.println(bi2.intValue()); 10 } 11 /* 输出结果如下： 12 bi.intValue == ii.intValue 13 int i = 1183728 14 1200112 15 */
4) 位操作：
1 public static void main(String args[]) { 2 byte[] bytes = new byte[] { 0x1, 0x00, 0x00 }; 3 BigInteger bi = new BigInteger(bytes); 4 //相当于 & (~)的位运算。 5 System.out.println("andNot = " + bi.andNot(bi)); 6 //相当于 | 的位运算 7 BigInteger bi2 = new BigInteger(bytes); 8 System.out.println("or = " + bi2.or(bi2)); 9 //相当于 ~ 的位运算 10 BigInteger bi3 = new BigInteger(bytes); 11 System.out.println("not = " + bi3.not()); 12 //相当于 & 的位运算 13 BigInteger bi4 = new BigInteger(bytes); 14 System.out.println("and = " + bi4.and(bi4)); 15 //相当于 ^ 的位运算 16 BigInteger bi5 = new BigInteger(bytes); 17 System.out.println("xor = " + bi5.xor(bi5)); 18 } 19 /* 输出结果如下： 20 andNot = 0 21 or = 65536 22 not = -65537 23 and = 65536 24 xor = 0 25 */
5) 移位运算：
1 public static void main(String args[]) { 2 byte[] bytes = new byte[] { 0x1, 0x00, 0x00 }; 3 BigInteger bi = new BigInteger(bytes); 4 System.out.println(bi); 5 //右移一位 6 System.out.println("after shift right is " + bi.shiftRight(1)); 7 //左移3位 8 System.out.println("after shift left is " + bi.shiftLeft(3)); 9 //翻转第三位，既如果第三位(0 based)为0，则翻转为1，反之翻转为0. 10 //翻转之前：10000000000000000 11 //翻转之后：10000000000001000 12 bi = bi.flipBit(3); 13 System.out.println("after flip is " + bi); 14 //将第三位的bit清0 15 //clear之前：10000000000001000 16 //clear之后：10000000000000000 17 bi = bi.clearBit(3); 18 System.out.println("after clear is " + bi); 19 //将第三位设置为1 20 //set之前：10000000000000000 21 //set之后：10000000000001000 22 bi = bi.setBit(3); 23 System.out.println("after set is " + bi); 24 System.out.println("The binary result for bi is " + bi.toString(2)); 25 System.out.println("The test result for BIT 2 is " + bi.testBit(2)); 26 System.out.println("The test result for BIT 3 is " + bi.testBit(3)); 27 } 28 /* 输出结果如下： 29 65536 30 after shift right is 32768 31 after shift left is 524288 32 after flip is 65544 33 after clear is 65536 34 after set is 65544 35 The binary result for bi is 10000000000001000 36 The test result for BIT 2 is false 37 The test result for BIT 3 is true 38 */
3. 时区： 如果你的产品面向全世界的每一个角落，或者说你接到外包项目可能来自多个不同的国家，那么你的程序将会面临时区问题。 1) 基于不同时区设置本地时区的Calendar：
1 public static void main(String args[]) { 2 //获取基于日本时区的Calendar对象。 3 Calendar japanCal = new GregorianCalendar(TimeZone.getTimeZone("Japan")); 4 japanCal.set(Calendar.HOUR_OF_DAY, 10); // 0..23 5 japanCal.set(Calendar.MINUTE, 0); 6 japanCal.set(Calendar.SECOND, 0); 7 //本地时区为北京时区 8 Calendar local = new GregorianCalendar(); 9 local.setTimeInMillis(japanCal.getTimeInMillis()); 10 int hour = local.get(Calendar.HOUR); 11 int minutes = local.get(Calendar.MINUTE); 12 int seconds = local.get(Calendar.SECOND); 13 System.out.println("Hours = " + hour + "\tMinutes = " + minutes 14 + "\tSeconds = " + seconds); 15 } 16 /* 输出结果如下： 17 Hours = 9 Minutes = 0 Seconds = 0 18 */
和预想的一样，我们通过日本时区设置时间后，在通过该Calendar来设置本地时区的Calendar，结果是得到正确的本地时间，换句话说，时区参与了时间的计算。因此可以说，Calendar对象在生成小时部分的时间时，会结合当时的时间和本地的时区来构造该部分，当时区切换时，Calendar会根据初始的时区、初始的时间和当前的时区来进行推算并给出结果。 2) 获取本地时区和所有可用时区：
1 public static void main(String args[]) { 2 //获取本地时区 3 Calendar now = Calendar.getInstance(); 4 TimeZone timeZone = now.getTimeZone(); 5 System.out.println("Current TimeZone is : " + timeZone.getDisplayName()); 6 //获取系统当前所有可用的时区 7 String[] availableTimezones = TimeZone.getAvailableIDs(); 8 for (String timezone : availableTimezones) { 9 System.out.println("Timezone ID = " + timezone); 10 } 11 } 12 /* 输出结果如下： 13 Current TimeZone is : 中国标准时间 14 Timezone ID = Etc/GMT+12 15 Timezone ID = Etc/GMT+11 16 ... ... 17 */
4. 格式化： 1) 日期时间的格式化： 这里先列出日期和时间格式化的suffix： Suffix Replaced By a Abbreviated weekday name A Full weekday name b Abbreviated month name B Full month name c Standard date and time string formatted as day month date hh::mm:ss tzone year C First two digits of year d Day of month as a decimal (01-31) D month/day/year e Day of month as a decimal (1-31) F year-month-day h Abbreviated month name H Hour (00 to 23) I Hour (01 to 12) j Day of year as a decimal (001 to 366) k Hour (0 to 23) l Hour (1 to 12) L Millisecond (000 to 999) m Month as decimal (01 to 13) M Minute as decimal (00 to 59) N Nanosecond (000000000 to 999999999) p Locale equivalent of AM or PM in lowercase Q Milliseconds from 1/1/1970 r hh:mm:ss (12-hour format) R hh:mm (24-hour format) S Seconds (00 to 60) s Seconds from 1/1/1970 UTC T hh:mm:ss (24-hour format) y Year in decimal without century (00 to 99) Y Year in decimal including century (0001 to 9999) z Offset from UTC Z Time zone name
1 public static void main(String args[]) { 2 Formatter fmt = new Formatter(); 3 Calendar cal = Calendar.getInstance(); 4 //这里的<符号表示%tB取后面格式化参数的index等同于其前面的%te，均为1$,既cal。 5 fmt.format("Today is day %te of %
1 public static void main(String args[]) { 2 Formatter fmt = new Formatter(); 3 //-12表示左对齐，如果不足12个字符宽度则右侧补0,12则完全相反，既右对齐， 4 //如果不足12个字符宽度则左侧补0。 5 fmt.format("%-12s %12s\n", "Source", "Loss"); 6 fmt.format("%-12s %,12d\n", "Retail", 1232675); 7 fmt.format("Formatting %s is easy %d %f\n", "with Java", 10, 98.6); 8 //两个百分号%%表示转义后的百分号。 9 fmt.format("Copying file\nTransfer is %d%% complete", 88); 10 System.out.println(fmt); 11 } 12 /* 输出结果如下： 13 Source Loss 14 Retail 1,232,675 15 Formatting with Java is easy 10 98.600000 16 Copying file 17 Transfer is 88% complete 18 */
3) 数值格式化：
1 public static void main(String args[]) { 2 double data[] = { 12.3, 45.6, -7.89, -1.0, 1.01 }; 3 Formatter fmt = new Formatter(); 4 fmt.format("%12s %12s\n", "Value", "Cube Root"); 5 //这里的12.4表示为width.precision，既宽度.精度 6 //如果转换为字符串后的宽度不足12，则左侧补0。 7 for (double v : data) 8 fmt.format("%12.4f %12.4f\n", v, Math.cbrt(v)); 9 //如果没有指定宽度，则为实际宽度。 10 fmt.format("Default positive and negative format: %.2f %.2f\n", 423.78,-505.09); 11 //注意+和(的使用方式。 12 fmt.format("With + and parentheses: %+.2f %(.2f\n", 423.78, -505.09); 13 //这里用到缺省精度。 14 fmt.format("Default precision: %f\n", 10.0 / 3.0); 15 fmt.format("Two decimal digits: %.2f\n", 10.0 / 3.0); 16 //注意三者之间的差异。 17 fmt.format("|%f|\n|%12f|\n|%012f|", 10.12345, 10.12345, 10.12345); 18 System.out.println(fmt); 19 } 20 /* 输出结果如下： 21 Value Cube Root 22 12.3000 2.3084 23 45.6000 3.5726 24 -7.8900 -1.9908 25 -1.0000 -1.0000 26 1.0100 1.0033 27 Default positive and negative format: 423.78 -505.09 28 With + and parentheses: +423.78 (505.09) 29 Default precision: 3.333333 30 Two decimal digits: 3.33 31 |10.123450| 32 | 10.123450| 33 |00010.123450| 34 */
5. Runtime: 通过Runtime可以获得更多关于JVM的信息，以及更多和系统之间的交互。
1 public static void main(String args[]) throws IOException { 2 // 以下的返回值均以字节为单位。 3 // 获取JVM中空闲堆的大小 4 long heapFreeSize = Runtime.getRuntime().freeMemory(); 5 System.out.println(heapFreeSize); 6 // 获取JVM最大可分配堆的大小。 7 long heapMaxSize = Runtime.getRuntime().maxMemory(); 8 System.out.println(heapMaxSize); 9 // 当前JVM总共可用的堆空间。 10 long heapSize = Runtime.getRuntime().totalMemory(); 11 System.out.println(heapSize); 12 //获取当前主机的cpu数量 13 int nrOfProcessors = Runtime.getRuntime().availableProcessors(); 14 System.out.println("Number of processors available to the Java Virtual Machine: " 15 + nrOfProcessors); 16 // 通过Runtime运行外部程序，同时可以获取子进程的输出 17 // 作为当前进程的输入。 18 String[] commands = new String[] { "ls", "*" }; 19 Process child = Runtime.getRuntime().exec(commands); 20 InputStream pin = child.getInputStream(); 21 int c; 22 while ((c = pin.read()) != -1) { 23 System.out.println((char) c); 24 } 25 pin.close(); 26 try { 27 //阻塞等待直到子进程退出，并获取退出码。 28 System.out.println("Exit status = " + child.waitFor()); 29 } catch (InterruptedException e) { 30 e.printStackTrace(); 31 } 32 System.out.println("Over."); 33 //注册一个钩子，在虚拟机退出的时候会调用run方法，以完成一些必须的资源释放操作。 34 Runtime.getRuntime().addShutdownHook(new Thread() { 35 public void run() { 36 System.out.println("Do shutdown work ..."); 37 } 38 }); 39 } 40 /* 输出结果如下： 41 15840832 42 259522560 43 16252928 44 Number of processors available to the Java Virtual Machine: 1 45 Over. 46 Do shutdown work ... 47 */
6. TimeUnit： 一个表示时间跨度的对象，在很多其他语言的类库中均有类似这样的工具类，如C#的TimeSpan，他们的共同特征就是在该类和表示日期的对象之间提供了完美的结合。
1 public class MyTest { 2 public static long getDifference(Calendar a, Calendar b, TimeUnit units) { 3 return units.convert(b.getTimeInMillis() - a.getTimeInMillis(), 4 TimeUnit.MILLISECONDS); 5 } 6 7 public static void main(String args[]) { 8 Calendar first = Calendar.getInstance(); 9 first.set(2008, Calendar.AUGUST, 1); 10 Calendar second = Calendar.getInstance(); 11 System.out.println(getDifference(first, second, TimeUnit.DAYS) 12 + " day(s) between "); 13 } 14 } 15 /* 输出结果如下： 16 1132 day(s) between 17 */
7. 数学相关函数： 1) 三角函数：
1 public static void main(String args[]) { 2 double degrees = 45.0; 3 //去弧度 4 double radians = Math.toRadians(degrees); 5 System.out.println("The value of pi is " + Math.PI); 6 System.out.println("The sine of " + degrees + " is " 7 + Math.sin(radians)); 8 System.out.println("The cosine of " + degrees + " is " 9 + Math.cos(radians)); 10 System.out.println("The tangent of " + degrees + " is " 11 + Math.tan(radians)); 12 System.out.println("The arc sine of " + Math.sin(radians) + " is " 13 + Math.toDegrees(Math.asin(Math.sin(radians))) + " degrees"); 14 System.out.println("The arc cosine of " + Math.cos(radians) + " is " 15 + Math.toDegrees(Math.acos(Math.cos(radians))) + " degrees"); 16 System.out.println("The arc tangent of " + Math.tan(radians) + " is " 17 + Math.toDegrees(Math.atan(Math.tan(radians))) + " degrees"); 18 } 19 /* 输出结果如下： 20 The value of pi is 3.141592653589793 21 The sine of 45.0 is 0.8509035245341184 22 The cosine of 45.0 is 0.7071067811865476 23 The tangent of 45.0 is 0.9999999999999999 24 The arc sine of 0.7071067811865475 is 44.99999999999999 degrees 25 The arc cosine of 0.7071067811865476 is 45.0 degrees 26 The arc tangent of 0.9999999999999999 is 45.0 degrees 27 */
2) 原始浮点类型的相等性比较：
1 public class MyTest { 2 public static boolean equals(double v1,double v2) { 3 return Math.abs(v1 - v2) < 1.0E-10; 4 } 5 6 public static void main(String args[]) { 7 double a = 9.33333333333000; 8 double b = 9.33333333333333; 9 10 if (equals(a, b)) 11 System.out.println("double values are equal"); 12 else 13 System.out.println("double values are not equal"); 14 15 Double da = a; 16 Double db = b; 17 if (da.equals(b)) 18 System.out.println("Double values are equal"); 19 else 20 System.out.println("Double values are not equal"); 21 22 } 23 } 24 /* 输出结果如下： 25 double values are equal 26 Double values are not equal 27 */
在Double中比较两个对象的相等性时，由于是基于位的严格比较，因此判断结果是不相等的。然而在很多精度要求并不高的应用中，如果两个浮点数之间的差值小于一定的精度时，可以视为相等的浮点数。再者就是直接使用原始类型的double进行比较时效率会远远高于包装对象的计算。 3) 基本的数学函数：
1 public static void main(String args[]) { 2 // 1. 平方根的计算 3 double dd = 9.0; 4 System.out.println("Math.sqrt(9.0) = " + Math.sqrt(dd)); 5 // 2. 幂次计算 6 System.out.println("pow(9.0, 0.5) = " + Math.pow(9.0, 0.5)); 7 // 3. 对数计算 8 double num = 100.0d; 9 // 自然对数 10 double loge = Math.log(num); 11 System.out.println("log base e = " + loge); 12 // 常用对数 13 double log10 = Math.log(num) / Math.log(10.0); 14 System.out.println("log base 10 = " + log10); 15 // 返回以e为底数的loge幂次，相当于反自然对数 16 double aloge = Math.exp(loge); 17 System.out.println("antilog of log base e = " + aloge); 18 // 反常用对数 19 double alog10 = Math.pow(10.0, log10); 20 System.out.println("anitlog of log base 10 = " + alog10); 21 // 4. 基本数学计算 22 double aNumber = -191.235; 23 //绝对值 24 System.out.println("The absolute value of " + aNumber + " is " 25 + Math.abs(aNumber)); 26 //取高于aNumber的最小整数 27 System.out.println("The ceiling of " + aNumber + " is " 28 + Math.ceil(aNumber)); 29 //取低于aNumber的最大整数 30 System.out.println("The floor of " + aNumber + " is " 31 + Math.floor(aNumber)); 32 //返回距离aNumber最近的整数，如果aNumber = 191.666，则返回192. 33 System.out.println("The rint of " + aNumber + " is " 34 + Math.rint(aNumber)); 35 //5. 最值比较 36 double firstDouble = 45.875; 37 double secondDouble = 54.375; 38 System.out.println("The minimum value is: " 39 + Math.min(firstDouble, secondDouble)); 40 //6. 浮点进位到整数 41 double d1 = 0.49d; 42 double d2 = 0.5d; 43 System.out.println("d1 = 0.49 is " + Math.round(d1)); 44 System.out.println("d2 = 0.5 is " + Math.round(d2)); 45 } 46 /* 输出结果如下： 47 Math.sqrt(9.0) = 3.0 48 pow(9.0, 0.5) = 3.0 49 log base e = 4.605170185988092 50 log base 10 = 2.0 51 antilog of log base e = 100.00000000000004 52 anitlog of log base 10 = 100.0 53 The absolute value of -191.235 is 191.235 54 The ceiling of -191.235 is -191.0 55 The floor of -191.235 is -192.0 56 The rint of -191.235 is -191.0 57 The minimum value is: 45.875 58 d1 = 0.49 is 0 59 d2 = 0.5 is 1 60 */
8. System 工具类： 我们在开发中用到System类的最常用方法是System.currentTimeMillis()，用于获取当前的时间，然后再执行一段测试效率的代码，之后再一次执行该方法并减去之前调用该方法获得的时间值，计算的结果就是中间测试代码消耗的时间(毫秒)。事实上，如果我们充分了解System，他会给我们的开发带来更大的帮助，见如下代码：
1 public class MyTest { 2 private static void getSystemEnv() { 3 // 1. 获取系统当前的环境变量 4 Map map = System.getenv(); 5 Iterator iterator = map.keySet().iterator(); 6 while (iterator.hasNext()) { 7 String key = (String) iterator.next(); 8 String value = (String) map.get(key); 9 System.out.println(key + " = " + value); 10 } 11 } 12 13 private static void getJavaEnv() { 14 // 2. 获取Java自身的环境变量 15 Properties props = System.getProperties(); 16 Iterator iterator = props.entrySet().iterator(); 17 while (iterator.hasNext()) { 18 Map.Entry entry = (Map.Entry) iterator.next(); 19 System.out.println(entry.getKey() + " --- " + entry.getValue()); 20 } 21 } 22 23 private static void getSpecifiedSystemEnv() { 24 // 3. 获取指定的系统环境变量值 25 // 3.1 用户主目录 26 System.out.println("Home Path: " + System.getProperty("user.home")); 27 // 3.2 操作系统的名称 28 System.out.println("Name: " + System.getProperty("os.name")); 29 // 3.3 操作系统的版本 30 System.out.println("Version: " + System.getProperty("os.version")); 31 // 3.4 操作系统的体系结构 32 System.out.println("Architecture: " + System.getProperty("os.arch")); 33 // 3.5 获取当前执行目录 34 System.out.println("Current Directory: " + System.getProperty("user.dir")); 35 // 3.6 获取文件分隔符 36 System.out.println("File Separator: " + System.getProperty("file.separator")); 37 // 3.7 获取Path环境变量中各个路径间的分隔符 38 System.out.println("Path Separator = " + System.getProperty("path.separator")); 39 // 3.8 获取Java的主目录 40 System.out.println("Java Home = " + System.getProperty("java.home")); 41 // 3.9 获取操作系统的临时目录 42 System.out.println("OS current temporary directory is " 43 + System.getProperty("java.io.tmpdir")); 44 // 3.10获取JRE版本 45 String version = System.getProperty("java.version"); 46 char minor = version.charAt(2); 47 char point = version.charAt(4); 48 if (minor < '4' || point < '1') { 49 System.out.println("Your JRE version is higher than 1.4."); 50 } 51 System.out.println("JRE Version = " + System.getProperty("java.version")); 52 // 3.11获取当前用户 53 System.out.println("username = " + System.getProperty("user.name")); 54 // 3.12获取系统的Path环境变量 55 System.out.println("System.getenv(\"PATH\") = " + System.getenv("PATH")); 56 } 57 58 public static void main(String args[]) { 59 getSystemEnv(); 60 getJavaEnv(); 61 getSpecifiedSystemEnv(); 62 } 63 }
运行以后看看自己的结果吧。
最新评论