第十课时：与运行环境交互

一、与用户交互

1、使用 Scanner 获取键盘输入

获取键盘输入：

 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());
  }
 }

获取文件输入：

 public static void main(String[] args) throws FileNotFoundException {
  Scanner sc = new Scanner(new File("a.txt"));
  System.out.println("a.txt 文件的内容如下：");
  
  // 判断是否还有下一行
  while(sc.hasNextLine())
  {
   // 输出文件中的一行
   System.out.println(sc.nextLine());
  }
 }

2、使用 BufferedReader 获取键盘输入

 public static void main(String[] args) throws Exception
 {
  //以System.in节点流，创建一个BufferedReader对象
  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  String buffer = null;
  //逐行读取键盘输入
  while ((buffer = br.readLine()) != null)
  {
   System.out.println("用户键盘输入是:" + buffer);
  }
 }

 

二、系统相关

1、System 类

  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.getenv("JAVA_HOME"));
  //获取所有的系统属性
  Properties props = System.getProperties();
  //将所有系统属性保存到props.txt文件中
  props.store(new FileOutputStream("props.txt") , "System Properties");
  //输出特定的系统属性
  System.out.println(System.getProperty("os.name"));
 }

         System 类的 gc() 方法、runFinalization() 方法、currentTimeMillis() 方法、nanoTime() 方法、identityHashCode(Object x) 方法。

         System.identityHashCode(Object x)  方法返回指定对象的精确 hashCode 值，也就是根据该对象的地址计算得到的 hashCode 值。当某个类的 hashCode 方法被重写之后，该类实例的 hashCode 方法就不能唯一地标识该对象，但通过 identityHashCode(Object x)  方法返回的 hashCode 依然是根据该对象的地址计算得到的 hashCode 值，所以如果两个对象的 identityHashCode 值相同，则这两个对象绝对是同一个对象。

示例：

  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";
  //s3和s4是相同的字符串对象，所以它们的identityHashCode值相同
  System.out.println(System.identityHashCode(s3) + "----" +
   System.identityHashCode(s4));
 }

 

2、Runtime 类

         Runtime 类代表 Java 程序的运行时环境，每个 Java 程序都有一个与之对应的 Runtime 实例，应用程序通过该对象与其运行时环境相连。

         应用程序不能创建自己的 Runtime 实例，但可以通过 getRuntime() 方法获取与之关联的 Runtime 对象。

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

         Runtime 类代表了Java 程序运行时环境，可以访问 JVM 的相关信息，如处理器数量、内存信息等。

 示例：

 public static void main(String[] args)
 {
  Runtime rt = Runtime.getRuntime();
  System.out.println("处理器数量：" + rt.availableProcessors());
  System.out.println("空闲内存数：" + rt.freeMemory());
  System.out.println("总内存数：" + rt.totalMemory());
  System.out.println("可用最大内存数：" + rt.maxMemory());
 }

          Runtime 还有一个功能：它可以直接单独启动一条进程（注意是进程，而不是线程）来运行操作系统的命令，示例：

 public static void main(String[] args)throws Exception
 {
  Runtime rt = Runtime.getRuntime();
  rt.exec("notepad.exe");
 }

 

三、常用类

1、Object 类

2、String、StringBuffer、StringBuilder

     String 是一个不可变类

     StringBuffer 对象则代表一个字符序列可变的字符串

     StringBuilder 与 StringBuffer 基本相同，但是 StringBuffer 是线程安全的

    

     String 有一个十分令人迷惑的地方："hello" 和 new String("hello"); 的区别。"hello" 是存储在常量池中的，（常量池： constant pool 指的是在编译期间被确定、并被保存在已编译的 .class 文件中的一些数据，它包括了关于类、方法、接口中的常量，也包括字符串常量），示例：

     String s0 = "hello";

     String s1 = "hello";

     String s2 = "he" + "llo";

     System.out.println(s0 == s1);

     System.out.println(s0 == s2);

     System.out.println(new String("hello") == new String("hello"));

     运行结果是：

     true

     true

     false

3、Math 类

     Math 类是一个工具类，它的构造器被定义为 private 的，因此无法创建 Math 类的实例。

     Math 类中所有方法都是类方法，它还有两个类属性：PI 和 E，分别代表 π 和 e。

4、Random 类

     Random 类是专门用来生成伪随机数的类，它有两个构造器：一个使用默认的种子，另一个需要程序员显式传入一 long 型整数的种子。

     示例：

 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());
  //生成一个处于long整数取值范围的伪随机整数
  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());
 }

 

       Random 使用一个 48 位的种子，如果这个类的两个实例是用同一个种子创建的，对它们以同样的调用顺序调用方法，则它们会产生相同的数字序列。

       示例：

    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\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\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("种子为100的Random对象");
        System.out.println("r3.nextBoolean():\t" + r3.nextBoolean());
        System.out.println("r3.nextInt():\t\t" + r3.nextInt());
        System.out.println("r3.nextDouble():\t" + r3.nextDouble());
        System.out.println("r3.nextGaussian():\t" + r3.nextGaussian());       
    }

       为了避免两个 Random 对象产生相同的数字序列，可以使用另一个随机数作为种子，通常推荐使用当前时间来作为 Random 对象的种子，例如：

       Random rand = new Random(System.currentTimeMills()); // 使用当前时间来作为种子

5、BigDecimal 类

     由于 float 和 double 两个基本浮点类型数据容易产生精度丢失，例如：

     public static void main(String args[])
     {
        System.out.println("0.05 + 0.01 = " + (0.05 + 0.01));
        System.out.println("1.0 - 0.42 = " + (1.0 - 0.42));
        System.out.println("4.015 * 100 = " + (4.015 * 100));
        System.out.println("123.3 / 100 = " + (123.3 / 100));
     }

     结果是：

     0.05 + 0.01 = 0.060000000000000005
     1.0 - 0.42 = 0.5800000000000001
     4.015 * 100 = 401.49999999999994
     123.3 / 100 = 1.2329999999999999

     为了可以精确表示、计算浮点数，Java 提供了 BigDecimal 类。

     BigDecimal 有大量的构造器用于创建该类对象。

     

构造方法摘要

BigDecimal(BigInteger val)
          将 BigInteger 转换为 BigDecimal。

BigDecimal(BigInteger unscaledVal, int scale)
          将 BigInteger 非标度值和 int 标度转换为 BigDecimal。

BigDecimal(BigInteger unscaledVal, int scale, MathContext mc)
          将 BigInteger 非标度值和 int 标度转换为 BigDecimal（根据上下文设置进行舍入）。

BigDecimal(BigInteger val, MathContext mc)
          将 BigInteger 转换为 BigDecimal（根据上下文设置进行舍入）。

BigDecimal(char[] in)
          将 BigDecimal 的字符数组表示形式转换为 BigDecimal，接受与 BigDecimal(String) 构造方法相同的字符序列。

BigDecimal(char[] in, int offset, int len)
          将 BigDecimal 的字符数组表示形式转换为 BigDecimal，接受与 BigDecimal(String) 构造方法相同的字符序列，同时允许指定子数组。

BigDecimal(char[] in, int offset, int len, MathContext mc)
          将 BigDecimal 的字符数组表示形式转换为 BigDecimal，接受与 BigDecimal(String) 构造方法相同的字符序列，同时允许指定子数组，并根据上下文设置进行舍入。

BigDecimal(char[] in, MathContext mc)
          将 BigDecimal 的字符数组表示形式转换为 BigDecimal，接受与 BigDecimal(String) 构造方法相同的字符序列（根据上下文设置进行舍入）。

BigDecimal(double val)
          将 double 转换为 BigDecimal，后者是 double 的二进制浮点值准确的十进制表示形式。

BigDecimal(double val, MathContext mc)
          将 double 转换为 BigDecimal（根据上下文设置进行舍入）。

BigDecimal(int val)
          将 int 转换为 BigDecimal。

BigDecimal(int val, MathContext mc)
          将 int 转换为 BigDecimal（根据上下文设置进行舍入）。

BigDecimal(long val)
          将 long 转换为 BigDecimal。

BigDecimal(long val, MathContext mc)
          将 long 转换为 BigDecimal（根据上下文设置进行舍入）。

BigDecimal(String val)
          将 BigDecimal 的字符串表示形式转换为 BigDecimal。

BigDecimal(String val, MathContext mc)
          将 BigDecimal 的字符串表示形式转换为 BigDecimal，接受与 BigDecimal(String) 构造方法相同的字符串（按照上下文设置进行舍入）。

 

        不推荐使用 BigDecimal 类的 BigDecimal(double val) 构造器。因为例如当程序使用 new BigDecimal(0.1) 来创建一个 BigDecimal 对象时，它的值并不是 0.1，它实际上是 0.1000000000000000055511151231257827021181583404541015625，因为 0.1 无法准确地表示为 double 浮点数，所以传入 BigDecimal 构造器的值不会正好等于 0.1。

        但如果使用 Bigdecimal(String val) 构造器的结果是可预知的，例如写入 new BigDecimal("0.1") 创建一个 BigDecimal 实例，它正好是预期的 0.1。因此建议使用入参是 String 的构造器。

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

        BigDecimal 类提供了 add、subtract、multiply、divide、pow 等函数对精确浮点数进行常规算术运算。

        示例：

 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));
 }

 

四、处理日期的类

1、Date 类

     Date 类从 JDK 1.0 起就开始存在了，但正因为它历史悠久，所以它的大部分构造器、方法都已经过时，不再推荐使用。

     Date 类提供了 6 个构造器，在其中 4 个已经被 Deprecated，只剩下两个：

     Date()

     Date(long date)

     Date 类的大部分方法也被 Deprecated 了，剩下的方法有：

     boolean after(Date when)

     boolean before(Date when)

     int compareTo(Date anotherDate)

     boolean equals(Object obj)

     long getTime()

     void setTime(long time)

2、Calendar 类

     Calendar 是一个抽象类，它用于表示日历。为了统一计时，全世界通常选择最普及、最通用的日历：Gregorian Calendar。也就是通常所说的“公元几几年”。

     java.lang.Object
 
         java.util.Calendar
     
                java.util.GregorianCalendar

     Calendar 是一个抽象类，它是所有日历类的模板，不能使用构造起来创建 Calendar 对象。但它提供了几个静态 getInstance 方法来获取 Calendar 对象。这些方法根据 TimeZone、Locale 类获取特定 Calendar，如果不指定 TimeZone、Locale，则使用默认的 TimeZone、Locale 来创建 Calendar。

     Calendar 和 Date 类是可以互相转换的：

     // 创建一个默认的 Calendar 对象

     Calendar calendar = Calendar.getInstance();

     // 从 Calendar 对象中取出 Date 对象

     // 因为 Calendar / GregorianCalendar 没有构造函数可以接受 Date 对象

     // 所以必须先获得一个 Calendar 实例，然后再调用其 setTime 方法

     Calendar calendar2 = Calendar.getInstance();

     calendar2.setTime(date);

 

     Calendar 提供了大量访问、修改时间日期的方法，这些方法的使用示例如下：

 

import java.util.Calendar;
import static java.util.Calendar.*;

public class TestCalendar
{
 public static void main(String[] args)
 {
  Calendar c = Calendar.getInstance();
  // 取出年
  System.out.println(c.get(YEAR));
  // 取出月
  System.out.println(c.get(MONTH));
  // 取出日
  System.out.println(c.get(DATE));
  
  // 分别设置年、月、日、小时、分钟、秒
  c.set(2003, 10, 23, 12, 32, 23);
  System.out.println(c.getTime());
  

  // 将 Calendar 的年前推 1 年
  c.add(YEAR, -1);
  System.out.println(c.getTime());
  

  // 将 Calendar 的月向前推 8 个月
  c.roll(MONTH, -8);
  System.out.println(c.getTime());
  

  // 返回指定的日历字段可能拥有的最小值
  System.out.println(c.getActualMinimum(YEAR));

  // 返回指定的日历字段可能拥有的最大值
  System.out.println(c.getActualMaximum(YEAR));
  
  /*
   * 月份从 0 开始计算，0 代表 1 月份，11 代表 12 月份
   */
  System.out.println(c.getActualMinimum(MONTH));
  System.out.println(c.getActualMaximum(MONTH));
  
  System.out.println(c.getActualMinimum(DATE));
  System.out.println(c.getActualMaximum(DATE));
 }
}

 

add 与 roll 的区别

       add(int field, int amount) 主要用于改变 Calendar 的特定字段的值。如果需要增加某字段的值，则让 amount 为正数；如果需要减少某字段的值，让 amount 为负数即可。

       add 方法有两条规则：

• 当被修改的字段超出它允许的范围时，会发生进位，即上一级字段会增大。如：

          Calendar c = Calendar.getInstance();

          c.set(2010, 7, 23, 0, 0, 0); // 2010-8-23

          c.add(MONTH, 6); // 2010-8-23 => 2011-2-23

• 如果下一级字段也需要改变，那么该字段会修正到变化最小的值

          Calendar c = Calendar.getInstance();

          c.set(2010, 7, 31, 0, 0, 0); // 2010-8-31

          c.add(MONTH, 6); // 2010-8-23 => 2010-2-28

 

       roll 的规则与 add 的处理规则不同：当被修改的字段超出它允许的范围时，上一级字段不会增大。

          Calendar c = Calendar.getInstance();

          c.set(2010, 7, 23, 0, 0, 0); // 2010-8-23

          // MONTH 字段“进位”，但 YEAR 子弹并不增加

          c.add(MONTH, 6); // 2010-8-23 => 2010-2-23

       下一级字段的处理则与 add 相似：

          Calendar c = Calendar.getInstance();

          c.set(2010, 7, 31, 0, 0, 0); // 2010-8-31

          // MONTH 字段“进位”后变成2，2月没有 31 天，YEAR 字段不会改变，所以最后结果是 2010-2-28

          c.add(MONTH, 6); // 2010-8-23 => 2010-2-28

 

       设置 Calendar 的容错性

       当使用 Calendar 对象的 set 方法来改变指定时间字段上的值时，有可能输入一个不合法的参数