Java常用類
Common Class 常用類
1、內部類
Inner Class：內部類
一個類的內部再定義一個完整的類；
class waibulei{
class neibulei{
}
}
為什么要定義內部類？
- 例如身體和手，手是身體的一部分；
內部類也會生成class文件：外部類名&內部類名.class
特點：
- 編譯之后可生成獨立的字節碼文件（class文件）
- 內部類可直接訪問外部類的私有成員，而不破壞封裝；
- 可為外部類提供必要的內部功能組件；
1.1、成員內部類
- 在類的內部定義，與實例變量、實例方法同級別的類
- 外部類的一個實例部分，創建內部類對象時，必須依賴外部類對象；
- 當外部類、內部類存在重名屬性時，會優先訪問內部類屬性；
- 成員內部類不能定義靜態成員，可以包含靜態常量final；
//外部類
public class class01 {
private String name = "tom";
private int age = 20;
//內部類
class Inner{
private String name = "jeck";
private String address = "西天";
private String phone = "1234567890";
//方法
public void show(){
System.out.println(class01.this.name);
System.out.println(age);
System.out.println(name);
System.out.println(address);
System.out.println(phone);
}
}
}
public class Test01 {
public static void main(String[] args) {
//1、創建外部類對象
class01 class01 = new class01();
//2、創建內部類對象
com.feng.InnerClass.class01.Inner inner = class01.new Inner();
//以上兩步可一步到位
com.feng.InnerClass.class01.Inner inner1 = new class01().new Inner();
inner.show();
inner1.show();
}
}
1.2、靜態內部類 (static)
- 不依賴外部類對象，可直接創建或通過類名訪問，可聲明靜態成員；（不需要先創建外部類）
- 可包含靜態成員；（相當於一個外部類）
- 只能直接訪問外部類的靜態成員（實例成員需實例化外部類對象）
- 只有內部類才能用static修飾，外部類不行；
public class class02 {
private String name = "tom";
private int age = 20;
//靜態內部類，和外部類相同
static class Inner{
private String address = "上海";
private String phone = "123456";
//靜態成員
private static int count = 1000;
public void show(){
//調用外部類的屬性,不能直接調用外部類屬性；
//1、先創建外部類對象
class02 class02 = new class02();
//2、調用外部類的屬性
System.out.println(class02.name);
System.out.println(class02.age);
//調用靜態內部類的屬性和方法
System.out.println(address);
System.out.println(phone);
//調用靜態內部類的靜態屬性
System.out.println(Inner.count);
}
}
}
public class Test02 {
public static void main(String[] args) {
//直接創建靜態內部類對象
class02.Inner inner = new class02.Inner();
//調用方法
inner.show();
}
}
1.3、局部內部類
把一個類定義在方法的內部，這個類就叫內部類
- 定義在外部類方法中，作用范圍和創建對象范圍僅限於當前方法；
- 局部內部類訪問外部類當前方法中的局部變量時，因為無法保障變量的生命周期與自身相同，變量必須修飾為final；
- 限制類的使用范圍；
- 不能定義靜態變量；
public class class03 {
private String name = "tom";
private int age = 20;
//如果show()方法變成static，訪問外部類的屬性要用class03.屬性名；
public void show(){
//定義局部變量
String address = "北京";
//局部內部類：注意不能加任何訪問修飾符
class Inner{
private String phone = "123456";
private String email = "1hjfui9034";
public void show2(){
//訪問外部的屬性
System.out.println(name);
System.out.println(age);
//訪問局部類變量，jdk1.7之前要加final，jdk1.8之后他默認一個final在前面
System.out.println(address);
System.out.println(phone);
System.out.println(email);
}
}
//創建局部內部類對象
Inner inner = new Inner();
inner.show2();
}
}
public class Test03 {
public static void main(String[] args) {
//要在show方法里創建局部內部類對象，不然沒有返回任何結果，因為show()只是創建了一個值而已；
class03 class03 = new class03();
class03.show();
}
}
1.4、匿名內部類
沒有名字的內部類
- 沒有類名的局部內部類（一切特征都與局部內部類相同）
- 必須繼承一個父類或者實現一個接口；
- 定義類、實現類、創建對象的語法合並，只能創建一個該類的對象；
優點：減少代碼量
缺點：可讀性較差
public interface Usb {
void service();//前面默認了一個public
}
public class Mouse implements Usb {
@Override
public void service() {
System.out.println("連接電腦成功，鼠標開啟工作......");
}
}
public class TestUsb {
public static void main(String[] args) {
//創建接口類型的變量
// Usb usb = new Mouse();
// usb.service();
//局部內部類
// class Fan implements Usb{
// @Override
// public void service() {
// System.out.println("連接電腦成功，鼠標開啟工作......");
// }
// }
// //使用局部內部類創建對象
// Usb usb1 = new Fan();
// usb1.service();
//使用匿名內部類優化(像上面這個類，只用了一次，感覺很浪費，所以有了這個)
Usb usb2 = new Usb() {
@Override
public void service() {
System.out.println("連接電腦成功，鼠標開啟工作......");
}
};
usb2.service();
}
}
2、Object類
所以類的父類，我們寫的所有類，在特殊情況下都是默認繼承了object類
- 超類、基類，所有類的直接或間接父類，位於繼承樹的最頂層；
- 任何類，如沒有書寫extends顯示繼承某個類，都默認直接繼承object類，否則為間接繼承；
- object類中所定義的方法，是所有對象都具備的方法；
- object類型可以存儲任何對象
- 作為參考，可接受任何對象
- 作為返回值，可返回任何對象
3、Object類常用方法
1、getClass()方法
public final Class<> getClass(){}
//返回引用中存儲的實際對象類型
//應用：通常用於判斷兩個引用中實際存儲對象類型是否一致
2、hashCode()方法
public int hashCode(){}
//返回該對象的哈希碼值
//哈希值根據對象的地址或字符串或數字使用hash算法計算出來的int類型的數值
//一般情況下相同對象返回相同哈希碼
3、toString()方法
public String toString(){}
//返回該對象的字符串表示（表示形式）
//可以根據程序需求覆蓋該方法，如：展示對象各個屬性值
4、equals()方法
public Boolean equals(Object obj){}
//默認實現為（this == obj），比較兩個對象地址是否相同
//可進行覆蓋，比較兩個對象的內容是否相同
//比較兩個引用是否指向同一個對象
//判斷obj是否為null
//判斷兩個引用指向的實際對象類型是否一致
//強制類型轉換
//依次比較各個屬性值是否相同
5、finalize()方法
//當對象被判定為垃圾對象時，由JVM自動調用此方法，用以標記垃圾對象，進入回收隊列；
//垃圾對象：沒有有效引用指向此對象時，為垃圾對象；
//垃圾回收：有GC銷毀垃圾對象，釋放數據存儲空間；
//自動回收機制：JVM的內存耗盡，一次性回收所有垃圾對象；
//手動回收機制：使用System.gc()；通知JVM執行垃圾回收；
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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;
}
//重寫toString方法
public String toString() {
return name+":"+age;
}
//將equals進行覆蓋，比較兩個對象的內容是否相同
@Override //Override：覆蓋
public boolean equals(Object obj){
//判斷兩個對象是否是同一個引用
if (this == obj){
return true;
}
//判斷obj是否為null
if (this == null){
return false;
}
//判斷對象類型是否一致
// if (this.getClass() == obj.getClass()){
// return true;
// }
//instanceof：判斷對象是否是某種類型
if (obj instanceof Student){
//強制類型轉換
Student s = (Student) obj;
//依次比較各個屬性值是否相同
if (this.name.equals(s.getName()) && this.age == s.getAge()){
return true;
}
}
return false;
}
@Override
protected void finalize() throws Throwable {
System.out.println(this.name+"對象被回收了！");
}
}
public class TestStudent {
public static void main(String[] args) {
Student student1 = new Student("aa",19);
Student student2 = new Student("bb",20);
//1、getClass()方法；判斷student1和student2是不是同一個類型；使用getClass()方法
Class class1 = student1.getClass();
Class class2 = student2.getClass();
if (class1 == class2){
System.out.println("是同一個類型");
}else{
System.out.println("not是同一個類型");
}
//2、hashCode方法
System.out.println(student1.hashCode());
System.out.println(student2.hashCode());
Student student3 = student1;
System.out.println(student3.hashCode());
//3、toString()方法；
// 返回的數值是十進制的；這些數字對我們沒有用，
// 所以我們需要重寫tostring方法來讓他輸出的是姓名年齡
//按住Ctrl點擊toString方法進入查看，然后在我們的類中重寫
//或者直接在類中Alt+ins重寫toString方法
System.out.println(student1.toString());
System.out.println(student2.toString());
//equals()方法，判斷兩個值是否相同
System.out.println(student1.equals(student2));
Student s1 = new Student("cc",22);
Student s2 = new Student("cc",22);
System.out.println(s1.equals(s2));
}
}
public class TestStudent2 {
public static void main(String[] args) {
// Student student1= new Student("aaa",20);
// Student student2 = new Student("bbb",20);
// Student student3 = new Student("ccc",20);
// Student student4 = new Student("ddd",20);
// Student student5 = new Student("eee",20);
new Student("aaa",20);
new Student("bbb",20);
new Student("ccc",20);
new Student("ddd",20);
new Student("eee",20);
System.gc();
System.out.println("垃圾回收");
}
}
4、包裝類
packing：包裝
八大基本類型，每個類型都對應一個包裝類（byte、short、int、long、float、double、char、Boolean）
- 基本數據類型所對應的引用數據類型；
- Object可統一所有數據，包裝類的默認值是null；
裝箱和拆箱
public class Demo01 {
public static void main(String[] args) {
//轉換類型：裝箱，基本類型轉換成引用類型的過程
//基本類型
int num1 = 20;
//使用Integer類創建對象
Integer integer1 = new Integer(num1);
//valueOf() 方法用於返回給定參數的原生 Number 對象值，參數可以是原生數據類 型, String等。
//該方法是靜態方法。該方法可以接收兩個參數一個是字符串，一個是基數。
Integer integer2 = Integer.valueOf(num1);
System.out.println("裝箱");
System.out.println(integer1);
System.out.println(integer2);
//類型轉換：拆箱，引用類型轉換成基本類型
Integer integer3 = new Integer(1000);
//intValue:此方法的意思是：輸出int數據。
int num2 = integer3.intValue();
System.out.println("拆箱");
System.out.println(num2);
//以上是jdk1.5之前的方法
//jdk1.5之后，提供自動裝箱和拆箱
int age = 20;
//自動裝箱
Integer integer4 = age;
System.out.println("自動裝箱");
System.out.println(integer4);
//自動拆箱
int age2 = integer4;
System.out.println("自動拆箱");
System.out.println(age2);
System.out.println("====================================");
//基本類型和字符串之間轉換
//基本類型轉換成字符串
int n1 = 15;
//1.1使用+號
String s1 = n1 + "";
//1.2使用Integer中的toString()方法
String s2 = Integer.toString(n1,16);//16是表示十六進制
System.out.println(s1);
System.out.println(s2);
//字符串轉換成基本類型
String str = "200";
//使用Integer.parseXXX()方法
int n2 = Integer.parseInt(str);
System.out.println(n2);
//Boolean字符串形式轉換成基本類型，“true”----》true “true”---》false
String str2 = "false";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);
}
}
整數緩沖區
- java預先創建了256個常用的整數包裝類型對象；
- 在實際應用當中，對已創建的對象進行服用；
public class Demo02 {
public static void main(String[] args) {
//面試題
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
//結果是false；integer1和2是放在棧空間中的，而100是放在堆空間中的，
// 他比較的是棧中值，因為棧中1和2的地址不同（兩個地址），所以1 ！= 2；
System.out.println(integer1 == integer2);
Integer integer3 = 100;//自動裝箱：integer.valueOf()
Integer integer4 = 100;
System.out.println(integer3 == integer4);//true
Integer integer5 = 200;//自動裝箱：integer.valueOf()大於等於127就裝箱為new Integer()類型
Integer integer6 = 200;
System.out.println(integer5 == integer6);//false
}
}
5、String類
平時使用最高的類
創建字符串方法
//字符串是常量，創建之后不可以改變
//字符串字面值存儲在字符串池中，可以共享
String s = "hello";//產生一個對象，字符串池中存儲
String s = new String("hello");//產生兩個對象，堆、池各存儲一個
public class Demo01 {
public static void main(String[] args) {
String name = "hello";//hello常量存儲在字符池中
name = "zhangsan";//zhangsan賦值給name變量，給字符串賦值時，並沒有修改數據，而是重新開劈一個空間（不可變性）
String name2 = "zhangsan";//在字符串池中尋找有沒有zhangsan這個值，有的話，直接賦給name2，這時name和name2棧空間地址相同（字符串共享）
//字符串的另一種創建方式
String str = new String("java");
String str2 = new String("java");
System.out.println(str == str2);//false
System.out.println(str.equals(str2));//true
}
}
String常用方法
public class Demo01 {
public static void main(String[] args) {
String name = "hello";//hello常量存儲在字符池中
name = "zhangsan";//zhangsan賦值給name變量，給字符串賦值時，並沒有修改數據，而是重新開劈一個空間（不可變性）
String name2 = "zhangsan";//在字符串池中尋找有沒有zhangsan這個值，有的話，直接賦給name2，這時name和name2棧空間地址相同（字符串共享）
//字符串的另一種創建方式
String str = new String("java");
String str2 = new String("java");
System.out.println(str == str2);//false
System.out.println(str.equals(str2));//true
System.out.println("=============================");
//字符串方法的使用
//1、length();返回字符串的長度
//2、charAt(int index);返回某個位置的字段
//3、contains(String str);判斷是否包含某個字符串
String content = "java是世界上最好的編程語言java";
System.out.println(content.length());
System.out.println(content.charAt(content.length()-1));
System.out.println(content.contains("java"));
System.out.println(content.contains("php"));
System.out.println("=============================");
//4、toCharArray();返回字符串對應的數組
//5、indexOf();返回字符串首次出現的位置
//6、lastIndexOf();返回字符串最后一次出現的位置
System.out.println(content.toCharArray());
System.out.println(Arrays.toString(content.toCharArray()));//數組編程字符串
System.out.println(content.indexOf("語言"));
System.out.println(content.indexOf("java",14));//從下標14開始找
System.out.println(content.lastIndexOf("java"));
System.out.println("=========================");
//7、trim();去掉字符串前后的空格
//8、toUpperCase();把小寫轉換成大小;toLowerCase();把大寫轉換成小寫
//9、endWith(str);判斷是否已str結尾，starWith(str);判斷是否已str開頭
String content2 = " Hello World ";
String content3 = "Hello World";
System.out.println(content2);
System.out.println(content2.trim());
System.out.println(content2.toUpperCase());
System.out.println(content2.toLowerCase());
System.out.println(content3.endsWith("World"));
System.out.println(content3.startsWith("Hello"));
System.out.println("=================================");
//10、replace(char old,char new);用新的字符或字符串替換舊的字符或字符串
//11、split();對字符串進行拆分
System.out.println(content.replace("java","php"));
System.out.println(content.replace("java","easy java"));//在java面前插入一個easy
String say = "java is teh best programing language,java";
// String[] arr = say.split(" ");//表示遇到空格進行拆分
//String[] arr = say.split("[ ,]");//表示空格和逗號
String[] arr = say.split("[ ,]+");//表示空格和逗號可以出現多個
System.out.println(arr.length);
for (String string : arr){
System.out.println(string);
}
//補充兩個方法equals、compareTo();比較大小
System.out.println("=======================");
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equalsIgnoreCase(s2));//equalsIgnoreCase：忽略大小寫比較大小
String s3 = "abc";//a:97
String s4 = "xyz";//x:120
System.out.println(s3.compareTo(s4));//-23
String s5 = "abc";//abc:3個
String s6 = "abcxyz";//abcxyz：6個
System.out.println(s5.compareTo(s6));//-3
}
}
public class Demo02 {
public static void main(String[] args) {
String str = "this is a text";
//將str中的單詞單獨獲取出來
String[] arr = str.split(" ");
for (String s : arr){
System.out.println(s);
}
//將str中間的text替換成java；replace：代替
System.out.println("==========================");
String str2 = str.replace("text","java");
System.out.println(str2);
//在text前面插入easy
System.out.println("=========================");
String str3 = str.replace("text","easy text");
System.out.println(str3);
//將每個單詞的首字母改為大寫
System.out.println("==========================");
for (int i = 0; i < arr.length; i++) {
char first = arr[i].charAt(0);
//把第一個字符轉換成大寫
char upperfirst = Character.toUpperCase(first);
String news = upperfirst + arr[i].substring(1);
System.out.print(news+" ");
}
}
}
StringBuffer和StringBuilder
public class Demo03 {
public static void main(String[] args) {
//StringBuffer和StringBuilder的使用，
//和String的區別（1）效率比String高（2）比String節省內存
//StringBuild功能和StringBuffer一樣，將下面這個StringBuffer換成StringBuild就行
StringBuffer sb = new StringBuffer();
//1、append();追加
sb.append("java是最好的編程語言");
System.out.println(sb.toString());
sb.append("java真好");
System.out.println(sb.toString());
sb.append("hello world");
System.out.println(sb.toString());
System.out.println("============================");
//2、inset();添加
sb.insert(0,"aaa");
System.out.println(sb.toString());
System.out.println("============================");
//3、replace();替換
sb.replace(0,5,"javascript");
System.out.println(sb.toString());
System.out.println("============================");
//4、delete();刪除
sb.delete(0,5);
System.out.println(sb.toString());
System.out.println("============================");
//5、清空
sb.delete(0,sb.length());
System.out.println(sb.toString());
}
}
public class Demo04 {
public static void main(String[] args) {
//驗證StringBuilder效率高於String
//開始時間
long start = System.currentTimeMillis();
//String
// String string = "";
// for (int i = 0; i < 99999; i++) { //用時：46881
// string += i;
// }
// System.out.println(string);
//StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 99999; i++) { //用時：100
sb.append(i);
}
System.out.println(sb.toString());
long end = System.currentTimeMillis();
System.out.println("用時："+(end-start));
}
}
6、BigDecimal類
需求精度比較高是使用的類
public class Demo01 {
public static void main(String[] args) {
double b1 = 1.0;
double b2 = 0.9;
System.out.println(b1-b2);
System.out.println("=======================");
//面試題
double result = (1.4-0.5)/0.9;
System.out.println(result);
System.out.println("======================");
// BigDecimal，大的浮點數精確計算
BigDecimal db1 = new BigDecimal("1.0");
BigDecimal db2 = new BigDecimal("0.9");
//減法
BigDecimal r1 = db1.subtract(db2);
System.out.println(r1);
//加法
BigDecimal r2 = db1.add(db2);
System.out.println(r2);
//乘法
BigDecimal r3 = db1.multiply(db2);
System.out.println(r3);
//除法
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));
System.out.println(r4);
System.out.println("========================");
//當數除不盡時可能會報錯
// BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal(3));
// System.out.println(r5);
BigDecimal r5 = new BigDecimal("10")
.divide(new BigDecimal(3),2,BigDecimal.ROUND_HALF_UP);//保留2位小數，ROUND_HALF_UP四舍五入
System.out.println(r5);
}
}
補充類
Data類
public class Demo01 {
public static void main(String[] args) {
//創建date對象
//今天
Date date1 = new Date();
System.out.println(date1.toString());
System.out.println(date1.toLocaleString());
System.out.println("=======================");
//昨天
Date date2 = new Date(date1.getTime()-(60*60*24*1000));
System.out.println(date2.toLocaleString());
//方法after before
boolean b1 = date1.after(date2);
System.out.println(b1);
boolean b2 = date1.before(date2);
System.out.println(b2);
System.out.println("===========================");
//比較compareTo();
int d = date2.compareTo(date1);
System.out.println(d);
//比較是否相等equals
boolean b3 = date1.equals(date2);
System.out.println(b3);
}
}
Calendar類
public class Demo02 {
public static void main(String[] args) {
//創建Calendar對象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());
System.out.println(calendar.getTimeInMillis());
System.out.println("===============================");
//獲取時間信息
//獲取年
int year = calendar.get(Calendar.YEAR);
//月
int month = calendar.get(Calendar.MONTH);//MONTH是0~11,0代表1月
//日
int day = calendar.get(Calendar.DAY_OF_MONTH);//Date
//小時
int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR是12小時的；HOUR_OF_DAY是24小時的
//分
int minute = calendar.get(Calendar.MINUTE);
//秒
int second = calendar.get(Calendar.SECOND);
System.out.println(year+"年"+(month+1)+"月"+day+"日"+"\n"+hour+":"+minute+":"+second);
System.out.println("=====================");
//修改時間
Calendar calendar2 = calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH,5);
System.out.println(calendar2.getTime().toLocaleString());
//add方法修改時間
calendar2.add(Calendar.HOUR,1);//加一個小時，減少時間就-
System.out.println(calendar2.getTime().toLocaleString());
System.out.println("====================================");
//補充方法
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max);
System.out.println(min);
}
}
SimpleDateFormat類
public class Demo03 {
public static void main(String[] args) throws Exception {
//創建SimpleDateFormat對象 y年M月
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
//創建Date
Date date = new Date();
//格式化date（把日期轉成字符串）
String str = simpleDateFormat.format(date);
System.out.println(str);
System.out.println("=============================");
//解析（把字符串轉成日期）
Date date2 = simpleDateFormat.parse("1949/10/01 10:01:00");//這里要按照simpleDateFormat那里的格式
System.out.println(date2);
}
}
System類
public class Demo04 {
public static void main(String[] args) {
//1、arraycopy：數組的復制
//src：源數組
//srcPos：從那個位置開始復制0
//dest：目標數組
//destPos：目標數組的位置
//length：復制的長度
int[] arr = {20,18,4,9,39,64,100,98};
int[] dest = new int[8];
System.arraycopy(arr,4,dest,0,4); //length的值只能小於等於srcPos的值；destPos從哪個位置開始存數據
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
//Arrays.copyOf(original,newLength);
System.out.println("===========================");
//currentTimeMillis：可以計算程序運行的時間
System.out.println(System.currentTimeMillis());
//2、獲取毫秒數
Long start = System.currentTimeMillis();
for (int i = 0; i < 999999; i++) {
for (int j=0;j<99999;j++){
int re = i+j;
}
}
Long end = System.currentTimeMillis();
System.out.println("用時："+(start-end));
System.out.println("=========================");
//類正在被使用，不回收
// Demo05 s1 = new Demo05("aaa",20);
// Demo05 s2 = new Demo05("bbb",20);
// Demo05 s3 = new Demo05("ccc",20);
//類沒使用，被回收了
new Demo05("aaa",20);
new Demo05("bbb",20);
new Demo05("ccc",20);
//3、System.gc();告訴垃圾回收
System.gc();
System.out.println("===========================");
//4、推出JVM
System.exit(0);
//下面就不會被執行了
System.out.println("程序結束了......");
}
}