Collection方法实例
一、此类完全由在 collection 上进行操作或返回 collection 的静态方法组成
二、static <T> void sort(List<T> list, Comparator<? super T> c)
三、full方法：将集合中的所有元素替换成制定元素
五、Arrays工具类：操作数组
1、asList将数组变成List集合
好处：可以使用集合的思想和方法来操作数组，但不能
使用增删方法，因为数组的长度是不可变的
如果使用了该方法，会发生UnSupportedOperationException异常
实例：
五、集合转成数组
六、可变参数
七、可变参数
二、static <T> void sort(List<T> list, Comparator<? super T> c)
实例：
import java.util.*;
/*
Collections.sort()排序实例
二分法查找
*/
class CollectionsTest1 {
public static void main(String[] args) {
binarySearchTest();
}
//二分法常找
public static void binarySearchTest() {
ArrayList<String> list = new ArrayList<String>();
list.add("Java");
list.add("c++");
list.add("aaa");
list.add("c");
list.add("ef");
list.add("aa");
Collections.sort(list, new StrLenComparator());
out(list);
// int index = Collections.binarySearch(list, "b");
// out(index);
int index = selfBinarySearch(list, "bbb", new StrLenComparator());
out(index);
}
//自定义二分法
public static int selfBinarySearch(ArrayList<String> arr, String key, Comparator<String> comp) {
int max = arr.size() - 1;
int min = 0;
int mid = (max + min) >> 1;
while(min <= max) {
String str = arr.get(mid);
int num = comp.compare(str, key);
if (num > 0) {
max = mid - 1;
} else if (num < 0) {
min = mid + 1;
} else {
return mid;
}
mid = (max + min) >> 1;
}
return -mid - 1;
}
//字符串最大值
public static void strTest() {
ArrayList<String> list = new ArrayList<String>();
list.add("Java");
list.add("c++");
list.add("aaa");
list.add("c");
list.add("ef");
list.add("aa");
out(list);
out("max=" + Collections.max(list));
}
//字符串长度排序
public static void strLenTest() {
ArrayList<String> list = new ArrayList<String>();
list.add("Java");
list.add("c++");
list.add("aaa");
list.add("c");
list.add("ef");
list.add("aa");
out(list);
Collections.sort(list, new StrLenComparator());
out(list);
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
//字符串长度排序比较器
class StrLenComparator implements Comparator<String> {
public int compare(String s1, String s2) {
int num = s1.length() - s2.length();
if (num == 0) {
return s1.compareTo(s2);
}
return num;
}
}
三、full方法：将集合中的所有元素替换成制定元素
import java.util.*;
/*
fill方法测试
练习：将集合中一部分元素替换成制定元素
*/
//mina
class FillTest {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("Java");
list.add("c++");
list.add("aaa");
list.add("c");
list.add("ef");
list.add("aa");
out(list);
selfFill(list, "ccc", 1, 4);
out(list);
}
//将集合中一部分元素替换成制定元素
public static void selfFill(ArrayList<String> list, String key, int start, int end) {
for (int i=start;i<end;i++) {
list.set(i, key);
}
}
//full方法测试
public static void fillTest() {
ArrayList<String> list = new ArrayList<String>();
list.add("Java");
list.add("c++");
list.add("aaa");
list.add("c");
list.add("ef");
list.add("aa");
out(list);
Collections.fill(list, "Java");
out(list);
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}四、TreeSet元素反序
import java.util.*;
/*
static <T> Comparator<T> reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行逆转指定比较器的顺序。
测试：
*/
//mian
class ReverseTest
{
public static void main(String[] args) {
reverseElement();
}
//元素反转
public static void reverseElement() {
//将StrLenComparator()比较器构造器反转
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
ts.add("Java");
ts.add("c++");
ts.add("aaaff");
ts.add("c");
ts.add("ef");
ts.add("aa");
out(ts);
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
//字符串长度排序比较器
class StrLenComparator implements Comparator<String> {
public int compare(String s1, String s2) {
int num = s1.length() - s2.length();
if (num == 0) {
return s1.compareTo(s2);
}
return num;
}
}
五、Arrays工具类：操作数组
1、asList将数组变成List集合
好处：可以使用集合的思想和方法来操作数组，但不能
使用增删方法，因为数组的长度是不可变的
如果使用了该方法，会发生UnSupportedOperationException异常
实例：
import java.util.*;
/*
Collections.asList()方法实例
结论：
1、如果数组中的元素是对象，那么变成集合时，
数组中的元素直接转成集合中的元素
2、如果数组中的元素是基本类型，那么会将该数组作为
集合中的元素，即现在集合中存储的是一个数组
*/
class AsList
{
public static void main(String[] args) {
String[] arr1 = {"Java","gg","aa","cd"};
List<String> al = Arrays.asList(arr1);
out(al); //[Java, gg, aa, cd]
int[] nums = {1,5,7,3,8};
List<int[]> a2 = Arrays.asList(nums);
out(a2); //[[I@55f33675]
Integer[] n = {1,5,7,3,8};
List<Integer> a3 = Arrays.asList(n);
out(a3); //[1, 5, 7, 3, 8]
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
}
五、集合转成数组
import java.util.*;
/*
ArrayList转成数组
好处：限制对元素的操作，不需要增删
<T> T[] toArray(T[] a)
按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；
返回数组的运行时类型是指定数组的运行时类型。
结论：
1、制定的数组多长为恰当
当制定类型的数组长度小于集合size那么，该方法会在内部自动开辟一个
与该size相同的数组
当制定的数组长度大于集合的size时，就不开辟数组，
而是使用该数组，没有使用的位置为null，因为数组自动初始化
由此可以看看出制定的数组大小和size相同时，性能最优
*/
class ArrayListToArray
{
public static void main(String[] args) {
ArrayList<String> arr = new ArrayList<String>();
arr.add("java");
arr.add("fgava");
arr.add("jffa");
arr.add("aa");
String[] a = arr.toArray(new String[arr.size()]);
out(a);
}
//输出
public static void out(Object obj) {
System.out.println(obj);
}
//输出
public static void out(String[] s) {
for(int i=0;i<s.length;i++) {
System.out.print(s[i] + " ");
}
}
}
六、可变参数
/*
JDK1.5可变参数
原理：将传进来的参数在内部封装成数组
注意：只能将可变参数定义在参数的最后面
*/
class ChangeParameter
{
public static void main(String[] args) {
out(1,4,6,7);
out(1.3,5.7,7.4);
out("ff","fffgh");
}
//可变参数方法
public static <T> void out(T... t) {
for(int i=0;i<t.length;i++) {
out(t[i]);
}
out("\n");
}
public static void out(Object obj) {
System.out.print(obj + " ");
}
}
七、可变参数
import static java.lang.Math.*;
import static java.lang.System.*;
/*
静态导入
1、当类名重名时，需要指定所属包名
也可以在导入一次需要的类名
2、当方法同名时，需要制定包名和类名
*/
class StaticImport
{
public static void main(String[] args)
{
out.println((int)(random() * 100));
}
}