设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Java 基础类库：System、Runtime、Object、Math

2016-12-16 12:53| 发布者: zhangjf| 查看: 525| 评论: 0

摘要: 与用户互动 运行java程序的参数//Java程序入口：main()方法public static void main(String args){...}复制代码 public修饰符：Java类由JVM调用，为了让JVM可以自由调用这个main()方法，所以使用public修饰符把这个 ...
与用户互动 运行java程序的参数
  1. //Java程序入口：main()方法
  2. public static void main(String[] args){...}
复制代码

public修饰符：Java类由JVM调用，为了让JVM可以自由调用这个main()方法，所以使用public修饰符把这个方法暴露出来

static修饰符：JVM调用这个主方法时，不会先创建该主类的对象，然后通过对象来调用该主方法。JVM直接通过该类来调用主方法，因此使用static修饰该主方法。

void返回值：因为主方法被JVM调用，该方法的返回值将返回给JVM，因此main()方法没有返回值。

使用Scanner获取键盘输入

使用Scanner类可以很方便地获取用户的键盘输入，Scanner是一个基于正则表达式的文本扫描器，可以从文件、输入流、字符串中解析出基本类型值和字符串值。

Scanner主要提供了两个方法来扫描输入

hasNextXxx()：是否还有下一个输入项，其中Xxx可以是Int、Long等代表基本数据类型的字符串。如果只是判断是否包含下一个字符串，则直接使用hasNext()

nextXxx()：获取下一个输入项。

默认情况下，Scanner使用空白（空格、Tab空白、回车）作为多个输入项之间的分隔符。

  1. import java.util.Scanner;
  3. public class ScannerKeyBoardTest
  4. {
  5. public static void main(String[] args)
  6. {
  7. //System.in代表标准输入，就是键盘输入
  8. Scanner sc = new Scanner(System.in);
  9. //增加下面一行将只把回车作为分隔符
  10. //sc.useDelimiter("n");
  11. //判断是否还有下一个输入项
  12. while (sc.hasNext())
  13. {
  14. //输出输入项
  15. System.out.println("键盘输入的内容是："+ sc.next());
  16. }
  17. }
  18. }
复制代码

Scanner提供了两个简单的方法来逐行读取

boolean hasNextLine()：返回输入源中是否还有下一行

String nextLine()：返回输入源中下一行的字符串

创建Scanner对象，传入一个File对象作为参数，程序将读取ScannerFileTest.java文件中的内容

  1. import java.io.File;
  2. import java.util.Scanner;
  4. public class ScannerFileTest
  5. {
  6. public static void main(String[] args) throws Exception
  7. {
  8. //将一个File对象作为Scanner的构造器参数，Scanner读取文件内容
  9. Scanner sc = new Scanner(new File("ScannerFileTest.java"));
  10. System.out.println("ScannerFileTest.java文件内容如下：");
  11. //判断是否还有下一行
  12. while (sc.hasNextLine())
  13. {
  14. //输出文件中的下一行
  15. System.out.println(sc.nextLine());
  16. }
  17. }
  18. }
复制代码
系统相关 System类

System类代表了当前Java程序的运行平台，程序不能创建System类的对象，System类提供了一些类变量和类方法，允许直接通过System类来调用这些类变量和类方法。

加载文件和动态链接库主要对naive方法有用，对于一些特殊的功能（如访问操作系统底层硬件设备等）Java程序无法实现必须借助C语音来完成，此时需要使用C语音为Java方法提供实现

Java程序中声明native修饰的方法，类似于abstract方法，只有方法签名，没有实现。编译该Java程序，生成一个class文件

用javah编译第1步生成的class文件，将生成一个.h文件

写一个.cpp文件实现native，这一步需要包含第2步生成的.h文件（.h文件中包含JDK带的jni.h文件）

将第3步的.cpp文件编译成动态链接库文件

在Java中用System类的loadLibrary..()方法或Runtime类的loadLibrary()方法加载第4步产生的动态链接库文件，Java程序中就可以调用这个native方法了。

  1. import java.io.FileOutputStream;
  2. import java.util.Map;
  3. import java.util.Properties;
  5. public class SystemTest
  6. {
  7. public static void main(String[] args) throws Exception
  8. {
  9. //获取系统所有的环境变量
  10. Map<String, String> env = System.getenv();
  11. for(String name : env.keySet())
  12. {
  13. System.out.println(name + " ---> " + env.get(name));
  14. }
  15. //获取指定环境变量的值
  16. System.out.println(System.getenv("JAVA_HOME"));
  17. //获取所有的系统属性
  18. Properties properties = System.getProperties();
  19. //将所有的系统属性保存到properties.txt文件中
  20. properties.store(new FileOutputStream("properties.txt"), "System Properties");
  21. //输出特定的系统属性
  22. System.out.println(System.getProperty("os.name"));
  23. }
  24. }
复制代码

System类的in、out和err分别代表系统的标准输入（通常是键盘）、标准输出（通常是显示器）和错误输出流，并提供了setIn()、setOut()和setErr()方法

identityHashCode(Object x)方法，该方法返回指定对象的精确hashCode值，也就是根据该对象的地址计算得到的hashCode值。如果两个对象的identityHashCode值相同，则两个对象绝对是同一个对象。

  1. public class IdentityHashCodeTest
  2. {
  3. public static void main(String[] args)
  4. {
  5. //下面程序中s1和s2是两个不同的对象
  6. String s1 = new String("Hello");
  7. String s2 = new String("Hello");
  8. //String重写了hashCode()方法——改为根据字符序列计算hashCode值
  9. //因为s1和s2的字符序列相同，所有它们的hashCode()方法返回值相同
  10. System.out.println(s1.hashCode() + "---" + s2.hashCode());
  11. //s1和s2是不同的字符串对象，所以它们的identityHashCode值不同
  12. System.out.println(System.identityHashCode(s1) + "---" + System.identityHashCode(s2));
  13. String s3 = "Java";
  14. String s4 = "Java";
  15. //s3和s4是相同的字符串对象，所以它们的identityHashCode值相同
  16. System.out.println(System.identityHashCode(s3) + "---" + System.identityHashCode(s4));
  17. }
  18. }
复制代码
Runtime类

Runtime类代表Java程序的运行时环境，可以访问JVM的相关信息，如处理器数量、内存信息等。每个Java程序都有一个与之对应的Runtime实例，应用程序通过该对象与其运行时环境相连。应用程序不能创建自己的Runtime实例，但可以通过getRuntime()方法获取与之关联的Runtime对象。

Runtime类提供gc()方法和runFinalization()方法来通知系统进行垃圾回收、清理系统资源，并提供了load(String filename)和loadLibrary(String libname)方法来加载文件和动态链接库。

  1. public class ExecTest
  2. {
  3. public static void main(String[] args) throws Exception
  4. {
  5. //获取Java程序关联的运行时对象
  6. Runtime runtime = Runtime.getRuntime();
  7. System.out.println("处理器数量：" + runtime.availableProcessors());
  8. System.out.println("空闲内存数：" + runtime.freeMemory());
  9. System.out.println("总内存数：" + runtime.totalMemory());
  10. System.out.println("可用最大内存数" + runtime.maxMemory());
  11. //运行记事本程序
  12. runtime.exec("notepad.exe");
  13. }
  14. }
复制代码
常用类 Object类

Object类是所有类、数组、枚举类的父类，Java允许把任何类型的对象赋给Object类型的变量。

boolean equals(Object obj)：判断指定对象与该对象是否相等

protected void finalize()：当系统中没有引用变量引用到该对象时，垃圾回收器调用该方法来清理该对象的资源

ClassgetClass()：返回该对象的运行时类

int hashCode()：返回该对象的hashCode()值

String toString()：返回该对象的字符串表示，当程序使用System.out.println()方法输出一个对象，或者把某个对象和字符串进行连接运算时，系统会自动调用该对象的toString()方法返回该对象的字符串表示。

Java提供protected修饰的clone()方法，用于帮助其他对象来实现“自我克隆”，需要被子类重写或调用。

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

自定义类实现Cloneable接口

自定义实现自己的clone()方法

实现clone()方法时通过super.clone();调用Object实现的clone()方法来得到该对象的副本，并返回该副本。

  1. class Address
  2. {
  3. String detail;
  4. public Address(String detail)
  5. {
  6. this.detail =detail;
  7. }
  8. }
  9. //实现Cloneable接口
  10. class User implements Cloneable
  11. {
  12. int age;
  13. Address address;
  14. public User(int age)
  15. {
  16. this.age = age;
  17. address = new Address("珠江新城");
  18. }
  19. //通过调用super.clone()来实现clone()方法
  20. public User clone() throws CloneNotSupportedException
  21. {
  22. return (User)(super.clone());
  23. }
  24. }
  25. public class CloneTest
  26. {
  27. public static void main(String[] args) throws CloneNotSupportedException
  28. {
  29. User u1 = new User(27);
  30. //clone得到u1对象的副本
  31. User u2 = u1.clone();
  32. //判断u1、u2是否相同
  33. System.out.println(u1 == u2);
  34. //判断u1、u2的address是否相同
  35. System.out.println(u1.address == u2.address);
  36. }
  37. }
复制代码

Java7新增的Object类

如果不能确定一个引用变量是否为null，如果贸然地调用该变量的toString()方法，则可能引发NullPointerException异常；如果使用Object类提供的toString(Object o)方法，就不会引发空指针异常，当o为null时，程序将返回一个"null"字符串。

Java为工具类的命名习惯是添加一个字母s，比如操作数组的工具类Arrays，操作集合的工具类Collections。

  1. import java.util.Objects;
  2. public class ObjectsTest
  3. {
  4. //定义一个objectsTest变量，它的默认值是null
  5. static ObjectsTest objectsTest;
  6. public static void main(String[] args)
  7. {
  8. //输出一个null对象的hashCode值，输出0
  9. System.out.println(Objects.hashCode(objectsTest));
  10. //输出一个null对象的toString，输出null
  11. System.out.println(Objects.toString(objectsTest));
  12. //要求objectsTest不能为null，如果objectsTest为null
  13. System.out.println(Objects.requireNonNull(objectsTest,"objectsTest参数不能是null!"));
  14. }
  15. }
复制代码

requireNonNull()方法，当传入的参数不为null时，该方法返回参数本身；否则将会引发NullPointerException异常。

Math类

构造器被定义成private的，因此无法参加Math类的对象，所有方法都是类方法，可以直接通过类名来调用它们，还提供了两个类变量：PI和E

  1. public class MathTest
  2. {
  3. public static void main(String[] args)
  4. {
  5. /*---------下面是三角运算---------*/
  6. // 将弧度转换角度
  7. System.out.println("Math.toDegrees(1.57)："
  8. + Math.toDegrees(1.57));
  9. // 将角度转换为弧度
  10. System.out.println("Math.toRadians(90)："
  11. + Math.toRadians(90));
  12. // 计算反余弦，返回的角度范围在 0.0 到 pi 之间。
  13. System.out.println("Math.acos(1.2)：" + Math.acos(1.2));
  14. // 计算反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。
  15. System.out.println("Math.asin(0.8)：" + Math.asin(0.8));
  16. // 计算反正切；返回的角度范围在 -pi/2 到 pi/2 之间。
  17. System.out.println("Math.atan(2.3)：" + Math.atan(2.3));
  18. // 计算三角余弦。
  19. System.out.println("Math.cos(1.57)：" + Math.cos(1.57));
  20. // 计算值的双曲余弦。
  21. System.out.println("Math.cosh(1.2 )：" + Math.cosh(1.2 ));
  22. // 计算正弦
  23. System.out.println("Math.sin(1.57 )：" + Math.sin(1.57 ));
  24. // 计算双曲正弦
  25. System.out.println("Math.sinh(1.2 )：" + Math.sinh(1.2 ));
  26. // 计算三角正切
  27. System.out.println("Math.tan(0.8 )：" + Math.tan(0.8 ));
  28. // 计算双曲正切
  29. System.out.println("Math.tanh(2.1 )：" + Math.tanh(2.1 ));
  30. // 将矩形坐标 (x, y) 转换成极坐标 (r, thet));
  31. System.out.println("Math.atan2(0.1, 0.2)：" + Math.atan2(0.1, 0.2));
  32. /*---------下面是取整运算---------*/
  33. // 取整，返回小于目标数的最大整数。
  34. System.out.println("Math.floor(-1.2 )：" + Math.floor(-1.2 ));
  35. // 取整，返回大于目标数的最小整数。
  36. System.out.println("Math.ceil(1.2)：" + Math.ceil(1.2));
  37. // 四舍五入取整
  38. System.out.println("Math.round(2.3 )：" + Math.round(2.3 ));
  39. /*---------下面是乘方、开方、指数运算---------*/
  40. // 计算平方根。
  41. System.out.println("Math.sqrt(2.3 )：" + Math.sqrt(2.3 ));
  42. // 计算立方根。
  43. System.out.println("Math.cbrt(9)：" + Math.cbrt(9));
  44. // 返回欧拉数 e 的n次幂。
  45. System.out.println("Math.exp(2)：" + Math.exp(2));
  46. // 返回 sqrt(x2 +y2)
  47. System.out.println("Math.hypot(4 , 4)：" + Math.hypot(4 , 4));
  48. // 按照 IEEE 754 标准的规定，对两个参数进行余数运算。
  49. System.out.println("Math.IEEEremainder(5 , 2)："
  50. + Math.IEEEremainder(5 , 2));
  51. // 计算乘方
  52. System.out.println("Math.pow(3, 2)：" + Math.pow(3, 2));
  53. // 计算自然对数
  54. System.out.println("Math.log(12)：" + Math.log(12));
  55. // 计算底数为 10 的对数。
  56. System.out.println("Math.log10(9)：" + Math.log10(9));
  57. // 返回参数与 1 之和的自然对数。
  58. System.out.println("Math.log1p(9)：" + Math.log1p(9));
  59. /*---------下面是符号相关的运算---------*/
  60. // 计算绝对值。
  61. System.out.println("Math.abs(-4.5)：" + Math.abs(-4.5));
  62. // 符号赋值，返回带有第二个浮点数符号的第一个浮点参数。
  63. System.out.println("Math.copySign(1.2, -1.0)："
  64. + Math.copySign(1.2, -1.0));
  65. // 符号函数；如果参数为 0，则返回 0；如果参数大于 0，
  66. // 则返回 1.0；如果参数小于 0，则返回 -1.0。
  67. System.out.println("Math.signum(2.3)：" + Math.signum(2.3));
  68. /*---------下面是大小相关的运算---------*/
  69. // 找出最大值
  70. System.out.println("Math.max(2.3 , 4.5)：" + Math.max(2.3 , 4.5));
  71. // 计算最小值
  72. System.out.println("Math.min(1.2 , 3.4)：" + Math.min(1.2 , 3.4));
  73. // 返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
  74. System.out.println("Math.nextAfter(1.2, 1.0)："
  75. + Math.nextAfter(1.2, 1.0));
  76. // 返回比目标数略大的浮点数
  77. System.out.println("Math.nextUp(1.2 )：" + Math.nextUp(1.2 ));
  78. // 返回一个伪随机数，该值大于等于 0.0 且小于 1.0。
  79. System.out.println("Math.random()：" + Math.random());
  80. }
  81. }
复制代码
Java 7的ThreadLocalRandom与Random

Random类专门用于生成一个伪随机数，它有两个构造器：一个构造器使用默认的种子（当前时间作为种子），另一个构造器需要程序员显式传入一个long型整数的种子

ThreadLocalRandom类是Java7新增的一个类，在并发访问环境下，可以减少多线程资源竞争，最终保证系统具有更好的线程安全性。提供静态的current()方法来获取ThreadLocalRandom对象，获取该对象之后调用各种nextXxx()方法来获取伪随机数

  1. import java.util.Arrays;
  2. import java.util.Random;
  4. public class RandomTest
  5. {
  6. public static void main(String[] args)
  7. {
  8. Random random = new Random();
  9. System.out.println("random.nextBoolean():"+random.nextBoolean());
  10. byte[] buffer = new byte[16];
  11. random.nextBytes(buffer);
  12. System.out.println(Arrays.toString(buffer));
  13. //生成0.0~1.0之间的伪随机double数
  14. System.out.println("random.nextDouble():"+random.nextDouble());
  15. //生成0.0~1.0之间的伪随机float数
  16. System.out.println("random.nextFloat():"+random.nextFloat());
  17. //生成平均值是0.0，标准差是1.0的伪高斯数
  18. System.out.println("random.nextGaussian():"+random.nextGaussian());
  19. //生成0~26之间的伪随机整数
  20. System.out.println("random.nextInt(26):"+random.nextInt(26));
  21. //生成一个处于long整数取值范围的伪随机整数
  22. System.out.println("random.nextLong():"+random.nextLong());
  23. }
  24. }
复制代码

Random使用一个48位的种子，如果这个类的两个实例是用同一个种子创建的，对它们以同样的顺序调用方法，则它们会产生相同的数字序列。为避免两个Random对象产生相同的数字序列，推荐使用当前时间作为Random对象的种子

  1. Random rt = new Random(System.currentTimeMillis());
复制代码
  1. ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
  2. //生成一个4~20之间的伪随机整数
  3. int vall = threadLocalRandom.nextInt(4, 20);
  4. //生成一个2.0~10.0之间的伪随机浮点数
  5. int vall2 = threadLocalRandom.nextDouble(2.0, 10.0);
复制代码
BigDecimal类

BigDecimal能精确表示、计算浮点数。该类提供了大量的构造器用于创建BigDecimal对象，包括把所有基本数值型变量转换成一个BigDecimal对象，也包括利用数字字符串、数字字符数组来创建BigDecimal对象。

BigDecimal(String val)构造器的结果是可预知的——写入new BigDecimal("0.1")将创建一个BigDecimal对象，优先建议使用基于String的构造器

如果必须使用double浮点数作为BigDecimal构造器的参数时， 不要直接将该double浮点数作为构造器参数创建BigDecimal对象，而是通过BigDecimal.valueOf(double calue)静态方法来创建BigDecimal对象

收藏 邀请
上一篇：Android安全之Intent Scheme Url攻击下一篇：译文-Hotspot VM中Oop Maps的含义？

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-7 18:22

Copyright 2015-2025 djqfx

返回顶部