Java經常使用類庫API

時間 2020-06-22

標籤 java 經常使用 api 欄目 Java 简体版

原文原文鏈接

字符串操做

String類

String能夠表示一個字符串
String類實際是使用字符數組存儲的

String兩種賦值方式

直接賦值:java推薦使用java

String name = "xiaoyu";//對象生成在常量池中

經過關鍵字new調用String的構造方法賦值正則表達式

String name = new String("xiaoyu");//建立了兩個對象 new：表示申請內存空間

String表示一個字符串，內部使用字符數組實現，不能被繼承（它是最終類），不可變算法

package com.API.demo01;

public class Demo01{
    public static void main(String[] args) {
        //直接賦值字符串鏈接時，考慮編譯器和運行期
        //若是在編譯器值能夠被肯定，那麼使用已有的對象，不然會建立新的對象
        String a = "a";
        String a1 = a+1;//在堆中建立一個「a1」
        String a2 = "a1";//這個a1是在常量池中
        System.out.println(a1==a2);//false


        final String b = "b";//final是常量
        String b1=b+1;//常量相加
        String b2="b1";
        System.out.println(b1==b2);//true

        String c = getC();
        String c1=c+1;
        String c2="c1";
        System.out.println(c1==c2);//false

        final String d = getD();
        String d1=d+1;
        String d2="d1";
        System.out.println(d1==d2);//false

    }

    private static String getC(){
        return "c";
    }

    private static String getD(){
        return "d";
    }
}

String類中的構造函數

String()方法

構造一個空字符串對象編程

String s = new String();

String(byte[] bytes)方法

經過byte數組構造字符串對象數組

String(byte[] bytes,int offset,int length)方法

經過byte數組，從offset開始，總共length長的字節構造字符串對象安全

String(char[] value)方法

經過char數組構造字符串對象多線程

char[] cs ={'a','b','c'};
String s1 = new String(cs);//將數組變成字符串

String(byte[] char,int offset,int length)方法

經過char數組，從offset開始，總共length長的字節構造字符串對象app

char[] cs ={'a','b','c'};
String s2 = new String(cs,0,2);
System.out.println(s2);//a

String類的經常使用方法

isEmpty()方法

判斷是否爲空，指的是內容爲空dom

String str1="";
System.out.println(str1.isEmpty());//true

length()方法

查看字符串長度ide

String str = "sads1231sad";
System.out.println(str.length());//11

toUpperCase()轉大寫

String str = "sads1231sad";
System.out.println(str.toUpperCase());//SADS1231SAD

toLowerCase()轉小寫

String str1= "WEDVCSDFZZVC";
System.out.println(str1.toLowerCase());//wedvcsdfzzvc

trim()方法

用戶數據後臺校驗前的過濾，返回字符串的副本，忽略前部空白和尾部空白

String str1= " WEDVCS DFZZVC ";
System.out.println(str1.trim());//WEDVCS DFZZVC

concat(String str)方法

字符號鏈接操做

String str = "sads1231sad";
System.out.println(str.concat("***8*"));//sads1231sad***8*

charAt(int index)方法

獲取字符串中的某個值

String str = "sads1231sad";
char c=str.charAt(1);
System.out.println(c);//a

contains(String str)方法

判斷一個字符串是否包含另外一個字符串

String str = "sads1231sad";
System.out.println(str.contains("a"));//true

getBytes( )將字符串轉換爲字節數組

String str = "sads1231sad";
System.out.println(Arrays.toString(str.getBytes()));//[115, 97, 100, 115, 49, 50, 51, 49, 115, 97, 100]

toCharArray( )將字符串轉換爲字符數組

String str = "sads1231sad";
System.out.println(str.toCharArray());//sads1231sad

compareTo()

比較兩個字符串的大小，相等返回0，大於返回正數，小於返回負數

String str = "sads1231sad";
String str1= "WEDVCSDFZZVC";
System.out.println(str.compareTo(str1));//28

compareToIgnoreCase( )

比較兩個字符串的大小，不考慮大小寫

String str = "sads1231sad";
String str1 = "SADS1231SAD"
System.out.println(str.compareToIgnoreCase(str1));//0

indexOf(int ch)

從頭查找指定字符是否存在，char→int，若是存在則返回第一個出現的位置，若是不存在則返回-1 ch是阿斯克碼

String str = "sads1231sad";
System.out.println(str.indexOf(97));//1

indexOf(int ch，int fromIndex)

從頭指定位置查找指定的字符是否存在，char→int，若是存在則返回位置，若是不存在則返回-1

String str = "sads1231sad";
System.out.println(str.indexOf(97,2));//9

indexOf(String str)

從頭查找指定字符串是否存在，若是存在則返回第一個出現的位置，若是不存在則返回-1

String str = "sads1231sad";
System.out.println(str.indexOf("a"));//1

indexOf(String str，int fromIndex)】

從頭指定位置查找字符串是否存在，若是存在則返回位置，若是不存在則返回-1

String str = "sads1231sad";
System.out.println(str.indexOf("a",2));//9

lastIndexOf(string str)

從後查找指定字符串是否存在，若是存在則返回第一個出現的位置，若是不存在則返回-1

String str = "sads1231sad";
System.out.println(str.lastIndexOf("a"));//9

startsWith(String str)

從第一個位置開始判斷是否以指定的內容開頭

String str = "sads1231sad";
System.out.println(str.startsWith("s"));//true

startsWith(String str，int toffset)

從指定的位置開始判斷是否以指定的內容開頭

String str = "sads1231sad";
System.out.println(str.startsWith("s",4));//false

endsWith(String str )

判斷是否以指定的內容結尾 能夠用於判斷文件以什麼格式結束

String str = "sads1231sad";
System.out.println(str.endsWith("d"));//true

replace(char oldChar，char newChar)替換指定字符

String str = "sads1231sad";
System.out.println(str.replace('s','*'));//*ad*1231*ad

replace(CharSequence target，CharSequence replacement)替換指定字符串

String str = "sads1231sad";
System.out.println(str.replace("12","DD"));//sadsDD31sad

replaceAll(String regex，String replacement)替換指定的字符串

regex是正則表達式的意思

String str = "sads1231sad";
System.out.println(str.replaceAll("[0-9]","*"));//sads****sad
//System.out.println(str.replaceAll("\\d","*"));//sads****sad

repalceFirst(String regex，String replacement)

替換第一個知足條件的字符串

String str = "sads1231sad";
System.out.println(str.replaceFirst("[0-9]","*"));//sads*231sad

substring(int beginIndex)

從指定位置開始一直截取到末尾

String str = "sads1231sad";
System.out.println(str.substring(4));//1231sad

substring(int beginIndex, int endIndex)

截取指定範圍的字符串

String str = "sads1231sad";
System.out.println(str.substring(0,4));//sads

split(String regex)

根據給定正則表達式的匹配拆分此字符串。

String str = "sads1231sad";
System.out.println(Arrays.toString(str.split("s")));//[, ad, 1231, ad]

split(String regex，int limit)

根據給定正則表達式的匹配拆分此字符串，並指定拆分的個數。

String str = "sads1231sad";
System.out.println(Arrays.toString(str.split("1",2)));//[sads, 231sad]

valueOf()

把各類類型轉換成字符串

System.out.println(String.valueOf(true));//true

StringBuffer類

在實際開發當中，咱們常常會使用到字符串鏈接的操做，若是String來操做，則使用"+"號完成字符串的鏈接操做

使用String鏈接字符串，代碼性能會很是低，由於String的內容不可改變，解決這個問題的方法是使用StringBuffer

package com.API.demo01;

public class Demo03 {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String c = a+b+1;//變量和常量相加產生三個對象
        String d = "a"+"b"+1;//常量相加產生1個對象 沒有性能問題，由於在編譯器就進行了優化
        //System.out.println(c);//ab1 產生五個對象
        
        //StringBuffer目的是來解決字符串相加時帶來的性能問題（常量與變量相加）
        //StringBuffer的內部實現採用字符數組，默認數組的長度爲16，超過數組大小時，動態擴充的算法是原來長度*2+2
        //因此當咱們預知要添加的數據長度時，建議使用帶初始化容量的構造方法，來避免動態擴充的次數，從而提升效率
        //線程安全的，會影響性能
        StringBuffer sb = new StringBuffer();
        sb.append(a).append(b).append(1);
        System.out.println(sb.toString());//ab1 產生一個對象
    }
}

StringBuffer經常使用的方法

StringBuffer()

構造一個空的StringBuffer對象

StringBuffer s = new StringBuffer();
StringBuffer s1 = new StringBuffer(32);//帶容量的構造（推薦）

StringBuffer(String str)

將制定的String變爲StringBuffer的內容

StringBuffer s = new StringBuffer("ABC");

StringBuffer(CharSequence seq)

接收CharSequence接口的實例

append(數據類型 b)

提供了不少append()方法，用於進行字符串鏈接

delete(int start，int end)

刪除指定位置的內容

StringBuffer s = new StringBuffer("ABC");
System.out.println(s.delete(0,1));//BC

indexOf(String str)

字符串的查詢功能

insert(int offset，數據類型 b)

在指定位置上增長一個內容

StringBuffer s = new StringBuffer("ABC");
System.out.println(s.insert(1,"f"));//AfBC

replace(int start，int end，String str)

將指定範圍的內容替換成其餘內容

substring(int start, int end)

截取指定範圍的字符串

substring(int start)

字符串截取

reverse()

字符串反轉

StringBuffer s = new StringBuffer("ABC");
System.out.println(s.reverse());//CBA

StringBuilder類

一個可變的字符序列。此類提同一個與StringBuffer兼容的API，但不保證同步。該類被設計用做StringBuffer的一個簡易替換，用在字符串緩衝區被單個線程使用的時候。若是可能，建議先採用該類，由於在大多數實現中，它比StringBuffer要快

public class Demo04 {
    public static void main(String[] args) {
        //StringBuffery與StringBuilder的區別？
        //StringBuffer是線程安全的，性能低，適合在多線程中使用,JDK1.0
        //StringBuilder是線程不安全的，性能高，適合在單線程中使用，這種狀況佔大多數，在JDK1.5後使用
        StringBuilder s = new StringBuilder();

        //字符串相加操做
        //1.多個常量相加沒有性能問題
        //2.變量與常量相加，會產生多個垃圾對象、

        String a = "a"+1;
        //字符串相加，在編譯後，會使用StringBuilder相優化代碼，實現拼接
    }
}

程序國際化

Locale類

Locale對象表示特定的地理、政治和文化地區。須要locale來執行其任務的操做稱爲語言環境敏感的操做，它使用Locale爲用戶量身定製信息。例如，顯示一個數值就是語言環境敏感的操做，應該根據用戶的國家、地區或文化的風俗/傳統來格式化該數值

Locale(String language)

Locale(String language，String country)

經過靜態方法建立Locale：getDefault()

package com.API.demo02;

import java.util.Locale;

public class I18Demo {
    public static void main(String[] args) {
        //建立一個本地語言環境對象，該對象會根據參數設置來自動選擇與之相關的語言環境
        //參數：語言，地區
        Locale locale_CN = new Locale("zh","CN");
        Locale locale_US = new Locale("en","US");
        //獲取當前系統默認的語言環境
        Locale locale_default = Locale.getDefault();
        
    }
}

ResourceBundle類

國際化的實現核心在於顯示的語言上，一般的作法是將其定義成若干個屬性文件（文件後綴是*.properties），屬性文件中的格式採用「key=value」的格式來進行操做。Properties文件：屬性文件（配置文件），內容以鍵值對的形式存放（key-value）

ResourceBundle類表示的是一個資源文件的讀取操做，全部的資源文件須要使用ResourceBundle進行讀取，讀取的時候不須要加上文件的後綴。ResourceBundle工具類，來綁定屬性文件，並指定Locale對象，來自動選擇使用哪一個屬性文件，默認將使用與操做系統相同的語言環境

package com.API.demo02;

import java.util.Locale;
import java.util.ResourceBundle;
import java.util.Scanner;

public class I18Demo {
    public static void main(String[] args) {
        //建立一個本地語言環境對象，該對象會根據參數設置來自動選擇與之相關的語言環境
        //參數：語言，地區
        Locale locale_CN = new Locale("zh","CN");
        Locale locale_US = new Locale("en","US");
        //獲取當前系統默認的語言環境
        Locale locale_default = Locale.getDefault();
        Scanner input = new Scanner(System.in);
        //用於綁定屬性文件的工具類（參數：屬性文件的基本名，就是前綴）
        ResourceBundle r = ResourceBundle.getBundle("com.API.demo02.info",locale_CN);//中文
        //ResourceBundle r = ResourceBundle.getBundle("com.API.demo02.info",locale_US);英文
        System.out.println(r.getString("system.name"));
        System.out.println(r.getString("input.username"));
        String username = input.nextLine();
        System.out.println(r.getString("input.password"));
        String password = input.nextLine();
        if("admin".equals(username) && "123".equals(password)){
            System.out.println(r.getString("login.success"));
        }else{
            System.out.println(r.getString("login.error"));
        }
    }
}

結果：中文

英文

getBundle(String baseName)方法

用於綁定屬性文件的工具類（參數：屬性文件的基本名（就是前綴））

getBundle(String baseName，Locale locale)

getString(String key)方法

從屬性文件中使用key來獲取value

注：ResourceBundle工具類是隻讀的

MessageFormat類

用來處理動態文本

package com.API.demo02;

import java.text.MessageFormat;
import java.util.Locale;
import java.util.ResourceBundle;
import java.util.Scanner;

public class I18Demo {
    public static void main(String[] args) {
        //建立一個本地語言環境對象，該對象會根據參數設置來自動選擇與之相關的語言環境
        //參數：語言，地區
        Locale locale_CN = new Locale("zh","CN");
        Locale locale_US = new Locale("en","US");
        //獲取當前系統默認的語言環境
        Locale locale_default = Locale.getDefault();
        Scanner input = new Scanner(System.in);
        //用於綁定屬性文件的工具類（參數：屬性文件的基本名，就是前綴）
        ResourceBundle r = ResourceBundle.getBundle("com.API.demo02.info",locale_CN);
        System.out.println(r.getString("system.name"));
        System.out.println(r.getString("input.username"));
        String username = input.nextLine();
        System.out.println(r.getString("input.password"));
        String password = input.nextLine();
        if("admin".equals(username) && "123".equals(password)){
            System.out.println(r.getString("login.success"));
            String welcome = r.getString("welcome");
            //動態文本格式化
            welcome =MessageFormat.format(welcome,username);
            System.out.println(welcome);
        }else{
            System.out.println(r.getString("login.error"));
            String sorry = r.getString("sorry");
            //動態文本格式化
            sorry =MessageFormat.format(sorry,username);
            System.out.println(sorry);
        }
    }
}

結果：

Math與Random類

Math類

Math類包含用於執行的基本數學運算方法，如初等指數、對數、平方根和三角函數。

使用Math類能夠有兩種方式：

直接使用（Math所在的包java.lang爲默認引入的包）
使用import static java.lang.Math.abs;靜態導入

PI

比任何其餘值都更接近pi的double值

System.out.println(Math.PI);//3.141592653589793

abs(double a)方法

返回double值的絕對值

System.out.println(Math.abs(-10));//10

random()方法

返回帶正號的double值，該值大於等於0.0且小於1.0

System.out.println(Math.random());//隨機0-1之間的小數

round(double a)方法

返回最接近參數並等於某一整數的double值

System.out.println(Math.round(Math.random()*10));//5 隨機數擴大十倍再取整
System.out.println(Math.round(Math.random()*100)/100.0);//0.92隨機數保留兩位小數

sqrt(double a)方法

返回正確舍入的double值的正平方根

System.out.println(Math.sqrt(2));//1.4142135623730951

floor()方法

返回一個四捨五入的近似值

package com.API.demo03;
import static java.lang.Math.floor;
public class MathDemo {
    public static void main(String[] args) {
        System.out.println(floor(1.23235341));//1.0
    }
}

Random類

此類的實例用於生成僞隨機數流

nextLong()方法

返回下一個僞隨機數的long值

package com.API.demo03;

import java.util.Random;

public class MathRandomDemo {
    public static void main(String[] args) {
        Random r = new Random();
        System.out.println(r.nextLong());//-2965780218345956466
    }
}

nextBoolean()方法

返回下一個僞隨機數的boolean值

nextDouble()方法

返回下一個僞隨機數，在0.0和1.0之間的double值

nextInt()方法

返回下一個僞隨機數，int值

nextInt(int n)方法

返回一個僞隨機數，在0（包括）和指定值分佈的int值

Random r = new Random();
System.out.println(r.nextInt(20));//11 隨機20之內的整數

日期操做類

Date類

表示特定的瞬間，精確到毫秒，也就是程序運行時的當前時間

Date date = new Date();//實例化Date對象，表示當前時間

Date()方法

分配Date對象並初始化此對象，以表示分配它的時間

import java.util.Date;
public class DateDemo {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);//Wed May 27 22:43:36 CST 2020
    }
}

Date(long date)方法

分配一個毫秒來獲取時間參數是毫秒

import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        Date d1 = new Date(520000);
        System.out.println(d1);//Thu Jan 01 08:08:40 CST 1970
    }
}

Calendar類

日曆類，使用此類能夠將時間精確到毫秒顯示

兩種實例化方式：

Calendar c1 = Calendar.getInstance();
Calendar c2 = new GregorianCalendar();

package com.API.demo04;

import java.util.Calendar;
import java.util.GregorianCalendar;
public class DateDemo {
    public static void main(String[] args) {

        Calendar c1 = Calendar.getInstance();
        Calendar c2 = new GregorianCalendar();

        int year = c1.get(Calendar.YEAR);
        int month = c1.get(Calendar.MONTH);
        int day = c1.get(Calendar.DAY_OF_MONTH);
        int hour = c1.get(Calendar.HOUR_OF_DAY);
        int minute = c1.get(Calendar.MINUTE);
        int second = c1.get(Calendar.SECOND);
        int millisecond = c1.get(Calendar.MILLISECOND);
        StringBuilder sb = new StringBuilder(50);
        sb.append(year).append("年").append(month).append("月").append(day).append("日")
                .append(hour).append(":").append(minute)
            .append(":").append(second).append(" ").append(millisecond);
        System.out.println(sb.toString());//2020年4月27日23:7:7 361
    }
}

DateFormat類及子類SimpleDateFormat

package com.API.demo04;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateDemo {
    public static void main(String[] args) {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss SSS");
        String nowDate = df.format(new Date());
        System.out.println(nowDate);//2020年05月27日 23:13:36 809
    }
}

對象比較器

對兩個或多個數據項進行比較，以肯定它們是否相等，或肯定它們之間的大小關係及排列順序稱爲比較。

前面咱們學習的Arrays.sorts方法能夠實現對象的排序操做

Comparable接口

此接口強行對實現它的每一個類的對象進行總體排序。這種排序被稱爲類的天然排序，類的compareTo方法被稱爲它的天然比較方法。

測試類：

package com.API.demo05;
import java.util.Arrays;

public class ComDemo {
    public static void main(String[] args) {
        Cat[] cats = {new Cat("魚魚",1),new Cat("付付",4),new Cat("tom",2)};
        Arrays.sort(cats);
        System.out.println(Arrays.toString(cats));//[Cat{name='魚魚', age=1}, Cat{name='tom', age=2}, Cat{name='付付', age=4}]
    }

Cat類：

package com.API.demo05;
//<>裏寫的是比較對象
public class Cat implements Comparable<Cat>{
    private String name;
    private int age;

    public Cat() {
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Cat o) {
        //if(this.age<o.age)return -1;
        //if(this.age>o.age)return 1;
        //return 0;
        return this.age-o.age;
    }
}

Comparator接口

Comparable接口是要求自定義類去實現，按照OO原則：對修改關閉，對擴展開放。（在類裏直接加接口）

Comparator接口是強行對某個對象collection進行總體排序的比較。（新建一個接口類）

測試類：

package com.API.demo05;
import java.util.Arrays;

public class ComDemo {
    public static void main(String[] args) {
        Dog[] dogs = {new Dog("魚魚",1),new Dog("付付",4),new Dog("tom",2)};
        Arrays.sort(dogs,new DogComparator());//選擇比較器
        System.out.println(Arrays.toString(dogs));//[Dog{names='魚魚', age=1}, Dog{names='tom', age=2}, Dog{names='付付', age=4}]
    }
}

在Dog類裏若是沒有toString方法則輸出結果，會變成[com.API.demo05.Dog@1b6d3586, com.API.demo05.Dog@4554617c, com.API.demo05.Dog@74a14482]，就和直接System.out.println()數組不能直接輸出數組必須藉助Arrays.toString()一個道理。

Dog類：

package com.API.demo05;

public class Dog {
    private String names;
    private int age;

    public Dog() {
        super();
    }

    public Dog(String names, int age) {
        this.names = names;
        this.age = age;
    }

    public String getNames() {
        return names;
    }

    public void setNames(String names) {
        this.names = names;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override//若是沒有這個就會出現亂碼
    public String toString() {
        return "Dog{" +
                "names='" + names + '\'' +
                ", age=" + age +
                '}';
    }
}

接口類DogComparator：

package com.API.demo05;

import java.util.Comparator;

public class DogComparator implements Comparator<Dog> {

    @Override
    public int compare(Dog o1, Dog o2) {
        return o1.getAge()-o2.getAge();
    }
}

對象的克隆

Clone()方法

若是某個類的對象要想被克隆，則對象所在的類必須實現Cloneable接口。此接口沒有定義任何方法，是一個標記接口

測試類：

package com.API.Demo06;

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("付付",2);
        try {
            Cat newCat = (Cat) cat.clone();
            System.out.println("cat="+cat);//cat=Cat{name='付付', age=2}
            System.out.println("new cat="+newCat);//new cat=Cat{name='付付', age=2}地址不同
            System.out.println(cat==newCat);//false
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

Cat類：

package com.API.Demo06;

/**
 * 對象須要具有克隆功能：
 * 1.實現Cloneable接口（標記接口）
 * 2.重寫Object類中的Clone方法
 * @Author 油炸蘑菇魚
 */
public class Cat implements Cloneable{
    private String name;
    private int age;

    public Cat() {
    }

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

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //重寫Object中的clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

System與Runtime類

System類

System類表明系統，系統級的不少屬性和控制方法都放置在該類的內部。該類位於java.lang包
System類內包含三個成員變量，in標準輸入流（鍵盤輸入），out標準輸出流（顯示器）和err標準錯誤流

System.out.println("向控制檯輸出");//向控制檯輸出
System.err.println("出錯啦");//出錯啦(紅色字體)

arraycopy()方法

該方法是數組拷貝，也就是將一個數組中的內容複製到另一個數組的指定位置，因爲該方法是native本地方法，因此性能上比使用循環高效

int[] num1 = {1,2,3,4,5,6,7,8};
int[] num2 = new int[num1.length];
//參數（原數組，原數組的起始位置，目標數組，目標數組的起始位置，長度）
System.arraycopy(num1,0,num2,0,num1.length);
System.out.println(Arrays.toString(num2));//[1, 2, 3, 4, 5, 6, 7, 8]

currentTimeMillis()方法

該方法的做用是返回當前的計算機的時間，時間的表達式爲當前計算機時間和GMT時間（格林威治時間）1970年1月1日0時0分0秒所差的毫秒差

System.out.println(System.currentTimeMillis());//1592743150979

Date nowDate = new Date(System.currentTimeMillis());
DateFormat DF = new SimpleDateFormat("HH:MM:SS");
String now  = DF.format(nowDate);
System.out.println(now);//20:06:523

exit(int status)方法

該方法做用是退出程序。其中status的值爲0表示正常退出，非零表明異常退出。使用該方法能夠在圖形界面編程中實現程序的退出功能等

System.exit(0);//退出JVM

gc()方法

該方法的做用是請求系統進行垃圾回收。至於系統是否馬上回收，則取決於系統中垃圾回收算法的實現以及系統執行時的狀況

getProperty(String key)方法

該方法的做用是得到系統中屬性名爲key的屬性對應的值

java.version java運行時環境版本
java.home java安裝目錄
os.name 操做系統的名稱
os.version 操做系統的版本
user.name 用戶的帳戶名稱
user.home 用戶的主目錄
user.dir 用戶當前的工做目錄

System.out.println(System.getProperty("java.version"));//1.8.0_251
System.out.println(System.getProperty("java.home"));//C:\Program Files\Java\xxxxxxx
System.out.println(System.getProperty("os.name"));//Windows 10
System.out.println(System.getProperty("user.name"));//10260
System.out.println(System.getProperty("os.version"));//10.0

loadLibrary(string libname)

用於加載第三方類庫，例如加載C，C++編寫的類庫

Runtime類

每一個java應用程序都有一個Runtime類實例，使應用程序可以與其運行環境相鏈接

Runtime rt = Runtime.getRuntime();
System.out.println("處理器數量:"+rt.availableProcessors());//處理器數量:4
System.out.println("JVM總內存數:"+rt.totalMemory()+"byte");//JVM總內存數:124780544byte
System.out.println("JVM空閒內存數:"+rt.freeMemory()+"byte");//JVM空閒內存數:120840808byte
System.out.println("JVM可用最大內存數:"+rt.maxMemory()+"byte");//JVM可用最大內存數:1836580864byte
//在單獨的進程中執行指定的字符串命令
try {
    rt.exec("notepad");//打開筆記本
} catch (IOException e) {
    e.printStackTrace();
}

數字處理工具類

BigInteger類

可讓超出integer範圍內的數據進行運算

構造方法

BigInteger(String val)

//大整數運算
String val1="122313142342342";
String val2="858938563422344";
BigInteger b1 = new BigInteger(val1);
BigInteger b2 = new BigInteger(val2);

經常使用方法

add(BigInteger val)

加

System.out.println(b1.add(b2));//981251705764686

subtract(BigInteger val)

減

System.out.println(b1.subtract(b2));//-736625421080002

multiply(BigInteger val)

乘

System.out.println(b1.multiply(b2));//105059474771203913323980089648

divide(BigInteger val)

除

System.out.println(b1.divide(b2));//0

remainder(BigInteger val)

取模

System.out.println(b1.remainder(b2));//122313142342342

divideAndRemainder(BigInteger val)

除加取餘

System.out.println(Arrays.toString(b1.divideAndRemainder(b2)));//[0, 122313142342342]

BigDecimal類

用於運算的時候，float類型和double類型很容易丟失精度，爲了能精確的表示、計算浮點數，java提供了BigDecimal，不可變的、任意精度的有符號十進制數

構造方法

BigDecimal(String val)

String val3 = "5679.97979080728929";
String val4 = "398.2192381964231419129";
BigDecimal b3 = new BigDecimal(val3);
BigDecimal b4 = new BigDecimal(val4);

經常使用方法

add(BigDecimal val)

System.out.println(b3.add(b4));//6078.1990290037124319129

substract(BigDecimal val)

System.out.println(b3.subtract(b4));//5281.7605526108661480871

multiply(BigDecimal val)

System.out.println(b3.multiply(b4));//2261877.225266357622421505259065434282841

divide(BigDecimal val)

System.out.println(b3.divide(b4));//出錯

DecimalFormat類

用於小數處理的問題

double pi = 3.14159265358;
//取一位整數
System.out.println(new DecimalFormat("0").format(pi));//3
//取一位整數和兩位小數
System.out.println(new DecimalFormat("0.00").format(pi));//3.14
//取兩位整數和三位小數
System.out.println(new DecimalFormat("00.000").format(pi));//03.142
//取全部整數部分
System.out.println(new DecimalFormat("#").format(pi));//3
//以百分比方式計數
System.out.println(new DecimalFormat("#.##%").format(pi));//314.16%

long num = 683892097;
System.out.println(new DecimalFormat("###,###").format(num));//683,892,097

MD5工具類

Message-Digest Algorithm 5 (信息摘要算法)

關於密碼存儲

package com.API.Demo09;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;


public class MDA5Demo {
    private static String savePassword = "pmq7VoTEWWLYh1ZPCDRujQ==";//存儲的密文
    public static void main(String[] args) {
        //test();
        System.out.println(login("admin112ss"));//false
        System.out.println(login("admin123456"));//true
    }
    private static boolean login(String password){
        if(savePassword.equals(md5(password))){
            return true;
        }else{
            return false;
        }
    }

    //計算md5的工具方法
    private static String md5(String password){
        try {
            MessageDigest md = MessageDigest.getInstance("md5");
            byte[]  bytes = md.digest(password.getBytes("UTF-8"));//經過MD5計算摘要
            String str = Base64.getEncoder().encodeToString(bytes);
            return str;
        } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }
    private static void test() {
        String password = "admin123456";//原文
        String savePassword = "pmq7VoTEWWLYh1ZPCDRujQ==";//存儲的密文
        try {
            MessageDigest md = MessageDigest.getInstance("md5");
            byte[]  bytes = md.digest(password.getBytes("UTF-8"));//經過MD5計算摘要
            System.out.println(Arrays.toString(bytes));//[-90, 106, -69, 86, -124, -60, 89, 98, -40, -121, 86, 79, 8, 52, 110, -115]
            //String mdStr = new String(bytes);
            //System.out.println(mdStr);//�j�V��Yb؇V4n�
            //a-z  A-Z 0-9 / *  BASE64編碼算法
            String str = Base64.getEncoder().encodeToString(bytes);//編碼
            System.out.println(str);//pmq7VoTEWWLYh1ZPCDRujQ==
            byte[] bs = Base64.getDecoder().decode(str);//解碼
            System.out.println(Arrays.toString(bs));//[-90, 106, -69, 86, -124, -60, 89, 98, -40, -121, 86, 79, 8, 52, 110, -115]
        } catch (NoSuchAlgorithmException | UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}