不包含的符號怎麼寫

1、String類：字串（重點）

（1）多個字元組成的一個序列，叫字串。

生活中很多資料的描述都採用的是字串的。而且我們還會對其進行操作。

所以，java就提供了這樣的一個類供我們使用。

（2）建立字串物件

A：String（）：無參構造

**舉例：

String s = new String（）；

s = “hello”；

sop（s）；

B：String（byte［］ bys）：傳一個位元組陣列作為引數 *****

**舉例

byte［］ bys = {97，98，99，100，101}；

String s = new String（bys）；

sop（s）；

C：String（byte［］ bys，int index，int length）：把位元組陣列的一部分轉換成一個字串 *****

**舉例

byte［］ bys = {97，98，99，100，101}；

String s = new String（bys，1，2）；

sop（s）；

D：String（char［］ chs）：傳一個字元陣列作為引數 *****

**舉例

char［］ chs = {‘a’，‘b’，‘c’，‘d’，‘e’}；

String s = new String（chs）；

sop（s）；

E：String（char［］ chs，int index，int length）：把字元陣列的一部分轉換成一個字串 *****

**舉例

char［］ chs = {‘a’，‘b’，‘c’，‘d’，‘e’}；

String s = new String（chs，1，2）；

sop（s）；

F：String（String str）：把一個字串傳遞過來作為引數

char［］ chs = {‘a’，‘b’，‘c’，‘d’，‘e’}；

String ss = new String（s）；

sop（ss）；

G：直接把字串常量賦值給字串引用物件（最常用） *****

**舉例

String s = “hello”；

sop（s）；

（3）面試題

A：請問String s = new String（“hello”）；建立了幾個物件。

兩個。一個“hello”字串物件，在方法區的常量池；一個s物件，在棧記憶體。

B：請寫出下面的結果

String s1 = new String（“abc”）；

Strign s2 = new String（“abc”）；

String s3 = “abc”；

String s4 = “abc”；

sop（s1==s2）； //false

sop（s1==s3）； //false

sop（s3==s4）； //true

C：字串物件一旦被建立就不能被改變。

指的是字串常量值不改變。

（4）字串中各種功能的方法

A：判斷

**** boolean equals（Object anObject）：判斷兩個字串的內容是否相同，複寫了Object的方法

**** boolean equalsIgnoreCase（String anotherString）：判斷兩個字串的內容是否相同，

不區分大小寫

**** boolean contains（String s）：判斷一個字串中是否包含另一個字串

注意：判斷字串是否包含特殊字元。直接表示為str。contains（“。”）

boolean endsWith（String suffix）：測試此字串是否以指定的字尾結束

boolean startsWith（String suffix）：測試此字串是否以指定的字首開始

boolean isEmpty（）：測試字串是否為空

B：獲取

***** int length（）：返回此字串的長度

***** char charAt（int index）：返回指定索引處的 char值

***** int indexOf（int ch）：返回指定字元在此字串中第一次出現處的索引。

int indexOf（int ch， int fromIndex）：返回在此字串中第一次出現指定字元處的索引，

從指定的索引開始搜尋。

int indexOf（String str）：返回指定子字串在此字串中第一次出現處的索引。

int indexOf（String str， int fromIndex）：返回指定子字串在此字串中第一次

出現處的索引，從指定的索引開始。

*** int lastIndexOf（int ch）：返回指定字元在此字串中最後一次出現處的索引。

int lastIndexOf（int ch， int fromIndex）

返回指定字元在此字串中最後一次出現處的索引，從指定的索引處開始進行反向搜尋。

int lastIndexOf（String str）

返回指定子字串在此字串中最右邊出現處的索引。

int lastIndexOf（String str， int fromIndex）

返回指定子字串在此字串中最後一次出現處的索引，從指定的索引開始反向搜尋。

***** String substring（int beginIndex） （注意：該方法substring的String是小寫！！！）

返回一個新的字串，它是此字串的一個子字串。

String substring（int beginIndex， int endIndex） （注意該方法的String是小寫！！！）

返回一個新字串，它是此字串的一個子字串，包含頭不包含尾。

C：轉換

***** byte［］ getBytes（）：（很常用！）從字串到位元組陣列的方法

void getChars（int srcBegin， int srcEnd， char［］ dst， int dstBegin）

將字元從此字串複製到目標字元陣列。

***** char［］ toCharArray（）：（很常用！）從字串到字元陣列的方法

**** static String copyValueOf（char［］ data）

返回指定陣列中表示該字元序列的 String。

static String copyValueOf（char［］ data， int offset， int count）

返回指定陣列中表示該字元序列的 String。

***** static String valueOf（資料型別）：把該資料型別的資料轉換成字串。

*** String toLowerCase（）：把字串轉換成小寫

String toUpperCase（）：把字串轉換成大寫

*** 字串的連線

String concat（String str）：將指定字串連線到此字串的結尾。

D：替換

String replace（char oldChar， char newChar）：用新字元替換舊字元（替換所有）

String replace（String target， String replacement）：用新的子串換舊串

E：分割

String［］ split（String regex）：根據指定的字串把一個字串分割成一個字串陣列

F：

String trim（）：去除字串的前後空格

G：

int compareTo（String anotherString）

按字典順序比較兩個字串。

int compareToIgnoreCase（String str）

按字典順序比較兩個字串，不考慮大小寫。

（5）練習

1：模擬登入，給三次機會，並提示還有幾次。

預設的使用者名稱和密碼為admin。 區分大小寫。

自己從鍵盤輸入使用者名稱和密碼。

2：給定一個字串統計，統計大寫字母，小寫字母，數字出現的個數。

***注意：不包括特殊字元

從鍵盤輸入一個不包含特殊字元的字串（只有26個字母和0-9組成）。

3：給定一個字串，把它變成首字母大寫，其他字母小寫的字串。

從鍵盤輸入一個字串，全部26個字母組成的。

4：子串在整串中出現的次數。

也就是說：獲取一個字串中，指定的字串在該字串中出現的次數。

例如：

“nbasdnbafllgnbahjnbakqqqqlnba” 在這個字串中，多有個nba。

5：對字串中字元進行自然順序排序。

“basckd”——>“abcdks”

先留做思考內容：

6：兩個字串的最大相同子串。

兩個字串的最大相同子串。

比如：

“sadabcdfghjkl”

werabcdtyu“

2、StringBuffer

（1）字串的緩衝區，是一個容器。

（2）它和String的區別

它是緩衝區可變長度的。

（3）構造方法

StringBuffer（） 構造一個其中不帶字元的字串緩衝區，初始容量為 16 個字元。

StringBuffer（int num） 構造一個不帶字元，但具有指定初始容量的字串緩衝區。

StringBuffer（String str） 構造一個字串緩衝區，並將其內容初始化為指定的字串內容。

（4）常用方法

A：增加資料

**append ：新增各種型別的資料

**insert ： 在容器指定位置插入各種型別的資料。

B：刪除資料

**deleteCharAt ： 刪除指定位置的字元

**delete 還可以用於清空StringBuffer的緩衝區

C：替換

**replace

D：獲取

**charAt

E：長度和容量

**length（） 元素的個數

**capacity 元素的理論值

F：獲取元素的位置

**indexOf

**lastIndexOf

G：擷取

**substring（int start）

**substring（int start，int end）

H：反轉

**reverse

（5）字串和StringBuffer的轉換

String——>StringBuffer透過構造：

如：StringBuffer sb = new StringBuffer（String str）

StringBuffer——String透過toString方法

如：StringBuffer sb = new StringBuffer（）；

sb。toString（）；

3、StringBuilder

和StringBuffer的功能是一樣的，但是有區別：

StringBuffer（JDK1。0）是執行緒安全的。

StringBuilder（JDK1。5）不保證執行緒安全。

一般來說，我們寫的程式都是單執行緒的，所以，用StringBuilder，效率高。

JDK版本的升級原則：

A：提高效率

B：提高安全性

C：簡化書寫

4、基本資料型別的物件包裝類

（1）為了更方便的操作每個基本資料型別，java對其提供了很多的屬性和方法供我們使用。

（2）用途：

**將基本資料型別封裝成物件的好處在於可以在物件中定義更多的功能操作該資料。

**常用的操作之一：用於基本資料型別與字串之間的轉換。

A：方便操作

B：用於和字串進行相互轉換

（3）基本資料型別和物件型別的對應

byte Byte

short Short

int Integer

long Long

float Float

double Double

boolean Boolean

char Character

（4）構造方法

欄位摘要：

static int MAX_VALUE 值為 2^31-1 的常量，它表示 int 型別能夠表示的最大值

static int MIN_VALUE 值為 -2^31 的常量，它表示 int 型別能夠表示的最小值

static Class TYPE 表示基本型別int的Class 例項

Integer（int value） 構造一個新分配的Integer物件，它表示指定的int值。

Inreger（String s） 注意：s必須是純數字的字串。否則會有異常NumberFormatException

（5）幾個常用的方法

Integer。toBinaryString（）；

以二進位制（基數 2）無符號整數形式返回一個整數引數的字串表示形式。

Integer。toOctalString（）；

以八進位制（基數 8）無符號整數形式返回一個整數引數的字串表示形式。

Integer。toHexString（）；

以十六進位制（基數 16）無符號整數形式返回一個整數引數的字串表示形式。

static int Integer。parseInt（String s） 將字串引數作為有符號的十進位制整數進行解析，

字串必須是int型範圍內的數字字串

static int Integer。parseInt（String s，int basic）

使用第二個引數指定的基數，將字串引數解析為有符號的整數。

字串必須是int型範圍內的數字字串

short shortValue（） 以short型別返回該Integer的值。

int intValue（） 以int型別返回該Integer的值。

static Integer valueOf（int num） 返回一個表示指定的 int 值的 Integer 例項。

static Integer valueOf（String s） 返回儲存指定的String的值的Integer物件。

static Integer valueOf（String s， int radix）

返回一個Integer物件，該物件中儲存了用第二個引數提供的基數進行

解析時從指定的String中提取的值。

（6）型別轉換

int —— Integer

int num = 20；

A：Integer i = new Integer（num）；

B：Integer i = Integer。valueOf（num）；

Integer —— int

Integer i = new Integer（20）；

A：int num = i。intValue（）；

int —— String

int num = 20；

A：String s = String。valueOf（num）；

B：String s = ”“+num；

C：String s = Integer。toString（num）；

String —— int

String s = ”20“；

A：int num = Integer。parseInt（s）；

B：Integer i = new Integer（s）；或者Integer i = Integer。valueOf（s）；

int num = i。intValue（）；

6、集合框架

（1）為什麼出現集合類？

面向物件對事物的體現都是以物件的形式，為了方便對多個物件的操作，就對物件進行儲存。

集合就是儲存物件最常用的一種方式。

（2）陣列和集合都是容器，兩者有何不同？

**陣列長度固定，而集合長度是可變的

**陣列值可以儲存物件，還可以儲存基本資料型別；而集合只能儲存物件

**陣列儲存資料型別是固定的，而集合儲存的資料型別不固定

（3）集合類的特點：

集合只能儲存物件

集合的長度是可變的

集合可以儲存不同型別的物件

（4）集合類框架（重要！！！要分清幾種容器間的區別）：

**Collection：頂層介面

|——->List：列表，元素是有序的（元素帶角標索引），可以有重複元素，可以有null元素。

|——->ArrayList（JDK1。2）：底層的資料結構是陣列資料結構，特點是查詢速度快（因為帶角標），

但是增刪速度稍慢，因為當元素多時，增刪一個元素則所有元素的角標都得改變

執行緒不同步。預設長度是10，當超過長度時，按50%延長集合長度。

|——->LinkedList（JDK1。2）：底層資料結構式連結串列資料結構（即後面一個元素記錄前一個），

特點：查詢速度慢，因為每個元素只知道前面一個元素，但增刪速度快

因為元素再多，增刪一個，只要讓其前後的元素重新相連即可

執行緒是不同步的。

|——->Vector（JDK1。0）：底層資料結構是陣列資料結構。特點是查詢和增刪速度都很慢。

預設長度是10，當超過長度時，按100%延長集合長度。

執行緒同步。

（Vector功能跟ArrayList功能一模一樣，已被ArrayList替代）

**List使用注意！

|——->ArrayList：

（1）當往ArrayList裡面存入元素沒什麼要求時，即只要求有序就行時；

（2）當往ArrayList裡面存入元素要求不重複時，比如存入學生物件，當同名同姓時

視為同一個人，則不往裡面儲存。則定義學生物件時，需複寫equals方法

public boolean equals（Object obj）{ if（！（obj instanceof Student）） return false； Student stu = （Student）obj； return this。name。equals（stu。name）&&this。age==stu。age；}

則往ArrayList集合透過add存入學生物件時，集合底層自己會呼叫學生類的equals方法，

判斷重複學生則不存入。

注：對於List集合，無論是add、contains、還是remove方法，判斷元素是否相同，

都是透過複寫equals方法來判斷！

|——->LinkedList

（1）LinkLedist的特有方法：

boolean offerFirst（E e） 在此列表的開頭插入指定的元素。

boolean offerLast（E e） 在此列表末尾插入指定的元素。

E peekFirst（） 獲取但不移除此列表的第一個元素；如果此列表為空，則返回 null。

E peekLast（） 獲取但不移除此列表的最後一個元素；如果此列表為空，則返回 null。

E pollFirst（） 獲取並移除此列表的第一個元素；如果此列表為空，則返回 null。

E pollLast（） 獲取並移除此列表的最後一個元素；如果此列表為空，則返回 null。

（2）透過LinkLedist的特有方法，可以實現某些資料特殊方式的存取，比如堆疊和佇列。

一般情況下，使用哪種List介面下的實現類呢？

如果要求增刪快，考慮使用LinkedList

如果要求查詢快，考慮使用ArrayList

如果要求執行緒安全，考慮使用Vector。

|——->Set：集合，元素是無序的（因為沒有索引），元素不可以重複。可以有null元素。

|——->HashSet（JDK1。2）：底層資料結構是雜湊表、存取速度快、元素唯一、執行緒不同步。

保證性元素唯一的原理：

先判斷元素的hashCode值是否相同，再判斷兩元素的equals方法是否為true

（往HashSet裡面存的自定義元素要複寫hashCode和equals方法，

以保證元素的唯一性！）

|——->TreeSet：底層資料結構式二叉樹。可以對Set集合中的元素進行排序。元素有序、執行緒不同步。

保證元素唯一性的依據：compareTo方法return 0

TreeSet排序的第一種方式：讓元素自身具備比較性，比如八種基本資料型別或則字串，

實現Compareble介面，覆蓋compareTo方法，

此方式是元素的自然順序

TreeSet排序的第一種方式：當元素自身不具備比較性（比如儲存學生物件時）或者具備的

比較性不是我們所需要的比較性時（比如想字串的長度排序），

此時就需要讓集合自身具備自定義的比較性。

那如何讓集合自身具備比較性呢？可在集合初始化時，

就讓集合具備比較方式。即定義一個類，

實現Comparator介面，覆蓋compare方法。

**Set集合使用注意事項：

（1）HashSet：

透過new的方式往HashSet裡面存的元素的hashCode都不同，但通常我們定義物件，

比如學生物件時，雖然是new的兩個學生物件，但是當他們name和age一樣時，我們認為是

同一個物件，所以為了保證元素的唯一性，我們通常在往HashSet集合裡面儲存元素時，

在定義物件的類中通常複寫hashCode和equals方法。

public int hashCode（）{ return name。hashCode（）+age*39；}public boolean equals（Object obj）{ if（！（obj instanceof Student）） return false； Student stu = （Student）obj； return this。name。equals（stu。name）&&this。age==stu。age；}

HashSet是如何保證元素唯一性的呢？

**如果兩元素的hashCode值不同，則不會呼叫equals方法

**如果兩元素的hashCode值相同，則繼續判斷equals是否返回true；

**hashCode和equals方法雖然定義在自定義物件類裡面，但不是我們手動呼叫

而是往HashSet集合裡面儲存元素的時候，集合底層自己呼叫hashCode和equals

它自己拿物件去判斷，自己判斷兩元素是否是同一個元素。

（2）TreeSet：

TreeSet要求往裡面存的元素具備比較性，否則會報錯。

TreeSet排序的第一種方式：讓元素自身具備比較性

定義物件類，實現Compareble介面，複寫compareTo方法，此方式是元素的自然順序

class Student implements Comparable{ private String name； private int age； public Student（String name，int age） { this。name=name； this。age=age； } public String getName（） { return name； } public int getAge（） { return age； } public int compareTo（Object obj） { if（！（obj instanceof Student）） throw new RuntimeException（”不是學生物件！“）； Student stu = （Student）obj； int num = this。age-stu。age； if（num==0） return this。name。compareTo（stu。name）； return num； }}TreeSet排序的第一種方式：讓集合具備比較性當元素自身不具備比較性（比如儲存學生物件時）或者具備的比較性不是我們所需要的比較性時（比如想字串的長度排序）， 此時就需要讓集合自身具備自定義的比較性。 那如何讓集合自身具備比較性呢？可在集合初始化時，就讓集合具備比較方式。即定義一個類，實現Comparator介面，覆蓋compare方法。class StringLengthComparator implements Comparator{ public int compare（Object obj1，Object obj2） { String s1 = （String）obj1； String s2 = （String）obj2； int num = new Integer（s1。length（））。compareTo（new Integer（s2。length（）））； if（num==0） return s1。compareTo（s2）； return num； }}class TreeSetTest{ public static void main（String［］ args） { TreeSet ts = new TreeSet（new StringLengthComparator（））； ts。add（”addfg“）； ts。add（”dfg“）； ts。add（”agtuug“）； ts。add（”vgjkg“）； sop（ts）； }}

基本資料型別或字串物件均實現了Comparable介面，故同種型別基本資料間具備比較性，即自然順序。

**Map：頂層介面，該集合儲存的是鍵值對，而且鍵是唯一的，Map和Set很像，Set集合底層就是使用了Map集合。

Map集合沒有迭代器，要取出元素必須先將Map集合轉換成Set集合才能遍歷元素

|——->HashTable（JDK1。0）：

底層是雜湊表資料結構；

不可以使用null鍵和null值；

用作鍵的物件必須實現hashCode和equals方法來保證鍵的唯一性

執行緒同步，效率低

|——->HashMap（JDK1。2）：

底層是雜湊表資料結構；

允許使用null鍵和null值；

執行緒不同步，效率高；

保證元素唯一性的：

原理：先判斷元素的hashCode值是否相同，再判斷兩元素的equals方法是否為true

（往HashSet裡面存的自定義元素要複寫hashCode和equals方法，

以保證元素的唯一性！）

class Student { private String name； private int age； public Student（String name， int age） { super（）； this。name = name； this。age = age； } public int getAge（） { return age； } public void setAge（int age） { this。age = age； } public String getName（） { return name； } public void setName（String name） { this。name = name； } @Override public int hashCode（）{ return name。hashCode（）+age*34； } @Override public boolean equals（Object obj）{ if（！（obj instanceof Student）） return false； Student stu = （Student）obj； return this。name。equals（stu。name）&&this。age==stu。age； } public class HashMapDemo1 { public static void main（String［］ args） { Map hmap = new HashMap（）； hmap。put（new Student（”001“，20）， ”beijing“）； hmap。put（new Student（”002“，25）， ”hebei“）； hmap。put（new Student（”003“，50）， ”hainan“）； hmap。put（new Student（”001“，20）， ”beijing“）； System。out。println（hmap。size（））； Set keySet = hmap。keySet（）； Iterator it = keySet。iterator（）； while（it。hasNext（））{ Student stu = it。next（）； String addr = hmap。get（stu）； System。out。println（stu。getName（）+”。。“+stu。getAge（）+”：：“+addr）； }     }     }

|——->TreeMap（JDK1。0）：

底層是二叉樹結構；

允許使用null鍵和null值；

執行緒不同步；

可以給Map集合中的鍵進行排序。

TreeMap排序的第一種方式：讓元素自身具備比較性，比如八種基本資料型別或則字串，

實現Compareble介面，覆蓋compareTo方法，

此方式是元素的自然順序

TreeMap排序的第一種方式：當元素自身不具備比較性（比如儲存學生物件時）或者具備的

比較性不是我們所需要的比較性時（比如想字串的長度排序），

此時就需要讓集合自身具備自定義的比較性。

那如何讓集合自身具備比較性呢？可在集合初始化時，

就讓集合具備比較方式。即定義一個類，

實現Comparator介面，覆蓋compare方法。

class Student implements Comparable{ private String name； private int age； public Student（String name， int age） { super（）； this。name = name； this。age = age； }public int getAge（） { return age；}public void setAge（int age） { this。age = age；}public String getName（） { return name；}public void setName（String name） { this。name = name；}@Overridepublic int compareTo（Student stu） { int num = new     Integer（this。age）。compareTo（new Integer（stu。age））； if（num==0） return this。name。compareTo（stu。name）； return num；}            }public class HashMapDemo1 { public static void main（String［］ args） { Map tmap = new TreeMap（）； tmap。put（new Student（”001“，20）， ”beijing“）； tmap。put（new Student（”002“，25）， ”hebei“）； tmap。put（new Student（”003“，50）， ”hainan“）； tmap。put（new Student（”001“，20）， ”beijing“）； System。out。println（tmap。size（））； Set keySet1 = tmap。keySet（）； Iterator it1 = keySet1。iterator（）； while（it1。hasNext（））{ Student stu = it1。next（）； String addr = tmap。get（stu）； System。out。println（stu。getName（）+”。。“+stu。getAge（）+”：：“+addr）；         } }}

**Iterator：對collection進行迭代的迭代器。迭代器取代了Enumeration。

迭代器和列舉的區別：

迭代器允許呼叫者利用定義良好的語義在迭代期間從迭代器所指向的collection移除元素

方法名稱得到了改進，簡化書寫

**LisIterator：系列表迭代器，允許程式設計師按任一方向遍歷列表、迭代期間修改列表

**Comparable：此介面強行對實現它的每個類的物件進行整體自然排序。使元素具備比較性

**Comparator：強行對某個物件collection進行整體排序的比較函式，使集合具備比較性

**Collections：此類完全由在 collection 上進行操作或返回 collection 的靜態方法組成。

**Arrays：此類包含用來運算元組（比如排序和搜尋）的各種靜態方法

7、集合類各容器方法

**介面Collection方法摘要（沒有構造方法）

a）新增：

i。 boolean add（E e）

j。 boolean addAll（Collection c）

b）刪除：

i。 void clear（）：清空容器

j。 boolean remove（Objec object）：

k。 boolean removeAll（Collection c）：

c）判斷：

i。 boolean contains（Object object）：判斷是否包含此元素

j。 boolean containsAll（Collection c）：判斷是否包含一堆元素

k。 boolean equals（Object object）：比較此collection與指定物件是否相等

m。 boolean isEmpty（）：判斷是否集合為空

d）獲取：

h。 Iterator iterator（）：取出

i。 int hashCode（）：返回此collection的雜湊值

j。 int size（）：返回此collection中元素的個數

k。 boolean retainAll（Collection c）：取交集

m。 Object toArray（）：返回此collection中所有元素的陣列

n。 T［］ toArray（T［］ a）：返回包含此collection中所有元素的數值。

*****List集合子類及其方法

（1）List介面是Collection介面的一個子介面。

（2）List介面中的元素有如下特點（對角標的操作都是特有方法，因為有序）：

A：元素有序（儲存順序和取出順序一致）

B：元素可以重複

（3）List介面中的特有方法

A：add（int index，Object obj）：在指定位置加入元素

B：remove（int index）：移除指定位置的元素

C：set（int index，Object obj）：修改指定位置的元素

D：get（int index）：獲取指定位置的元素

E：indexOf（Object obj）：獲取指定元素的位置

F：subList（int start，int end）：從一個大的List中擷取一個小的List

G：listIterator（）：返回一個List介面特有的迭代器

（1）、ArrayList：

|——->構造方法摘要：（少用，不是重點）

ArrayList（）：構造一個初始容量為 10 的空列表。

ArrayList（Collection<？ extends E> c）： 構造一個包含指定 collection 的元素的列表，

ArrayList（int initialCapacity）： 構造一個具有指定初始容量的空列表。

|——->方法摘要：

|——->新增：

boolean add（E e）： 將指定的元素新增到此列表的尾部。

void add（int index， E element）： 將指定的元素插入此列表中的指定位置。

boolean addAll（Collection<？ extends E> c）：按照指定 collection 的迭代器所返回的元素順序，

將該 collection 中的所有元素新增到此列表的尾部

boolean addAll（int index， Collection<？ extends E> c）： 從指定的位置開始，將指定 collection

中的所有元素插入到此列表中。

|——->刪除：

void clear（）： 移除此列表中的所有元素。

E remove（int index）： 移除此列表中指定位置上的元素。

boolean remove（Object o）： 移除此列表中首次出現的指定元素（如果存在）。

protected void removeRange（int fromIndex， int toIndex）：

移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之間的所有元素。

boolean removeAll（Collection<？> c）： 從列表中移除指定 collection 中包含的其所有元素

|——->獲取：

E get（int index）： 返回此列表中指定位置上的元素。

int indexOf（Object o）： 返回此列表中首次出現的指定元素的索引，或如果此列表不包含元素，則返回 -1。

int lastIndexOf（Object o） 返回此列表中最後一次出現的指定元素的索引，或如果此列表不包含索引，則返回 -1。

public List subList（int fromIndex，int toIndex）： 返回列表中指定的 fromIndex（包括 ） 和 toIndex（不包括）之間的部分檢視。

Iterator iterator（）： 返回按適當順序在列表的元素上進行迭代的迭代器。

ListIterator listIterator（int index）：返回列表中元素的列表迭代器（按適當順序），從列表的指定位置開始。

|——->修改：（特有方法！！）

E set（int index， E element）： 用指定的元素替代此列表中指定位置上的元素。

（2）LinkedList：

|——->構造方法摘要：

LinkedList（）： 構造一個空列表。

LinkedList（Collection<？ extends E> c）： 構造一個包含指定 collection 中的元素的列表，

這些元素按其 collection 的迭代器返回的順序排列。

|——->方法摘要：（特有的）

|——->新增

void addFirst（E e）： 將指定元素插入此列表的開頭。

void addLast（E e）： 將指定元素新增到此列表的結尾。

|——->獲取元素，但不刪除元素

E get（int index）： 返回此列表中指定位置處的元素。

E getFirst（）： 返回此列表的第一個元素。

E getLast（）： 返回此列表的最後一個元素。

|——->獲取元素且刪除元素

E remove（）： 獲取並移除此列表的頭（第一個元素）。

E remove（int index）： 移除此列表中指定位置處的元素。

boolean remove（Object o）： 從此列表中移除首次出現的指定元素（如果存在）。

E removeFirst（）： 移除並返回此列表的第一個元素。

E removeLast（）： 移除並返回此列表的最後一個元素。

|——->修改

E set（int index， E element） 將此列表中指定位置的元素替換為指定的元素。

（3）Vector

|——->構造方法摘要：

Vector（）： 構造一個空向量，使其內部資料陣列的大小為 10，其標準容量增量為零。

Vector（Collection<？ extends E> c）： 構造一個包含指定 collection 中的元素的向量，

這些元素按其 collection 的迭代器返回元素的順序排列。

|——->方法摘要：

|——->新增：

boolean add（E e）： 將指定元素新增到此向量的末尾。

void add（int index， E element）： 在此向量的指定位置插入指定的元素。

boolean addAll（Collection<？ extends E> c）：

將指定 Collection 中的所有元素新增到此向量的末尾，

按照指定 collection 的迭代器所返回的順序新增這些元素。

boolean addAll（int index， Collection<？ extends E> c）： 在指定位置將指定 Collection 中的所有元素插入到此向量中。

|——->獲取：

Enumeration elements（）： 返回此向量的元件的列舉。

Vector特有的取出方式：

列舉和迭代器很像，其實列舉和迭代器是一樣的，只是因為列舉的名稱和方法的名稱

名字都過長，所以列舉被迭代器取代了。

|——->列舉Enumeration的方法摘要：

boolean hasMoreElements（）： 測試此列舉是否包含更多的元素。

E nextElement（）： 如果此列舉物件至少還有一個可提供的元素，

則返回此列舉的下一個元素。

*****Set集合子類及其方法

（1）HashSet：它不保證set的迭代順序；特別是它不保證該順序恆久不變。此類允許使用null元素。

|——->構造方法：

HashSet（） 構造一個新的空 set，其底層 HashMap 例項的預設初始容量是 16，載入因子是 0。75。

HashSet（Collection<？ extends E> c） 構造一個包含指定 collection 中的元素的新 set。

|——->方法摘要：

boolean add（E e） 如果此 set 中尚未包含指定元素，則新增指定元素。

void clear（） 從此 set 中移除所有元素。

Object clone（） 返回此 HashSet 例項的淺表副本：並沒有複製這些元素本身。

boolean contains（Object o） 如果此 set 包含指定元素，則返回 true。

boolean isEmpty（） 如果此 set 不包含任何元素，則返回 true。

Iterator iterator（） 返回對此 set 中元素進行迭代的迭代器。

boolean remove（Object o） 如果指定元素存在於此 set 中，則將其移除。

int size（） 返回此 set 中的元素的數量（set 的容量）。

（2）TreeSet：使用元素的自然順序對元素進行排序，或者根據建立 set 時提供的 Comparator 進行排序。

|——->構造方法：

TreeSet（） 構造一個新的空 set，該set根據其元素的自然順序進行排序。

TreeSet（Collection<？ extends E> c）

構造一個包含指定 collection 元素的新 TreeSet，它按照其元素的自然順序進行排序。

TreeSet（Comparator<？ super E> comparator） 構造一個新的空 TreeSet，它根據指定比較器進行排序。

|——->方法摘要：

新增：

boolean add（E e） 將指定的元素新增到此 set（如果該元素尚未存在於 set 中）。

boolean addAll（Collection<？ extends E> c） 將指定 collection 中的所有元素新增到此 set 中。

刪除：

void clear（） 移除此 set 中的所有元素。

boolean remove（Object o） 將指定的元素從 set 中移除（如果該元素存在於此 set 中）。

E pollFirst（） 獲取並移除第一個（最低）元素；如果此 set 為空，則返回 null。

E pollLast（） 獲取並移除最後一個（最高）元素；如果此 set 為空，則返回 null。

獲取：

Iterator iterator（） 返回在此 set 中的元素上按升序進行迭代的迭代器。

E first（） 返回此 set 中當前第一個（最低）元素。

E last（） 返回此 set 中當前最後一個（最高）元素。

int size（） 返回 set 中的元素數（set 的容量）。

判斷：

boolean isEmpty（） 如果此 set 不包含任何元素，則返回 true。

boolean contains（Object o） 如果此 set 包含指定的元素，則返回 true。

**Map：將鍵對映到值的物件。Map集合沒有迭代器！Map集合特點：該集合儲存鍵值對。而且鍵是唯一的。

|——->方法摘要：

|——->新增：

V put（K key， V value） 將指定的值與此對映中的指定鍵關聯（可選操作）。

void putAll（Map<？ extends K，？ extends V> m） 從指定對映中將所有對映關係複製到此對映中

|——->刪除：

void clear（） 從此對映中移除所有對映關係（可選操作）。

V remove（Object key） 如果存在一個鍵的對映關係，則將其從此對映中移除（可選操作）。

|——->判斷

boolean containsKey（Object key） 如果此對映包含指定鍵的對映關係，則返回 true。

boolean containsValue（Object value） 如果此對映將一個或多個鍵對映到指定值，則返回 true。

boolean isEmpty（） 如果此對映未包含鍵-值對映關係，則返回 true。

|——->獲取

int size（） 返回此對映中的鍵-值對映關係數。

Collection values（） 返回此對映中包含的值的 Collection 檢視。

重點：Map集合沒有迭代器，以下是Map的兩種取出方式：

第一種：Set keySet（）

返回此對映中包含的鍵的Set檢視，將Map集合中所有的鍵存入Set集合，然後再透過Set集合的

迭代器取出所有的鍵，再根據get方法獲取每個鍵的值；

第二種：Set> entrySet（）

返回此對映中包含的對映關係的Set檢視，將Map集合中的對映關係存入到Set集合中，

這個對映關係的資料型別是Map。entry，再透過Map。Entry類的方法再要取出關係裡面的鍵和值

Map。Entry的方法摘要：

boolean equals（Object o） 比較指定物件與此項的相等性。

K getKey（） 返回與此項對應的鍵。

V getValue（） 返回與此項對應的值。

int hashCode（） 返回此對映項的雜湊碼值。

V setValue（V value） 用指定的值替換與此項對應的值（特有！！！）。

8、Map集合和Collection集合的區別？

1，

Map中一次儲存是鍵值對。

Collection中一次儲存是單個元素。

2，

Map的儲存使用的put方法。

Collection儲存使用的是add方法。

3，

Map集合沒有迭代器，Map的取出，是將Map轉成Set，在使用迭代器取出。

Collection取出，使用就是迭代器。

4，

如果物件很多，必須使用集合儲存。

如果元素存在著對映關係，可以優先考慮使用Map儲存或者用陣列，

如果沒有對映關係，可以使用Collection儲存。

8、迭代器：Iterator（Map集合沒有迭代器）

（1）迭代器就是取出集合元素的方式

（2）迭代器的作用

因為每個集合中元素的取出方式都不一樣，於是就把元素的取出方式進行抽取，並定義在集合內部，

這樣取出方式就可以直接訪問集合內部的元素；

而每個容器的資料結構不同，所以取出動作的細節也不一樣，但是有共性內容：判斷和取出。

那麼就將共性內容進行抽取，從而形成了介面Iterater

（3）獲取迭代器的方法：

Iterator iterator（） 返回在此 collection 的元素上進行迭代的迭代器。

Iterator iterator（） 返回在此 set 中的元素上進行迭代的迭代器。

（3）迭代器方法：

boolean hasNext（） 如果仍有元素可以迭代，則返回 true。

E next（） 返回迭代的下一個元素。

void remove（） 從迭代器指向的collection中移除迭代器返回的最後一個元素（可選操作）。

9、列表迭代器：ListIterator

（1）List集合特有的迭代器ListIterator是Iterator的子介面，在迭代時，不可以透過集合物件的

方法操作集合中的元素，因為會發生ConcurrentModificationException（當方法檢測到物件的併發修改，

但不允許這種修改時，丟擲此異常）

（2）Iterator方法有限，只能對元素進行判斷、取出和刪除的操作

ListIterator可以對元素進行新增和修改動作等。

（3）獲取列表迭代器方法：

ListIterator listIterator（） 返回此列表元素的列表迭代器（按適當順序）。

ListIterator listIterator（int index）

返回此列表中的元素的列表迭代器（按適當順序），從列表中指定位置開始。

（4）列表迭代器方法：

void add（E e） 將指定的元素插入列表（可選操作）。

boolean hasPrevious（） 如果以逆向遍歷列表，列表迭代器有多個元素，則返回 true。

int nextIndex（） 返回對 next 的後續呼叫所返回元素的索引。

E previous（） 返回列表中的前一個元素。

int previousIndex（） 返回對 previous 的後續呼叫所返回元素的索引。

void set（E e） 用指定元素替換 next 或 previous 返回的最後一個元素（可選操作）。

10、堆疊和佇列

堆疊：先進後出，比如杯子裡的水

佇列：先進先出，比如水管的水

11、集合類各種容器的使用注意細節

（1）迭代器：

**迭代器的next方法是自動向下取元素，要避免出現NoSuchElementException。

也就是在迭代迴圈中呼叫一次next方法一次就要hasNext判斷一次，比如語句

sop（it。next（）+”。。。“+it。next（））會發生上述異常。

**迭代器的next方法返回值型別是Object，所以要記得型別轉換，應用泛型後就不用強轉

（2）List集合：

**List集合裡面的元素因為是帶角標，所以List集合裡面的元素都是有序的，

另外List集合可以包含重複元素，也可以包含null。

**List集合有迭代器Iterator，還有一個特有迭代器列表ListIterator

**List集合中判斷元素是否相同都是用equals方法，無論contains、remove都依賴equals方法

比如往ArrayList集合裡面存放學生，同名同年齡視為同一個人，此時就需要在學生類複寫Object類

裡面的equals方法（非常重要！！！要注意！！）

（3）Set集合：

**Set接口裡面存放的是元素是無序的，不可以有重複元素，可以包含null

**Set集合只有一種取出方式，就是迭代器Iterator

**Set集合功能和Collection是一致的，沒有特殊方法

|——->HashSet：

**集合裡面存放的元素是無序的，唯一的

**底層資料結構是雜湊表，雜湊表結構的資料都是無序的，雜湊表結構的操作效率都高效

**執行緒不同步

**保證元素唯一性的原理是：透過複寫hashCode和equals方法

****如果兩元素的hashCode值相同，則繼續判斷兩元素equals是否為真

****如果兩元素的hashCode值不同，則不會呼叫equals方法。

**當我們往HashSet集合存放自定義的元素時（比如學生物件），通常都要複寫hashCode和equals方法，

而且hashCode和equals方法不透過我們呼叫，HashSet集合底層內部自己呼叫，自己拿元素去比較

|——->TreeSet

**TreeSet集合可以對存放的元素進行排序，彌補了Set集合元素無序的缺點，且元素是唯一的

**底層資料結構是二叉樹，二叉樹結構都是有序的

**執行緒不同步

**TreeSet集合要求往集合裡存放的元素自身具備比較性，否則會報錯

**TreeSet集合保證元素唯一性的依據是：透過compareTo或者compare方法中的來保證元素的唯一性。

TreeSet排序的第一種方式：讓元素自身具備比較性，

定義元素類實現Compareble介面，覆蓋compare方法，

此方式是元素的自然順序。

TreeSet排序的第二種方式：讓集合具備比較性

當元素自身不具備比較性或者具備的比較性不是

我們所需要的比較性時，此時就需要讓集合具備自定義的比較性。

那如何讓集合自身具備比較性呢？

可在集合初始化時，就讓集合具備比較方式。

即定義一個類，實現Comparator介面，覆蓋compare方法。

注：

**判斷元素唯一時，當主要條件一樣時，判斷次要條件

**兩種排序方式都在時，以比較器為主！！！

（4）Map集合：

|——Hashtable

底層是雜湊表結構

執行緒安全的，並且鍵和值不能為null。

|——HashMap

底層是雜湊表結構

執行緒不安全的，鍵和值可以為null。

|——LinkedHashMap

底層是連結串列和雜湊表

執行緒不安全

|——TreeMap

底層是二叉樹

執行緒不安全的

12、如果你想將一組物件按一定順序存取，在不考慮併發訪問的情況下會使用____C_____ ，

反之則會使用____A_____；如果你想儲存一組無序但唯一的物件，你會使用___B______ ；

如果你想按關鍵字對物件進行存取，在不考慮併發訪問的情況下會使用___D______ ，反之則會使用_____E____。

A。 Vector

B。 HashSet

C。 ArrayList

D。 HashMap

E。 Hashtable

13、泛型

（1）為什麼會出現泛型？

因為集合存放的資料型別不固定，故往集合裡面存放元素時，存在安全隱患，

如果在定義集合時，可以想定義陣列一樣指定資料型別，那麼就可以解決該類安全問題。

JDK1。5後出現了泛型，用於解決集合框架的安全問題。

泛型是一個型別安全機制。

（2）泛型定義格式：透過<>來定義要操作的引用資料型別

ArrayList al = new ArrayList；

（3）泛型的好處：

**將執行時期出現的ClassCastException（型別轉換異常）問題轉移到編譯時期；

**避免了強制轉換的麻煩

（4）什麼時候定義泛型？

泛型在集合框架中很常見，只要見到<>就要定義泛型。其實<>就是用來接收型別的。

當使用集合時，將集合中要儲存的資料型別作為引數傳遞到<>中即可

（5）泛型的形式

**泛型類：即自定義泛型類

A：當類中要操作的引用資料型別不確定時，早起定義Object來完成擴充套件，現在定義泛型來完成

B：侷限性：泛型類定義的泛型，在整個類中有效，如果該泛型類的方法被呼叫，

當泛型類的物件明確要操作的型別後，所有要操作的型別就被固定。

**泛型方法：泛型放在返回值前面，修飾符的後面

A：為了避免泛型類的侷限性，讓不同方法可以操作不同的型別，而且型別還不確定，

則可以將泛型定義在方法上

B：特殊之處：靜態方法不可以反問類上定義的泛型

如果靜態方法操作的應用資料型別不確定，可以講泛型定義在靜態方法上

**泛型介面：

當泛型定義在介面上時，則子類中要指定實現介面型別，同時還可以子類也可以定義為泛型類

（6）泛型的高階應用：？萬用字元

**當指定兩種泛型的集合，則迭代時也要定義兩種泛型的迭代器，麻煩，此時可透過將迭代器的泛型

改為？，如Iterator<？> it=al。iterator（）；

**兩種泛型限定

向上限定： ？ extends E ；E可以接收E型別或者E的子類

向下限定： ？ super E ；E可以接收E型別或者E的父類

14、高階for迴圈

（1）JDK1。5新特性，代替迭代器使用時的不爽，簡化書寫，底層原理是迭代器凡是支援迭代器的都支援高階for迴圈

高階for迴圈，只用於集合和陣列的遍歷，集合只能用Collection不能用Map集合

只能把Map集合轉化成Set集合，才能用for迴圈。

（2）格式

for（資料型別 變數名：被遍歷的集合（Collection）或者陣列）

{

}

（3）侷限性：

必須要有遍歷的目標

對集合或者陣列進行遍歷時，只能獲取集合元素，不能對集合元素進行操作

迭代器除了遍歷，還可以進行remove操作集合中的元素

列表迭代器還可以在遍歷過程中進行增刪改查的操作

（4）傳統for迴圈和高階for迴圈的區別

高階for迴圈有一個侷限性，就是必須要有遍歷的目標（集合或者陣列）

遍歷陣列時建議使用傳統for迴圈，因為可以定義角標，比如列印100次helloworld時用傳統for迴圈方便

15、可變引數

（1）陣列的可變引數

格式：

int。。。 arr

（3）方法的可變引數

格式：

public static void show（String str，int。。。 arr）

{

}

注意：可變引數一定要放在引數列表的最後面

16、靜態匯入

**import static java。util。Arrays。* 匯入的是Arrays這個類中所有的靜態方法

**當類名重名時，需要制定具體的報名

**當方法重名時，需要制定具體所屬的物件或者類

17、Collections類

（1）此類完全由在 collection 上進行操作或返回 collection 的靜態方法組成。

（2）靜態方法摘要：

static boolean addAll（Collection<？ super T> c， T。。。 elements）

將所有指定元素新增到指定 collection 中。

static void fill（List<？ super T> list， T obj）

使用指定元素替換指定列表中的所有元素。

static boolean replaceAll（List list， T oldVal， T newVal）

使用另一個值替換列表中出現的所有某一指定值。

static void reverse（List<？> list）

反轉指定列表中元素的順序。

static Comparator reverseOrder（）

返回一個比較器，它強行逆轉實現了 Comparable 介面的物件 collection 的自然順序

static Comparator reverseOrder（Comparator cmp）

返回一個比較器，它強行逆轉指定比較器的順序。

（3）Collections類特牛的方法：

集合有一個共同的缺點，那就是執行緒不安全，被多執行緒操作時，容易出現問題，雖然可以自己加鎖

但是麻煩。Collections提供特牛的方法，就是給它一個不同步的集合，它返回一個同步的安全的集合

static Collection synchronizedCollection（Collection c）

返回指定 collection 支援的同步（執行緒安全的）collection。

static List synchronizedList（List list）

返回指定列表支援的同步（執行緒安全的）列表。

static Map synchronizedMap（Map m）

返回由指定對映支援的同步（執行緒安全的）對映。

static Set synchronizedSet（Set s）

返回指定 set 支援的同步（執行緒安全的）set。

static SortedMap synchronizedSortedMap（SortedMap m）

返回指定有序對映支援的同步（執行緒安全的）有序對映。

static SortedSet synchronizedSortedSet（SortedSet s）

返回指定有序 set 支援的同步（執行緒安全的）有序 set。

18、Arrays類

此類包含用來運算元組（比如排序和搜尋）的各種方法。裡面都是靜態方法。

如果指定陣列引用為 null，則此類中的方法都會丟擲 NullPointerException。

（1）靜態方法摘要：

static List asList（T。。。 a）

返回一個受指定陣列支援的固定大小的列表。

注意：

A：該方法將一個數組變成集合後，不可以使用集合的增刪方法，因為陣列的長度是固定的！

如果增刪，則發生UnsupportedOprationException（不支援操作異常）

B：如果陣列中的元素都是基本資料型別，則該陣列變成集合時，會將該陣列作為集合的一個

元素出入集合

C：如果陣列中的元素都是物件，如String，那麼陣列變成集合後，陣列中的元素就直接轉成

集合中的元素

19、陣列變集合以及集合變陣列的對比

（1）陣列變集合：

方法：static List asList（T。。。 a） 返回一個受指定陣列支援的固定大小的列表。

好處：可以使用集合的思想和方法運算元組中的元素，陣列是一個物件，但是陣列中的功能很少

（2）集合變陣列：

方法：Collction中的toArray方法

好處：可以限定對集合元素的操作，防止對集合的元素進行增刪，因為陣列長度是固定的。

20、Collections類和Arrays類的使用。（重點）

A：Collections

排序

二分查詢

發轉

B：Arrays

把陣列變成字串輸出

排序

二分查詢

21、System

（1）描述系統資訊的類

（2）該類沒有構造方法，該類的方法和屬性都是靜態的

（3）欄位摘要：

static InputStream in “標準”輸入流。

static PrintStream out “標準”輸出流。

（4）方法摘要：

static void exit（int status） 終止當前正在執行的 Java 虛擬機器。

static void gc（） 執行垃圾回收器。

static Properties getProperties（） 確定當前的系統屬性

static String getProperty（String key） 獲取指定鍵指示的系統屬性。

static String getProperty（String key， String def） 獲取用指定鍵描述的系統屬性。

static void setIn（InputStream in） 重新分配“標準”輸入流。

static void setOut（PrintStream out） 重新分配“標準”輸出流。

static void setProperties（Properties props） 將系統屬性設定為 Properties 引數。

static String setProperty（String key， String value） 設定指定鍵指示的系統屬性。

22、Runtime

（1）每個 Java 應用程式都有一個 Runtime 類例項，使應用程式能夠與其執行的環境相連線。

可以透過 getRuntime 方法獲取當前執行時。 應用程式不能建立自己的 Runtime 類例項。

（2）該類沒有建構函式，也就是它不能直接建立物件，但是它裡裡面的方法又不是靜態的

，故它一定有一個方法返回本類物件

（3）故該類是單例設計模式，保證在記憶體中只有一個物件

（4）方法摘要：

Process exec（String command） 在單獨的程序中執行指定的字串命令

void gc（） 執行垃圾回收器。

static Runtime getRuntime（） 返回與當前 Java 應用程式相關的執行時物件

void exit（int status） 透過啟動虛擬機器的關閉序列，終止當前正在執行的 Java 虛擬機器

23、Date

（1）Date介面表示特定的瞬間，精確到毫秒

（2）構造方法

Date（） 分配 Date 物件並初始化此物件，以表示分配它的時間（精確到毫秒）。

Date（long date） 分配Date物件並初始化此物件，以表示自從標準基準時間（稱為“曆元（epoch）”，

即1970年1月1日00：00：00GMT）以來的指定毫秒數。

（3）方法摘要：

int compareTo（Date anotherDate） 比較兩個日期的順序。

boolean equals（Object obj） 比較兩個日期的相等性。

24、Calendar

（1）直接已知子類： GregorianCalendar

（2）構造方法：

protected Calendar（） 構造一個帶有預設時區和語言環境的 Calendar。

protected Calendar（TimeZone zone， Locale aLocale） 構造一個帶有指定時區和語言環境的 Calendar。

（3）方法摘要：

static Calendar getInstance（） 使用預設時區和語言環境獲得一個日曆。