Java高级笔记——常用类

Java高级笔记——常用类 1、字符串相关的类

1.1、String类及常用方法

String的特性

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

import org.junit.Test;

public class StringTest {
    



    @Test
    public void test1(){
        String s1 = "abc"; //字面量的定义方式
        String s2 = "abc";
        s1 = "hello";

        //1）当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
        System.out.println(s1 == s2);//比较s1和s2的地址值

        System.out.println(s1);
        System.out.println(s2);

        System.out.println("*********");

        //2）对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
        String s3 = "abc";
        s3 += "def";
        System.out.println(s3);
        System.out.println(s2);

        System.out.println("*********");

        //当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
        String s4 = "abc";
        String s5 = s4.replace('a','m');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc


    }
}

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):比较两个字符串的大小
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):返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str,int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str,int fromIndex):返回指定子字符串在此字符串中最后一次出现的索引，从指定的索引开始反向索引
- 注：indexOf和lastIndexOf方法如果未找到都是返回-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个，如果超过了，剩下的全部都放到最后一个元素中

import org.junit.Test;

public class StringMethodTest {

    @Test
    public void test4(){
        String str1 = "Java编程从入门到入坟";
        String str2 = str1.replace('坟', '土');

        System.out.println(str1);
        System.out.println(str2);

        String str3 = str1.replace("入门", "基础");
        System.out.println(str3);

        String str4 = "12sad345asdgf6546dsfds796";
        //把字符串中的数字替换成‘，’ 如果结果中开头和结尾有‘，’ 的话去掉
        String string = str4.replaceAll("\d+",",").replaceAll("^,|,$","");
        System.out.println(string);

        System.out.println("****************");
        str4 = "12345";
        //判断str4字符串中是否全部由数字组成，即有1-n个数字组成
        boolean matches = str4.matches("\d+");
        System.out.println(matches);

        String tel = "0571-3425353";
        //判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\d{7,8}");
        System.out.println(result);

        System.out.println("****************");
        String str = "hello|world|java";
        String[] strs = str.split("\|");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        System.out.println();
        str2 = "hello.world.java";
        String[] strs2 = str2.split("\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }

    }




    @Test
    public void test3(){
        String str1 = "helloworld";
        boolean b1 = str1.endsWith("ld");//括号中无字符限制
        System.out.println(b1);

        boolean b2 = str1.startsWith("h");
        System.out.println(b2);

        boolean b3 = str1.startsWith("ll",2);
        System.out.println(b3);

        String str2 = "wo";
        System.out.println(str1.contains(str2));

        System.out.println(str1.indexOf("lo"));
        System.out.println(str1.indexOf("lo", 5));

        System.out.println(str1.lastIndexOf("lo"));
        System.out.println(str1.lastIndexOf("lo", 5));

        //什么情况下，indexOf(str)和lastIndexOf(str)返回值相同？
        //情况一：存在唯一的一个str;情况二：不存在str

    }

    

    

    @Test
    public void test2(){
        String s1 = "HelloWorld";
        String s2 = "helloworld";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));

        String s3 = "abc";
        String s4 = s3.concat("def");
        System.out.println(s4);

        String s5 = "abc";
        String s6 = new String("abe");
        System.out.println(s5.compareTo(s6));//涉及到字符串排序

        String s7 = "Java编程从入门到入坟";
        String s8 = s7.substring(4);
        System.out.println(s7);
        System.out.println(s8);

        String s9 = s7.substring(4, 6);//左闭右开，不包含6
        System.out.println(s9);


    }


    @Test
    public void test1(){
        String s1 = "HelloWorld";
        System.out.println(s1.length());
        System.out.println(s1.charAt(0));
        System.out.println(s1.charAt(9));
       // System.out.println(s1.charAt(10)); //超出字符串长度，运行报错

        System.out.println(s1.isEmpty());

        String s2 = s1.toLowerCase();
        System.out.println(s1);//s1不变
        System.out.println(s2);//s2转换为小写

        String s3 = s1.toUpperCase();
        System.out.println(s3);

        String s4 = "    he  llo      ";
        String s5 = s4.trim();
        System.out.println("---" + s4 + "---");
        System.out.println("---" + s5 + "---");

    }
}

String类与其他结构之间的转换

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;


public class StringTest1 {
    
    @Test
    public void test3() throws UnsupportedEncodingException {

        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符集，进行转换
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码
        System.out.println(Arrays.toString(gbks));

        System.out.println("*********************");

        String str2 = new String(bytes);//使用默认的字符集进行解码
        System.out.println(str2);

        String str3 = new String(gbks);
        System.out.println(str3);//出现乱码。原因：编码集和解码集不一致！

        String str4 = new String(gbks, "gbk");
        System.out.println(str4);//没有出现乱码。原因：编码集和解码集保持一致！

    }



    
    @Test
    public void test2(){
        //String --> char[]:调用String的toCharArray()
        String str = "abc123";
        char[] charArray = str.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }
        //char[] --> String:调用String的构造器
        char[] arr = {'h', 'e', 'l', 'l', 'o'};
        String str2 = new String(arr);
        System.out.println(str2);
    }



    
    @Test
    public void test1(){
        String str = "123";
        //int num = (int)str; //错误的
        int num = Integer.parseInt(str);

        String str1 = String.valueOf(num);

    }


}

1.2、StringBuffer、StringBuilder

StringBuffer类的常用方法 (StringBuilder 的方法名同StringBuffer一致) ：
- StringBuffer append(xxx):提供了很多的append()方法，用于进行字符串拼接
- StringBuffer delete(int start,int 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):
- public String substring(int start,int end)
- public int length()
- public char charAt(int n)
- public void setCharAt(int n ,char ch)
```
public class StringBufferBuilderTest {
    
    @Test
    public void test2(){
        StringBuffer s1 = new StringBuffer("abc");
        s1.append(1);
        s1.append('1');
        System.out.println(s1);
        //s1.delete(2,4);//左闭右开
        //s1.replace(2,4,"hello");
        //s1.insert(2,false);
        s1.reverse();
        System.out.println(s1);

    }
}
```

2、JDK 8之前的日期时间API

2.1、System静态方法

java.lang.System类

System类提供的 public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。（此方法适用于计算时间差）
计算世界时间的主要标准有：
- UTC(Coordinated Universal Time)
- GMT(Greenwith Mean Time)
- CST(Central Standard Time)

2.2、Date类

JDK 8 之前日期和时间的API测试:

import java.util.Date;


public class DateTimeTest {

    @Test
    public void test2(){
        //构造器1：Date()：创建了一个对应当前时间的Date对象
        Date date1 = new Date();
        System.out.println(date1.toString());//Sun Nov 21 20:11:48 CST 2021
        System.out.println(date1.getTime());//1637496807330

        //构造器2：创建指定毫秒数的Date对象
        Date date2 = new Date(1637496807330L);
        System.out.println(date2.toString());
    }


    //System类中的currentTimeMillis()
    @Test
    public void test(){
        long time = System.currentTimeMillis();
        System.out.println(time);
    }
}

2.3、Calendar类

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

    @Test
    public void test4(){
        //1、实例化
        //方式一：创建子类（GregorianCalender）对象
        //方式二：调用其静态方法getInstance()
        Calendar instance = Calendar.getInstance();

        //2、常用方法
        //get()
        int days = instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);
        System.out.println(instance.get(Calendar.DAY_OF_YEAR));

        //set()
        //calendar可变性
        instance.set(Calendar.DAY_OF_YEAR,344);//修改instance对象本身
        days = instance.get(Calendar.DAY_OF_YEAR);
        System.out.println(days);

        //add():原有基础上进行修改，若需要进行减法操作，只需将正整数改成负整数
        instance.add(Calendar.DAY_OF_YEAR,6);
        days = instance.get(Calendar.DAY_OF_YEAR);
        System.out.println(days);

        //getTime():日历类 --> Date
        Date date = instance.getTime();
        System.out.println(date);

        //setTime()：Date --> 日历类
        Date date1 = new Date();//实例化Date
        instance.setTime(date1);//Date --> 日历类
        days = instance.get(Calendar.DAY_OF_YEAR);
        System.out.println(days);


    }

2.4、SimpleDateFormat类

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

    @Test
    public void test3() throws ParseException {
        //实例化SimpleDateFormat:使用默认构造器
        SimpleDateFormat sdf = new SimpleDateFormat();

        //格式化日期
        Date date = new Date();

        System.out.println(date);

        String format = sdf.format(date);
        System.out.println(format);


        //解析：格式化的逆过程，字符串 --> 日期
        String str = "2021/11/22 下午7:31";
        Date parse = sdf.parse(str);
        System.out.println(parse);

        System.out.println("***按照指定方式格式化和解析***");
        //修改构造器中日期输出的默认格式，此处M：月份；m:分钟
        SimpleDateFormat sim = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
        //格式化
        String str1 = sim.format(date);
        System.out.println(str1);

        //解析:要求字符串必须是符合SimpleDateFormat识别的格式（通过构造器参数体现）
        String str2 = "2021/11/22 07:43:16";
        Date parse1 = sim.parse(str2);
        System.out.println(parse1);

    }

3、JDK 8 中新日期时间API

新时间日期API
- java.time--包含值对象的基础包
- java.time.chrono--提供对不同的日历系统的访问
- java.time.format--格式化和解析时间和日期
- java.time.temporal--包含底层框架和扩展特性
- java.time.zone--包含时区支持的类

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

3.1、LocalDate(本地日期)、LocalTime(本地时间)、LocalDateTime（本地日期时间）

@Test
public void test1(){
    //now():获取当前的
    LocalDate localDate = LocalDate.now();
    LocalTime localTime = LocalTime.now();
    LocalDateTime localDateTime = LocalDateTime.now();

    System.out.println(localDate);
    System.out.println(localTime);
    System.out.println(localDateTime);


    //of():设置指定时间年、月、日、时、分（秒、毫秒），没有偏移量
    LocalDateTime dateTime = LocalDateTime.of(19, 5, 22,7,7,59,23222);
    System.out.println(dateTime);

    //getXxx()：获取相关属性
    System.out.println(dateTime.getDayOfMonth());
    System.out.println(dateTime.getDayOfYear());
    System.out.println(dateTime.getDayOfWeek());
    System.out.println(dateTime.getMonth());
    System.out.println(dateTime.getMonthValue());
    System.out.println(dateTime.getMinute());//获取分钟的前提是在dateTime中存了分钟

    //withXxx():设置相关属性，不影响原值数据，体现不可变性
    LocalDateTime dateTime1 = dateTime.withDayOfMonth(11);
    System.out.println(dateTime);//原值不变,
    System.out.println(dateTime1);

    LocalDateTime dateTime2 = dateTime.withHour(12);
    System.out.println(dateTime);
    System.out.println(dateTime2);

    //plusXxx():增加
    LocalDateTime dateTime3 = dateTime.plusDays(8);
    System.out.println(dateTime);
    System.out.println(dateTime3);

    //minusXxx():减少
    LocalDateTime dateTime4 = dateTime.minusDays(10);
    System.out.println(dateTime);
    System.out.println(dateTime4);


}

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九次方s ） 1秒 = 1000毫秒 = 10^6微秒 = 10^9纳秒

   @Test
   public void test2(){
       //now():获取的是本初子午线的标准时间
       Instant instant = Instant.now();
       System.out.println(instant);
 
       //添加时间的偏移量，在本初子午线的基础上＋了8个小时
       OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
       System.out.println(offsetDateTime);
 
       //toEpochMilli()：获取自1970年1月1日0时0分0秒（UTC）开始到现在的毫秒数 -->Date类的getTime()
       long milli = instant.toEpochMilli();
       System.out.println(milli);
 
       //ofEpochMilli():通过给定的毫秒数，获取Instant的实例 --> Date(long millis)
       Instant instant1 = Instant.ofEpochMilli(1637754355207L);
       System.out.println(instant1);
 
   }

3.3、DateTimeFormatter（格式化与解析日期或时间）

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

方式一：预定义的标准格式
方式二：本地化相关格式
方式三：自定义格式

   @Test
   public void test3(){
       //方式一：预定义的标准格式。如:ISO_LOCAL_DATE_TIME、ISO_LOCAL_DATE、ISO_LOCAL_TIME
       DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
       //格式化:日期 --> 字符串
       LocalDateTime local = LocalDateTime.now();
       String str = formatter.format(local);
       System.out.println(str);
       //解析：字符串 --> 日期
       TemporalAccessor parse = formatter.parse("2021-11-24T19:59:35.0651741");//只能识别这种特定格式
       System.out.println(parse);
             //方式二：本地化相关格式。如：ofLocalizedDateTime()
      //FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
      DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
      //格式化
      String str2 = formatter1.format(local);
      System.out.println(str2);
      //解析
      TemporalAccessor parse1 = formatter1.parse("2021/11/24 下午8:17");
      System.out.println(parse1);
  
      //本地化相关格式。如：ofLocalizedDate()
      //FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDate
      DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
      //格式化
      String str3 = formatter2.format(LocalDate.now());
      System.out.println(str3);
             //方式三：自定义格式。如：ofPattern(ofPattern("yyyy-MM-dd hh:mm:ss E"))
      DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd");
      //格式化
      String str4 = formatter3.format(LocalDateTime.now());
      System.out.println(str4);
      //解析:上下格式对应
      TemporalAccessor parse2 = formatter3.parse("2021-11-24");
      System.out.println(parse2);
         }

3.4、其他类

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

4、Java比较器

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

4.1、Comparable接口

Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序叫做自然排序：java.lang.Comparable
实现Comparable的类必须实现compareTo(obj)方法，两个对象即通过compareTo(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一致。

4.2、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提供排序。

package com.atguigu.java;

import org.junit.Test;

import java.util.Arrays;
import java.util.Comparator;


public class CompareTest {
    
    @Test
    public void test2(){
        String[] arr = new String[]{"AA","PP","GG","DD"};
        Arrays.sort(arr,new Comparator(){

            //按照字符串从大到小的顺序排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof String && o2 instanceof String){
                    String s1 = (String) o1;
                    String s2 = (String) o2;
                    return s1.compareTo(s2);//若为return -s1.compareTo(s2)返回值类型则为从小到大
                }
//                return 0;
                throw new RuntimeException("输入的数据不一致！");
            }
        });
        System.out.println(Arrays.toString(arr));

    }



    
    @Test
    public void test1(){
        String[] arr = new String[]{"AA","PP","GG","DD"};

        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }


}

5、System类

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

6、Math类

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

7、BigInteger与BigDecimal

7.1、BigInteger

Integer类作为int的包装类，能存储的最大的整形值为2^31 - 1，Long类也是有限的，最大为2^63 - 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):返回其值为（this^exponent）的BigInteger

7.2、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)

Java高级笔记——常用类

Java相关栏目本月热门文章