String、基本資料型別包裝類、集合和泛型

阿新 • • 發佈：2019-01-18

String類：

· 字串是一個特殊的物件，在java中只要被雙引號引起來的都是字串物件

· 字串一旦初始化就不可以被改變

· String類複寫了Object類中的equals方法，該用法用於判斷字串是否相同

· String s1 = "abc" 和 String s2 = new String("abc");有什麼區別？

答：s1在記憶體中只有1個物件。而s2在記憶體中有2個物件

· String s1 = "abc"，String s2 = new String("abc");String s3 = "abc";這些字串用==連線結果是什麼？

答：s1==s2結果為false，因為s1和s2不是同一個物件。

s1==s3結果為true，因為字串作為一個特殊的物件，已經在記憶體中存在了，就不會建立新的物件。所以s1和s3指向的是同一個物件

字串的常見操作：

獲取：

1. 字串中包含的字元數，也就是字串長度： int length()

2. 根據位置獲取位置上某個字元 char charAt(int index); 當訪問到不存在的腳標時，會發生字串角標越界異常

3. 根據字元獲取該字元在字串中的位置：

int indexOf(int ch) ： 返回的是ch在字串中第一次出現的位置
int indexOf(int ch, int fromIndex) ： 從fromIndex指定位置開始，獲取ch在字串中出現的位置

int indexOf(String str) ： 返回的是str在字串中第一次出現的位置
int indexOf(String str, int fromIndex) ： 從fromIndex指定位置開始，獲取str在字串中出現的位置

如果沒有找到，返回-1

還提供了lastIndexOf的方法，反向索引

判斷：

//字串中是否包含某一個字串
boolean contains(CharSequence str);//CharSequence是一個介面，String是其子類
//字串中是否有內容
boolean isEmpty();
//字串是否是以指定內容開頭
boolean startsWith(String str);
//字串是否是以指定內容結尾
boolean endsWith(String str);
//判斷字串內容是否相同。複寫了Object類中的equals方法
boolean equals(String str);
//判斷字串內容是否相同，並且忽略大小寫
boolean equalsIgnoreCase(String str);

轉換：

//將字元陣列轉成字串：
//通過String的建構函式：	
String(char[])
String(charr[],offset,count)：將字元陣列中第一部分轉換成字串
//靜態方法：
static String copyValueOf(char[])
static String copyValueOf(char[] data, int offset, int count 

//將字串轉成字元陣列 **
char[] toCharArray()

//將位元組陣列轉成字串和字元陣列轉成字串一樣，也是構造方法

//將字串轉成位元組陣列
byte getBytes()

//將基本資料型別轉換成字串
static String valueOf(int)：int可以是double等等

特殊：字串和位元組陣列在轉換過程中，是可以指定編碼表的

替換：

String replace(char oldChar,char new Char);//如果要替換的字串不存在，返回的還是原串

切割：

String[] split(rString egex);

子串，獲取字串的一部分：

String substring(int begIndex)：從指定位置開始到結尾

String substring(int begIndex, int endIndex)：包含頭不包含尾

轉換，去除空格，比較：

String toUpperCase()//將字串轉換轉成大寫
String toLowerCase()//將字串轉換轉成小寫

String trim()//將字串兩端的多個空格去除
 
int compareTo(String);//將兩個字串進行自然順序的比較。大於返回的是正數，等於返回的是0，小於返回的是負數

StringBuffer：

· StringBuilder：和StringBuffer一樣，只是執行緒不同步。並且StringBuilder是JDK1.5之後才有的

· StringBuffer是字串緩衝區：

1. 長度是可變的

2. 可以直接操作多個數據型別

3. 最終會通過toString方法變成字串

· StringBuffer是一個容器：CURD（create，update，read，delete）

1. 增 create：

StringBuffer append(引數)：將指定資料作為引數新增到已有資料的結尾處
StringBuffer insert(int offset,引數)：將制定資料作為引數新增到指定位置

2. 刪 delete：

StringBuffer delete(int start,int end)：刪除緩衝區的資料，包含start，不包含end
StringBuffer deleteCharAt(int index)：刪除指定位置的字元

3. 讀 read：

char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start,int end)

4. 改 update：

StringBuffer replace(int start,int end,String str)：替換一段位置內的字串
void setCharAt(int index,char c)：替換指定位置的字元
StringBuffer reverse()：反轉
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)：將緩衝區中的指定

· 字串的組成原理就是通過該類實現的，很多方法和String相同

基本資料型別物件包裝類：

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

· 對應關係中，都是將首字母大寫的就是對應的包裝類，除了int對應Integer和char對應Character

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

例：Integer.parseInt("43");//將字串轉成整數

例：在Integer中，就可以直接獲取整數型別的最大值，Integer.MAX_VALUE

· 新特性：在JDK1.5之後，簡化了定義的方法：

例：Integer x = new Integer(4) 可以直接寫成 Integer x = 4;//自動裝箱。x = x + 5;//自動拆箱，x變成了int型別，通過intValue()

· 需要注意：

1. 在使用時，Integer x = null，上面的程式碼就會出現NullPointException

2. 當數值在byte範圍內，對於新特性，如果該值已經存在，則不會開闢新的記憶體空間。所以Integer a = 128 和 Integer b = 128。進行==判斷的結果為false

集合：

· 為什麼要出現集合？

答：面嚮物件語言對事物的體現都是以物件的形式，所以為了方便多個物件的操作，就對物件進行儲存，集合就是就是儲存物件最常用的一個方法。

· 陣列和集合類同是容器，有何不同？

答：陣列雖然也可以儲存物件，但是長度是固定的；集合長度是可變的。陣列中可以儲存基本資料型別，集合只能儲存物件

· 集合的特點：

答：集合只用於儲存物件，集合長度是可變的，集合可以儲存不同型別的物件

集合框架的構成以及分類：

· 為什麼要有這麼多容器？

答：因為每一個容器對資料的儲存方式都不同，這個儲存稱之為：資料結構

集合框架中的常用介面：

· Collection介面中有2個子介面：List（列表），Set（集）

· Collection中定義的常用方法：

1. 增：add(Object obj)

2. 刪：remove(Object obj)

3. 獲取，通過迭代器：Iterator iter = collection.iterator()

· List：可存放重複元素，元素存取是有序的。因為該集合體繫有索引。凡是可以操作腳標的方法，都是該體系特有的方法

1. 增：add(index, element)：指定腳標新增元素；addAll(index, Collection)：指定角標新增一堆元素

2. 刪：remove(index)

3. 改：set(index, element)

4.查：get(Index) subList(from) ListIterator()：Iterator的子介面，比Iterator多了新增和修改的方法

· Set：不可以存放重複元素，元素存取是無序的。該集合體系沒有索引

· 注意：集合中儲存的都是物件的引用

List介面中常用類：

· Victor：執行緒安全，但速度慢，已經被ArrayList取代。Vector特有方法，elements()放回的一個列舉Enumeration。Enumeration方法和Iterator一樣，但是Enumeration方法和方法名都過長，所以Iterator取代了

· ArrayList：執行緒不安全，查詢速度快。底層使用的是資料結構

· LinkedList：連結串列結構，增刪速度快。

迭代：

· 迭代是取出集合中元素的一種方法

· 因為Collection中有iterator方法，所以每一個子類集合物件都具備迭代器

· 用法：

//for迴圈方法
for(Iterator iterator = collection.iterator();iter.hasNext(); ) 	{
	iterator.next();//返回值型別是Object
}
//while迴圈方式
Iterator iterator = collection.iterator();//獲取迭代其
while(iterator.hasNext()) {
	iterator.next();
}

迭代器注意事項：

· 迭代器在Collection介面中是通用的，它替代了Vector類總的Enumeration

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

· 迭代器的next方法返回值型別是Object，所以記得要做強制型別轉換

Set介面中常用的類：

· HashSet：執行緒不安全，存取速度快

· TreeSet：執行緒不安全，可以對Set集合中的元素進行排序

Set集合元素唯一性原因：

· HashSet：通過equals方法和hashCode方法來保證元素的唯一性。判斷元素的hashCode值是否相同，如果相同，還會繼續判斷元素的equals方法，是否為true

· TreeSet：通過compareTo或者compare方法來保證元素的唯一性。元素是以二叉樹形式存在的。

1. TreeSet排序的第1種方法，讓元素自身具備比較性，元素實現Comparable介面，覆蓋compareTo方法。這種方法也稱為元素的自然順序，或者叫預設順序

2. TreeSet的第2種排序方式，當元素自身不具備比較性時，或者具備的比較性不是所需要的。這時就要讓集合自身具備比較性。在集合初始化時就有了比較方式，定義了比較器，將比較器作為引數傳遞給TreeSet集合建構函式。

· 當2種排序都存在時，以比較器為主。

· 定義比較器的方法：定義一個類，實現Comparator介面，覆蓋compare方法。

泛型：

· JDK1.5以後出現的新特性。用於解決安全問題，是一個型別安全機制

· 好處：

1. 將執行時期出現的問題ClassCastException，轉移到了編譯時期。方便與程式設計師解決問題。讓執行時問題減少，安全

2. 避免了強制型別轉換的麻煩

· 在使用java提供的物件時，什麼時候寫泛型？

答：通常在集合框架中很常見，只要見到<>就要定義泛型。其實<>就是用來接收型別的。當使用集合時，將集合中要儲存的資料型別作為引數傳遞到<>中即可。

· 缺點：不能預先使用子類中特有的方法

自定義泛型：

· 程式碼示例：

class Utils<E> {
	private E e;
	public void setObject(E e) {
		this.e = e;
	}
	public E getObject() {
		return e;
	}
}

· 自定義泛型方法，泛型類定義的泛型，在整個類中有效，如果被方法呼叫，那麼泛型類的物件明確要操作的具體型別後，所有要操作的型別就已經固定了。

//為了然不同的方法可以操作不同的型別，而且型別還不確定。那麼可以將方法定義在泛型上！
public <T> void show(T t) {
	System.out.println("show"+t);
}
//特殊之處：靜態方法不可以訪問類上定義的泛型，如果靜態方法操作的應用資料型別不確定，可以將泛型定義在方法上。
public static <E> void print(E e) {
	System.out.println("print"+e);
}

· 什麼時候定義泛型？

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

泛型的特點：

· 提高了程式的安全性

· 將執行期間遇到的問題轉移到了編譯時期

· 省去了型別轉換的麻煩

· 泛型類的出現優化了程式設計

泛型限定：

· ? 萬用字元，也可以理解為佔位符。

· ? extends E：可以接收E型別或者E型別的子類。稱為上限

· ? super E：可以接收E型別或者E型別的父類。稱為上限

所以：在java設計的時候，就用到了泛型的限定。例如Collection就可以接收類和類的子類。

Map集合

· Set集合底層就是使用了Map集合

· Map集合儲存與取出元素的方法

//1. 新增
V put(K key, V value);//當你存了相同的鍵的時候，新的value換替換原來的value。並且會返回原來的value
V putAll(Map<? extends K,? extends V> n)
//2. 刪除
void clear()：移除所有
V remove(Object key)
//3. 判斷
boolean containsKey(Object key)
boolean cotainsValue(Object value)
boolean isEmpty();
//4. 獲取
V get(Object key)
int size()
Collection<V> values()
Set<Map,Entry<K,Y>> entrySet()
Set<K> keySet()

· 什麼時候用Map集合呢？

答：當資料之間存在著對映關係時，就要先想到map集合

Map與Collection：

· Map與Collection在集合框架中並列存在

· Map儲存的是鍵值對

· Map儲存元素使用put方法，Collection使用add方法

· Map集合沒有直接取出元素的方法，而是先轉成Set集合，再通過迭代取出

· Map集合要保證元素的唯一性

Map集合的2種取出方式：

//第1種：Set<K> keySet：將map中所有的鍵存入到Set集合，因為set具備迭代器，可以用迭代方式取出所有的鍵，再根據get方法。獲取每一個鍵對應的值
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "張飛");
map.put(2, "關羽");
map.put(3, "劉備");
map.put(4, "趙雲");
//先獲取map集合中鍵的Set集合
Set<Integer> keySet = map.keySet();
//有了Set集合，就可以獲取其迭代器了
Iterator<Integer> iterator = keySet.iterator();
while(iterator.hasNext()) {
	int key = iterator.next();
	String value = map.get(key);
	System.out.println("key="+key+",value="+value);
}

//第2種：Set<Map.Entry<K,V>> entrySet：將Map集合中的對映關係存入到了set集合中，而這個關係資料型別就是：Map.Entry
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "張飛");
map.put(2, "關羽");
map.put(3, "劉備");
map.put(4, "趙雲");
//將Map集合中的對映關係取出，存入到集合中
Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
Iterator<Map.Entry<Integer,String>> iterator = entrySet.iterator();
while(iterator.hasNext()) {
	//每個對映關係就是一個Map.Entry
	Map.Entry<Integer,String> entry = iterator.next();
	int key = entry.getKey();
	String value = entry.getValue();
	System.out.println("key="+key+",value="+value);
}

· Map.Entry：其實Entry也是一個介面，是Map介面中的一個static interface。因為Entry存放的是對映關係，所以要先有Map才能有Entry，所以Entry作為Map的內部類。

Map集合常用類：

· Hashtable：執行緒安全，速度慢。不允許存放null鍵、null值，已被HashMap替代

· HashMap：執行緒不安全，速度快。允許存放null鍵，null值

· TreeMap：執行緒不安全，對鍵進行排序，排序原理與TreeSet相同

Map集合的擴充套件知識：

· Map集合中還可以巢狀Map集合。也就是存在一對多的關係的時候，雖然可以使用多個Map，但是在取出的時候需要多個巢狀迴圈。所以開發一般把物件封裝起來。

集合框架中的工具類：

· Collections就是對Collection集合提供的一些工具方法

· 常用方法：

//1，使用二分搜尋法搜尋指定列表，獲取指定物件。返回插入點-1
static<T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
static<T> int binarySearch(List<? extends Comparable<? super T> list, T key, Comparator<? super T> c)
//2，反轉指定列表中元素的順序
static reverse(List<?> list)
//3，強行逆轉一個比較器或者一個元素的自然順序
static<T> Comparator<T> reverseOrder()
static<T> Comparator <T> reverseOrder(Comparator<T> cmp)
//4，使用預設隨機源對指定列表進行置換，也可以使用指定隨機源
static void shuffle(List<?> list)
static void shuffle(List<?> list,Random rnd)
//5，根據元素的自然順序對指定列表進行排序，也可以指定一個比較器
static <T extends Comparable<? super T>> void sort(List<T>  list)
static<T> void sort(List<T> list,Comparator<? super T> c)
//6，在指定列表的指定位置出交換元素
static void swap(List<?> list,int i,int j)

· Collection和Collections有什麼區別？

答：Collection是集合框架的一個頂層介面，它裡面定義了單列集合的共性方法。它有2個常用子類介面（List和Set）。而Collections是集合框架的一個工具類，該類中的方法都是靜態的。提供的方法中有可以對List集合進行排序，二分查詢等。通常常用的集合都是執行緒不安全的，因為要提高效率。如果多執行緒操作這些集合時，可以通過該工具類中的方法，將執行緒不安全的集合，轉換成安全的。

· Arrays：用於運算元組的工具類。大部分方法與Collections一致

//1. 陣列變集合：
static <T> list <T> asList(T... a) 返回一個受指定陣列支援的固定大小的列表
/*
把陣列變集合有什麼好處？
可以使用集合的思想和方法來運算元組中的元素。
注意：
(a)將陣列變成集合，不可以使用集合的增刪方法。因為陣列的長度是固定的。如果使用了增刪方法，會發生UnsupportedOperationException。
(b)如果陣列中的元素都是物件，那麼變成集合時，陣列中的元素就直接轉成集合中的元素。
(c)如果陣列中的元素是基本資料型別，那麼會將該陣列作為集合中的元素存在。例如：
int[] arr = {3,7,1};
					List<int[]> list = Arrays.asList(arr);
	System.out.println(list);//這時輸出值是陣列的地址值
*/
//2. 集合變陣列：
//Collection介面中的toArray方法：
Object[] toArray()
<T> T[] toArray(T[] a)
/*
1，指定型別的陣列到底要定義多長呢？
當指定型別的陣列長度小於了集合的size，那麼該方法內部就會建立一個新的陣列。長度為集合的size。
當指定型別陣列的長度大於了集合的size，就不會建立新的陣列。而是使用傳遞進來的陣列。
所以建立一個剛剛好的陣列最優。
2，為什麼要將集合變陣列？
為了限定對元素的操作。不需要進行增刪了。
*/

高階for迴圈：

· Collection在JDK1.5後出現的父介面，iterator就是提供了這個for語句 · 格式：

for(資料型別 變數名：陣列或集合) {
	執行語句；
}

· 簡化了對陣列，集合的遍歷。但是隻能獲取集合元素，不能對集合進行操作。迭代器除了遍歷，還可以進行remove集合中的元素。如果是ListIterator，還可以的在遍歷過程中對集合進行增刪改查的動作。

· 傳統for迴圈和高階for迴圈有什麼區別？

答：高階for迴圈有一個侷限性，必須有被遍歷的目標。所以建立遍歷陣列時，還是希望使用傳統for迴圈。因為傳統for迴圈可以定義腳標。