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
  • WPF中輕鬆生成動態圖表：實例詳解(MVVM模式)
    概述：本文代碼示例演示瞭如何在WPF中使用LiveCharts庫創建動態條形圖。通過創建數據模型、ViewModel和在XAML中使用`CartesianChart`控制項，你可以輕鬆實現圖表的數據綁定和動態更新。我將通過清晰的步驟指南包括詳細的中文註釋，幫助你快速理解並應用這一功能。 先上效果： 在 ...
  • .NET 中使用 GaussDB C# ORM
    openGauss(GaussDB ) openGauss是一款全面友好開放，攜手伙伴共同打造的企業級開源關係型資料庫。openGauss採用木蘭寬鬆許可證v2發行，提供面向多核架構的極致性能、全鏈路的業務、數據安全、基於AI的調優和高效運維的能力。openGauss深度融合華為在資料庫領域多年的研 ...
  • .NET中使用 openGauss C# ORM
    openGauss(GaussDB ) openGauss是一款全面友好開放，攜手伙伴共同打造的企業級開源關係型資料庫。openGauss採用木蘭寬鬆許可證v2發行，提供面向多核架構的極致性能、全鏈路的業務、數據安全、基於AI的調優和高效運維的能力。openGauss深度融合華為在資料庫領域多年的研 ...
  • 輕鬆使用Aspire rabbitmq framework
    概述：本示例演示了在WPF應用程式中實現多語言支持的詳細步驟。通過資源字典和數據綁定，以及使用語言管理器類，應用程式能夠在運行時動態切換語言。這種方法使得多語言支持更加靈活，便於維護，同時提供清晰的代碼結構。 在WPF中實現多語言的一種常見方法是使用資源字典和數據綁定。以下是一個詳細的步驟和示例源代 ...
  • .net事件
    描述（做一個簡單的記錄）： 事件（event）的本質是一個委托；（聲明一個事件： public event TestDelegate eventTest;） 委托（delegate）可以理解為一個符合某種簽名的方法類型；比如：TestDelegate委托的返回數據類型為string，參數為 int和 ...
  • .NET CORE 完美支持AOT 的 ORM SqlSugar 教程
    1、AOT適合場景 Aot適合工具類型的項目使用，優點禁止反編 ，第一次啟動快，業務型項目或者反射多的項目不適合用AOT AOT更新記錄: 實實在在經過實踐的AOT ORM 5.1.4.117 +支持AOT 5.1.4.123 +支持CodeFirst和非同步方法 5.1.4.129-preview1 ...
  • 【UWP】修改清單脫離沙盒運行
    總說周知，UWP 是運行在沙盒裡面的，所有許可權都有嚴格限制，和沙盒外交互也需要特殊的通道，所以從根本杜絕了 UWP 毒瘤的存在。但是實際上 UWP 只是一個應用模型，本身是沒有什麼許可權管理的，許可權管理全靠 App Container 沙盒控制，如果我們脫離了這個沙盒，UWP 就會放飛自我了。那麼有沒... ...
  • 《Effective C++》第三版-4. 設計與聲明（Design and Declarations）
    目錄條款17：讓介面容易被正確使用，不易被誤用（Make interfaces easy to use correctly and hard to use incorrectly）限制類型和值規定能做和不能做的事提供行為一致的介面條款19：設計class猶如設計type（Treat class de ...
  • 從零開始：Django項目的創建與配置指南
    title: 從零開始：Django項目的創建與配置指南 date: 2024/5/2 18:29:33 updated: 2024/5/2 18:29:33 categories: 後端開發 tags: Django WebDev Python ORM Security Deployment Op ...
  • mORMot 1.18 第18章 使用REST/JSON的客戶端/伺服器
    1、BOM對象 BOM:Broswer object model,即瀏覽器提供我們開發者在javascript用於操作瀏覽器的對象。 1.1、window對象 視窗方法 // BOM Browser object model 瀏覽器對象模型 // js中最大的一個對象.整個瀏覽器視窗出現的所有東西都 ...
所有分類