Java基础8：Java常用类

字符串相关类1：String

• String的使用
  • 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源码

    public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    	/** The value is used for character storage. */
    	//JDK9后改称byte型数组
    	private final char value[];
    	/** Cache the hash code for the string */
    	private int hash; // Default to 0
    

• String的特性
  • String类为final，不可被继承
  • String类实现了Serializable接口：表示字符换支持序列化
  • String类实现了Comparable接口：表示字符串可以比较大小
  • String内部定义了final char[] value用于存储字符换数据
  • 以字面量方式给字符串赋值时，字符串在方法区的字符串常量池中，且字符串常量池中没有相同内容的字符串，即相同内容的字符串会指向同一个字符串常量池地址
  • String代表不可变的字符序列，即不可变性
    • 当对字符串重新赋值时，需要重新指定内存区域赋值，不能对原有value重新赋值
    • 对字符串做连接操作时，同上
    • 用String的replace方法修改指定字符和字符串时，同上

字符串的不可变性

• 字符串的存储方式

  • 字面量与new两种方式的存储
    • 对于字面量形式的字符串，地址指向字符串常量池；对于new方式的字符串，地址会先指向堆中的对象，对象中的value指向字符串常量池地址（这个过程新建了两个对象，如果常量池内没有字符串的话）
  
  
  字面量与new在内存中的存储方式
  • 字符串拼接后在内存中的存储形式
    • 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量
    • 只要其中有一个是变量，结果就在堆中
    • 如果拼接的结果调用intern()方法，返回值就在常量池中
    • 注：如果String前用final修饰，那么此时变量就成了常量，要以常量来判断拼接后它在内存中的位置，即如果s1被final修饰，则s2==s4为true，s5==s2仍为false
  
  
  拼接后字符串的存储方式

• String例题

  public class StringTest {
  	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) {
  		StringTest ex = new StringTest();
  		ex.change(ex.str, ex.ch);
  		System.out.print(ex.str);//good
  		System.out.println(ex.ch);//best
  	}
  }
  //形参和属性同名，在方法中声明同名变量指的是形参
  //形参str存了属性str的地址值，形参要改变，由于字符串的不可变性，所以不能在原来地址
  //修改，只能新开辟空间赋值，故属性str未改变
  //形参ch存了属性ch的地址值，形参改变，直接在原来地址改变，故属性ch也跟着发生改变
  

  String s1 = new String("A"+"B");
  //涉及四个对象：字符串常量池：A、B、AB，堆：new的一个对象
  //只涉及一个用户创建的引用：s1
  

• String常用方法

  • int length()：返回字符串的长度： return value.length
  • char charAt(int index)： 返回某索引处的字符return value[index]
  • boolean isEmpty()：判断是否是空字符串：return value.length == 0
  • String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
  • String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
  • String trim()：返回字符串的副本，忽略前导空白和尾部空白
  • boolean equals(Object obj)：比较字符串的内容是否相同
  • boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
  • String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
  • int compareTo(String anotherString)：比较两个字符串的大小
    • 从两个字符串的第一位开始比较，如果出现不同的字符，则返回这两个字符的ASCII码差值，如果直到其中一个字符串全部比较完成都没有出现不同字符，则返回两个字符串的长度差(“AEE"与"AE”,比较结果是1)
  • String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串
  • String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串
  • boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
  • boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
  • boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始
  • boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
  • int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引，没有则返回-1
  • int indexOf(String str, int fromIndex)：从指定的索引开始寻找，返回指定子字符串在此字符串中第一次出现处的索引，没有则返回-1
  • int lastIndexOf(String str)：返回指定子字符串在此字符串中最后出现处的索引，没有则返回-1
  • int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索，没有则返回-1
  • String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
  • String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串
  • String replaceAll(String regex, String replacement) ：使用给定replacement 替换此字符串所有匹配给定的正则表达式的子字符串
  • String replaceFirst(String regex, String replacement)：使用给定replacement 替换此字符串匹配给定的正则表达式的第一个子字符串
  • boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式
  • String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串
  • String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中

• String与char[]的转换

  • String转换char型数组：调用String的toCharArray()方法
  • char型数组转换为String：调用String构造器即可

• String与byte[]的转换

  • 字符串转换字节数组（编码）：调用String的getBytes()方法

    String str = "ABC哈哈";
    byte[] bytes = str.getBytes();//使用默认编码集
    byte[] bytes2 = str.getBytes("gbk");//使用指定编码集gbk编码
    

  • 字节数组转换字符串（解码）：调用String的构造器，解码和编码必须要使用同一个编码集，否则会乱码

    String str1 = new String(bytes);//使用默认编码集解码
    String str2 = new String(bytes2,"gbk");//使用指定编码集gbk解码
    String str3 = new String(bytes,1,3);从bytes索引为1的位置往后取三个长度构成一个字符串对象
    

字符串相关类：StringBuffer、StringBuilder

• 三者的异同点
  • String：不可变的字符序列，底层使用char[]存储
  • StringBuffer：可变的字符序列，线程安全的，效率低，底层使用char[]存储
  • StringBuilder：可变的字符序列，JDK5新增，线程不安全的，效率高，底层使用char[]存储
  • StringBuffer与StringBuilder都继承了AbstractStringBuilder，很多功能借助了该类实现，StringBuffer与StringBuilder很多地方类似，提供相关功能的方法也一样，只是StringBuffer加了同步方法
• 关于StringBuffer可变序列的实现
  • StringBuffer底层存储数据的char[]不是final，内容可以变化
  • StringBuffer的构造器一般会多设置长度，如果StringBuffer后续长度不够，会自动扩容，一般是扩大为原来两倍（位运算，向左移两位）

    String str = new String();//本质上char[] value = new char[0];
    String str1 = new String("a");//本质上char[] value = new char[]{"a"};
    
    StringBuffer sb1 = new StringBuffer();//本质上char[] value = new char[16];
    StringBuffer sb2 = new StringBuffer("ab");//本质上char[] value = new char["ab".lengtg() + 16];
    

• StringBuffer构造器
  • StringBuffer()：初始容量为16的字符串缓冲区
  • StringBuffer(int size)：构造指定容量的字符串缓冲区
  • StringBuffer(String str)：将内容初始化为指定字符串内容，长度为字符串长度+16
• StringBuffer常用方法
  • StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
  • StringBuffer delete(int start,int end)：删除指定位置的内容，不包括end
  • StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
  • StringBuffer insert(int offset, xxx)：在指定位置插入xxx
  • StringBuffer reverse() ：把当前字符序列逆转
  • public int indexOf(String str)：返回str首次出现的位置
  • public String substring(int start,int end)：返回[start,end)位置的子字符串，不会改变原来字符串，只是提取
  • public int length()：返回实际字符串长度，而不是总长度
  • public char charAt(int n )：返回指定位置字符
  • public void setCharAt(int n ,char ch)：将指定位置字符换成ch
• 三者效率：StringBuilder>StringBuffer>String，开发上一般使用StringBuffer(int size)或StringBuilder(int size)来构造字符串
• 例题

  String str = null;
  StringBuffer sb = new StringBuffer();
  sb.append(str);
  System.out.println(sb.length());//4
  System.out.println(sb);//"null",appen方法会识别是不是null，如果是，则把“n”、“u”、“l”、“l”加进去
  StringBuffer sb1 = new StringBuffer(str);
  //报错，构造器是含字符串形参，会调用str.length(),此时报空指针错
  System.out.println(sb1);
  

JDK8之前的日期时间API

有关时间日期的类结构

• java.lang.System类
  • public static long currentTimeMillis()：用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差（时间戳）
• java.util.Date类
  • 构造器：
    • Date()：使用无参构造器创建的对象可以获取本地当前时间
    • Date(long date)：创建一个指定时间戳的日期对象

    public Date() {
    	//虽然是空参，但实际上是把当前时间戳赋上了
    	this(System.currentTimeMillis());
    }
    public Date(long date) {
    	fastTime = 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是时间标准
• java.sql.Date:对用数据库中的日期格式，是java.util.Date的子类
  • 构造器
    • Date(long date)：一般只是用这种构造器
  • 常用方法
    • getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数
    • toString():把此 Date 对象转换为以下形式的 String：yyyy-mm-dd
  • 两种Date的转换
    • java.sql.Date转化为Date：利用多态

      java.sql.Date dates = new java.sql.Date(13246545L);
      Date date = dates;
      

    • Date转化为java.sql.Date

      //多态情况下可以强转
      Date date = new java.sql.Date(13246545L);
      java.sql.Date dates = (java.sql.Date) date
      //非多态情况下不能强转，可以借助getTime()方法
      Date date = new Date();
      java.sql.Date dates = new java.sql.Date(date.getTime());
      

• java.text.SimpleDateFormat
  • 它允许进行格式化：日期->字符串、解析：字符串->日期
  • 构造器：
    • SimpleDateFormat()：默认的格式和语言环境创建对象
    • SimpleDateFormat(String pattern)：创建指定格式的对象，常用格式：yyyy-MM-dd hh:mm:ss
  • 格式化
    • public String format(Date date)：格式化时间对象date，将它转成SimpleDateFormat对象被指定的格式
  • 解析
    • public Date parse(String source)：从给定字符串的开始解析文本，以生成一个Date对象
    • 使用parse方法报编译时异常ParseException
    • 解析的格式必须与SimpleDateFormat对象中被指定的格式保持一致
• java.util.Calendar(日历)类，抽象类
  • 实例化
    • 调用静态方法Calendar.getInstance()，返回的是它的子类GregorianCalendar对象
    • 调用子类GregorianCalendar构造器
  • 常用方法
    • int field参数格式Calendar.YEAR、Calendar.MONTH、Calendar.DAY_OF_WEEK、Calendar.HOUR_OF_DAY、Calendar.MINUTE、SECOND
    • get(int field)：返回指定属性的值，注：一月是0，一个星期的第一天根据地区不同而定，一般是星期天是第一天，可以修改
    • set(int field,int value)：为指定属性设置指定值
    • add(int field,int amount)：为指定属性添加指定值，如果amount为负，则为减少指定值
    • public final Date getTime()：获取一个Date对象
    • public final void setTime(Date date)：将一个Date对象传给Calendar对象，用于Date转化为Calendar

      //判断一周第一天是否为星期天
      Calendar now = Calendar.getInstance();
      boolean isFirstSunday = (now.getFirstDayOfWeek() == Calendar.SUNDAY);
      //设置一周的第一天
      now.setFirstDayOfWeek(Calendar.MONDAY);
      //一周第一天的默认值根据地区不同而定，通过设置地区来改变一周的第一天
       Locale.setDefault(Locale.地区名)
      

新时间日趋API

• 出现背景
  如果我们可以跟别人说：“我们在1502643933071见面，别晚了！”那么就再简单不过了。但是我们希望时间与昼夜和四季有关，于是事情就变复杂了。JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入Calendar类之后被弃用了。而Calendar并不比Date好多少。它们面临的问题是：
  • 可变性：像日期和时间这样的类应该是不可变的
  • 偏移性：Date中的年份是从1900开始的，而月份都从0开始
  • 格式化：格式化只对Date有用，Calendar则不行
  • 此外，它们也不是线程安全的；不能处理闰秒等
• 新API
  • java.time – 包含值对象的基础包（常用）
  • java.time.chrono – 提供对不同的日历系统的访问
  • java.time.format – 格式化和解析时间和日期（常用）
  • java.time.temporal – 包括底层框架和扩展特性
  • java.time.zone – 包含时区支持的类
• java.time.LocalDate、LocalTime、LocalDateTime
  • 说明：
    • 它们的实例对象均为不可变对象
    • LocalDate代表IOS格式（yyyy-MM-dd）的日期,可以存储 生日、纪念日等日期
    • LocalTime表示一个时间，而不是日期
    • LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一
  • 常用方法：
    • now() / * now(ZoneId zone)： 静态方法，根据当前时间创建对象/根据指定时区创建对象，由三个类中哪个类调用，就创建哪种对象

      LocalDate localDate = LocalDate.now();
      System.out.println(localDate);//yyyy-MM-dd格式的当前日期
      

    • of()：静态方法，根据指定日期、时间、日期时间（of中的参数）创建对象

      LocalDate localDate = LocalDate.of(2020,11,5);
      System.out.println(localDate);//2020-11-05
      

    • getDayOfMonth()/getDayOfYear() ：获得当前这个月的第几天(1-31) /获得当前年份的第几天(1-366)
    • getHour()/getMinute()/getSecond()：获得当前对象对应的小时、分钟、秒
    • getMonthValue() / getYear()：获得月份(1-12) /获得年份
    • getDayOfWeek()：获得星期几，返回一个DayOfWeek枚举值
    • getMonth()：获得月份, 返回一个 Month 枚举值
    • withDayOfMonth()/withDayOfYear()/withMonth()/withYear()：将月份天数、年份天数、月份、年份修改为指定的值并返回新的对象，原对象无法改变
    • plusDays()/plusWeeks()/plusMonths()/plusYears()/plusHours()向当前对象添加几天/几周/几个月/几年/几小时，返回的是一个新对象
    • minusMonths()/minusWeeks()/minusDays()/minusYears()/minusHours()从当前对象减去几月/几周/几天/几年/几小时
• java.time.Instant
  • 说明：
    • Instant：时间线上的一个瞬时点。 这可能被用来记录应用程序中的事件时间戳
    • 在处理时间和日期的时候，我们通常会想到年,月,日,时,分,秒。然而，这只是时间的一个模型，是面向人类的。第二种通用模型是面向机器的，或者说是连续的。在此模型中，时间线中的一个点表示为一个很大的数，这有利于计算机处理。在UNIX中，这个数从1970年开始，以秒为的单位；同样的，在Java中，也是从1970年开始，但以毫秒为单位
    • java.time包通过值类型Instant提供机器视图，不提供处理人类意义上的时间单位。 Instant表示时间线上的一点，而不需要任何上下文信息，例如，时区。概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（UTC）开始的秒数。因为java.time包是基于纳秒计算的，所以Instant的精度可以达到纳秒级。
  • 常用方法：
    • now()：静态方法，返回默认UTC时区的Instant类的对象
    • ofEpochMilli(long epochMilli)：静态方法，返回在1970-01-01 00:00:00基础上加上指定毫秒数之后的Instant类的对象
    • atOffset(ZoneOffset offset)：结合即时的偏移来创建一个 OffsetDateTime对象

      //创建一个默认时区的当前日期时间的Instance对象
      Instant instant = Instant.now();
      //创建一个偏移8小时（东八区）的OffsetDateTime对象
      OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
      

    • toEpochMilli()：返回1970-01-01 00:00:00（时区：UTC）到当前时间的毫秒数，long型，即为时间戳，类似Date类的getTime()
    • toEpochMilli(Long time)：返回一个指定毫秒数的Instance实例，类似Date(Long millions)构造器
• java.time.format.DateTimeFormatter
  • 格式化或解析日期时间
  • 实例化：
    • 预定义标准格式，如ISO_LOCAL_DATE_TIME、ISO_LOCAL_DATE、ISO_LOCAL_TIME

      DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
      

    • 本地化方式，ofLocalizedDateTime()，参数有FormatStyle.Full、FormatStyle.LONG、FormatStyle.MEDIUM、FormatStyle.SHORT，适用于LocalDateTime，类似还有适用于LocalDate的ofLocalizedDate()

      DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
      String str = formatter1.format(LocalDate.now());
      System.out.println(str);
      //FULL：2021年4月28日星期三
      //LONG：2021年4月28日
      //MEDIUM：2021年4月28日
      //SHORT：2021/4/28
      

    • 自定义格式，ofPattern(String pattern)

      DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
      String str2 = formatter2.format(LocalDateTime.now());
      System.out.println(str2);
      

  • 格式化，format(TemporalAccessor t)格式化一个日期、时间，返回字符串,上述类均实现自TemporalAccessor接口的子接口Temporal
  • 解析，parse(CharSequence text) 将指定格式的字符序列解析为一个日期、时间
• 其他API
  • 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 的实现。
• 新旧时间日期类的转换

新旧时间日期类的转换

Java比较器

• 实现对象间排序的两种方式
  • 自然排序：java.lang.Comparable
  • 定制排序：java.util.Comparator
• 方式一：自然排序：java.lang.Comparable
  • Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序
  • 实现：
    • 继承Comparable接口
    • 实现compareTo(Object obj) 方法，将比较方法写在该方法中
  • 实现compareTo的规则：
    • 如果当前对象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 一致。

  class Goods implements Comparable {
  	private String name;
  	private double price;
  	//按照价格，比较商品的大小
  	@Override
  	public int compareTo(Object o) {
  		if(o instanceof Goods) {
  			Goods other = (Goods) o;
  			if (this.price > other.price) {
  				return 1;
  			} else if (this.price < other.price) {
  				return -1;
  			}
  			return 0;
  		}
  		throw new RuntimeException("输入的数据类型不一致");
  	}
  	//构造器、getter、setter、toString()方法略
  }
  

  • Comparable 的典型实现:
    • String：按照字符串中字符的Unicode值进行比较
    • Character：按照字符的Unicode值来进行比较
    • 数值类型对应的包装类以及BigInteger、BigDecimal：按照它们对应的数值大小进行比较
    • Boolean：true 对应的包装类实例大于 false 对应的包装类实例
    • Date、Time等：后面的日期时间比前面的日期时间大
• 方式二：定制排序：java.util.Comparator
  • 背景：当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序
  • 实现：
    • 一般是以匿名实现类的方式实现Comparator接口
    • 重写compare(Object o1,Object o2)，将需要的排序操作写入
  • 应用：
    • 可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制
    • 还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

  Goods[] all = new Goods[4];
  all[0] = new Goods("War and Peace", 100);
  all[1] = new Goods("Childhood", 80);
  all[2] = new Goods("Scarlet and Black", 140);
  all[3] = new Goods("Notre Dame de Paris", 120);
  Arrays.sort(all, new Comparator() {
  	@Override
  	public int compare(Object o1, Object o2) {
  		Goods g1 = (Goods) o1;
  		Goods g2 = (Goods) o2;
  		//加负号相当于实现了从大到小排序
  		return -g1.getName().compareTo(g2.getName());
  	}
  });
  System.out.println(Arrays.toString(all));
  

• 两种实现比较方式的对比
  • Comparable一般由类实现，写好后，Comparable接口实现类的对象在任何位置上都可以比较大小
  • Comparator接口一般用于临时性比较

System类

• System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包
• 由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用
• 成员变量
  • System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)
• 成员方法
  • native long currentTimeMillis()：该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数
  • void exit(int status)：该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等
  • void gc()：该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况
  • String getProperty(String key)：该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见的属性名以及属性的作用如下表所示：

key对应的值

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) 角度—>弧度

BigInteger类

• Integer类作为int的包装类，能存储的最大整型值为2³¹ -1，Long类也是有限的，最大为2⁶³-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了
• java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作
• 构造器：BigInteger(String val)：根据字符串构建BigInteger对象
• 常用方法：
  • public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger
  • BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger
  • BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger
  • BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger
  • BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数相除只保留整数部分
  • BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的 BigInteger
  • BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组
  • BigInteger pow(int exponent)：返回其值为 (thisexponent) 的 BigInteger

BigDecimal类

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

public void testBigInteger() {
	BigInteger bi = new BigInteger("12433241123");
	BigDecimal bd = new BigDecimal("12435.351");
	BigDecimal bd2 = new BigDecimal("11");
	System.out.println(bi);
	//如果没有指定精度又除不尽会报错
	// System.out.println(bd.divide(bd2));
	//四舍五入
	System.out.println(bd.divide(bd2,BigDecimal.ROUND_HALF_UP));
	//保留15位小数且四舍五入
	System.out.println(bd.divide(bd2, 15,BigDecimal.ROUND_HALF_UP));
}