JKD8新特性
- 接口中可以定義有方法體的方法，如果是非靜態必須用dafault修飾，靜態就不用了
- 局部變量可以省去final
JKD7的新特性
- 二進制字面量
- 數字字面量下劃線
- 泛型簡化(菱形泛型)
- switch語句可以用字符串
- 異常的多個catch合併，每個用異常或｜
- try（）｛｝不用關流
JKD5的新特性
- 自動拆裝箱
- 可變參數
- 靜態導入
- 增強for循環
- 互斥鎖
- 泛型
- 枚舉
JAVA基礎
邏輯與，短路與，邏輯或，短路或
&&左邊爲false右邊不執行
｜｜左邊爲ture右邊不執行
& |都執行
char型變量中能不能存貯一箇中文漢字?
中文是Unicode,unicode編碼佔用兩個字節，所以，char類型的變量也是佔用2個字節
1個字節是8位
path,classpath
path配置的是exe
classpath配置的是class
如果classpath的值結尾處有分號，在具體路徑中沒有找到運行的類，會默認在當前目錄再找一次
熟悉Dos命令操作
cd進入，cd..退回，cd\退回根目錄，cls清屏，md創建，rd刪除目錄，dle刪除文件
java語言特點
開源，跨平臺，面向對象
有垃圾回收機制
標識符
就是給類，接口，方法，變量，起名字的字符序列，
由大小寫英文，數字$和_ 組成，不能使用關鍵字，數字不能開頭
關鍵字
java語言賦予特殊含義的單詞
保留：goto, const
常量
- 字面值常量：
整數常量
浮點數常量
字符常量
布爾常量
空常量 null
字符串常量
- 自定義常量：
用final修飾
進制
- JDK7新特性：
以0b開頭表示二進制
以0開頭表示八進制
以0x開頭表示十六進制
- 其他進制到十進制的轉換：
係數*基數的權次冪，結果相加。
- 十進制到其他進制的轉換：
除以基數，取餘數，結果反轉。
- 快速轉換：
二進制和十進制的相互轉換 -- 8421碼
二進制到八進制的簡易方式 -- 3位組合
二進制到十六進制的簡易方式 -- 4位組合
- 有符號數據的表示形式：原碼、反碼、補碼
正數：
原碼、反碼、補碼都一樣，最高位表示符號位。
byte範圍：-128 ~ 127
負數：
反碼是對其原碼逐位取反，但符號位除外。
補碼是在其反碼的末位加1。
- 理解強制類型轉換的結果是怎麼來的
注意是截取補碼。
變量
Int I = 10 ;//I 就是變量, 變量就是用來儲存數據的容器
數據類型
四類八種：
整數型
byte 1個字節(8位)
short 2個字節(16位)
int 4個字節(32位)
long 8個字節(64位)
浮點型
float 4個字節(32位)
double 8個字節(64位)
字符型
char 2個字節(16位) （一對單引號括起來的字符）
布爾型
boolean 1個字節
基本類型（四類八種）
整數byte--short--int--long 浮點float--double 字符char 布爾boolean
從小 到大byte--short--char--int--long--float--double
引用數據類型
數組，類，接口
掌握數據類型轉換中的隱式轉換和強制轉換
運算符
- 算術運算符:
+ , - , * , / , % , ++ , --
注意：
前置++和後置++問題
int i = 10;
int j = i++ + i++ + i++; // j = ?
int a = 10;
a = a++; // 10
- 賦值運算符
=,+=,-=,*=,/=,%=
注意：
short s = 1;
s = s+1; // 可能損失精度
short s = 1;
s += 1; // 隱含一個強制類型轉換
s = (short)(s + 1);
- 比較(關係或條件)運算符
==,!=,>,>=,<,<=
- 邏輯運算符
&,|,^,!,&&,||
- 位運算符
&,|,^,~ ,>>,>>>,<<
- 三目(元)運算符
(關係表達式) ? 表達式1 : 表達式2;
流程控制語句
- 順序結構
自上而下
- 選擇結構
if語句
if(){}
switch語句:
執行流程：
1. 先挨個匹配每一個case，匹配不上才走default
2. 結束，遇到break，或者執行到右方大括號
3. break可以省略，最好不要省略，容易出現case穿透
- 循環結構
for
while
do...while
do while至少執行一次循環體
for.while要先判斷條件是否成立
for可以將變量及早釋放
方法
實現某功能的代碼塊
方法之間是平級關係
方法調用纔會執行
二維數組格式
- int[][] arr = new int[3][2].
- 2,int[][]arr = new[3][].
- 3,int[][]arr = {{1,2,3},{1,2,3},{2,3,3,4}};
最大長方度length - 1,長度length
java語言能否跨平臺
各個平臺安裝對應的jvm
Jre包括jdk
jre:jvm+類庫
jdk:jre+java開發工具
永久：JAVA_HOME=%directory%\Java\jdk path=%JAVA_HOME%\bin
臨時:set path=%path%;
面向對象
功能
StringBuilder反轉
Collections排序
Arrays排序
jdk中哪些類是不能繼承的
String,Integer...包裝類
帶包的類的編譯運行
編譯javac -d . HelloWorld.java，運行java包名.HelloWorld
構造方法和和一般方法的區別
方法名與類名相同，沒有返回值類型，連void也沒有，沒有返回值return;
構造函數是在對象創建時，就被調用，用於初始化，而且初始化動作只執行一次
什麼時候使用構造函數呢？
分析事物時，發現具體事物一出現，就具備了一些特徵，那就將這些特徵定義到構造函數內
一般函數，是對象創建後，需要調用才執行，可以被調用多次
構造器Constructor不能被繼承，因此不能重寫Override，但可以被重載Overload
4個權限修飾符
private:本類，默認:同一個包下（子類和無關類）
protected:不同包下(子類)
public:不同包下（無關類）
默認:
成員(實例)變量和局部變量區別
1在類位置不同
2在內存中的的位置不同
3生命週期不同
4初始化值 不同
成員變量和靜態變量的區別
1.所屬 成員是對象，靜態是類
2.內存 成員是堆，靜態是方法區
3.生命週期
4.調用
思想特點
是一種更符合我們思想習慣的思想
可以將複雜的事情簡單化
將程序員從執行者變成了指揮者
類與對象
類：是一組相關的屬性和行爲的集合
構造方法 -- 構造器
成員變量 -- 屬性、字段、域
成員方法
對象：是該類事物的具體體現
面向對象三大特性
封裝
是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。
隱藏實現細節，提供公共的訪問方式
提高了代碼的複用性
提高安全性。
private關鍵字：
修飾成員變量
修飾成員方法
private修飾的成員只可以在本類中訪問
this關鍵字
當前對象的引用,誰來調用我，我就代表誰
static關鍵字
隨着類的加載面加載
優先於對象的存在
被類的所有對象共享
靜態只能訪問靜態
（只能修飾成員變量，不能修飾局部變量）
注意：
在靜態方法中是沒有this關鍵字的
靜態方法只能訪問靜態的成員變量和靜態的成員方法，靜態只能訪問靜態
代碼塊：
a:局部代碼塊
在方法中出現；限定變量生命週期，及早釋放，提高內存利用率
b:構造代碼塊 (初始化塊)
在類中方法外出現；多個構造方法方法中相同的代碼存放到一起，每次調用構造都執行，並且在構造方法前執行
c:靜態代碼塊
在類中方法外出現，並加上static修飾；用於給類進行初始化，在加載的時候就執行，並且只執行一次。
一般用於加載驅動（JDBC）
執行順序：
靜態代碼塊 --> 構造代碼塊 --> 構造方法
其中靜態代碼塊只加載一次，構造代碼塊和構造方法每次創建對象都會執行。
繼承
好處：
a:提高了代碼的複用性
b:提高了代碼的維護性
c:讓類與類之間產生了關係，是多態的前提
特點：
java支持單繼承，不支持多繼承，但支持多層繼承 -- 避免多繼承的調用不明確
注意：
a:子類只能繼承父類所有非私有的成員(成員方法和成員變量)
b:子類不能繼承父類的構造方法，但是可以通過super關鍵字去訪問父類構造方法。
c:不要爲了部分功能而去繼承，體現"is a"的關係。
super關鍵字：
代表父類的存儲空間標識。(可以理解爲父類的引用)
類與類，接口與接口
A：類與類：只能是單繼承。
B：接口與接口：可以是單繼承，也可以是多繼承。
C：類與接口：可以是單實現，也可以是多實現
java中只支持單繼承，可以多層繼承，接口可以多繼承，也可以在繼承的同時實現。（相同的是繼承，不同的是實現）
abstract與哪些關鍵字不能共存爲什麼
private：私有的方法是不可見的，無法被複寫
final：被final修飾的方法是最終方法，無法被複寫
static：被static修飾的方法，要隨類加載到方法區，由於抽象方法沒有方法體所以不能加載
static的特點
隨着類的加載而加載；優先於對象存在；被所有對象所共享；可以直接被類名所調用。
靜態方法只能訪問靜態成員，非靜態方法既可以訪問靜態也可訪問非靜態
靜態方法中不可以定義this、super關鍵字，因爲靜態優先於對象存在，所以靜態方法中不可以出現this；
Super和this
- this區分成員變量和局部變量重名，代表當前對象引用，誰調用我我就代表誰，super代表當前父類的引用
- super和this關鍵字可以在構造方法中共存
- super(有參或無參);和this(有參或無參);卻不可以在構造方法中共存，因爲它們都放在構造方法的第一行
- 一句話 this可以調用本類的也可以調用父類的(構造方法除外)
a:成員變量
this.變量 -- 本類的
super.變量 -- 父類的
b:構造方法
this(...) -- 本類的 -- 通過參數進行匹配的
super(...) -- 父類的
c:成員方法
this.方法名() -- 本類的
super.方法名() -- 父類的
重載與重寫：
重載：java允許在一個類中，多個方法擁有相同的名字，但在名字相同的同時，必須有不同的參數，這就是重載。與返回值類型無關。
重寫：
在子類中，方法聲明(修飾符,返回值,方法名,參數列表)相同的情況。
注意事項：
a:父類中私有方法是不能被重寫
b:子類重寫父類的方法不能縮小父類的訪問權限，不能拋出比父類更多的異常。
c:靜態只能重寫靜態。（類的特點）
子父類中構造方法的用法：
A:子類的初始化過程中，首先會去執行父類的初始化動作。
因爲子類的構造方法中默認有一個super()。
爲什麼?子類要使用父類的成員變量，這個初始化，必須在子類初始化之前完成。
所以，子類的初始化過程中，會先執行父類的初始化。
B:如果父類沒有無參構造方法
a:使用super調用父類的帶參構造。推薦方式。
b:使用this調用本身的其他構造。
final,finally,finallized
final修飾類不能被繼承，修飾方法不能被重寫，修飾變量是一個常量只能賦值一次。finally是try語句中的一個語句，不能單獨使用被它控制的語句一定會被執行用來釋放資源。
finallized是一個方法，當垃圾回收器不存在對該對象更多引用時，被GC(garbage collection)調用回收垃圾
使用final關鍵字修飾一個變量時，是指引用變量不能變，引用變量所指向的對象中的內容還是可以改變的
多態：
對象在不同時刻表現出來的不同狀態。（父類子對象）
多態的前提
A:要有繼承或者實現關係。
B:要有方法的重寫/實現。
C:要有父類引用或者父接口引用指向子類對象。
多態有三種體現形式
類多態
抽象類多態
接口多態
特點： 只有在非靜態方法時編譯看父類運行看子類
A:成員變量
編譯看左邊，運行看左邊。
B:成員方法
編譯看左邊，運行看右邊。 -- 編譯期只看語法
Fu f = new Zi();
f.show();
因爲方法存在着重寫，而變量沒有
好處：
可以提高代碼的擴展性和可維護性。
弊端：
父類(接口)引用不能使用子類特有功能。 -- 向下轉型
抽象類：
抽取出相同相象的，（看不懂的）
如果多個類中存在相同的方法聲明，而方法體不一樣，我們就可以只提取方法聲明。
如果一個方法只有方法聲明，沒有方法體，那麼這個方法必須用抽象修飾。
而一個類中如果有抽象方法，這個類必須定義爲抽象類。
抽象類的特點
A:抽象類和抽象方法必須使用abstract修飾
B:抽象類不能被實例化
C:抽象類有構造方法，用於子類實例化使用
D:如果一個類是抽象類，那麼，繼承它的子類
F: 沒有方法體
要麼是抽象類。
要麼重寫所有抽象方法。
抽象類的成員特點
A:成員變量 可以變量，也可以是常量
B:構造方法 有構造方法
C:成員方法 可以有抽象方法，也可以有非抽象方法（全是抽象方法或者非抽象方法都是可以的）
abstract不能和哪些關鍵字共存
final -- 不能重寫
private -- 子類不能訪問
static -- 調用出問題
抽象類與普通類的唯一區別就是不能創建實例對象
接口：
如果一個抽象類中的方法都是抽象的，這個時候，java就提供了一種更抽象的表示形式：接口。
規則的體現。
接口的特點：
A:接口不能被實例化。
B:一個類如果實現了接口：
要麼是抽象類。
要麼實現接口中的所有方法。
接口的成員特點：
A:成員變量 只能是常量。默認修飾符 public static final
B:成員方法 只能是抽象方法。默認修飾符 public abstract
接口的思想特點：
A:對外暴露的規則
B:是功能的擴展
C:降低耦合度
耦合：類與類的關係
內聚：類自己完成某件事情的能力
高內聚，低耦合。
D:接口可以多實現。 -- 彌補了java單繼承的侷限性。還不會出現調用不明確。
JDK8以後新特性：
接口可以定義實現的方法了，如果是非靜態的，要加default修飾，如果是靜態可以不用default修飾。
抽象類與接口的區別
A:成員特點:
抽象類:
成員變量:
可以是變量,可以是常量.
構造方法:
有構造方法,用來對父類數據進行初始化.
成員方法:
可以有抽象方法 -- 要求子類做某些事情
可以有非抽象方法 -- 供子類繼承.
接口:
成員變量:
全部都是常量.默認修飾符: public static final
成員方法:
全部都是抽象方法.默認修飾符: public abstract
B:關係特點:
類與類:
繼承關係,只能單繼承,但是可以多層繼承.
類與接口:
實現關係.可以單實現, 可以多實現.
還可以在繼承一個類的同時實現多個接口.
接口與接口:
繼承關係, 可以單繼承也可以多繼承.
C:設計理念的區別:
抽象類定義的是系統的共性內容,體現的是 is a 的關係.
接口定義的是系統的擴展功能, 體現的是 like a 的關係.
內部類；
一個類定義在了另一個類裏面，裏面這個類就是內部類。
訪問特點：
1:內部類可以直接訪問外部類成員，包括私有
2:外部類要想訪問內部類成員，必須創建對象。
內部類分類：
1:成員位置
private 安全
static 方便調用
格式：外部類名.內部類名 變量名 = new 外部類名.內部類名();
2:局部位置
定義在方法中。
局部內部類訪問局部變量必須加final修飾。延遲生命週期。(JDK8之後可以不必手動加了)
匿名內部類:
沒有名字的局部內部類。適合在調用一次的時候使用，可以當做參數傳遞
格式：
new 接口名或者抽象類名 () {
// 實現接口或抽象類的方法
// 可以有自己的方法（但是我們一般不這麼用）
};
本質：匿名內部類實際上是實現了接口（或者繼承了抽象類）的匿名子類對象。
理解上：其實是把定義子類（實現類）並重寫方法，然後創建子類（實現類）對象這些操作放到了一起完成，一個格式而已。
API
學類，學功能，維護類之間的關係
Object
public boolean equals(Object obj)
比較兩個對象，默認是比較地址值，一般我們會重寫，實現具體屬性的比較
public final Class<?> getClass()
返回對象所屬類的字節碼文件
public int hashCode()
返回一個int的哈希值，默認根據地址值算出來的，一般重寫根據具體的屬性值返回。
public String toString()
默認是全路徑類名+@+地址值的十六進制表示形式。重寫之後返回一些有意義的值。
public final void wait()
線程等待
public final void notify()
隨機喚醒單個線程
public final void notifyAll()
喚醒所有線程
protected void finalize() -- 配置釋放資源
final
finally -- 資源釋放
Math
public static int abs(int a)
public static double ceil(double a) -- 向上取整
public static double floor(double a) -- 向下取整
public static long round(double a) -- 四捨五入
public static double random() -- 隨機數
public static double sqrt(double a) -- 正平方根
Scanner
public int nextInt()
public String nextLine()
注意問題：
先int後String -- String獲取不到，"\r\n"
String
構造方法：
1) String()
2) String(byte[] bys)
3) String(byte[] bys, int start, int length)
4) String(char[] chs)
5) String(char[] chs, int start, int length)
6) String(String str)
7) String s = "abc";
成員方法：
判斷
equals(Object obj)
equalsIgnoreCase(String str)
contains(String s)
startsWith(String str)
endsWith(String str)
isEmpty() -- "" 與 null 區分開
獲取
int length()
char charAt(int index)
int indexOf(char ch)
int indexOf(char ch, int fromIndex)
int indexOf(String str)
int indexOf(String str, int fromIndex)
int lastIndexOf(String str)
String subString(int start)
String subString(int start, int end) -- 左閉右開
練習：
1、給定一個字符串常量，統計該串中有大寫字母、小寫字母、數字各有多少個。
2、查找子串在大串中出現的次數，例如"hanbasdnbafllgnbahjnbakqqqqlnbaxnbai"中有多少"nba"?
轉換
byte[] getBytes()
char[] toCharArray()
static String copyValueOf(char[] chs)
staitc String valueOf(int i)
String toUpperCase()
String toLowerCase()
String concat(String str)
其他功能
替換
String replace(String old, String new) -- 原串替換
String replaceAll(String regex, String new) -- 正則替換
切割
String[] split(String regex)
String trim()
int compareTo(String str)
字符串常量池的面試題
String s1 = "a";
String s2 = "b";
String s5 = "ab";
String s3 = "a" + "b";
String s4 = s1 + s2;
總結 String 17 個方法
首尾中空加判斷
截長取位取元素
大小拼串轉數組
除空切換正字典
1首startsWith
2尾endsWith
3中contains
4空isEmpty
5加判斷equals
6截長substring
7取位indexOf，lastIndexOf
8取元素charAt
9，10大小toUpperCase，toLowerCase
11拼串concat
12取數組toCharArray
13除空trim
14切split
15換replaceFirst，replace，replaceAll
16正matches
17字典compareTo
int和String互轉
1.int-->String String.ValueOf();
2. + "";
String-->int Integer.ParseInt();
StringBuffer -- 可變的字符序列
public int length()
public StringBuffer append(String str) -- 拼接
public StringBuffer insert(int offset,String str)
public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)
public StringBuffer replace(int start,int end,String str)
public StringBuffer reverse() -- 反轉
public String substring(int start)
public String substring(int start,int end)
String和StringBuffer區別
String是不可變的字符序列,StringBuffer是可變的字符序列
String是引用數據類型，當作參數傳遞相當於基本數據類型，不會影響其值
String是final類所以不能繼承
StringBuffer是安全的1.0(長度16),StringBuilder是不安全的1.5
Integer -- 基本數據類型的包裝類
Integer與String類型的互換
int -- String
String.valueOf(int i)
Integer.toString(int i)
String -- int
Integer.parseInt(String str)
JDK1.5新特性：
自動裝箱
自動拆箱
面試題：byte常量池
-128 ~ 127
Byte b1 = 100; // 保存到常量池
Byte b2 = 100;
Long lo1 = 120L;
Long lo2 = 120L;
Random
public int nextInt()
public int nextInt(int n) -- [0-n)之間的隨機數
System
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) -- 理解
public static void exit(int status) -- 退出jvm
public static long currentTimeMillis() -- 測試程序運行時間
public static Properties getProperties() -- 瞭解系統屬性
BigInteger
構造方法：
public BigInteger(String val)
成員方法：
public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger val)
public BigInteger divide(BigInteger val)
public BigInteger[] divideAndRemainder(BigInteger val)
BigDecimal
構造方法
public BigDecimal(String val) -- 解決浮點數參與運算會損失精度
成員方法
public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)
Date
與字符串之間的互換：
SimpleDateFormat
public final String format(Date date) -- 格式化
public Date parse(String source) -- 解析
Calendar
public static Calendar getInstance()
public int get(int field)
public void add(int field,int amount)
public final void set(int year,int month,int date)
正則表達式
正則表達式的分割功能
public String[] split(String regex)
正則表達式的替換功能
public String replaceAll(String regex,String replacement)
正則表達式的獲取功能
Pattern模式對象和Matcher匹配器對象的結合使用
典型調用順序：
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
//boolean b = m.matches();
Matcher匹配器
public boolean find()
public String group()
==和equals區別
==基本數據是比較值,引用地址值,
equals沒有重寫object跟==一樣,重寫後比較的是屬性值
Collection
數組和集合的區別
1、存儲類型不同
數組既可以存儲基本數據類型,又可以存儲引用數據類型,基本數據類型存儲的是值,引用數據類型存儲的是地址值
集合只能存儲引用數據類型(對象)集合中也可以存儲基本,數據類型,但是在存儲的時候會自動裝箱變成對象
2、長度不同
數組長度是固定的,不能自動增長
集合的長度的是可變的,可以根據元素的增加而增長
List
元素是有序的，元素可以重複。因爲該集合體繫有索引。
ArrayList:底層的數據結構使用的是數組結構。特點：查詢修改快。但是增刪稍慢。線程不同步。
因爲底層採用數組的數據結構,而數組中的元素在堆內存中是連續分配的,而且有索引,所以查詢快,增刪稍慢
在使用迭代器遍歷元素時,不能再使用集合的方法操作集合中的元素
調用集合的contains()或remove()方法時底層會調用equals方法,如果存入集合的對象沒有實現equals(),
則調用Object的equals()方法
ListIterator
LinkedList:底層使用的鏈表數據結構。特點：增刪速度很快，查詢修改慢。線程不同步。
棧 先進後出
堆 先進先出
Vector:底層是數組數據結構。線程同步。被ArrayList替代了。因爲效率低。
Set
元素是無序(存入和取出的順序不一定一致),元素不可以重複。
- HashSet:底層數據結構是哈希表。是線程不安全的。不同步。
HashSet是如何保證元素唯一性的呢？是通過元素的兩個方法，hashCode和equals來完成。
如果元素的HashCode值相同，纔會判斷equals是否爲true。
如果元素的hashcode值不同，不會調用equals。
注意,對於判斷元素是否存在，以及刪除等操作，依賴的方法是元素的hashcode和equals方法。
- LinkedHashSet
- TreeSet：可以對Set集合中的元素進行排序。
兩種排序方式：一定要考慮清楚什麼是主要條件，什麼是次要條件
自定義排序:元素需要實現Comparable接口，重寫compareTo方法。return int;
比較器排序: 創建一個比較器(實現Comparator接口,重寫compare方法),在創建TreeSet集合時將比較器傳遞給集合. return int;
Map
Map集合：該集合存儲鍵值對。一對一對往裏存。而且要保證鍵的唯一性。
- Hashtable:底層是哈希表數據結構，不可以存入null鍵null值。該集合是線程同步的。jdk0.效率低。
Properties
Properties是Hashtable的子類,是一個Map,存放的是鍵值對,一般用於項目的配置文件,配置文件中鍵和值的類型都爲String類型
setProperty(String key,String value)向Properties中存入鍵值對
getProperty(String key)根據鍵獲取值
public Enumeration<String> stringPropertyNames()以String的形式獲取所有的鍵,並封裝成Enumeration對象,之後進行遍歷
load(InputStream inStream) 將字節輸入流inStream所關聯的文件中的值加載到Properties對象中
store(OutputStream out, String comments) 將Properties對象中的內容寫入到out流所關聯的文件中,comments爲說明信息
- HashMap：底層是哈希表數據結構，允許使用 null 值和 null 鍵，該集合是不同步的。將hashtable替代，jdk1.效率高。
- TreeMap：底層是二叉樹數據結構。不同步。可以用於給map集合中的鍵進行排序。
和Set很像。其實，Set底層就是使用了Map集合
map集合的兩種取出方式:
Set<k> keySet：將map中所有的鍵存入到Set集合。因爲set具備迭代器。
所有可以迭代方式取出所有的鍵，在根據get方法。獲取每一個鍵對應的值。
Map集合的取出原理：將map集合轉成set集合。在通過迭代器取出。
Set<Map.Entry<k,v>> entrySet：將map集合中的映射關係存入到了set集合中，而這個關係的數據類型就是：Map.Entry
Entry其實就是Map中的一個static內部接口。
爲什麼要定義在內部呢？
因爲只有有了Map集合，有了鍵值對，纔會有鍵值的映射關係。
關係屬於Map集合中的一個內部事物。而且該事物在直接訪問Map集合中的元素。
HashMap和Hashtable的區別
Hashtable(注意t是小寫的)：JDK1.0以後的，線程安全，效率低。不能存null值和null鍵。
HashMap: JDK1.2以後的，線程不安全的，效率高。可以存null值和null鍵。
（加一句：）這兩個類也有共同點，他們都是雙列集合，底層都是哈希算法。
泛型
好處：
1、提高安全性（把運行期異常轉移到編譯期）
2、不用強轉了，省去強轉的麻煩
格式：
<> <>中的數據類型必須是引用數據類型
注意事項：
前後泛型必須一致，或者後邊的泛型可以不寫（1.7的新特性菱形泛型）ArrayList<String> list = new ArrayList<String>();
泛型和增強for都是JDK1.5的新特性
泛型的由來：
以前的集合能存的是Object類型的數據，這樣什麼類型的數據都可以存進集合了，但是好多時候我們要做類型轉換，這樣就不安全。而泛型就是來解決這個問題的
分類：
非靜態方法：
1、泛型可以與類的泛型一致，這樣不用定義自己的泛型 public void show(T t) { }
2、泛型與類的泛型不一致，需要定義自己的泛型 public <V> void method(V v) { }
靜態方法：
格式：
public static <B> void function(B b){ }
必須定義自己的泛型，爲什麼？
因爲靜態成員是隨着類的加載而加載的，類加載的時候，對象還沒有創建
泛型接口（瞭解）：
格式：在接口名後邊加泛型即可
實現方式：
1、用普通類來實現class Demo1 implements Smoke<Student> { }較常用
2、用泛型類來實現class Test<T> implements Somke<T> { }
泛型高級之通配符（瞭解）：
<?>任意類型，如果沒有明確，那麼就是Object以及任意的Java類了
? extends E固定上邊界（向下限定），E及其子類
? super E固定下邊界（向上限定），E及其父類
泛型練習
編寫一個泛型方法,實現指定位置數組元素的交換
編寫一個泛型方法,接收一個任意數組,並顛倒數組中的所有元素
注意:只有對象類型才能作爲泛型方法的實際參數
在泛型中可以同時有多個類型
public <K,V> V getValue(K key) return { return map.get(key)}
案例:
package com.heima.generic;
//自定義泛型練習
public class ArraysUtil {
//編寫一個泛形方法，實現指定位置數組元素的交換
public static <T> void exchange(T[] t,int index1,int index2){
T temp = t[index1];
t[index1] = t[index2];
t[index2] = temp;
}
//編寫一個泛形方法，接收一個任意數組，並顛倒數組中的所有元素
public static <T> void reverse(T[] t){
int startIndex = 0;
int endIndex = t.length -1;
while(startIndex<endIndex){
T temp = t[startIndex];
t[startIndex] = t[endIndex];
t[endIndex] = temp;
startIndex++;
endIndex--;
}
}
}
遍歷方式
數組 length屬性
字符串length();方法
集合
list.size(),list.get();
Iterator
ListIterator
for( : )
普通for size();（操作元素要減減或是倒着遍歷）
迭代器 （用ListInterator自身的方法操作元素）
增強for（不能刪除元素）
Thread
進程和線程
(1)進程是正在執行的程序
(2)線程是進程中一個獨立的控制單元(執行路徑)（一個程序可同時一時間執行多個線程）
(3)進程中至少有一個線程,對於JVM,啓動時至少有兩個線程:JVM的主線程和JVM的垃圾回收線程
程序-->線程-->進程
多線程(多線程並行和併發的區別)
(1)並行就是兩個任務同時運行，就是甲任務進行的同時，乙任務也在進行。(需要多核CPU，同時進行)
｜--比如我跟兩個網友聊天，左手操作一個電腦跟甲聊，同時右手用另一臺電腦跟乙聊天，這就叫並行。
(2)併發是指兩個任務都請求運行，而處理器只能按受一個任務，就把這兩個任務安排輪流進行，由於時間間隔較短，使人感覺兩個任務都在運行。（同時訪問）
｜--如果用一臺電腦我先給甲發個消息，然後立刻再給乙發消息，然後再跟甲聊，再跟乙聊。這就叫併發。
多線程(兩種方式的區別以及兩種實現方式的過程)
(1)查看源碼的區別:
* a.繼承Thread : 由於子類重寫了Thread類的run(), 當調用start()時, 直接找子類的run()方法
* b.實現Runnable : 構造函數中傳入了Runnable的引用, 成員變量記住了它, start()調用run()方法時內部判斷成員變量Runnable的引用是否爲空,
不爲空編譯時看的是Runnable的run(),運行時執行的是子類的run()方法
(2)繼承Thread
* 好處是:可以直接使用Thread類中的方法,代碼簡單
* 弊端是:如果已經有了父類,就不能用這種方法
用類名調用 Demo d = new Demo(); d.start();
this.name();
super(name);
Thread.currentThread().getName()
(3)實現Runnable接口
* 好處是:即使自己定義的線程類有了父類也沒關係,因爲有了父類也可以實現接口,而且接口是可以多實現的
* 弊端是:不能直接使用Thread中的方法需要先獲取到線程對象後,才能得到Thread的方法,代碼複雜
Demo d = new Demo()
Thread t1 = new Thread(d);
t1.start();
(4)start開啓線程並運行run方法
run 僅僅是對象調用方法沒用運行線程
wait()和sleep()的區別
(1)wait是Object類中的方法，sleep是Thread類中的方法
(2)sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。
(3)wait，notify和notifyAll只能在同步控制方法或者同步控制塊裏面使用，而sleep可以在任何地方使用
(4)sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常
休眠線程、守護線程、加入線程、禮讓線程
(1)休眠線程: sleep 控制當前線程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000納秒 1000000000
(2)守護線程:設置一個線程爲守護線程, 該線程不會單獨執行, 當其他非守護線程都執行結束後, 自動退出
(3)加入線程:join 當前線程暫停, 等待指定的線程執行結束後, 當前線程再繼續
(4)禮讓線程:yield讓出cpu
同步代碼塊,同步方法,靜態同步方法的區別?以及什麼時候使用同步?
當多線程併發, 有多段代碼同時執行時, 我們希望某一段代碼執行的過程中CPU不要切換到其他線程工作. 這時就需要同步.
如果兩段代碼是同步的, 那麼同一時間只能執行一段, 在一段代碼沒執行結束之前, 不會執行另外一段代碼.
(1).多線程操作共享數據
(2).有多條語句在操作共享數據
(3).要使用同一個鎖
1. 同步代碼塊可以使用任意對象作爲鎖對象
2. 同步方法的鎖爲this,
3. 靜態同步方法的鎖爲所在類的字節碼對象(類名.class)
什麼是死鎖?
在多線程中，各自想得到對方的鎖，繮持住了。
不要嵌套
說一下你所學過的線程安全的類?
(1)看源碼：Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)
(2)Vector是線程安全的,ArrayList是線程不安全的
(3)StringBuffer是線程安全的,StringBuilder是線程不安全的
(4)Hashtable是線程安全的,HashMap是線程不安全的
說一下你對線程間的通信的理解?（兩個或多個線程交替執行）
(1)什麼時候需要通信
* 多個線程併發執行時, 在默認情況下CPU是隨機切換線程的
* 如果我們希望他們有規律的執行, 就可以使用通信, 例如每個線程執行一次打印
(2)怎麼通信
* 如果希望線程等待, 就調用wait()
* 如果希望喚醒等待的線程, 就調用notify();
* 這兩個方法必須在同步代碼中執行, 並且使用同步鎖對象來調用
(3)多個線程通信的問題
* notify()方法是隨機喚醒一個線程
* notifyAll()方法是喚醒所有線程
* JDK5之前無法喚醒指定的一個線程
* 如果多個線程之間通信, 需要使用notifyAll()通知所有線程, 用while來反覆判斷條件
if notify
while notify
while notifyAll 1.5之前
reentrantlock 1.5新特性 new condition lock unlock singal
Runtime類,Timer類,互斥鎖(*******ReentrantLock)?
線程組的概念?線程池的概念?
線程實現的第三種方式?-Callable
設計模式
1. 單例
1.餓漢式是空間換時間，懶漢式是時間換空間
2.在多線程訪問時，懶漢式可能會創建多個對象
也叫: 延遲加載，非延遲加載
餓漢式
// 私有構造
private Student(){}
// 創建一個本類的唯一對象
private static Student s = new Student();
// 提供公共的訪問方式返回這個對象
public static Student getInstance(){
return s;
}
懶漢式 -- 延遲加載
// 私有構造
private Student(){}
// 聲明一個本類的唯一對象
private static Student s = null;
// 提供公共的訪問方式返回這個對象
public static synchronized Student getInstance(){
if(s != null) {
s = new Student();
}
return s;
}
- 模版
- 裝飾
BufferedReader(Reader)就是包裝
- 工廠方法
- 簡單工廠
- 適配器.
定義一個抽象類實現這個接口，然後繼承這個抽象類
線程的5種狀態
1.新建
2.就緒
3.運行
4.阻塞
5.死亡
網絡編程三要素
ip,端口，協議
端口0-65535，0-1024是系統保留端口，
udp面向無連接，數據不安全，速度快
tcp面向連接，三次握手，數據安全，速度略低
IO
異常
Throwable
- Error
- Exception
RuntimeException
非RuntimeException
Error和RuntimeException，這些是需要改代碼的。
RuntimeException也可以去做異常處理，但如果出現這樣的異常，一般還是程序出了問題。
非RuntimeException 必須做異常處理：
1、聲明異常 -- throws 異常類名
2、捕獲異常 -- try...catch
常見異常
ArrayIndexOutOfBoundsException數組索引越界異常
NullPointerException空指針異常
ClassCastException類型轉換異常
NumberFormatException數字格式異常
ConcurrentModificationException併發修改異常
Unsupported Encoding Exception不支持異常
EOFExceptions文件到了末尾異常
概念
* IO流用來處理設備之間的數據傳輸
* Java對數據的操作是通過流的方式
* Java用於操作流的類都在IO包中
* 流按流向分爲兩種：輸入流，輸出流。
* 流按操作類型分爲兩種：
* 字節流 : 字節流可以操作任何數據,因爲在計算機中任何數據都是以字節的形式存儲的
* 字符流 : 字符流只能操作純字符數據，比較方便。
InputStream/OutputStream
字節流InputStream/OutputStream
|--FileInputStream/FileOutputStream：文件字節流，用於文件的讀寫操作
|--BufferedInputStream/BufferedOutputStream：加緩衝區的字節流，用於提高效率
|--InputStream(字節輸入流,字節流的抽象父類,抽象類不能直接創建對象,必須使用子類)
|--FileInputStream(文件字節輸入流,就是以字節的形式讀取文件內容)
|--read()每次讀取一個字節(byte),但是返回值類型,爲int類型,防止出現文件提前結束
|--read(byte[] b)每次讀取多個字節,將內容放入字節數組b中
|--BufferedInputStream(字節輸入緩衝流,其實就是一個包裝類,創建對象時要接收一個InputStream,內部封裝了一個1024*8的字節數組)
|--使用BufferedInputStream就不用再定義數組了
|--OutputStream(字節輸出流,字節流的抽象父類)
|--FileOutputStream(文件字節輸出流,就是以字節的形式將內容寫入到文件中)
|--write()一次寫出一個字節
|--write(byte[] b)將字節數組b裏的內容寫入到文件中
|--write(byte[] b, int off, int len)將字節數組b裏的內容,從所以爲off的位置開始,總共寫len個
|--BufferedOutputStream(字節輸出緩衝流,其實就是一個包裝類,創建對象時要接收一個OutputStream,內部封裝了一個1024*8的字節數組)
Reader/Writer
字符流Reader/Writer
|--FileReader/FileWriter：文件字符流，用於文本文件的讀寫操作
|--BufferedReader/BufferedWrite：加緩衝區的字符流，用於提高效率
轉換流InputStreamReader/OutputStreamWriter：是字節流和字符流之間的橋樑
配置文件Properties
|--Reader(字符輸入流,字符流的抽象父類,抽象類不能直接創建對象,必須使用子類)
|--FileReader(文件字符輸入流,就是以字符的形式讀取文件中的內容)
|--read()每次讀取一個字符,即可以按照字符大小讀取,返回值類型提升爲int類型
|--read(char[] b)每次讀取多個字符,將內容放入字符數組b中
|--BufferedReader(字符輸入緩衝流,其實就是一個包裝類,創建對象時要接收一個Reader,內部封裝了一個1024*8的字符數組)
|--使用BufferedReader和BufferedWriter就不用再定義數組了
|--readLine()可以讀取一行字符(不包含換行符號)
|--LineNumberReader是BufferedReader的子類, 具有相同的功能, 並且可以統計行號
|--getLineNumber()方法可以獲取當前行號
|--setLineNumber()方法可以設置當前行號
|--Writer(字符輸出流,字符流的抽象父類)
|--FileWriter(文件字符輸出流,就是以字符的形式將內容寫入到文件中)
|--write('a')/write("aaaa")可以寫入單個字符或者寫入字符串
|--write(char[] b, int off, int len)將字符數組b裏的內容,從所以爲off的位置開始,總共寫len個
|--BufferedWriter(字符輸出緩衝流,其實就是一個包裝類,創建對象時要接收一個Writer,內部封裝了一個1024*8的字符數組)
|--newLine()可以輸出一個跨平臺的換行符號"\r\n"
轉換流(使用指定的碼錶讀寫字符)
|--InputStreamReader字節輸入流到字符輸入流的橋樑
|--OutputStreamWriter字符輸出流到字節輸出流的橋樑
其它流
SequenceInputStream序列流
序列流可以把多個字節輸入流整合成一個, 從序列流中讀取數據時, 將從被整合的第一個流開始讀, 讀完一個之後繼續讀第二個, 以此類推.
SequenceInputStream(InputStream in1,InputStream in2)
SequenceInputStream(Enumeration en)
ByteArrayOutputStream字節數組內存輸出流
是將文件或鍵盤錄入的數據寫入到內存中的字節數組
ByteArrayInputStream字節數組內存輸入流
是以字節的方式讀取內存中的字節數組數據
創建此對象要傳遞一個字節數組
RandomAccessFile隨機讀寫訪問流
該流同時具有讀和寫的功能
seek(long pos)設置讀取和寫入的位置
ObjectOutputStream對象操作流,將對象寫入到文件,要求對象所屬的類實現Serializable接口,該接口裏面沒有內容,只是一個標記
writeObject()將對象寫入文件
ObjectInputStream將上面存入到文件中的對象讀取出來,因爲存的時候所有對象是按照Object存入,所以取出來要進行強制類型轉換
readObject()從文件讀取一個對象出來
DataInputStream數據輸入流,就是從文件讀取特定類型的數據
readInt()從文件中讀取一個int類型的數據
readLong()從文件讀取一個long類型的數據
DataOutputStream數據輸出流,向文件寫出特定類型的數據
writeInt()向文件寫入一個int類型的數據
writeLong()向文件寫入一個long類型的數據
標準流
System.in是InputStream, 標準輸入流, 默認可以從鍵盤輸入讀取字節數據
System.setIn(InputStream)修改輸入流
System.out是PrintStream, 標準輸出流, 默認可以向Console中輸出字符和字節數據
System.setOut(PrintStream)修改輸出流
第十種拷貝文件方法
System.setIn
System.setOut
鍵盤錄入的兩種方式
Scanner sc = new Scanner(System.in);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Close和flush區別
flush用來刷新緩衝區的,刷新後可以再次寫出,即flush後流仍然可以使用
close用來關閉流釋放資源的的,如果是帶緩衝區的流對象的close()方法,不但會關閉流,還會再關閉流之前刷新緩衝區,關閉後不能再寫出,即不能再使用該流
IO流的標準異常處理
Refelt
什麼是反射
反射是拿到字節碼文件，通過字節碼文件反向得到字段getField，方法getMethod，構造方法getConustructor
什麼時候加載類(類的加載時機)?
當程序要使用某個類時，如果該類還未被加載到內存中，則系統會通過加載，連接，初始化三步來實現對這個類進行初始化。
(1)創建類的實例
(2)訪問類的靜態變量，或者爲靜態變量賦值
(3)調用類的靜態方法
(4)使用反射方式來強制創建某個類或接口對應的java.lang.Class對象
(5)初始化某個類的子類
(6)直接使用java.exe命令來運行某個主類
類加載器的分類?
(1)Bootstrap ClassLoader （引導）根類加載器
* 也被稱爲引導類加載器，負責Java核心類的加載
* 比如System,String等。在JDK中JRE的lib目錄下rt.jar文件中
(2)Extension ClassLoader 擴展類加載器
* 負責JRE的擴展目錄中jar包的加載。
* 在JDK中JRE的lib目錄下ext目錄
(3)Sysetm ClassLoader 系統類加載器
* 負責在JVM啓動時加載來自java命令的class文件，以及classpath環境變量所指定的jar包和類路徑
獲取字節碼對象的三種方式?
(1)Object類的getClass()方法,判斷兩個對象是否是同一個字節碼文件
｜-- Person p = new Person();
Class clazz3 = p.getClass();
(2)靜態屬性class,鎖對象
｜-- Class clazz1 =類名.class 當作靜態方法的鎖對象
(3)Class類中靜態方法forName(),讀取配置文件
｜-- Class clazz = Class.forName(全類名)
反射中所用到的方法?
反射是拿到字節碼文件，通過字節碼文件反向得到字段getField，方法getMethod，構造方法getConustructor
(1)構造方法
|--獲取:getConstructor()和getConstructors()
|--執行:newInstance()
(2)普通的成員方法
|--獲取:getMethod()和getMethods()
|--執行:invoke()
(3)成員變量
|--非私有:getField()和getFields()
|--私有:getDeclaredField
|--訪問私有的成員變量先執行:setAccessible(true),然後執行set方法
暴力反射?
可以獲取字節碼對象中的所有屬性和方法,包括私有.對於私有的屬性和方法要使用暴力反射,即使用getDeclaredXxx()方法獲取,
然後再設置可以訪問,即調用setAccessible(true)
泛型的擦除?
泛型只在編譯期有效,在運行期會被擦除掉,生成.class文件之後泛型就沒有了
談談你對動態代理的理解?