Java常用類：7000+字一次性幫你總結(jié)好啦！
超全技術(shù)棧的Java入門+進(jìn)階+實戰(zhàn)！（非白嫖，點擊查看）
來源：cnblogs.com/lwtyyds/p/15678152.html
常用類概述 內(nèi)部類 內(nèi)部類的分類： 1.成員內(nèi)部類（非靜態(tài)內(nèi)部類） 2.局部內(nèi)部類 4.匿名內(nèi)部類 Object類 Object類常用方法： 1.equals方法 2.hashCode方法 3.toString方法 4.finzlize方法 包裝類 「1.基本數(shù)據(jù)類型以及對應(yīng)的包裝類：」 「2.包裝類的意義：」 3.包裝類常用方法： 數(shù)學(xué)類 時間類 Java常用時間類： 1.Date 日期 2.Calendar 日歷 3.SimpleDateFormat格式化時間 4.計算時間差 String類 字符串類常用方法 String Builder和StringBuffer DecimalFormat 總結(jié)
常用類概述
內(nèi)部類 Object類 包裝類 數(shù)學(xué)類 時間類 字符串 String Builder和StringBuffer DecimalFormat
內(nèi)部類
「概念」 ：在一個類內(nèi)部再定義一個完整的類。
一般情況下類與類之間是相互獨(dú)立的，內(nèi)部類的意思就是打破這種獨(dú)立思想，讓一個類成為另一個類的內(nèi)部信息，和成員變量、成員方法同等級別。
「內(nèi)部類的好處：」
把一個類寫在外面和寫在里面最終達(dá)到的結(jié)果都一樣，那我們?yōu)槭裁催€要使用內(nèi)部類，豈不是多此一舉嗎？
「采用內(nèi)部類這種技術(shù)，可以隱藏細(xì)節(jié)和內(nèi)部結(jié)構(gòu)，封裝性更好，讓程序的結(jié)構(gòu)更加合理！如果類很多且都暴露在外面，那么類與類之間的調(diào)用就會十分繁瑣！」
內(nèi)部類的分類：
1.成員內(nèi)部類（非靜態(tài)內(nèi)部類）
參考代碼如下：
package NeiBuLei;
public class OuterClass {
//成員變量
private String OuterName;
//成員方法
public void display(){
System.out.println("這是外部類方法！");
System.out.println(OuterName);
}
//內(nèi)部類
public class InnerClass{
//成員變量
private String InnerNme;
//構(gòu)造方法
public InnerClass() {
InnerNme = "Inner Class";
}
//成員方法
public void display(){
System.out.println("這是內(nèi)部類方法！");
System.out.println(InnerNme);
}
}
// 主方法
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.display();//這是外部類方法！null
// 這個類是內(nèi)部類，已經(jīng)不是獨(dú)立的類了，因此不能像外部類一樣直接創(chuàng)建！
//InnerClass innerClass = new InnerClass(); 行不通
OuterClass.InnerClass innerClass = outerClass.new InnerClass();// 同成員方法/變量 只是加了個前綴
innerClass.display();// 這是內(nèi)部類方法！
}
}
輸出結(jié)果：
這是外部類方法！null 這是內(nèi)部類方法！Inner Class
「總結(jié)：成員內(nèi)部類（非靜態(tài)內(nèi)部類）的使用就是將內(nèi)部類作為外部類的的一個成員變量/成員方法來使用，所以必須依賴于外部類的對象才能調(diào)用，用法和成員變量/成員方法一致！」
2.局部內(nèi)部類
局部內(nèi)部類：基本的內(nèi)部類還可以在一個方法體中定義。
package NeiBuLei;
public class OuterClass {
//成員變量
private String OuterName;
//成員方法
public void display(){
class InnerClass {
public void print(){
System.out.println("這是一個局部內(nèi)部類方法！");
}
}
InnerClass innerClass = new InnerClass();
innerClass.print();
}
// 主方法
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.display();
}
}
靜態(tài)內(nèi)部類
靜態(tài)內(nèi)部類的構(gòu)造不需要依賴于外部類對象，類中的靜態(tài)組件都不需要依賴于任何對象，可以直接通過「類本身」 進(jìn)行構(gòu)造。
package NeiBuLei;
public class OuterClass {
//成員變量
private String OuterName;
//成員方法
public void display(){
System.out.println("這是外部類方法！");
System.out.println(OuterName);
}
//靜態(tài)內(nèi)部類
public static class InnerClass{
private String InnerName;
public InnerClass() {
InnerName = "Inner Class";
}
//成員方法
public void display(){
System.out.println("這是靜態(tài)內(nèi)部類方法！");
System.out.println(InnerName);
}
}
// 主方法
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.display();
// 靜態(tài)內(nèi)部類的構(gòu)造不依賴與外部類，可以直接通過類本身進(jìn)行構(gòu)造！
InnerClass innerClass = new InnerClass();
innerClass.display();
}
}
輸出結(jié)果：
這是外部類方法！null 這是靜態(tài)內(nèi)部類方法！Inner Class
4.匿名內(nèi)部類
匿名內(nèi)部類：沒有名字的內(nèi)部類。
匿名內(nèi)部類「主要應(yīng)用與接口的實現(xiàn)！」
接口：
package NeiBuLei;
public interface MyInterface {
public void test();
}
實現(xiàn)類：
package NeiBuLei;
public class MyImplement implements MyInterface{
@Override
public void test() {
System.out.println("test");
}
}
匿名內(nèi)部類的使用：
package NeiBuLei;
public class MyImplement implements MyInterface{
@Override
public void test() {
System.out.println("test");
}
}
「匿名內(nèi)部類的好處：」
我們定義接口之后，「它的實現(xiàn)類不需要去單獨(dú)創(chuàng)建一個文件去寫它的實現(xiàn)」 ，我們可以把這個實現(xiàn)類的操作寫到我們調(diào)用的地方就可以了！寫起來更加簡潔、方便。
「匿名內(nèi)部類的缺點：」
耦合度太高了！
Object類
匿名內(nèi)部類的缺點
Object類常用方法：
1.equals方法
「==與equals的對比【面試題】+ jdk查看原碼」
==是一個比較運(yùn)算符
==：既可以判斷基本類型，又可以判斷引用類型 ==：如果判斷的是「基本類型」 ，「判斷的是值是否相等」 。
//==： 如果判斷的是基本類型，判斷的是 值 是否相等
int x1 = 10;
int x2 = 10;
double x3 = 10.0;
System.out.println(x1 == x2);//true
System.out.println(x1 == x3);//true
==：如果判斷的是「引用類型」 ，「判斷的是地址是否相等，即判斷是不是同一個對象」
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{}
equals方法是Object類中的方法，「只能判斷引用類型」 。
?
idea查看Jdk原碼：鼠標(biāo)光標(biāo)放在要查看的方法上，直接輸入ctrl + b
查看某個類所有方法：ctrl + F12
?
默認(rèn)判斷的是地址是否相等，「子類(Object類是所有類的父類)往往重寫該方法，用于判斷內(nèi)容是否相等」 。
/*
Object類 equals()方法原碼
//默認(rèn)判斷地址是否一樣
public boolean equals(Object obj) {
return (this == obj);
}
子類往往重寫該方法，用于判斷內(nèi)容是否相等 String類中的equals()方法原碼（重寫了父類equals()方法）
public boolean equals(Object anObject) {
if (this == anObject) { // 如果是同一個對象(地址相同)
return true; // 返回true
}
if (anObject instanceof String) { // 判斷類型
String anotherString = (String)anObject; // 向下轉(zhuǎn)型
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;
}
*/
在看個例子
【小練習(xí)】
寫出輸出結(jié)果：
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()方法——判斷內(nèi)容是否一樣
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;
}
輸出結(jié)果：
false true false true false
2.hashCode方法
小結(jié)：（可以當(dāng)作地址來看但它本質(zhì)上不是地址）
提高具有哈希結(jié)構(gòu)的容器的效率 兩個引用，如果指向的是同一個對象，則哈希值肯定一樣 兩個引用，如果指向的是不同對象，則哈希值是不一樣的 哈希值主要根據(jù)地址號來！不能將哈希值完全等價于地址 在后面的集合中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{}
輸出結(jié)果：
?
aa.hashCode()=460141958 aa2.hashCode()=1163157884 aa3.hashCode()=460141958
?
3.toString方法
toString方法
基本介紹：
默認(rèn)返回：全類名 + @ + 哈希值的十六進(jìn)制
/*
Object toString()原碼
//(1)getClass().getName() 類的全類名（包名+類名）
//(2)Integer.toHexString(hashCode()) 將hashCode的值轉(zhuǎn)成16進(jìn)制字符串
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
*/
「子類往往重寫toString方法，用于返回對象的屬性信息（快捷鍵：alt + insert），當(dāng)然我們也可以自己定制。」
當(dāng)我們輸出一個對象時，toString()方法會被默認(rèn)調(diào)用
4.finzlize方法
finzlize方法：當(dāng)垃圾收集確定不再有對該對象的引用時，垃圾收集器在對象上調(diào)用該對象。
當(dāng)對象被回收時，系統(tǒng)自動調(diào)用該對象的finzlize方法。子類可以重寫該方法，做一些釋放資源的操作 什么時候被回收：當(dāng)某個對象沒有任何引用時，則jvm就認(rèn)為這個對象是一個垃圾對象，就會時候垃圾回收機(jī)制來銷毀該對象，在銷毀該對象前，會先調(diào)用finzlize方法。
垃圾回收機(jī)制的調(diào)用，是由系統(tǒng)來決定（即有自己的GC算法），也可以通過System.gc()主動觸發(fā)垃圾回收機(jī)制。
?
注：在實際開發(fā)中，幾乎不會用finzlize方法，更多的是為了應(yīng)付面試
?
包裝類
「1.基本數(shù)據(jù)類型以及對應(yīng)的包裝類：」
byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean
這些類都在java.lang包
「2.包裝類的意義：」
讓基本數(shù)據(jù)類型有面向?qū)ο蟮奶卣?/section> 「封裝了字符串轉(zhuǎn)化成基本數(shù)據(jù)類型的方法（重點）」
3.包裝類常用方法：
Integer.parseInt() Long.paseLong() Double.parseDouble()
【參考代碼】
public class Test {
public static void main(String[] args) {
// Integer i = new Integer(10);// 創(chuàng)建包裝類對象
// Integer ii = 10; // 自動打包
// System.out.println(i+10); // 在使用上，int 和Integer 其實沒有區(qū)別，可以互相使用
// 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
// 轉(zhuǎn)型:
// 字符串轉(zhuǎn)成int的唯一方案
int c = Integer.parseInt(a);
int d = Integer.parseInt(b);
System.out.println(c+d); // 46
// 字符串轉(zhuǎn)成double類型
String e = "1.25";
double f = Double.parseDouble(e);
System.out.println(f*6); // 7.5
// 轉(zhuǎn)成long類型
long l = Long.parseLong("1234567");
System.out.println(l);
}
}
數(shù)學(xué)類
?
數(shù)學(xué)類的方法都是靜態(tài)方法，可以直接引用——Math.方法();
?
「常用數(shù)學(xué)類方法：」
abs()：獲取絕對值 max()：求最大值 min()：求最小值 pow()：求次冪 round()：四舍五入 sqrt()：求平方根
時間類
Java常用時間類：
Date 日期類 Calendar 日歷類 SimpleDateFormat 格式化時間類
?
Date和Calendar類 在java.util包中， SimpleDateFormat類 在java.text包
?
1.Date 日期
【1】new Date() 可以獲取到系統(tǒng)時間
【2】getTime() 能獲取到時間的long形式，可以用來計算時間差
?
getTime()——獲取計算機(jī)底層存儲的數(shù)字，返回一個數(shù)字用來表示時間，這個數(shù)字的類型long，單位為毫秒。
?
【參考代碼】
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date d = new Date();
System.out.println(d); // 系統(tǒng)時間
//get...()——獲取年月日.....
System.out.println(d.getYear()+1900); // 從1900年開始算的
System.out.println(d.getMonth()+1); // 月份從0開始計算
System.out.println(d.getDate()); // 天數(shù)
System.out.println(d.getHours());// 小時
//getTime()——獲取到時間的毫秒形式 返回的是long
System.out.println(d.getTime());
}
}
2.Calendar 日歷
【1】get() 獲取到時間的某一部分
【2】set() 設(shè)置時間 - -> 計算時間：系統(tǒng)已經(jīng)幫我們設(shè)置好了，不用擔(dān)心二月有多少天等問題，計算時間十分方便
?
注：Calendar 日歷類是抽象類，因此不可以去new對象。雖然抽象類不能創(chuàng)建對象，但是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);
/*
假設(shè)當(dāng)天：
2021
8
10
*/
cal.set(Calendar.DATE,cal.get(Calendar.DATE)+31); // 計算時間(這里用天數(shù)計算的)
// 獲取Calendar創(chuàng)建的對象里的所有內(nèi)容
System.out.println(cal.get(Calendar.YEAR)); // 2021 年
System.out.println(cal.get(Calendar.MONTH)+1); // 月份：從0開始的 結(jié)果：為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() 設(shè)置時間 - -> 計算時間：
?
注：cal.setTime(d); 把Date轉(zhuǎn)化成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轉(zhuǎn)化成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通過引用也可以進(jìn)行時間的格式化，但比較繁瑣，而SimpleDateFormat類是專門幫我們格式化時間的工具類，它在java.text包中。
【時間格式】：yyyy-MM-dd HH:mm:ss
SimpleDateFormat類有兩大常用方法：
【1】format(Date)：
?
format(Date) 幫我們把時間轉(zhuǎn)成字符串，字符串的格式為SimpleDateFormat類定義對象時設(shè)置的時間格式
?
【參考代碼】
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 不美觀
// 設(shè)置格式化時間的模式，我們常用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) 幫我們把字符串轉(zhuǎn)化成時間
?
【參考代碼】
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); // 把字符串轉(zhuǎn)成時間
System.out.println(d);
/*
請輸入一個時間(yyyy-MM-dd HH:mm:ss)：
2021-08-12 12:25:21
Thu Aug 12 12:25:21 CST 2021
*/
}
}
?
注：由于用戶輸入的字符串不一定是我們要求的格式，可能是任何東西，想把它們轉(zhuǎn)成時間是不可能的，你不可能把一個人轉(zhuǎn)成時間 對吧，因此存在著很大的風(fēng)險未處理(異常: java.text.ParseException)，為此我們需要處理異常。
?
4.計算時間差
計算思路：
格式化時間 先將字符串轉(zhuǎn)化成long類型時間 計算毫秒級別時間差，取絕對值 毫秒級別時間差轉(zhuǎn)成秒級別 秒級別時間差轉(zhuǎn)成分鐘級別 分鐘級別時間差轉(zhuǎn)化顯示成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"; // 結(jié)束時間
//格式化時間
SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
//將字符串轉(zhuǎn)成時間形式
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("您學(xué)習(xí)的時長為："+displayHours+"小時"+displayMin+"分鐘");
}
}
String類
字符串類常用方法
「方法匯總：」
?
「注：字符串是一個不可變的類型（final類），幾乎所有的字符串操作都會返回一個新字符串而不是在原有基礎(chǔ)上進(jìn)行修改。」
?
【示例代碼】
public class Test {
public static void main(String[] args) {
String s = "我的名字叫李華";
s.concat("hhh"); // 在字符串s上拼接，拼接hhh
System.out.println(s);// 我的名字叫李華
//字符串是不可變的數(shù)據(jù)類型
//幾乎所有的字符串操作都會返回一個新字符串
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);// 我的名字叫李華
//字符串是不可變的數(shù)據(jù)類型
//幾乎所有的字符串操作都會返回一個新字符串
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為結(jié)尾
System.out.println("邀請李華來參加英語沙龍活動".startsWith("李華"));//false 判斷是否以xxx開頭
// equals字符串內(nèi)容是否相同
// 接受邀請參加活動的李華到現(xiàn)場后要輸入驗證碼
// String yanZhengMa = "AAkm";
//
// Scanner sc = new Scanner(System.in);
//
// System.out.println("請輸入驗證碼("+yanZhengMa+")");
//
// String userInput = sc.nextLine();
//
// if(yanZhengMa.equalsIgnoreCase("aakm")){ // 忽略大小寫判斷兩邊的內(nèi)容是否一樣
// System.out.println("歡迎參加英語沙龍活動！");
// }else{
// System.out.println("您未受到邀請，請現(xiàn)場報名！");
// }
// String str = "李華玩得很開心！";
// System.out.println(str.indexOf("開心"));// 5 計算給出字符串第一個出現(xiàn)的位置
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)); // 基本數(shù)據(jù)類型轉(zhuǎn)為字符串
System.out.println(i+""); // 野路子
}
}
String Builder和StringBuffer
「String類的缺點：」
String 是一個不可變的數(shù)據(jù)類型，每每拼接都會產(chǎn)生一個新的字符串，那么內(nèi)存遲早會被這些拼接的字符串塞滿。
「String類和StringBuilder和StringBuffer類的區(qū)別：」
StringBuilder和StringBuffer：「可變的字符串，不產(chǎn)生新對象，比較省內(nèi)存」 ，當(dāng)進(jìn)行大量的字符串拼接時建議使用StringBuffer和StringBuilder，但它們兩個一些方法的實現(xiàn)幾乎跟String一樣。
「StringBuffer和StringBuilder類：」
【相似點】
兩者用法一模一樣，可以認(rèn)為是一個類
【區(qū)別】
StringBuffer線程安全，StringBuilder非線程安全。 StringBuilder相比于StringBuffer有速度優(yōu)勢，「多數(shù)情況下建議使用StringBuilder類，但當(dāng)被要求線程安全時必須使用StringBuilder類」
?
字符串拼接方法：append()方法
StringBuffer和StringBuilder 轉(zhuǎn)成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轉(zhuǎn)化成String
String s = sb2.toString();
System.out.println(s); //貓哈哈哈喜歡吃魚，狗也喜歡吃魚
// 上述操作都可以將StringBuilder換成StringBuffer，結(jié)果一樣
}
}
DecimalFormat
DecimalFormat：對小數(shù)進(jìn)行格式化，保留幾位小數(shù)。與格式化時間聯(lián)想記。
?
. 表示小數(shù)點
0和# 表示數(shù)位，保留幾位就幾個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
// . 表示小數(shù)點
// 0和#表示數(shù)字
// 保留兩位小數(shù) 格式
DecimalFormat df = new DecimalFormat(".00"); // 或者.##
String s = df.format(d); // 把 d 轉(zhuǎn)成上面設(shè)置的格式
System.out.println(s);//3.33
}
}
總結(jié)
萬變不離其宗，Java 的其他類和功能，都離不開這些基礎(chǔ)。牢記基礎(chǔ)，成長的更穩(wěn)！
胖虎聯(lián)合一線大廠朋友花費(fèi)8個月的時間，錄制了一份Java入門+進(jìn)階視頻教程
課程特色：
總共88G，時常高達(dá)365小時，覆蓋所有主流技術(shù)棧
均為同一人錄制，不是東拼西湊的
對標(biāo)線下T0級別的培訓(xùn)課，講師大廠架構(gòu)師，多年授課經(jīng)驗，通俗易懂
內(nèi)容豐富，每一個技術(shù)點除了視頻，還有課堂源碼、筆記、PPT、圖解
五大實戰(zhàn)項目（視頻+源碼+筆記+SQL+軟件）
一次付費(fèi)，持續(xù)更新，永無二次費(fèi)用
點擊下方超鏈接查看詳情
（或者點擊文末閱讀原文）：
