本文介绍了Java基础中的集合框架工具类Collections，包括如何使用Collections.sort()进行列表排序，同时讲解了自然顺序排序和自定义Comparator排序的用法。此外，还涵盖了集合转数组、高级for循环、可变参数方法和静态导入等Java编程中的关键概念。
------- android培训、java培训、期待与您交流！ ----------
主要内容：一、二集合框架的工具类:Collections,Arrays；三、集合变数组；四、高级for循环；五、方法的可变参数；六、静态导入
一、Collections：集合框架的工具类：方法都是静态的
1，Collections.sort(list);按自然顺序给list集合排序。
Collections.sort(list, Comparator);根据指定比较器产生的顺序对指定列表进行排序。
例：按自然顺序排序 和 按长度排序。
import java.util.*;
class CollectionsDemo
{
public static void main(String[] args)
{
sortDemo();
}
public static void sortDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
sop(list);
Collections.sort(list);//按自然顺序排序。
sop(list);
Collections.sort(list,new StrLenComparator());//将比较器传进来，按长度排序
sop(list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
//设定一个比较器，按长度排序
class StrLenComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);
}
}
例：求集合中最大元素，注意：可以自己制定一个比较器，如上例中的长度比较器
import java.util.*;
class CollectionsDemo
{
public static void main(String[] args)
{
maxDemo();
}
public static void maxDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
Collections.sort(list);
sop(list);
String max = Collections.max(list/*,new StrLenComparator()*/);//可指定比较器。
sop("max="+max);
}
}
3，Collections.binarySearch(list,"aaa");二分查找指定元素，返回角标值。注意：必须是有序集合。
如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
例：查找指定元素，返回角标值。注意：必须是有序集合。
import java.util.*;
class CollectionsDemo
{
public static void main(String[] args)
{
binarySearchDemo();
}
public static void binarySearchDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
list.add("qq");
Collections.sort(list);//排序
sop(list);
int index = Collections.binarySearch(list,"aaa");//二分查找"aaa",返回角标值
sop("index="+index);
}
}
演示折半查找原理：例
//折半查找原理
public static int halfSearch(List<String> list,String key)
{
int max,min,mid;
max = list.size();
min = 0;
while(min<=max)
{
mid = (max+min)>>1;// /2;
String str = list.get(mid);
int num = str.compareTo(key);
if(num>0)
max = mid-1;
else if(num<0)
min = mid+1;
else
return mid;
}
return -min-1;//没找着，返回插入(角标)再减1；
}
4，Collections.fill(list,"pp");使用指定元素替换指定列表中的所有元素。
练习。fill方法可以将list集合中所有元素替换成指定元素。
public static void fillDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("ccc");
list.add("zzzz");
sop(list);
Collections.fill(list,"pp");//将集合中的元素，都替换成指定元素。
sop(list);
}
5，Collections.replaceAll(list,"aaa","pp");使用另一个值替换列表中出现的所有某一指定值。
public static void replaceAllDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("ccc");
list.add("zzzz");
sop(list);
Collections.replaceAll(list,"aaa","pp");
sop(list);
}
6，reverse(List<?> list); 反转指定列表中元素的顺序。
7，reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行逆转指定比较器的顺序。
例：
class StrLenComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()<s2.length())
return -1;
return s1.compareTo(s2);//长度相同，按字符串自然顺序排序。
}
}
class CollectionsDemo2
{
public static void main(String[] args)
{
orderDemo();
}
public static void orderDemo()
{
//强行逆转，按字符串长度，倒序排序。
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
ts.add("abcde");
ts.add("aaa");
ts.add("ccc");
ts.add("zz");
ts.add("q");
Iterator it = ts.iterator();
while(it.hasNext())
{
sop(it.next());
}
}
}
8，synchronizedList(List<T> list);返回指定列表支持的同步（线程安全的）列表。
9，swap(List<?> list, int i, int j); 在指定列表的指定位置处交换元素。
10，shuffle(List<?> list);使用默认随机源对指定列表进行置换。
例：实际应用：如扑克牌，色子等
public static void shuffleDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcde");
list.add("aaa");
list.add("ccc");
list.add("zzz");
sop(list);
Collections.shuffle(list);
sop(list);
}
二、Arrays:用于操作数组的工具类。里面都是静态方法。
1，toString();返回指定数组内容的字符串表示形式。
例：
import java.util.*;
class ArraysDemo
{
public static void main(String[] args)
{
int[] arr = {2,3,4};
sop(Arrays.toString(arr));//数组转成字符串。
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
2，asList：将数字变成list集合。
2.1 把数组变成list集合有什么好处？
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法。
因为数组的长度是固定的。
可以使用：
contains
get
indexOf()
subList()
等
如果增删，那么会发生不支持操作异常：UnsupportedOperationException
2.2 如果数组中元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
例：
import java.util.*;
class ArraysDemo
{
public static void main(String[] args)
{
String[] arr = {"abc","dd","dfaf"};
//把数组变成list集合有什么好处？
/*
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法。
因为数组的长度是固定的。
可以使用：
contains
get
indexOf()
subList()
等
如果增删，那么会发生不支持操作异常：UnsupportedOperationException
*/
List<String> list = Arrays.asList(arr);
sop("contains:"+list.contains("dd"));
//list.add("qq");//UnsupportedOperationException：不支持的操作异常
sop(list);
int[] nums = {2,3,5};
List<int[]> li = Arrays.asList(nums);
/*
如果数组中元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
*/
sop(li);//打印结果是数组的哈希值
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
三、集合变数组：
1，指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
2，为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。
例：
import java.util.*;
class CollectionToArray
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
String[] arr = al.toArray(new String[al.size()]);//集合转数组
sop(Arrays.toString(arr));//打印数组字符串表现形式。
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
四、高级for循环。
1， 格式：
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{
}
2，对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
3，传统for和高级for有什么区别呢？
高级for有一个局限性，必须由被遍历的目标。
建议在遍历数组的时候还是希望使用传统for，因为传统for可以定义角标。
例：
import java.util.*;
class ForEachDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
for(String s : al)
{
sop(s);
}
/*
Iterator it = al.iterator();
while(it.hasNext())
{
sop(it.next());
}
*/
int[] arr = {3,6,5};
for(int a : arr)
{
sop("a="+a);
}
HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"abc1");
hm.put(2,"abc2");
hm.put(3,"abc3");
Set<Integer> keySet = hm.keySet();
for(Integer i : keySet)
{
sop(i+"::"+hm.get(i));
}
//Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
//for(Map.Entry<Integer,String> me : entrySet)
for(Map.Entry<Integer,String> me : hm.entrySet())
{
sop(me.getKey()+"----"+me.getValue());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
五、方法的可变参数。JDK1.5版本出现的新特性。
1，方法的可变参数。
其实就是数组参数的简写形式。
不用每一次都手动的建立数组对象。
只有将要操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
2，方法的可变参数：
在使用时注意：可变参数一定要定义在参数列表的最后面。
例：
import java.util.*;
class ParamMethodDemo
{
public static void main(String[] args)
{
show("haha",2,3,4,5,6);
//show(2,3,4,5,6,7,32,6,4);
//show();
}
public static void show(String str,int...arr)
{
System.out.println(Arrays.toString(arr));
System.out.println(arr.length);
System.out.println(str);
}
}
六、静态导入：
1，StaticImport 静态导入。
当类名重名时，需要指定具体的包名。
当方法重名时，指定具备所属的对象或者类。
例：
import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.lang.System.*;//导入了System类中所有静态成员。
class StaticImport extends Object
{
public static void main(String[] args)
{
int[] arr = {3,1,5};
sort(arr);//排序：Arrays.sort(arr);
int index = binarySearch(arr,1);//二分查找：Arrays.binarySearch(arr,1);
out.println(Arrays.toString(arr));
System.out.println("Index="+index);
}
}
扫一扫
1443
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
