1w+ 字總結 Java 常用類，整理太全了，建議收藏..

来源:https://www.cnblogs.com/javastack/archive/2022/06/09/16358057.html
-Advertisement-
Play Games

來源：cnblogs.com/lwtyyds/p/15678152.html 常用類概述 內部類 Object類 包裝類 數學類 時間類 字元串 String Builder和StringBuffer DecimalFormat 內部類 「概念」 ：在一個類內部再定義一個完整的類。 一般情況下類與類 ...


來源：cnblogs.com/lwtyyds/p/15678152.html

常用類概述

  1. 內部類
  2. Object類
  3. 包裝類
  4. 數學類
  5. 時間類
  6. 字元串
  7. String Builder和StringBuffer
  8. DecimalFormat

內部類

「概念」 ：在一個類內部再定義一個完整的類。

一般情況下類與類之間是相互獨立的，內部類的意思就是打破這種獨立思想，讓一個類成為另一個類的內部信息，和成員變數、成員方法同等級別。

「內部類的好處：」

把一個類寫在外面和寫在裡面最終達到的結果都一樣，那我們為什麼還要使用內部類，豈不是多此一舉嗎？

「採用內部類這種技術，可以隱藏細節和內部結構，封裝性更好，讓程式的結構更加合理！如果類很多且都暴露在外面，那麼類與類之間的調用就會十分繁瑣！」

內部類的分類：

1.成員內部類（非靜態內部類）

參考代碼如下：

package NeiBuLei;
public class OuterClass {
    //成員變數
    private String OuterName;
    //成員方法
    public void display(){
        System.out.println("這是外部類方法！");
        System.out.println(OuterName);
    }
    //內部類
    public class InnerClass{
        //成員變數
        private String InnerNme;
        //構造方法
        public InnerClass() {
            InnerNme = "Inner Class";
        }
        //成員方法
        public void display(){
            System.out.println("這是內部類方法！");
            System.out.println(InnerNme);
        }
    }
    // 主方法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();//這是外部類方法！null

        // 這個類是內部類，已經不是獨立的類了，因此不能像外部類一樣直接創建！
        //InnerClass innerClass = new InnerClass(); 行不通
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();// 同成員方法/變數 只是加了個首碼
        innerClass.display();// 這是內部類方法！
    }
}

輸出結果：

這是外部類方法！null 這是內部類方法！Inner Class

「總結：成員內部類（非靜態內部類）的使用就是將內部類作為外部類的的一個成員變數/成員方法來使用，所以必須依賴於外部類的對象才能調用，用法和成員變數/成員方法一致！」

2.局部內部類

局部內部類：基本的內部類還可以在一個方法體中定義。

package NeiBuLei;
public class OuterClass {
    //成員變數
    private String OuterName;
    //成員方法
    public void display(){
        class InnerClass {
            public void print(){
                System.out.println("這是一個局部內部類方法！");
            }
        }
        InnerClass innerClass = new InnerClass();
        innerClass.print();
    }

    // 主方法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
    }
}
  1. 靜態內部類

靜態內部類的構造不需要依賴於外部類對象，類中的靜態組件都不需要依賴於任何對象，可以直接通過「類本身」 進行構造。

package NeiBuLei;
public class OuterClass {
    //成員變數
    private String OuterName;
    //成員方法
    public void display(){
        System.out.println("這是外部類方法！");
        System.out.println(OuterName);
    }
    //靜態內部類
    public static class InnerClass{
        private String InnerName;
        public InnerClass() {
            InnerName = "Inner Class";
        }

        //成員方法
        public void display(){
            System.out.println("這是靜態內部類方法！");
            System.out.println(InnerName);
        }
    }

    // 主方法
    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        outerClass.display();
        // 靜態內部類的構造不依賴與外部類，可以直接通過類本身進行構造！
        InnerClass innerClass = new InnerClass();
        innerClass.display();
    }
}

輸出結果：

這是外部類方法！null 這是靜態內部類方法！Inner Class

4.匿名內部類

匿名內部類：沒有名字的內部類。

匿名內部類「主要應用與介面的實現！」

介面：

package NeiBuLei;
public interface MyInterface {
    public void test();
}

實現類：

package NeiBuLei;
public class MyImplement implements MyInterface{
    @Override
    public void test() {
        System.out.println("test");
    }
}

匿名內部類的使用：

package NeiBuLei;
public class MyImplement implements MyInterface{
    @Override
    public void test() {
        System.out.println("test");
    }
}

「匿名內部類的好處：」

我們定義介面之後，「它的實現類不需要去單獨創建一個文件去寫它的實現」 ，我們可以把這個實現類的操作寫到我們調用的地方就可以了！寫起來更加簡潔、方便。

「匿名內部類的缺點：」

耦合度太高了！

Object類

匿名內部類的缺點

Object類常用方法：

1.equals方法

「==與equals的對比【面試題】+ jdk查看原碼」

==是一個比較運算符

  1. ==：既可以判斷基本類型，又可以判斷引用類型
  2. ==：如果判斷的是「基本類型」 ，「判斷的是值是否相等」 。
//==： 如果判斷的是基本類型，判斷的是 值 是否相等
int x1 = 10;
int x2 = 10;
double x3 = 10.0;
System.out.println(x1 == x2);//true
System.out.println(x1 == x3);//true
  1. ==：如果判斷的是「引用類型」 ，「判斷的是地址是否相等，即判斷是不是同一個對象」
package Equals;
public class Test01 {
    public static void main(String[] args) {
        //==： 如果判斷的是引用類型，判斷的是地址是否相等，即判斷是不是同一個對象
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a==c);// ? true
        System.out.println(b==c);// true
        B obj = a;
        System.out.println(obj==c);// true
    }
}

class B{}
class A extends B{}

  1. equals方法是Object類中的方法，「只能判斷引用類型」 。

❝

idea查看Jdk原碼：滑鼠游標放在要查看的方法上，直接輸入ctrl + b

查看某個類所有方法：ctrl + F12

❞

  1. 預設判斷的是地址是否相等，「子類(Object類是所有類的父類)往往重寫該方法，用於判斷內容是否相等」 。
/*
Object類 equals()方法原碼

//預設判斷地址是否一樣
    public boolean equals(Object obj) {
        return (this == obj);
    }

子類往往重寫該方法，用於判斷內容是否相等  String類中的equals()方法原碼（重寫了父類equals()方法）

    public boolean equals(Object anObject) {
        if (this == anObject) { // 如果是同一個對象(地址相同)
            return true; // 返回true
        }
        if (anObject instanceof String) { // 判斷類型
            String anotherString = (String)anObject; // 向下轉型
            int n = value.length;
            if (n == anotherString.value.length) { // 如果長度相同
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) { // 比較每一個字元
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true; // 如果兩個字元串每一個字元都相同，則返回true
            }
        }
        return false;
    }
 */

在看個例子

【小練習】

寫出輸出結果：

package Equals;
public class EqualsTest01 {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "tom";
        Person p2 = new Person();
        p2.name = "tom";
        System.out.println(p1 == p2);// 引用類型——判斷是否為同一個對象（地址）
        System.out.println(p1.name.equals(p2.name));// p.name是String類型，重寫了equals()方法——判斷內容是否一樣
        System.out.println(p1.equals(p2));//p1,p2屬於Person類，該類並沒有重寫equals()方法（繼承父類equals()方法，即判斷地址）

        String s1 = new String("abc");
        String s2 = new String("abc");

        System.out.println(s1.equals(s2));
        System.out.println(s1 == s2);
    }
}

class Person{
    public String name;
}

輸出結果：

false true false true false

2.hashCode方法

小結：（可以當作地址來看但它本質上不是地址）

  1. 提高具有哈希結構的容器的效率
  2. 兩個引用，如果指向的是同一個對象，則哈希值肯定一樣
  3. 兩個引用，如果指向的是不同對象，則哈希值是不一樣的
  4. 哈希值主要根據地址號來！不能將哈希值完全等價於地址
  5. 在後面的集合中hashCode如果需要的話，也會重寫
package hashCode;
public class HashCode {
    public static void main(String[] args) {
        AA aa = new AA();
        AA aa2 = new AA();
        AA aa3 = aa;
        System.out.println("aa.hashCode()="+ aa.hashCode());
        System.out.println("aa2.hashCode()="+ aa2.hashCode());
        System.out.println("aa3.hashCode()="+ aa3.hashCode());
    }
}

class AA{}

輸出結果：

❝

aa.hashCode()=460141958 aa2.hashCode()=1163157884 aa3.hashCode()=460141958

❞

3.toString方法

toString方法

基本介紹：

預設返回：全類名 + @ + 哈希值的十六進位

/*
    Object toString()原碼
    //(1)getClass().getName() 類的全類名（包名+類名）
    //(2)Integer.toHexString(hashCode()) 將hashCode的值轉成16進位字元串
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
 */

「子類往往重寫toString方法，用於返回對象的屬性信息（快捷鍵：alt + insert），當然我們也可以自己定製。」

當我們輸出一個對象時，toString()方法會被預設調用

4.finzlize方法

finzlize方法：當垃圾收集確定不再有對該對象的引用時，垃圾收集器在對象上調用該對象。

  1. 當對象被回收時，系統自動調用該對象的finzlize方法。子類可以重寫該方法，做一些釋放資源的操作
  2. 什麼時候被回收：當某個對象沒有任何引用時，則jvm就認為這個對象是一個垃圾對象，就會時候垃圾回收機制來銷毀該對象，在銷毀該對象前，會先調用finzlize方法。

  1. 垃圾回收機制的調用，是由系統來決定（即有自己的GC演算法），也可以通過System.gc()主動觸發垃圾回收機制。

❝

註：在實際開發中，幾乎不會用finzlize方法，更多的是為了應付面試

❞

包裝類

「1.基本數據類型以及對應的包裝類：」

byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean

這些類都在java.lang包

「2.包裝類的意義：」

  1. 讓基本數據類型有面向對象的特征
  2. 「封裝了字元串轉化成基本數據類型的方法（重點）」

3.包裝類常用方法：

  1. Integer.parseInt()
  2. Long.paseLong()
  3. Double.parseDouble()

【參考代碼】

public class Test {
    public static void main(String[] args) {

//        Integer i = new Integer(10);// 創建包裝類對象
//        Integer ii = 10; // 自動打包
//        System.out.println(i+10); // 在使用上，int 和Integer 其實沒有區別，可以互相使用
//        System.out.println(ii+10);
//        int j = ii;// 自動解包
//        System.out.println(j+100);

        String a = "12";
        String b = "34";
        System.out.println(a+b); // 1234
    // 轉型:
        // 字元串轉成int的唯一方案
        int c = Integer.parseInt(a);
        int d = Integer.parseInt(b);
        System.out.println(c+d); // 46

        // 字元串轉成double類型
        String e = "1.25";
        double f = Double.parseDouble(e);
        System.out.println(f*6); // 7.5

        // 轉成long類型
        long l = Long.parseLong("1234567");
        System.out.println(l);
    }
}

數學類

❝

數學類的方法都是靜態方法，可以直接引用——Math.方法();

❞

「常用數學類方法：」

  1. abs()：獲取絕對值
  2. max()：求最大值
  3. min()：求最小值
  4. pow()：求次冪
  5. round()：四捨五入
  6. sqrt()：求平方根

時間類

Java常用時間類：

  1. Date 日期類
  2. Calendar 日曆類
  3. SimpleDateFormat 格式化時間類

❝

Date和Calendar類 在java.util包中， SimpleDateFormat類 在java.text包

❞

1.Date 日期

【1】new Date() 可以獲取到系統時間

【2】getTime() 能獲取到時間的long形式，可以用來計算時間差

❝

getTime()——獲取電腦底層存儲的數字，返回一個數字用來表示時間，這個數字的類型long，單位為毫秒。

❞

【參考代碼】

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d); // 系統時間
        //get...()——獲取年月日.....
        System.out.println(d.getYear()+1900); // 從1900年開始算的
        System.out.println(d.getMonth()+1); // 月份從0開始計算
        System.out.println(d.getDate()); // 天數
        System.out.println(d.getHours());// 小時

        //getTime()——獲取到時間的毫秒形式 返回的是long
        System.out.println(d.getTime());
    }
}

2.Calendar 日曆

【1】get() 獲取到時間的某一部分

【2】set() 設置時間 - -> 計算時間：系統已經幫我們設置好了，不用擔心二月有多少天等問題，計算時間十分方便

❝

註：Calendar 日曆類是抽象類，因此不可以去new對象。雖然抽象類不能創建對象，但是jdk官方提供了一個實例對象的操作：

Calendar rightNow = Calendar.getInstance();

我們通過這條代碼就是直接造了一個Calender的對象

❞

【參考代碼】：get() 獲取到時間的某一部分：

package date;
import java.util.Calendar;
public class TestCalendar {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
//        System.out.println(cal);

        /*
 假設當天：
        2021
        8
        10
         */
  cal.set(Calendar.DATE,cal.get(Calendar.DATE)+31); // 計算時間(這裡用天數計算的)

        // 獲取Calendar創建的對象里的所有內容
        System.out.println(cal.get(Calendar.YEAR)); // 2021 年
        System.out.println(cal.get(Calendar.MONTH)+1); // 月份：從0開始的  結果：為10月
        System.out.println(cal.get(Calendar.DATE)); // 日
        System.out.println(cal.get(Calendar.HOUR_OF_DAY));// 小時
        System.out.println(cal.get(Calendar.MINUTE));
        System.out.println(cal.get(Calendar.SECOND));
    }
}

【參考代碼】：set() 設置時間 - -> 計算時間：

❝

註：cal.setTime(d); 把Date轉化成Calendar

❞

package date;
import java.util.Calendar;
import java.util.Date;
public class TestCalendar {
    public static void main(String[] args) {
        Date d = new Date();
        Calendar cal = Calendar.getInstance();
        cal.setTime(d);// 把Date轉化成Calendar
        System.out.println(cal);
        System.out.println(cal.get(Calendar.YEAR)); //  年
        System.out.println(cal.get(Calendar.MONTH)+1); // 月份：從0開始的
        System.out.println(cal.get(Calendar.DATE)); // 日
    }
}

3.SimpleDateFormat格式化時間

Date，Calendar通過引用也可以進行時間的格式化，但比較繁瑣，而SimpleDateFormat類是專門幫我們格式化時間的工具類，它在java.text包中。

【時間格式】：yyyy-MM-dd HH:mm:ss

SimpleDateFormat類有兩大常用方法：

【1】format(Date)：

❝

format(Date) 幫我們把時間轉成字元串，字元串的格式為SimpleDateFormat類定義對象時設置的時間格式

❞

【參考代碼】

package Simple;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;
public class Test {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d); //Thu Aug 12 08:40:08 CST 2021  不美觀

  //                  設置格式化時間的模式，我們常用yyyy-MM-dd HH:mm:ss這個模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 時間格式
        String s = sdf.format(d); // 格式化時間
        System.out.println(s); // 2021-08-12 08:45:09
    }
}

【2】parse(String)：

❝

parse(String) 幫我們把字元串轉化成時間

❞

【參考代碼】

package Simple;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Test2 {
    public static void main(String[] args) throws ParseException {
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個時間(yyyy-MM-dd HH:mm:ss)：");
        String s = sc.nextLine();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
       Date d =  sdf.parse(s); // 把字元串轉成時間
        System.out.println(d);
        /*
        請輸入一個時間(yyyy-MM-dd HH:mm:ss)：
        2021-08-12 12:25:21
        Thu Aug 12 12:25:21 CST 2021
         */
    }
}

❝

註：由於用戶輸入的字元串不一定是我們要求的格式，可能是任何東西，想把它們轉成時間是不可能的，你不可能把一個人轉成時間 對吧，因此存在著很大的風險未處理(異常: java.text.ParseException)，為此我們需要處理異常。

❞

4.計算時間差

計算思路：

  1. 格式化時間
  2. 先將字元串轉化成long類型時間
  3. 計算毫秒級別時間差，取絕對值
  4. 毫秒級別時間差轉成秒級別
  5. 秒級別時間差轉成分鐘級別
  6. 分鐘級別時間差轉化顯示成xx小時xx分鐘

【參考代碼】

package Simple;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestDiff {
    public static void main(String[] args) throws ParseException {
        String s1 = "2021-08-12 12:00:00"; // 開始時間
        String s2 = "2021-08-12 14:35:00"; // 結束時間
        //格式化時間
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
        //將字元串轉成時間形式
        Date d1 = sdf.parse(s1);
        Date d2 = sdf.parse(s2);

        //計算時間差:先要獲取時間毫秒形式（long類型） 再做差
        long long1 = d1.getTime();
        long long2 = d2.getTime();
        long diffTime = Math.abs(long1 - long2);

        // 秒級別時間差
        long diffSec = diffTime / 1000;

        // 分級別時間差
        long diffMin = diffSec / 60;

        //顯示 xx小時xx分鐘
        long displayHours = diffMin / 60; // 小時
        long displayMin = diffMin % 60; //分鐘
        System.out.println("您學習的時長為："+displayHours+"小時"+displayMin+"分鐘");
    }
}

String類

字元串類常用方法

「方法彙總：」

❝

「註：字元串是一個不可變的類型（final類），幾乎所有的字元串操作都會返回一個新字元串而不是在原有基礎上進行修改。」

❞

【示例代碼】

public class Test {
    public static void main(String[] args) {
        String s = "我的名字叫李華";
        s.concat("hhh"); // 在字元串s上拼接，拼接hhh
        System.out.println(s);// 我的名字叫李華
        //字元串是不可變的數據類型
        //幾乎所有的字元串操作都會返回一個新字元串
        String s1 = s.concat("hhh"); // 在字元串s上拼接，拼接hhh
        System.out.println(s1);//我的名字叫李華hhh

        String str1 = "李華喜歡看羅老師的視頻";
        str1.replace("李華","張三");
        System.out.println(str3); //李華喜歡看羅老師的視頻  並沒有替換 字元串是不變的str1還是str1

        String str2 = str1.replace("李華","張三");//幾乎所有的字元串操作都會返回一個新字元串 新串要用新變數接
        System.out.println(str2);//張三喜歡看羅老師的視頻
   }
}
package String;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        String s = "我的名字叫李華";
        System.out.println(s.charAt(0)); // 獲取第0個位置的字元
        s.concat("hhh");
        System.out.println(s);// 我的名字叫李華
        //字元串是不可變的數據類型
        //幾乎所有的字元串操作都會返回一個新字元串
        String s1 = s.concat("hhh"); // 在字元串s上拼接，拼接hhh
        System.out.println(s1);//我的名字叫李華hhh
        System.out.println(s.contains("李華")); //true
        System.out.println(s.contains("牛津")); //false
        System.out.println("邀請李華來參加英語沙龍活動".endsWith("活動"));//true 判斷是否以xxx為結尾
        System.out.println("邀請李華來參加英語沙龍活動".startsWith("李華"));//false 判斷是否以xxx開頭

        // equals字元串內容是否相同

        // 接受邀請參加活動的李華到現場後要輸入驗證碼
//        String yanZhengMa = "AAkm";
//
//        Scanner sc = new Scanner(System.in);
//
//        System.out.println("請輸入驗證碼("+yanZhengMa+")");
//
//        String userInput = sc.nextLine();
//
//        if(yanZhengMa.equalsIgnoreCase("aakm")){  // 忽略大小寫判斷兩邊的內容是否一樣
//            System.out.println("歡迎參加英語沙龍活動！");
//        }else{
//            System.out.println("您未受到邀請，請現場報名！");
//        }

//        String str = "李華玩得很開心！";
//        System.out.println(str.indexOf("開心"));// 5 計算給出字元串第一個出現的位置

        String str2 = "李華成績很好";
        System.out.println(str2.length()); // 6 計算字元串的長度

        String str3 = "李華喜歡看羅老師的視頻";
        str3.replace("李華","張三");
        System.out.println(str3); //李華喜歡看羅老師的視頻  並沒有替換 字元串是不變的str3還是str3

        String str4 = str3.replace("李華","張三");//幾乎所有的字元串操作都會返回一個新字元串 新串要用新變數接
        System.out.println(str4);//張三喜歡看羅老師的視頻
        String str5 = "哈哈_呵呵_嘻嘻_噢no";
        String[] ss = str5.split("_");//切割
        System.out.println(ss[0]);//哈哈
        System.out.println(ss[1]);//哈哈
        System.out.println(ss[2]);//嘻嘻
        System.out.println(ss[3]);//噢no

        String str6 = "今天天氣不錯";
        System.out.println(str6.substring(2,4));//天氣 字元串截取 [ ) 左閉右開，右邊取不到

        String str7 ="     哈    哈      ";
        System.out.println(str7.trim());// 去掉左右兩邊的空格
        int i = 10;
        System.out.println(String.valueOf(i)); // 基本數據類型轉為字元串
        System.out.println(i+""); // 野路子
    }
}

String Builder和StringBuffer

「String類的缺點：」

String 是一個不可變的數據類型，每每拼接都會產生一個新的字元串，那麼記憶體遲早會被這些拼接的字元串塞滿。

「String類和StringBuilder和StringBuffer類的區別：」

StringBuilder和StringBuffer：「可變的字元串，不產生新對象，比較省記憶體」 ，當進行大量的字元串拼接時建議使用StringBuffer和StringBuilder，但它們兩個一些方法的實現幾乎跟String一樣。

「StringBuffer和StringBuilder類：」

【相似點】

兩者用法一模一樣，可以認為是一個類

【區別】

  1. StringBuffer線程安全，StringBuilder非線程安全。
  2. StringBuilder相比於StringBuffer有速度優勢，「多數情況下建議使用StringBuilder類，但當被要求線程安全時必須使用StringBuilder類」

❝

字元串拼接方法：append()方法

StringBuffer和StringBuilder 轉成String類 ：

StringBuilder sb = new StringBuilder("貓喜歡吃魚"); String s = sb.toString();

❞

【參考代碼】

package String;
public class TestStringBuilder {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();// 一個空的字元串""
        StringBuilder sb2 = new StringBuilder("貓喜歡吃魚");
        System.out.println(sb2);// 貓喜歡吃魚

        sb2.append("，狗也喜歡吃魚");
        System.out.println(sb2);// 追加  貓喜歡吃魚，狗也喜歡吃魚

        sb2.insert(1,"哈哈哈");
        System.out.println(sb2); //貓哈哈哈喜歡吃魚，狗也喜歡吃魚

        // 上述的操作huan'c
        // 把StringBuilder轉化成String
        String s = sb2.toString();
        System.out.println(s); //貓哈哈哈喜歡吃魚，狗也喜歡吃魚
        // 上述操作都可以將StringBuilder換成StringBuffer，結果一樣
    }
}

DecimalFormat

DecimalFormat：對小數進行格式化，保留幾位小數。與格式化時間聯想記。

❝

. 表示小數點

0和# 表示數位，保留幾位就幾個0或者#

❞

【參考代碼】

import java.text.DecimalFormat;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        double d= 10/3.0;
        System.out.println(d);//3.3333333333333335

        // . 表示小數點
        // 0和#表示數字

        // 保留兩位小數                        格式
        DecimalFormat df = new DecimalFormat(".00"); // 或者.##
        String s = df.format(d); // 把 d 轉成上面設置的格式
        System.out.println(s);//3.33
   }
}

總結

萬變不離其宗，Java 的其他類和功能，都離不開這些基礎。牢記基礎，成長的更穩！

近期熱文推薦：

1.1,000+ 道 Java面試題及答案整理(2022最新版)

2.勁爆！Java 協程要來了。。。

3.Spring Boot 2.x 教程，太全了！

4.別再寫滿屏的爆爆爆炸類了，試試裝飾器模式，這才是優雅的方式！！

5.《Java開發手冊（嵩山版）》最新發佈，速速下載！

覺得不錯，別忘了隨手點贊+轉發哦！


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • TL,你是如何管理項目風險的？
    沙包和打傘的故事 美國在1961年到1972年組織實施的一系列載人登月飛行任務。目的是實現載人登月飛行和人對月球的實地考察，為載人行星飛行和探測進行技術準備，它是世界航天史上具有劃時代意義的一項成就。阿波羅計劃始於1961年5月，至1972年12月第6次登月成功結束，歷時約11年，耗資255億美元。 ...
  • 乾貨合集│最好用的 python 庫都在這
    一、分詞 - jieba 優秀的中文分詞庫，依靠中文詞庫，利用詞庫確定漢子之間關聯的概率，形成分詞結果 import jieba word = '偉大的中華人民共和國' jieba.cut(word) jieba.lcut(word) 二、詞雲庫 - wordcloud 對數據中出現頻率較高的 關鍵 ...
  • EasyExcel-合併單元格
    pom版本 <dependency> <groupId>com.alibaba</groupId> <artifactId>easyexcel</artifactId> <version>2.2.7</version> </dependency> 1.自定義合併單元格 在某些業務場景中可能會有合併單 ...
  • Java日誌體系一本通
    主要內容 1·學習java日誌體系及日誌工具的演進 2·瞭解日誌採集、處理、分析等各階段的常用中間件 3·學會搭建完整的elk日誌平臺 4·學習日誌打點，切麵，日誌文件等輸出手段 5·項目實戰，完成一訪問日誌鏈路的跟蹤 1、Java日誌體系 1.1 體系概述 1.1.1 日誌介面 JCL：Apach ...
  • SpringCloud微服務實戰——搭建企業級開發框架（四十一）：擴展JustAuth+SpringSecurity+Vue實現多租戶系統微信掃碼、釘釘掃碼等第三方登錄
    前面我們詳細介紹了SSO、OAuth2的定義和實現原理，也舉例說明瞭如何在微服務框架中使用spring-security-oauth2實現單點登錄授權伺服器和單點登錄客戶端。目前很多平臺都提供了單點登錄授權伺服器功能，比如我們經常用到的QQ登錄、微信登錄、新浪微博登錄、支付寶登錄等等。 如果我們自己 ...
  • 【Java面試】什麼是可重入，什麼是可重入鎖? 它用來解決什麼問題?
    一個工作了3年的粉絲，去一個互聯網公司面試，結果被面試官懟了。 面試官說：”這麼簡單的問題你都不知道？ 沒法聊了，回去等通知吧“。 這個問題是： ”什麼是可重入鎖，以及它的作用是什麼？“ 對於這個問題，來看看普通人和高手的回答吧 普通人： 嗯。。。。。。。。。。。。。。。。。。 高手： 好的。 可重 ...
  • Java連接MySQL
    JDBC概述 JDBC（Java Data Base Connectivity,java資料庫連接）是一種用於執行SQL語句的Java API，可以為多種關係資料庫提供統一訪問，它由一組用Java語言編寫的類和介面組成。是Java訪問資料庫的標準規範。 JDBC提供了一種基準,據此可以構建更高級的工 ...
  • 手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（十） - ShardingSphere-JDBC 集成與配置
    手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（一） - 介紹 手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（二） - 資料庫設計 手把手教你使用 Spring Boot 3 開發上線一個前後端分離的生產級系統（三） - 項目初始化 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類