zzz‘sJava知識點概括總結

類型轉化

字符串：c語言：char? Java：string

表達式值的類型由最高類型決定：

取值范圍：byte<short<int<long<float<double（且運算時byte和short都是轉化為int類型進行計算防止數據溢出）

強制轉換數據類型：大范圍的賦值給小范圍（但可能會導致數據丟失溢出，如浮點型轉為整型會直接丟掉小數，保留整數）

運算符：

邏輯運算符：

&&（短路與）從左邊開始運行，如果左邊false，則右邊不運行

||（短路或）從左邊開始運行，如果左邊true，則右邊不運行

&&優先級高于||

&或者|左右都要執行

算術運算符：

當字符+字符或者字符+數字時會先把字符通過ASCII碼表查詢到對應的數字再進行計算

賦值運算符：底層下都隱藏了一個強制類型轉換

三元運算符：

條件表達式b?x:y;，先計算條件b，然后進行判斷。如果b的值為true，計算x的值，運算結果為x的值；否則，計算y的值，運算結果為y的值。

拓展：

case穿透：語句體中未寫break導致

流程跳轉語句：

break：在switch中結束case條件判斷，在循環體中結束循環

continue：作用在循環體中，結束循環體的本次循環，從而進入下次循環

多個數組變量對應同一個地址：

數組1的地址被賦給數組2，則兩數組的地址是相同的

代碼塊：

局部代碼塊：節省內存空間

構造代碼塊：寫在成員位置，可以把多個構造方法中重復的代碼抽取出來。創建本類對象的時候會先執行構造代碼塊再執行構造代碼。

靜態代碼塊：隨著類的加載而加載，并且只執行一次。

數組：

地址值：

D：表示當前數組內元素是double類型的

索引

=>下標，從0開始

最大索引：數組長度-1

把數據存儲到數組中，一旦覆蓋之后，原來的數據就不存在了

數組的遍歷：

是取出數據的過程，遍歷≠打印

數組的長度屬性：

數組名.length

數據類型的默認初始值：

1.整數類型：0? ? ? ? ?2.小數類型：0.0

3.字符類型：空格? ? 4.布爾類型：false

5.引用數據類型：null

動/靜態初始化：

動態初始化：明確元素個數

靜態初始化：明確具體元素內容

隨機數讀入：

打亂數組：

二維數組：

二維數組的length屬性：

public class ArrayTest4 {public static void main(String[] args) {int[][] a ={{1,2,3},{10,20,30,40,50},{6,7,8,9},{0}};System.out.println(a.length);//指二維數組中有幾個大括號//輸出4System.out.println(a[0].length);//指{1,2,3}的長度//輸出3}
}

二維數組的元素訪問：

a[二維數組中的一維數組的下標][一維數組的小標]

a[0][0]:表示第一個一維數組中的一個一維元素。

遍歷：

public class ArrayTest5 {public static void main(String[] args) {String[][] array = {{"java","oracle","c++","python","c#"},{"張三","李四","王五"},{"lucy","jack","rose"}};for (int i = 0; i < array.length; i++){for (int j = 0 ; j < array[i].length ; j++){System.out.print(array[i][j] + " ");}System.out.println("");}}
}

方法：

類似于c語言的函數

注意：Java中沒有指針，但是改變數組數據時是對地址中數據改變（類似于指針操作，但僅限于數組中）稱之為引用傳遞。

方法重載：

數組遍歷：

方法的內存分配：

數據類型：

基本數據類型：變量里面存儲的是真實數據

引用數據類型：例如數組，new出來的類型

? ? ? ? ? ? ? ? ? ? ? ? ?變量里面存儲的是地址值

? ? ? ? ? ? ? ? ? ? ? ? ?引用：使用了其他空間的數據。

方法的值傳遞：

方法引用：

靜態方法內不存在this和super

示例：
把字符串改為大寫：
方法1.內部類

方法2.方法引用：

引用數組的構造方法就是為了構建一個數組。

泛型當中不能寫基本數據類型。

數組的類型需要跟流中的數據類型保持一致，也就是說一開始是什么類型的容器去儲存數組后面也要是什么類型的容器。

面向對象：

類似于c語言的結構體，但具有儲存方法，可以直接調用方法

初始化：

public class 類名{1.變量，用來說明對象可以處理什么數據2.方法，描述對象有什么功能，可以對數據進行什么樣的處理。...
}

關鍵字：
private關鍵字：權限修飾符

被private修飾后需要在本類中進行編寫set和get類型函數，才能在其他類中進行輸入輸出內容

set方法：給成員變量賦值

get方法：對外提供成員變量的值

this關鍵字：

作用：區別局部變量和成員變量

本質：所在方法調用者的地址值

就近原則

static關鍵字：

靜態方法不能調用非靜態

非靜態可以訪問所有

final關鍵字：
最終的，不能被改變

final定義的父方法不能被子類重寫。

final定義的變量叫常量，常量只能被賦值一次。

常量記錄的數據不能發生改變。

字符串不可變。

權限修飾符：

變量：

局部變量：定義在方法里面

成員變量：類中的變量

JavaBean類：

對象內存圖：

String函數：

快捷函數

類如：

比較字符：

String str = "smart";String str1 = "scarf";System.out.println(str.equals(str1));System.out.println(str.equalsIgnoreCase(str1));

相同返回true，不同返回false

截取字符串：

 String s3 = "java is the best";String rs=s3.substring(0,8);System.out.println(rs);

上述例子中0，8表示從開頭開始截取八位字符（一個空格占兩個字符空間）

克隆：
分為淺克隆和深克隆

淺克隆：拷貝出的新對象，與原對象中的數據一模一樣（引用類型拷貝的是地址）

深克隆：

StringBuilder：

使用場景：1.字符串的拼接，2.字符串的反轉。

示例：

容量：能存儲的

長度：實際存儲的

StringJoiner：

不用，那個位置就不寫

例如，只需間隔符號：（---）；那么每個字符間就會多一個---間隔

只需間隔和開始：（---，[）；

注意：添加只能添加字符串，不能添加整數。

字符串原理：

API：

Math類常用方法：

正則表達式：

System工具類：

存在時間差：我們國家時間原點為：00：08：00

Runtime：

表示當前虛擬機的運行環境

Object和Objects：

object：Java中的頂級父類，所有的類都直接或者間接的繼承它

object中的成員方法：

toString方法返回的是地址值

objects成員方法：

BigInteger：

大的整數

整數四種類型：byte(1個字節)，short(2個字節)，int(4個字節)，long(8個字節)。

二進制第一位是符號位：0表示正數，1表示負數。

字符串中必須是整數，否則會報錯。

字符串中數字必須跟進制吻合。

valueOf方法的能表示范圍比較小，只能在long的取值范圍內。在內部對-16—16進行了優化，提前把-16—16先創建好BigInteger的對象，如果多次獲取不會重新創建新的對象。

成員方法：

BigDecimal：

大的小數。

用于小數的精確計算，也可以用來表示很大的小數。

鏈式編程：

在調用一個方法的時候，不需要用變量去接受它的結果，可以繼續調用其他方法。

集合的使用Arraylist：

示例：

導入數據：

插入數據：

根據索引獲取某個地方的值：

獲取集合的大小，內含數據的個數：

根據索引刪除某個位置的元素值：

直接刪除某個元素值，成功返回true，反之false

修改集合中某個位置的數據值：

Arraylist集合：

底層原理：

右移運算符：

雙列集合：Map

Map的遍歷方式：

1.鍵找值：

import java.util.*;
public class test {public static void main(String[] args) {Map<String,String>map=new HashMap<>();//第一個string是鍵的類型，第二個string是值的類型map.put("1","1");map.put("2","2");map.put("3","3");Set<String>keys=map.keySet();for(String key:keys){//key是鍵，value是值String value=map.get(key);System.out.println(key+"="+value);}}
}

2.鍵值對：
entry：鍵值對對象

entry：鍵值對對象

3.Lambda表達式：

import java.util.*;
import java.util.function.BiConsumer;
public class test {public static void main(String[] args) {Map<String,String>map=new HashMap<>();//第一個string是鍵的類型，第二個string是值的類型map.put("1","1");map.put("2","2");map.put("3","3");/* map.forEach(new BiConsumer<String,String>(){@Overridepublic void accept(String key,String value){System.out.println(key+"="+value);}});*///lambda表達式map.forEach((key,value)->System.out.println(key+"="+value));}
}

Hashmap：

特點：

LinkHashmap：

import java.util.*;
import java.util.function.BiConsumer;
public class test {public static void main(String[] args) {LinkedHashMap<String,Integer> lhm=new LinkedHashMap<>();lhm.put("java",100);//put方法有兩個功能，一個添加，一個覆蓋。lhm.put("python",90);lhm.put("c++",80);System.out.println(lhm);}
}

Treemap：

集合工具類Collections：

只能給單列集合進行批量添加元素。

獲取隨機數：

import java.util.*;
public class test {public static void main(String[] args) {ArrayList<Integer>list=new ArrayList<>();Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);Collections.shuffle(list);Random r=new Random();int index=r.nextInt(list.size());int number=list.get(index);System.out.println(number);}
}

不可變集合：

不可以被修改的集合（長度、內容不可變）

一旦創建完畢后，只能進行查詢操作。

參數不能相同

方法為ofEntries方法。

正則表達式：

作用：

校驗字符串是否滿足規則

在一段文本中查找滿足要求的內容

爬蟲：

分為本地爬蟲和網絡爬蟲

兩個特殊類：

包裝類：

把數據包裝成對象

（泛型不制裁基本類型數據，只能支持引用類型數據）

基本數據類型	對應的包裝類（引用數據類型）
byte	Byte
short	Short
int	Integer
long????????????????	Long
char	Character
float	Float
double????????	Double
boolean	Boolean

繼承：

爸爸：父類

兒子：子類

父類有的子類都具有，所以子類中只需創造它特有的就行，子類需要用的時候可以直接在父類里面調用。

繼承特點：Java只支持單繼承，不支持多繼承，但支持多層繼承。

單繼承：一個子類只能繼承一個父類，子類不能同時繼承多個父類。

多層繼承：子類A繼承父類B，父類B可以繼承父類C。AC關系為間接父類。AB為直接父類。

每一個類都直接或間接的繼承于Object。Object類Java虛擬機內本身就存在的。

書寫代碼：從父類開始寫

子類只能訪問父類中非私有的成員//私有：private

如果一個類中沒有構造方法，虛擬機會自動添加一個空參構造

繼承過程中：
成員變量訪問特點：就近原則，誰近用誰

虛方法表：非private，非static，非final。

方法重寫的本質：如果發生了重寫，則會覆蓋。

只有被添加到虛方法表中的方法才能被重寫。

不能被繼承，就不能被重寫。

繼承中構造方法的訪問特點：

繼承中運用的關鍵字this，super：

super中調用的是父類的成員變量。

this是調用的子類的成員變量。

多態：

同類型的對象表現出的不同形態

多態調用成員的特點：
調用時變量是父類的，方法是子類的

在Java中加載字節碼文件時永遠先加載父類，再加載子類。

包：

就是文件夾，用來管理各種不同功能的Java類，方便后期代碼維護。

包名+類名：全類名/全限定名

使用其他類的規則：使用其他類時，需要使用全類名。

抽象類和抽象方法：

注意事項、特點：

抽象類中不一定有抽象方法，有抽象方法的類一定是抽象類。
類該有的成員(成員變量、方法、構造器)抽象類都可以有。
抽象類最主要的特點:抽象類不能創建對象，僅作為一種特殊的父類，讓子類繼承并實現。
一個類繼承抽象類，必須重寫完抽象類的全部抽象方法，否則這個類也必須定義成抽象類。
抽象類不能創造對象
沒有方法體的方法是抽象方法，抽象方法所在的類必須是抽象類

接口：

一種規則，對行為的抽象

接口中成員的特點：

多個接口中同名且同參的方法，只需重寫一次。而同名不同參的視為兩個不同的方法，都需要重寫。

如果實現多個接口，需要重寫所有的抽象方法。

接口中default關鍵字定義默認方法，默認方法重寫時去掉default關鍵字。

static修飾靜態方法，private修飾私有方法。

重寫：子類把從父類繼承下來的虛方法表里面的方法覆蓋

類的五大成員：屬性，方法，構造方法，代碼塊，內部類。

內部類：

在一個類的里面，再次定義一個類。

如果外部類想要訪問內部類的成員，必須定義一個內部類成員對象。

成員內部類：

想要調用成員變量，只能通過對象去調用。

內部類里面外部類成員變量的調用。

示例：

靜態內部類：

靜態方法只能訪問靜態變量。

局部內部類：

匿名內部類：

時間表達：

同一個經線上的時間是一致的。

利用空參構造創建的對象，默認表示當前時間

利用有參構造創建的對象，表示指定時間。

對象不能直接進行計算。

JDK7：Date類：

JDK7：SimpleDateFormat類：

JDK7:Calender類：

JDK8：

List系列集合：

特點：

特有方法：

示例代碼：
?

import java.util.List;
import java.util.ArrayList;
public class test {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("aaa");list.add("bbb");list.add("ccc");System.out.println(list);//[aaa, bbb, ccc]list.add(1,"ddd");//1為想要插入的索引位置。//原來索引上的元素后移System.out.println(list);//[aaa, ddd, bbb, ccc]list.remove(1);System.out.println(list);//[aaa, bbb, ccc]}
}

list集合的五種遍歷方式：

迭代器遍歷：能刪除元素

增強for遍歷

Lambda表達式遍歷

普通for循環遍歷

列表迭代器遍歷：能添加元素（list集合系列獨有）

泛型類：

檢擦數據類型：

Integer類型不能強轉為String類型。

泛型的繼承和通配符：

泛型不具備繼承性，但數據具有繼承性。

泛型內寫什么類型，就只能傳遞什么類型的數據值。

泛型的通配符：？就是一個問號。

Set系列集合：

元素是唯一的。

HashSet：

哈希值：

如果沒有重寫hashcode方法和equals方法，那么哈希值是根據地址值計算的。

LinkedHashSet：

TreeSet底層為紅黑樹。

紅黑樹：兩個紅色節點不能相連。

可變參數：

細節：

1.在方法的形參中最多只能寫一個可變參數。

2.在方法中，如果除了可變參數之外還有其他的參數，可變參數就寫在最后。

public class test {public static void main(String[] args) {int sum=getSum(1,2,3,4,5,6,7,8,9,10);System.out.println(sum);}public static int getSum(int...arr){int sum=0;for(int i:arr){sum+=i;}return sum;}
}

Stream流：

import java.util.*;
import java.util.function.BiConsumer;
public class test {public static void main(String[] args) {ArrayList<String> list=new ArrayList<>();list.add("張婧儀");list.add("周雨彤");list.add("趙麗穎");list.add("張張");list.add("張凌赫");list.stream().filter(name->name.startsWith("張")).filter(name->name.length()==3).forEach(name->System.out.println(name));/*ArrayList<String> list1=new ArrayList<>();for(String name:list){if(name.startsWith("張")){list1.add(name);}}System.out.println(list1);ArrayList<String> list2=new ArrayList<>();for(String name:list1){if(name.length()==3){list2.add(name);}}System.out.println(list2);*/}
}

最長的那行代碼等于注釋掉的代碼。

HashMap不能保證存和取的順序的，只能保證內容不變。

異常：

File類：

常見構造方法：

成員方法：

length方法無法獲取文件夾的大小。內存之間的進制為1024.

IO流：

存儲和讀取數字的解決方案。

分類：

四大家族：字節輸入流??字節輸出流? 字符輸入流? 字符輸出流

純文本文件：用windows自帶筆記本打開能讀懂的文件

字節輸出流：FileOutputStream

import java.io.FileOutputStream;
import java.io.IOException;
public class test {public static void main(String[] args) throws IOException {FileOutputStream fos=new FileOutputStream("src\\a.txt");String str="abc";byte[] arr=str.getBytes();fos.write(arr);String str2="\r\n";//換行符byte[] byte1=str2.getBytes();fos.write(byte1);String str3="def";byte[] byte2=str3.getBytes();fos.write(byte2);fos.close();//釋放資源}
}

運行操作結果：

示例：

字節輸入流·：FileInputStream

循環讀取：

可以自行打印b，也可以強轉為char類型打印

如果b中存有字符a，自行打印就為97（ascll碼表對應數字），強轉就打印a。

文件拷貝：

字節流讀取中文會出現亂碼。

字符集：

計算機存儲英文，一個字節就足以。

漢字以兩個字節存儲。

在UTF—8的編碼規則下，英文占一個字節，中文3個字節（且第一個字節的首位是1）。

存在亂碼原因：讀取數據時未讀完整個漢字。

? ? ? ? ? ? ? ? ? ? ? ? ?編碼和解碼方法不統一。

Java中解碼和編碼的方法：

字符流：

字符輸入流FileReader:

idea默認是UTF—8

強轉為char類型就行。

字符輸出流FileWriter:

緩沖流：

拷貝文件操作：

將a.txt中的內容拷貝到b.txt中

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class test {public static void main(String[] args) throws IOException {BufferedInputStream bis=new BufferedInputStream (new FileInputStream("src\\a.txt"));BufferedOutputStream bos=new BufferedOutputStream (new FileOutputStream("src\\b.txt"));byte[] bytes=new byte[1024];int len;while((len=bis.read(bytes))!=-1){bos.write(bytes,0,len);}bos.close();bis.close();}
}

字節/字符緩沖流：