Collections
java.util.Collections
此類完全由在 collection 上進行操作或返回 collection 的靜態方法組成。它包含在 collection 上操作的多態算法,即“包裝器”,包裝器返回由指定 collection 支持的新 collection,以及少數其他內容。
示例代碼
import java.util.*;
class CollectionsDemo
{
public static void main(String[] args)
{
ArrayList<Integer> ilist=new ArrayList<Integer>();
ilist.add(1);
ilist.add(3);
ilist.add(9);
ilist.add(2);
ilist.add(4);
//fillDemo(ilist,1,3,0);
//System.out.println(ilist);
replaceAllDemo();
}
public static void replaceAllDemo()
{
ArrayList<Integer> ilist=new ArrayList<Integer>();
ilist.add(1);
ilist.add(3);
ilist.add(9);
ilist.add(9);
ilist.add(4);
Collections.replaceAll(ilist,9,0);
System.out.println(ilist);
}
public static <T> void fillDemo(ArrayList<T> list,int start,int end,T t)
{
List<T> sublist=list.subList(start,end);
Collections.fill(sublist,t);
}
public static void binarySearceDemo()
{
ArrayList<Integer> ilist=new ArrayList<Integer>();
ilist.add(1);
ilist.add(3);
ilist.add(9);
ilist.add(2);
ilist.add(4);
MyComparator cmp=new MyComparator();
Collections.sort(ilist,cmp);
int index=Collections.binarySearch(ilist,5);
System.out.println(ilist+"index:"+index);
}
public static void maxDemo()
{
ArrayList<Integer> ilist=new ArrayList<Integer>();
ilist.add(1);
ilist.add(3);
ilist.add(9);
ilist.add(2);
ilist.add(4);
MyComparator cmp=new MyComparator();
System.out.println(Collections.max(ilist));
Collections.sort(ilist,cmp);
System.out.println(ilist);
}
}
class MyComparator implements Comparator<Integer>
{
public int compare(Integer i1,Integer i2)
{
int num=i1.compareTo(i2);
return num;
}
}
搜索 binarySearch
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
使用二分搜索法搜索指定列表,以獲得指定對象。
逆轉順序
static void reverse(List<?> list)
反轉指定列表中元素的順序。
static <T> Comparator<T> reverseOrder()
返回一個比較器,它強行逆轉實現了 Comparable 接口的對象 collection 的自然順序。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一個比較器,它強行逆轉指定比較器的順序。
元素位置交換swap
static void swap(List<?> list, int i, int j)
在指定列表的指定位置處交換元素。
獲取線程安全的集合
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。
shuffle隨機調整List元素位置
static void shuffle(List<?> list)
使用默認隨機源對指定列表進行置換。
Arrays 用於操作數組的工具類
裏面都是靜態方法
asList:將數組變成List集合
如果數組中的元素都是對象,那麼變成集合時,數組中的元素就直接轉成集合中的元素。
如果數組中的元素都是基本數據類型,那麼會將該數組作爲集合中的元素存在。
可以用asList獲取數組的List對象
不能對list進行 增,刪,操作
可以使用其他操作。
contains()
get
set
indexOf
subList
因爲數組長度是固定的。
public static <T> List<T> asList(T... a)
返回一個受指定數組支持的固定大小的列表。(對返回列表的更改會“直接寫”到數組。)此方法同 Collection.toArray() 一起,充當了基於數組的 API 與基於 collection 的 API 之間的橋樑。返回的列表是可序列化的,並且實現了 RandomAccess。
此方法還提供了一個創建固定長度的列表的便捷方法,該列表被初始化爲包含多個元素:
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
import java.util.*;
class ArraysDemo
{
public static void main(String[] args)
{
//String[] strArr={"abc","def","ghi"};
Integer[] intArr={1,2,3};
//List<String> list=Arrays.asList(strArr);
List<Integer> list=Arrays.asList(intArr);
//list.set(1);
System.out.println(list.get(0));
}
}
集合轉成數組
toArray
import java.util.*;
class CollectionToArray
{
public static void main(String[] args)
{
ArrayList<String> alist=new ArrayList<String>();
alist.add("abc1");
alist.add("abc2");
alist.add("abc3");
/*
1.指定類型的數組長度
指定類型的數組長度小於了集合的size,那麼方法內部會創建一個
新的數組長度爲集合的size
當指定類型的數組長度大於了集合的size,就不會新創建數組,而是使用傳遞進來的數組
所以創建一個剛剛好的數組最優。
2.爲什麼要集合變數組
爲了限定對元素的操作。
*/
String sArr[]=new String[alist.size()];
String[] arr=alist.toArray(sArr);
System.out.println(Arrays.toString(arr));
}
}
增強for 循環
- 對集合進行遍歷。
只能獲取集合元素,不能對集合進行操作
迭代器除了遍歷,還能remove集合中元素的動作。
- 如果使用ListIterator還可以在遍歷過程中進行增刪改查的動作。
- 傳統for和高級for有什麼區別呢?
- 高級for有一個侷限性,必須有被遍歷的目標.
建議在遍歷數組的時候,使用傳統for,因爲傳統for可以定義角標。
格式:
for(數據類型 變量名 : 被遍歷的集合(Collection)或者數組)
{
}
示例代碼:
import java.util.*;
class ForEachDemo
{
public static void main(String[] args)
{
ArrayList<String> alist=new ArrayList<String>();
alist.add("abc1");
alist.add("abc2");
alist.add("abc3");
for(String s:alist)
{
System.out.println(s);
}
/* Iterator<String> it=alist.iterator();
while(it.hasNext())
{
System.out.println(it.next());
} */
int[] arr={2,3,4};
for(int i : arr)
{
System.out.println("i:"+i);
}
HashMap<Integer,String> hm=new HashMap<Integer,String>();
hm.put(1,"abc1");
hm.put(2,"abc2");
for(Integer i : hm.keySet())
{
System.out.println("K:"+i+" V:"+hm.get(i));
}
//Set<Map.Entry<Integer,String>> entrySet=hm.entrySet();
for(Map.Entry<Integer,String> me:hm.entrySet())
{
System.out.println(me.getKey()+"---"+me.getValue());
}
}
}
可變參數
使用3個點
函數(類型… 變量名)
import java.util.*;
/*
JDK1.5版本出現的新特性
方法的可變參數
使用時注意:可變參數一定要定義在參數列表的最後面。
*/
class ParamMethodDemo
{
public static void main(String[] args)
{
//show(3,4);
/* int[] arr={3,4};
show(arr);
雖然少定義了多個方法,但是每次都要定義一個數組.作爲實際參數.
int[] arr1={2,3,4,5}; */
/*
可變參數
其實就是上一種數組參數的簡寫形式。
不用每一次都手動的建立數組對象。
只要將要操作的元素作爲參數傳遞即可。
隱式的將這些參數封裝成了數組。
*/
show(2,3,2,2);
show2("test",2,3,4);
}
public static void show2(String s,int... arr)
{
System.out.println(s);
for(int i : arr)
System.out.println(i);
}
public static void show(int... arr)//第三種方法,可變參數
{
//自動封裝int型數組arr
for(int i : arr)
System.out.println(i);
}
/* public static void show(int[] arr)//第二種方法傳遞數組
{
}
public static void show(int a,int b)//第一種方法,寫多個重載函數
{
System.out.println(a+","+b);
} */
}
靜態導入 StaticImport
import java.util.*;
/*
JDK1.5版本出現的新特性
當類名重名時,需要指定具體的包名
當方法重名時,需要指定具體所屬的對象或者類。
*/
import static java.util.Arrays.*;//導入Arrays這個類中的靜態成員.
import static java.lang.System.*;
class StaticImport extends Object
{
public static void main(String[] args)
{
out.println("test");
int[] arr={3,1,5};
sort(arr);
int index = binarySearch(arr,1);
System.out.println("Index="+index);
System.out.println(Arrays.toString(arr));//toString方法重名
}
}