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<Integer> 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();
5、集合框架：
(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<Student , String> hmap = new HashMap<Student , String>();
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<Student> keySet = hmap.keySet();
Iterator<Student> 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<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 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<Student , String> tmap = new TreeMap<Student , String>();
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<Student> keySet1 = tmap.keySet();
Iterator<Student> 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：此類包含用來操作數組(比如排序和搜索)的各種靜態方法
6、集合類各容器方法：
**接口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<E> subList(int fromIndex,int toIndex): 返回列表中指定的 fromIndex（包括 ） 和 toIndex（不包括）之間的部分視圖。
Iterator<E> iterator(): 返回按適當順序在列表的元素上進行迭代的迭代器。
ListIterator<E> 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<E> 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<E> 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<E> 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<V> values() 返回此映射中包含的值的 Collection 視圖。
重點：Map集合沒有迭代器，以下是Map的兩種取出方式：
第一種：Set<K> keySet()
返回此映射中包含的鍵的Set視圖，將Map集合中所有的鍵存入Set集合，然後再通過Set集合的
迭代器取出所有的鍵，再根據get方法獲取每個鍵的值；
第二種：Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射關係的Set視圖，將Map集合中的映射關係存入到Set集合中，
這個映射關係的數據類型是Map.entry,再通過Map.Entry類的方法再要取出關係裏面的鍵和值
Map.Entry的方法摘要：
boolean equals(Object o) 比較指定對象與此項的相等性。
K getKey() 返回與此項對應的鍵。
V getValue() 返回與此項對應的值。
int hashCode() 返回此映射項的哈希碼值。
V setValue(V value) 用指定的值替換與此項對應的值(特有！！！)。
7、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<E> iterator() 返回在此 collection 的元素上進行迭代的迭代器。
Iterator<E> iterator() 返回在此 set 中的元素上進行迭代的迭代器。
(3)迭代器方法：
boolean hasNext() 如果仍有元素可以迭代,則返回 true。
E next() 返回迭代的下一個元素。
void remove() 從迭代器指向的collection中移除迭代器返回的最後一個元素（可選操作）。
9、列表迭代器：ListIterator
(1)List集合特有的迭代器ListIterator是Iterator的子接口，在迭代時，不可以通過集合對象的
方法操作集合中的元素，因爲會發生ConcurrentModificationException(當方法檢測到對象的併發修改，
但不允許這種修改時，拋出此異常)
(2)Iterator方法有限，只能對元素進行判斷、取出和刪除的操作
ListIterator可以對元素進行添加和修改動作等。
(3)獲取列表迭代器方法：
ListIterator<E> listIterator() 返回此列表元素的列表迭代器（按適當順序）。
ListIterator<E> 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<String> al = new ArrayList<String>;
(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 <T> boolean addAll(Collection<? super T> c, T... elements)
將所有指定元素添加到指定 collection 中。
static <T> void fill(List<? super T> list, T obj)
使用指定元素替換指定列表中的所有元素。
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
使用另一個值替換列表中出現的所有某一指定值。
static void reverse(List<?> list)
反轉指定列表中元素的順序。
static <T> Comparator<T> reverseOrder()
返回一個比較器，它強行逆轉實現了 Comparable 接口的對象 collection 的自然順序
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一個比較器，它強行逆轉指定比較器的順序。
(3)Collections類特牛的方法：
集合有一個共同的缺點，那就是線程不安全，被多線程操作時，容易出現問題，雖然可以自己加鎖
但是麻煩。Collections提供特牛的方法，就是給它一個不同步的集合，它返回一個同步的安全的集合
static <T> Collection<T> synchronizedCollection(Collection<T> c)
返回指定 collection 支持的同步（線程安全的）collection。
static <T> List<T> synchronizedList(List<T> list)
返回指定列表支持的同步（線程安全的）列表。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
返回由指定映射支持的同步（線程安全的）映射。
static <T> Set<T> synchronizedSet(Set<T> s)
返回指定 set 支持的同步（線程安全的）set。
static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
返回指定有序映射支持的同步（線程安全的）有序映射。
static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
返回指定有序 set 支持的同步（線程安全的）有序 set。
18、Arrays類：
此類包含用來操作數組（比如排序和搜索）的各種方法。裏面都是靜態方法。
如果指定數組引用爲 null，則此類中的方法都會拋出 NullPointerException。
(1)靜態方法摘要：
static <T> List<T> asList(T... a)
返回一個受指定數組支持的固定大小的列表。
注意：
A:該方法將一個數組變成集合後，不可以使用集合的增刪方法，因爲數組的長度是固定的！
如果增刪，則發生UnsupportedOprationException(不支持操作異常)
B:如果數組中的元素都是基本數據類型，則該數組變成集合時，會將該數組作爲集合的一個
元素出入集合
C:如果數組中的元素都是對象，如String，那麼數組變成集合後，數組中的元素就直接轉成
集合中的元素
19、數組變集合以及集合變數組的對比：
(1)數組變集合：
方法：static <T> List<T> 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() 使用默認時區和語言環境獲得一個日曆。