1、字符串相关的类

1.1 String类及常用方法

String的特性

• String类：代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现
• String是一个final类，代表不可变的字符序列
• 字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改
• String对象的字符内容是存储在一个字符数组value[]中的。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;
}

• String：字符串，使用一对""引起来表示；

• String声明为final的，不可被继承

• String实现了Serializable接口：表示字符串是支持序列化的；实现了Comparable接口：表示String可以比较大小

• String内部定义了final char[] value用于存储字符串数据

• String：代表不可变的字符串序列：简称：不可变性，主要体现在以下几点：

  1. 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
  2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
  3. 当调用String的replace()方法修改指定字符或者字符串时，也需要重新指定内存区域的赋值，不能使用原有的value进行赋值

• 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中

• 字符串常量池中是不会存储相同内容的字符串的

• String的实例化方法如下：

  1. 通过字面量定义的方式
  2. 通过new+构造器的方式

  

String对象的创建

String str = "hello";
//本质上this.value = new char[0];
String s1 = new String();
//this.value = original.value;
String s2 = new String(String.original);
//this.value = Arrays.copyOf(value,value.length);
String s3 = new String(char[] a);
String s4 = new String(char[] a, int startIndex,int count);

String str1 = “abc”;与String str2 = new String(“abc”);的区别？

• 字符串常量存储在字符串常量池，目的是共享
• 字符串非常量对象存储在堆中
  

字符串对象是如何存储的

@Test
public void  test(){
    //通过字面量定义的方式，此时的s1和s2的数据JavaEE声明在
    //方法区中的字符串常量池中
    String s1 = "JavaEE";
    String s2 = "JavaEE";

    //通过new+构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值
    String s3 = new String("JavaEE");
    String s4 = new String("JavaEE");
    Assert.assertEquals(true, (s1==s2));
    Assert.assertEquals(false, (s1==s3));
    Assert.assertEquals(false, (s1==s4));
    Assert.assertEquals(false, (s3==s4));
}

String使用陷阱

• String s1 = “a”;

  说明：在字符串常量池中创建了一个字面量为"a"的字符串。

• s1 = s1 + “b”;

  说明：实际上原来的“a”字符串对象已经丢弃了，现在在堆空间中产生了一个字符串s1+“b”（也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能。

• String s2 = “ab”;

  说明：直接在字符串常量池中创建一个字面量为"ab"的字符串。

• String s3 = “a” + “b”;

  说明：s3指向字符串常量池中已经创建的"ab"的字符串。

• String s4 = s1.intern();

  说明：堆空间的s1对象在调用intern()之后，会将常量池中已经存在的"ab"字符串赋值给s4。

面试题1

@Test
public void  test(){
    String s1 = "hello";
    String s2 = "world";
    String s3 = "hello" + "world";
    String s4 = s1 + "world";
    String s5 = s1 + s2;
    String s6 = (s1+s2).intern();
    Assert.assertEquals(false, (s3==s4));
    Assert.assertEquals(false, (s3==s5));
    Assert.assertEquals(false, (s4==s5));
    Assert.assertEquals(true, (s3==s6));
}

面试题2

下列程序运行的结果：good and best

String str = new String("good");
char[] ch = { 't', 'e', 's', 't' };
public void change(String str, char ch[]) {
    str = "test ok";
    ch[0] = 'b';
}
public static void main(String[] args) {
    StringDemo ex = new StringDemo();
    ex.change(ex.str, ex.ch);
    System.out.print(ex.str + " and ");//
    System.out.println(ex.ch);
}

结论：

• 常量与常量的拼接结果在常量池，且常量池中不会存在相同内容的常量
• 只要其中一个是变量，结果就在堆中
• 如果拼接的结果调用intern()方法，返回值就在常量池中

String常用方法

String与基本数据类型转换

• 字符串->基本数据类型、包装类

  1. Integer包装类的public static int parseInt(String s)：可以将由“数字”字符组成的字符串转换为整型
  2. 类似地,使用java.lang包中的Byte、Short、Long、Float、Double类调相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型

• 基本数据类型、包装类->字符串

  1. 调用String类的public String valueOf(int n)可将int型转换为字符串
  2. 相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(double d)、valueOf(boolean b)可由参数的相应类型到字符串的转换

String与字符数组转换

• 字符数组->字符串

  String 类的构造器：String(char[]) 和 String(char[]，int offset，int length) 分别用字符数组中的全部字符和部分字符创建字符串对象

• 字符串->字符数组

  1. public char[] toCharArray()：将字符串中的全部字符存放在一个字符数组中的方法
  2. public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：提供了将指定索引范围内的字符串存放到数组中的方法

String与字节数组转换

• 字节数组->字符串
  1. String(byte[])：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String
  2. String(byte[]，int offset，int length) ：用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象
• 字符串->字节数组
  1. public byte[] getBytes() ：使用平台的默认字符集将此 String 编码为byte序列，并将结果存储到一个新的byte数组中
  2. public byte[] getBytes(String charsetName) ：使用指定的字符集将此String编码到byte序列，并将结果存储到新的byte数组

1.2 StringBuffer 、StringBuilder

StringBuffer类

• java.lang.StringBuffer代表可变的字符序列，JDK1.0中声明，可以对字符串内容进行增删，此时不会产生新的对象
• 很多方法与String相同
• 作为参数传递时，方法内部可以改变值

* @author      Michael McCloskey
 * @author      Martin Buchholz
 * @author      Ulf Zibis
 * @since       1.5
 */
abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * The value is used for character storage.
     value没有final声明，value可以不断扩容
     */
    char[] value;

    /**
     * The count is the number of characters used.
     count记录有效字符的个数
     */
    int count;
}

StringBuffer类不同于String，其对象必须使用构造器生成。有三个构造器：

• StringBuffer()：初始容量为16的字符串缓冲区
• StringBuffer(int size)：构造指定容量的字符串缓冲区
• StringBuffer(String str)：将内容初始化为指定字符串内容

StringBuffer类的常用方法

注意：

• 当append和insert时，如果原来的value数组长度不够，可扩容

StringBuilder类

• StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且提供相关功能的方法也一样

面试题：

1、对比String、StringBuffer、StringBuilder（高频）

• String(JDK1.0)：不可变字符序列；底层使用char[]存储
• StringBuffer(JDK1.0)：可变字符序列、效率低、线程安全；底层使用char[]存储
• StringBuilder(JDK 5.0)：可变字符序列、效率高、线程不安全；底层使用char[]存储
• 注意：作为参数传递的话，方法内部String不会改变其值，StringBuffer和StringBuilder会改变其值。

源码分析如下

String str = new String ();//char[] value = new char[0];

String str = new String (“abc”);//char[] value = new char[]{‘a’,‘b’,‘c’};

StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组

• sb1.append(‘a’);//value[0]=‘a’;
• sb1.append(b’);//value[1]=‘b’;

StringBuffer sb1 = new StringBuffer(“ab”);//char[] value = new char[“abc”.length()+16];

//问题1：System.out.println(sb2.length());//3

//问题2：扩容问题：如果要添加的数据底层数组放不下了，那就需要扩容底层的数组。默认情况下，扩容原来容量的2倍+2，同时将原有数组中的元素复制到新的数组中

//扩容操作 
private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int newCapacity = (value.length << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }

2、以下程序的输出结果是什么？

String str = null;
StringBuffer sb = new StringBuffer();
sb.append(str);
System.out.println(sb.length());//输出：4
System.out.println(sb);//输出：null
StringBuffer sb1 = new StringBuffer(str);
System.out.println(sb1);//在声明sb1的构造方法中抛出java.lang.NullPointerException异常

3、程序输出

String a = "123";
String b = "123";
String c = new String("123");
String d = new String("123");
System.out.println(a.equals(b));//true
System.out.println(a == b);//true
System.out.println(c.equals(d));//true
System.out.println(c == d);//false
System.out.println(a.equals(c));//true
System.out.println(a == c);//false

4、JVM中字符串常量池存放位置说明

• JDK1.6（JDK6.0、Java6.0）：字符串常量池存储在方法区（永久区）
• JDK1.7：字符串常量池存储在堆空间
• JDK1.8：字符串常量池存储在方法区（元空间）

2、 JDK8之前的日期时间API

2.1 System静态方法

System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。

此方法适于计算时间差

计算世界时间的主要标准有：

• UTC(Coordinated Universal Time)
• GMT(Greenwich Mean Time)
• CST(Central Standard Time)

2.2 Date类

java.util.Date类：表示特定的瞬间，精确到毫秒

构造器

• Date()：使用无参构造器创建的对象可以获取本地当前时间
• Date(long date)

常用方法

• getTime():返回自1970年1月1日 00:00:00 GMT以来此Date对象表示的毫秒数
• toString():把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)，zzz是时间标准

public class DateDemo {
    public static void main(String[] args) {
        Date date = new Date();
        //Tue Apr 28 06:16:44 CST 2020
        System.out.println(date);
        //1588025805026
        System.out.println(System.currentTimeMillis());
        //1588025804972
        System.out.println(date.getTime());
        Date date1 = new Date(date.getTime());
        //1588025804972
        System.out.println(date1.getTime());
        //Tue Apr 28 06:16:44 CST 2020
        System.out.println(date1.toString());
    }
}

2.3 Calender类

java.util.Calendar(日历)类

• Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能
• 获取Calendar实例的方法
  1. 使用Calendar.getInstance()方法
  2. 调用它的子类GregorianCalendar的构造器
• 一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、MINUTE、SECOND
  1. public void set(int field,int value)
  2. public void add(int field,int amount)
  3. public final Date getTime()
  4. public final void setTime(Date date)
• 注意:
  1. 获取月份时：一月是0，二月是1，以此类推，12月是11
  2. 获取星期时：周日是1，周二是2 ， 。。。。周六是7

public class DateDemo {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        // 从一个 Calendar 对象中获取 Date 对象
        Date date = calendar.getTime();
        // 使用给定的 Date 设置此 Calendar 的时间
        date = new Date(234234235235L);
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, 8);
        // 当前时间日设置为8后,时间是:Wed Jun 08 09:03:55 CST 1977
        System.out.println("当前时间日设置为8后,时间是:" + calendar.getTime());
        calendar.add(Calendar.HOUR, 2);
        //当前时间加2小时后,时间是:Wed Jun 08 11:03:55 CST 1977
        System.out.println("当前时间加2小时后,时间是:" + calendar.getTime());
        calendar.add(Calendar.MONTH, -2);
        //当前日期减2个月后,时间是:Fri Apr 08 11:03:55 CST 1977
        System.out.println("当前日期减2个月后,时间是:" + calendar.getTime());
    }
}

2.4 SimpleDateFormat类

java.text.SimpleDateFormat类

• Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类
• 它允许进行格式化：日期->文本、解析：文本->日期
• 格式化：
  1. SimpleDateFormat() ：默认的模式和语言环境创建对象
  2. public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用
  3. public String format(Date date)：方法格式化时间对象date
• 解析：
  1. public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期

public class DateDemo {
    public static void main(String[] args) {
        Date date = new Date(); // 产生一个Date实例
        // 产生一个formater格式化的实例
        SimpleDateFormat formater = new SimpleDateFormat();
        //20-4-28 上午6:25
        System.out.println(formater.format(date));// 打印输出默认的格式
        SimpleDateFormat formater2 = new SimpleDateFormat("yyyy年MM月dd日 EEE HH:mm:ss");.
        //2020年04月28日 星期二 06:25:18
        System.out.println(formater2.format(date));
        try {
            // 实例化一个指定的格式对象
            Date date2 = formater2.parse("2020年04月28日 星期二 08:08:08");
            // 将指定的日期解析后格式化按指定的格式输出
            //Tue Apr 28 08:08:08 CST 2020
            System.out.println(date2.toString());
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

3、JDK8中新日期时间API

如果我们可以跟别人说：“我们在1502643933071见面，别晚了！”那么就再简单不过了。但是我们希望时间与昼夜和四季有关，于是事情就变复杂了。JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们面临的问题是：

• 可变性：像日期和时间这样的类应该是不可变的。
• 偏移性：Date中的年份是从1900开始的，而月份都从0开始。
• 格式化：格式化只对Date有用，Calendar则不行。
• 此外，它们也不是线程安全的；不能处理闰秒等。

总结：对日期和时间的操作一直是Java程序员最痛苦的地方之一。

第三次引入的API是成功的，并且Java 8中引入的java.time API 已经纠正了过去的缺陷，将来很长一段时间内它都会为我们服务。

Java 8 吸收了 Joda-Time 的精华，以一个新的开始为 Java 创建优秀的 API。新的 java.time中包含了所有关于本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime）和持续时间（Duration）的类。历史悠久的 Date 类新增了 toInstant() 方法，用于把 Date 转换成新的表示形式。这些新增的本地化时间日期 API 大大简化了日期时间和本地化的管理。

新时间日期API

说明：大多数情况下只会用到基础包和format包，也可能会用到temporal包。因此，尽管有68个新的公开类型，大多数开发者，大概将只会用到其中的三分之一

3.1 LocalDate、LocalTime、LocalDateTime类

LocalDate、LocalTime、LocalDateTime 类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。

• LocalDate代表IOS格式（yyyy-MM-dd）的日期,可以存储 生日、纪念日等日期。
• LocalTime表示一个时间，而不是日期。
• LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一。

注意：ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法，也就是公历

3.2 Instant

• Instant：时间线上的一个瞬时点。 这可能被用来记录应用程序中的事件时间戳。
• 在处理时间和日期的时候，我们通常会想到年,月,日,时,分,秒。然而，这只是时间的一个模型，是面向人类的。第二种通用模型是面向机器的，或者说是连续的。在此模型中，时间线中的一个点表示为一个很大的数，这有利于计算机处理。在UNIX中，这个数从1970年开始，以秒为的单位；同样的，在Java中，也是从1970年开始，但以毫秒为单位。
• java.time包通过值类型Instant提供机器视图，不提供处理人类意义上的时间单位。Instant表示时间线上的一点，而不需要任何上下文信息，例如，时区。概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（UTC）开始的秒数。因为java.time包是基于纳秒计算的，所以Instant的精度可以达到纳秒级。
• (1 ns = 10-9 s) 1秒 = 1000毫秒 =10^6微秒=109纳秒

时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。

3.3 DateTimeFormatter(格式化与解析日期或时间)

java.time.format.DateTimeFormatter 类：该类提供了三种格式化方法：

• 预定义的标准格式。如：

  ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME

• 本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)

• 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)

3.4 其它类

• ZoneId：该类中包含了所有的时区信息，一个时区的ID，如 Europe/Paris
• ZonedDateTime：一个在ISO-8601日历系统时区的日期时间，如 2007-12-03T10:15:30+01:00 Europe/Paris。其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”的格式，例如：Asia/Shanghai等
• Clock：使用时区提供对当前即时、日期和时间的访问的时钟。
• 持续时间：Duration，用于计算两个“时间”间隔
• 日期间隔：Period，用于计算两个“日期”间隔
• TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下一个工作日”等操作
• TemporalAdjusters : 该类通过静态方法
• firstDayOfXxx()/lastDayOfXxx()/nextXxx())提供了大量的常用TemporalAdjuster 的实现

3.5 与传统日期处理的转换

4、Java比较器

• 在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题
• Java实现对象排序的方式有两种：
  1. 自然排序：java.lang.Comparable
  2. 定制排序：java.util.Comparator

4.1 Comparable接口

自然排序：java.lang.Comparable

• Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。
• 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。如果当前对象this大于形参对象obj，则返回正整数，如果当前对象this小于形参对象obj，则返回负整数，如果当前对象this等于形参对象obj，则返回零。
• 实现Comparable接口的对象列表（和数组）可以通过 Collections.sort 或Arrays.sort进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
• 对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与e1.equals(e2) 具有相同的 boolean 值时，类 C 的自然排序才叫做与 equals 一致。建议（虽然不是必需的）最好使自然排序与 equals 一致。

Comparable 的典型实现：(默认都是从小到大排列的)

• String：按照字符串中字符的Unicode值进行比较
• Character：按照字符的Unicode值来进行比较
• 数值类型对应的包装类以及BigInteger、BigDecimal：按照它们对应的数值大小进行比较
• Boolean：true 对应的包装类实例大于 false 对应的包装类实例
• Date、Time等：后面的日期时间比前面的日期时间大

public class Goods implements Comparable<Goods>{
    private String name;
    private double price;

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    //按照价格，比较商品的大小
    @Override
    public int compareTo(Goods o) {
        if (this.price > o.price) {
            return 1;
        }else if (this.price < o.price){
            return -1;
        }
        return 0;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

public class ComparableTest {
    public static void main(String[] args) {
        Goods[] all = new Goods[4];
        all[0] = new Goods("《红楼梦》", 100);
        all[1] = new Goods("《西游记》", 80);
        all[2] = new Goods("《三国演义》", 140);
        all[3] = new Goods("《水浒传》", 120);
        Arrays.sort(all);
        //[Goods{name='《西游记》', price=80.0}, Goods{name='《红楼梦》', price=100.0}, Goods{name='《水浒传》', price=120.0}, Goods{name='《三国演义》', price=140.0}]
        System.out.println(Arrays.toString(all));
    }
}

4.2 Comparator接口

定制排序：java.util.Comparator

• 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那
  么可以考虑使用 Comparator 的对象来排序，强行对多个对象进行整体排序的比较。
• 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
• 可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。
• 还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

public class ComparableTest {
    public static void main(String[] args) {
        Goods[] all = new Goods[4];
        all[0] = new Goods("《红楼梦》", 100);
        all[1] = new Goods("《西游记》", 80);
        all[2] = new Goods("《三国演义》", 140);
        all[3] = new Goods("《水浒传》", 120);
        Arrays.sort(all, new Comparator<Goods>() {
            @Override
            public int compare(Goods o1, Goods o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        //[Goods{name='《三国演义》', price=140.0}, Goods{name='《水浒传》', price=120.0}, Goods{name='《红楼梦》', price=100.0}, Goods{name='《西游记》', price=80.0}]
        System.out.println(Arrays.toString(all));
    }
}

5、System类

• System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。

  该类位于java.lang包。

• 由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。

• 成员变量

  System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。

• 成员方法

String javaVersion = System.getProperty("java.version");
        System.out.println("java的version:" + javaVersion);
        String javaHome = System.getProperty("java.home");
        System.out.println("java的home:" + javaHome);
        String osName = System.getProperty("os.name");
        System.out.println("os的name:" + osName);
        String osVersion = System.getProperty("os.version");
        System.out.println("os的version:" + osVersion);
        String userName = System.getProperty("user.name");
        System.out.println("user的name:" + userName);
        String userHome = System.getProperty("user.home");
        System.out.println("user的home:" + userHome);
        String userDir = System.getProperty("user.dir");
        System.out.println("user的dir:" + userDir);

com.htzw.java.ComparableTest
java的version:1.8.0_121
java的home:C:\Program Files\Java\jdk1.8.0_121\jre
os的name:Windows 10
os的version:10.0
user的name:GULJ
user的home:C:\Users\Administrator
user的dir:F:\JavaDemo

6、Math类

java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。

• abs 绝对值
• acos,asin,atan,cos,sin,tan 三角函数
• sqrt 平方根
• pow(double a,doble b) a的b次幂
• log 自然对数
• exp e为底指数
• max(double a,double b)
• min(double a,double b)
• random() 返回0.0到1.0的随机数
• long round(double a) double型数据a转换为long型（四舍五入）
• toDegrees(double angrad) 弧度—>角度
• toRadians(double angdeg) 角度—>弧度

7、BigInteger与BigDecimal

###BigInteger类

• Integer类作为int的包装类，能存储的最大整型值为2^{31-1，Long类也是有限的，最大为2}63-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。

• java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。

• 构造器

  BigInteger(String val)：根据字符串构建BigInteger对象

• 常用方法

  1. public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger
  2. BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger
  3. BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger
  4. BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger
  5. BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分
  6. BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的 BigInteger
  7. BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组
  8. BigInteger pow(int exponent) ：返回其值为 (this^exponent) 的 BigInteger

BigDecimal类

• 一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。
• BigDecimal类支持不可变的、任意精度的有符号十进制定点数。
• 构造器
  1. public BigDecimal(double val)
  2. public BigDecimal(String val)
• 常用方法
  1. public BigDecimal add(BigDecimal augend)
  2. public BigDecimal subtract(BigDecimal subtrahend)
  3. public BigDecimal multiply(BigDecimal multiplicand)
  4. public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

BigInteger bi = new BigInteger("12433241123");
        BigDecimal bd = new BigDecimal("123435.351");
        BigDecimal bd2 = new BigDecimal("22");
        // 12433241123
        System.out.println(bi);
        //BigDecimal.ROUND_HALF_UP:遇到.5的情况时往上近似
        // 5610.698
        System.out.println(bd.divide(bd2,BigDecimal.ROUND_HALF_UP));
        // 5610.697772727272727
        System.out.println(bd.divide(bd2,15,BigDecimal.ROUND_HALF_UP));