面向對象
集合框架的工具類。
Collections:集合框架的工具類。裏面定義的都是靜態方法。(相信Java的新手們都知道,如果一個類全都是靜態方法的話,那麼這個類肯定不能創建對象,也不需要給你提供對象的獲取方法,因爲靜態都是優先於對象存在的)
Collections和Collection有什麼區別?
Collection是集合框架中的一個頂層接口,它裏面定義了單列集合的共性方法。
它有兩個常用的子接口,
List:對元素都有定義索引。有序的。可以重複元素。
Collections:靜態方法Set:不可以重複元素。無序。
Collections是集合框架中的一個工具類。該類中的方法都是靜態的。
提供的方法中有可以對List集合進行排序,二分查找等方法。
通常常用的集合都是線程不安全的。因爲要提高效率。
如果多線程操作這些集合時,可以通過該工具類中的同步方法,將線程不安全的集合,轉換成安全的。
static
<T extends Comparable<? super T>>
voidsort(List<T> list)
根據元素的自然順序 對指定列表按升序進行排序。/*
一個學校,每個學校都有學科,班級的名字就是對應的學科。
對每門學科進行自然排序。
*/
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class Test{
public static void main(String[] args){
List<String> list =new ArrayList<String>();
list.add("黑馬程序員");
list.add("黑馬程序員——雲計算");
list.add("黑馬程序員——android");
list.add("黑馬程序員——.Net");
list.add("黑馬程序員——iso");
for(Iterator <String>it = list.iterator();it.hasNext();){
sop(it.next());
}
Collections.sort(list);
for(Iterator <String>iter = list.iterator();iter.hasNext();){
sop(iter.next());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
Collections:靜態方法
static
<T> int
binarySearch(List<? extendsComparable<? super T>> list, T key)
使用二分搜索法搜索指定列表,以獲得指定對象。static
<T> int
binarySearch(List<? extends T> list, T key,Comparator<? super T> c)
使用二分搜索法搜索指定列表,以獲得指定對象。一個是按照Java指定的比較器進來二分查找,一個是自己指定比較器對集合進行二分查找。
這種思想跟我們之前學數組的時候是一樣的,二分查找,所以瞭解了數組的二分查找,再去看看Java的Src源代碼,就基本瞭解了二分查找的算法,建議使用Java默認的二分查找,因爲我們寫的不一定比它的效率高。
Collections:靜態方法 (排序)(自動反轉比較器)(自定義反轉比較器)
static
<T> void
sort(List<T> list,Comparator<? super T> c)
根據指定比較器產生的順序對指定列表進行排序。
static
<T> void
sort(List<T> list,Comparator<? super T> c)
根據指定比較器產生的順序對指定列表進行排序。
static
<T> Comparator<T>
reverseOrder()
返回一個比較器,它強行逆轉實現了 Comparable 接口的對象 collection 的自然順序。static
<T> Comparator<T>
reverseOrder(Comparator<T> cmp)
返回一個比較器,它強行逆轉指定比較器的順序。
/*
一個學校,每個學校都有學科,班級的名字就是對應的學科。
對每門學科進行長度排序。從短到長,從長到短。
這時候就可以使用Collections裏面的sort方法,並指定比較器進去。
也可以在構造器裏面直接比較器進行反轉。
*/
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.Comparator;
public class Test{
public static void main(String[] args){
List<String> list = new ArrayList<String>();
list.add("黑馬程序員");
list.add("黑馬程序員——雲計算");
list.add("黑馬程序員——android");
list.add("黑馬程序員——.Net");
list.add("黑馬程序員——iso");
sop("原集合");
for(Iterator <String>it = list.iterator();it.hasNext();){
sop(it.next());
}
sop("排序後的集合");
Collections.sort(list,new Comparator(){
public int compare(Object obj1,Object obj2){
String s1 = (String)obj1;
String s2 = (String)obj2;
int len = s1.length()-s2.length();
if(len==0)
return s1.compareTo(s2);
return len;
}
});
for(Iterator <String>iter = list.iterator();iter.hasNext();){
sop(iter.next());
}
sop("排序後再逆轉的集合");
Collections.sort(list,Collections.reverseOrder(new Comparator(){
public int compare(Object obj1,Object obj2){
String s1 = (String)obj1;
String s2 = (String)obj2;
int len = s1.length()-s2.length();
if(len==0)
return s1.compareTo(s2);
return len;
}
}));
for(Iterator <String>iter = list.iterator();iter.hasNext();){
sop(iter.next());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
Collections:靜態方法
}
static void
swap(List<?> list, int i, int j)
在指定列表的指定位置處交換元素。
/*
對List集合的倆個元素進行互換。
並獲取集合中元素的最值。
*/
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class Test{
public static void main(String[] args){
List<Integer>list = new ArrayList<Integer>();
list.add(7);
list.add(1);
list.add(8);
list.add(5);
//打印原集合。
sop(list);
Collections.swap(list,list.indexOf(5),list.indexOf(7));
//打印新集合。
sop(list);
sop("最大值:"+Collections.max(list));
sop("最小值:"+Collections.min(list));
}
public static void sop(Object obj){
System.out.println(obj);
}
Collections:靜態方法}
static
<T> void
fill(List<? super T> list, T obj)
使用指定元素替換指定列表中的所有元素。
static void
reverse(List<?> list)
反轉指定列表中元素的順序。
static
<T> boolean
replaceAll(List<T> list, T oldVal, T newVal)
使用另一個值替換列表中出現的所有某一指定值。
static void
shuffle(List<?> list)
使用默認隨機源對指定列表進行置換。static void
shuffle(List<?> list, Random rnd)
使用指定的隨機源對指定列表進行置換。
注意:此方法是替換集合所有元素的值。
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
public class Test{
public static void main(String[] args){
List<Integer>list = new ArrayList<Integer>();
list.add(7);
list.add(1);
list.add(8);
list.add(5);
sop("原集合:"+list);
Collections.shuffle(list);
sop("隨機集合:"+list);
Collections.reverse(list);
sop("反轉後的集合"+list);
Collections.replaceAll(list,1,2);
//打印出現值被替換後的集合
sop("替換出現值的集合:"+list);
Collections.fill(list,0);
//打印新集合。
sop("統一集合值的集合:"+list);
}
public static void sop(Object obj){
System.out.println(obj);
}
}
同步集合:貌似同步Set集合和同步Map還可以對集合進行有序的排序。
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。
Arrays:用於操作數組的工具類,裏面都是靜態方法。
static
<T> List<T>
asList(T... a)
返回一個受指定數組支持的固定大小的列表。static int
binarySearch(byte[] a, byte key)
使用二分搜索法來搜索指定的 byte 型數組,以獲得指定的值。
static boolean[]
copyOf(boolean[] original, int newLength)
複製指定的數組,截取或用 false 填充(如有必要),以使副本具有指定的長度。
static boolean[]
copyOfRange(boolean[] original, int from, int to)
將指定數組的指定範圍複製到一個新數組。
static void
sort(byte[] a)
對指定的 byte 型數組按數字升序進行排序。
static String
toString(boolean[] a)
返回指定數組內容的字符串表示形式。
數組變成集合(Arrays)
import java.util.Arrays;
import java.util.List;
public class Test{
public static void main(String[] args){
String str [] = {"黑馬程序員","CSDN","黑馬論壇"};
List<String>list =Arrays.asList(str);
sop(list);
//list.add("新長城");會發生異常。
int arr[] = {1,2,3,4};
List <Integer> list =Arrays.asList(arr);
sop(list);//打印的是哈希值,因爲集合把數組中基本數據類型的元素都是當成一個數組存在。
}
public static void sop(Object obj){
System.out.println(obj);
}
}
將數組變成集合,不可以使用集合的增刪方法,因爲數組的長度是固定的,如果你增刪了,會發生不支持操作異常。
如果數組中的元素,都是都像,變成集合時,數組中的元素就直接轉換成集合中的元素
如果數組中的元素都是基本數據類型,那麼會將該數組作爲集合中的元素存在。
集合變成數組
當我們不希望調用者對我們的集合進行操作時,這時候就要把集合變成數組,讓操作者不能對其進行基本的操作,但是數組的功能還是可以使用的,比如獲取。
Object[]
toArray()
返回包含此 collection 中所有元素的數組。
<T> T[]
toArray(T[] a)
返回包含此 collection 中所有元素的數組;返回數組的運行時類型與指定數組的運行時類型相同。
import java.util.List;
import java.util.ArrayList;
public class Test{
public static void main(String[] args){
List<String>list =new ArrayList<String>();
list.add("黑馬程序員");
list.add("CSDN");
list.add("黑馬論壇");
Object[] arr = list.toArray();
for(int x=0;x<arr.length;x++){
System.out.print(arr[x]);
}
}
}
指定類型的數組到底要定義多長呢?
當指定類型的數組長度小於了集合的size,那麼該方法內部都會創建一個新的數組,長度爲集合的size
當指定類型的數組長度大於了集合的size,就不會新創建數組,而是使用傳遞進來的數組,
所以應該創建一個剛剛好的。
String[] arr = list.toArray(new String[al.size()]);
爲什麼要將集合變數組?
爲了限定對元素的操作。不需要進行增刪。
集合(增強for循環)
1.5JDK的新特性
傳統for和高級for有什麼區別呢?
高級 for 循環(簡化書寫)
格式:
for(數據類型 變量名 : 被變量的集合(Collection)或者數組){
}對集合進行遍歷,只能獲取集合元素,但是不能對集合進行操作。
迭代器出了遍歷,還可以進行remove集合中元素的動作。
如若果使用ListIterator,還可以在遍歷過程中對集合進行增刪改查動作。
高級for有一個侷限性,必須有便利的目標
建議在遍歷數組的時候,還是希望使用傳統for,因爲傳統for可以定義腳標。
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test{
public static void main(String[] args){
List<String>list = new ArrayList<String>();
list.add("黑馬程序員");
list.add("CSDN");
list.add("黑馬論壇");
sop("高級for循環遍歷list");
for(String s:list){
sop(s);
}
Map<Integer,String>map = new HashMap<Integer,String>();
map.put(1,"黑馬程序員——張三");
map.put(2,"黑馬程序員——李四");
map.put(3,"黑馬程序員——王五");
map.put(4,"黑馬程序員——趙六");
Set<Integer>keySet = map.keySet();sop("高級for循環遍歷第一種獲取方式map獲取鍵,用鍵獲取map值");
for(Integer i :keySet){
sop(i+","+map.get(i));
}
Set<Map.Entry<Integer,String>>entrySet = map.entrySet();
sop("高級for循環遍歷第二種獲取方式map的鍵和值");
for(Map.Entry<Integer,String> me : entrySet){
sop(me.getKey()+","+me.getValue());
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}
集合(可變參數)
JDK 1.5 版本出現的新特性
方法的可變參數(簡化書寫)
注意:可變參數一定要定義在函數參數的末尾,另外是三個點不是二個。比如要調用一個函數,傳入的參數格式類型,一樣,但是個數不一樣,普通方式是重載,很麻煩。
所以應該傳入一個數組,但是自己定義一個數組也麻煩,所以Java有了這種函數參數定義方法接收。
public class Test{
public static void main(String... args){
int sum = method(1,2,3,4,5);
int num = method(1,2,3,4,5,6,7,8,9,10);
System.out.println(sum);
System.out.println(num);
}
public static int method(int ...arr){
int sum =0;
for(int i : arr)
sum+=i;
return sum;
}}
可變數組,其實就是上一種數組參數的簡寫形式。
不用每一次都手動的建立數組對象,只要將操作的元素作爲參數傳遞即可,
隱式將這些參數封裝成數組,可以傳入空參數,0長度數組。
集合(靜態導入)
JDK 1.5 版本出現的新特性
StaticImport 集合(靜態導入) (簡化書寫)當類名重名時,需要指定具體的包名。
當方法重名是,指定具備所屬的對象或者類。
import static java.util.Arrays.*;//導入Arrays類中的所有靜態成員。
public class Test{
public static void main(String... args){
int []arr = {1,7,3,5,2};
for(int i:arr){
System.out.print(i);
}
System.out.println();
sort(arr);//由於該方法是靜態的,而Arrays裏面的靜態成員全部導入進來了,就可以省略類名.調用。
for(int i:arr){
System.out.print(i);
}
}
}