Java基础17：集合工具类Collections；高级for循环；静态导入；可变参数

关键字：集合工具类Collections；高级for循环；静态导入；可变参数

一、集合工具类Collections-sort

工具类

public class Collections extends Object此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

/*
map扩展知识。
map结合被使用，是因为具备映射关系。

一个学校，每个学校都有班级，班级都有名称

*/
import java.util.*;
public class Demo{
public static void main(String[] args){
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("aaa");
list.add("ddd");
list.add("fff");
sop(list);
Collections.sort(list);
sop(list);
}
public static void sortDemo(){

}
public static void sop(Object obj){
System.out.println(obj);
}
}
//还支持自定义排序

二、集合工具类(Collections-max)

static <T extends Object & Comparable<? super T>>

T

max(Collection<? extends T> coll)

根据元素的自然顺序，返回给定 collection 的最大元素。

static <T> T

max(Collection<? extends T> coll, Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection 的最大元素。

static <T extends Object & Comparable<? super T>>

T

min(Collection<? extends T> coll)

根据元素的自然顺序 返回给定 collection 的最小元素。

static <T> T

min(Collection<? extends T> coll, Comparator<? super T> comp)

根据指定比较器产生的顺序，返回给定 collection 的最小元素。

import java.util.*;
public class Demo{
public static void main(String[] args){
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("aaa");
list.add("ddd");
list.add("fff");
sop(list);
sop(Collections.max(list));
}
public static void sortDemo(){

}
public static void sop(Object obj){
System.out.println(obj);
}
}
//还支持自定义排序

三、集合(Collections-binarySearch) 必须是有序集合，只要是二分法，就必须是有序集合

static <T> int

binarySearch(List<? extends Comparable<? super T>> list, T key)

使用二分搜索法搜索指定列表，以获得指定对象。

static <T> int

binarySearch(List<? extends T> list, T key, Comparator<? super T> c)

使用二分搜索法搜索指定列表，以获得指定对象。

如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引；如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

import java.util.*;
public class Demo{
public static void main(String[] args){
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("aaa");
list.add("ddd");
list.add("fff");
sop(list);
sop(Collections.binarySearch(list,"ddd"));
}
public static void sortDemo(){

}
public static void sop(Object obj){
System.out.println(obj);
}
}
//还支持自定义排序

四、集合(Collections-替换反转)

static void swap(List<?> list, int i, int j)

在指定列表的指定位置处交换元素。

static <T> void

fill(List<? super T> list, T obj)

使用指定元素替换指定列表中的所有元素。

static <T> boolean

replaceAll(List<T> list, T oldVal, T newVal)

使用另一个值替换列表中出现的所有某一指定值。

static void reverse(List<?> list)

反转指定列表中元素的顺序。

五、集合(Collections-reverseOrder)

static <T> Comparator<T>

reverseOrder()

返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

static <T> Comparator<T>

reverseOrder(Comparator<T> cmp)

返回一个比较器，它强行逆转指定比较器的顺序。

也可以逆转自己编写的比较器

import java.util.*;
public class Demo{
public static void main(String[] args){
//TreeSet<String> ts = new TreeSet<String>(new myComparator());自定义的是从小到大排序
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new myComparator()));
ts.add("aaaa");
ts.add("ddddddd");
ts.add("sss");
ts.add("SDccFS");
Iterator<String> it = ts.iterator();
while(it.hasNext()){
sop(it.next());
}
}
public static void sortDemo(){

}
public static void sop(Object obj){
System.out.println(obj);
}
}
class myComparator implements Comparator<String>{
public int compare(String s1,String s2){
int l1 = s1.length();
int l2 = s2.length();
if(l1>l2){
return 1;
}else if(l1<l2){
return -1;
}else{
return 0;
}
}
}

六、集合(Collections-SynList)

< 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。

static void shuffle(List<?> list)

使用默认随机源对指定列表进行置换。

static void shuffle(List<?> list, Random rnd)

使用指定的随机源对指定列表进行置换。

七、集合(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.*;
public class Demo{
public static void main(String[] args){
String[] arr = {"dsfasad","sad","sdfsd","sfd"};
//把数组编程集合，变成集合可以方便的使用集合的思想和方法，比如判断是否有某个方法
//注意，将数组编程的集合，不可以使用集合的增删方法，因为数组的长度是固定的，
//如果你增删了，会发发生不支持操作异常
List<String> list = Arrays.asList(arr);
sop(arr);
sop(list);

int[] nums = {2,4,5};
//数字数组得这样写
List<int[]> li = Arrays.asList(nums);//或者 Integer[] nums = {2,4,5};List<Integer> li = Arrays.asList(nums);
/*
如果数组中的元素，都是都像，变成集合时，数组中的元素就直接转换成集合中的元素
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在
*/

}
public static void sop(Object obj){
System.out.println(obj);
}
}

八、集合(集合转成数组)

Object[] toArray()

返回包含此 collection 中所有元素的数组。

< T> T[]

toArray(T[] a)

返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

import java.util.*;
public class Demo{
public static void main(String[] args){
ArrayList<String> al = new ArrayList<String>();
al.add("sdfsda");
al.add("afs");
al.add("sd");
/*
1、指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部都会创建一个新的数组，长度为集合的size
当指定类型的数组长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组
所以应该创建一个刚刚好的
String[] arr = al.toArray(new String[al.size()]);

2、为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删。
*/
String[] arr = al.toArray(new String[5]);
sop(Arrays.toString(arr));
}
public static void sop(Object obj){
System.out.println(obj);
}
}

九、集合(增强for循环)

/*
高级 for 循环
格式：
for(数据类型 变量名 ： 被变量的集合（Collection）或者数组){

}

对集合进行遍历，只能获取集合元素，但是不能对集合进行操作。

迭代器出了遍历，还可以进行remove集合中元素的动作

如若果使用ListIterator，还可以在遍历过程中对集合进行增删改查动作

传统for和高级for有什么区别呢？
高级for有一个局限性，必须有便利的目标
建议在遍历数组的时候，还是希望使用传统for，因为传统for可以定义脚标

*/
import java.util.*;
public class Demo{
public static void main(String[] args){

ArrayList<String> al = new ArrayList<String>();
al.add("sdfsda");
al.add("afs");
al.add("sd");
for(String s : al){
sop(s);
}

HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"1");
hm.put(2,"2");
hm.put(3,"3");
hm.put(4,"4");
Set<Integer> keyset = hm.keySet();
for(Integer i : keyset){
sop(hm.get(i));
}

Set<Map.Entry<Integer,String>> entryset = hm.entrySet();
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 版本出现的新特性
方法的可变参数
注意：
可变参数一定要定义在函数参数的末尾
*/
import java.util.*;
public class Demo{
public static void main(String[] args){
//比如要调用一个函数，传入的参数格式类型，一样，但是个数不一样，普通方式是重载，很麻烦
//所以应该传入一个数组，但是自己定义一个数组也麻烦，所以java有了这种 函数参数定义方法接收  public static void show(int... arr){
/*
可变数组，
其实就是上一种数组参数的简写形式
不用每一次都手动的建立数组对象
只要将操作的元素作为参数传递即可
隐式将这些参数封装成数组
可以传入空参数，0长度数组
*/

}

//public static void show(int... arr,String a ){ 错误
//public static void show(String a ，int... arr){正确
public static void show(int... arr){

}
// public static void show(int[] arr){

// }
public static void sop(Object obj){
System.out.println(obj);
}
}

十一、集合(静态导入)

/*
JDK 1.5 版本出现的新特性
StaticImport  集合(静态导入)
*/
import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类中所有的静态成员，使用的时候，可以直接写方法，不用写类名
//但是可能方法重名，比如，Arrays中有toString(),object中也有toString ，要使用 类名.方法名
//当类名重名时，需要指定具体的包名            import packa.*;  import packb.*;
//当方法重名时，指定具备所属的对象或者类
public class Demo{
public static void main(String[] args){
int[] arr = (3,1,5);
Arrays.sort(sort);
sop(Arrays.toString(arr));
}
public static void sop(Object obj){
System.out.println(obj);
}
}