Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口：
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序
Collections是集合框架中的一个工具类。该类中的方法都是静态的。提供的方法中有可以对list集合进行排序，二分查找等方法通常常用的集合都是线程不安全的。因为要提高效率。如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
| 方法 | 功能描述 |
| sort(List< T> list) | 根据自然顺序对指定列表排序，用法：参数中传入集合 |
| sort(List< T> list,Comparator< ? super T> c) | list-集合;c比较器；按指定比较器c为list排序。 |
| max(Collection< ? extends T> coll) | 根据自然顺序排序，返回collection的最大元素； |
| max(collection< ? extends T>,Comparator< ? super T>com) | 根据指定比较器排序，返回Collection的最大元素； |
| binarySearch(List<>list,T key) | 根据二分法搜索指定列表，获取指定对象；list-集合；key-指定对象； |
| binarySearch(List list,T key,Comparator comp) | 二分法搜索指定列表，获取指定对象，list-集合，key-指定对象，comp-指定比较器； |
| fill(List list,T obj) | 使用指定元素替换指定列表中的所有元素；obj-指定元素，list-指定集合 |
| replaceAll(List list,T oldValue,T newVaule) | 使用一个新值替换指定列表中的旧值 |
| reverse(List list) | 反转指定列表中元素的顺序，反转比较器； |
| reverseOlder() | 返回一个比较器，它强行逆转Comparable接口的对象collection的自然顺序，该方法自身可作为一个比较器传入集合的对象中； |
| reverseOlder(Comparator< T> comp) | 返回一个比较器，它强行逆转了指定比较器的顺序，comp-指定比较器 |
| synchronizedList(List list) | 返回由指定集合支持的同步的集合 |
| SynchronizedSet(Set< T> s) | 返回由指定集合支持的同步的集合 |
| SynchronizedMap(Map< k,v>m) | 返回由指定集合支持的同步的集合 |
| shuffle(List list) | 使用默认随机源对指定列表进行置换 |
| shuffle(List list,Random rnd) | 使用指定的随机源对指定列表进行置换 |
import java.util.*;
class CollectionsDemo
{
public static void main(String[] args)
{
//sortDemo();
//maxDemo();
binarySearchDemo();
}
public static void binarySearchDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkkkk");
list.add("qq");
list.add("z");
sop(list);
Collections.sort(list);
sop(list);
int index = Collections.binarySearch(list,"aaa");
sop("index= "+index);
}
public static int halfSearch(List<String> list,String key)
{
int max,min,mid;
max = list.size()-1;
min = 0;
while(min<= max)
{
mid = (max+min)>>1;
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;
}
public static void maxDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkkkk");
list.add("qq");
list.add("z");
sop(list);
Collections.sort(list);
String max = Collections.max(list,new StrLenComparator());
sop("max= "+max);
}
public static void sortDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkkkkk");
list.add("qq");
list.add("z");
sop(list);
//Collections.sort(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 StrComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
return s2.compareTo(s1);
}
}
class CollectionsDemo2
{
public static void main(String[] args)
{
//orderDemo();
shuffleDemo();
}
public static void shuffleDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkkkk");
sop(list);
Collections.replaceAll(list,"aaa","pp");
sop(list);
//int index = Collections.binarySearch(list,"aaa");
//sop("index= "+index);
}
public static void orderDemo()
{
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrComparator()));
ts.add("abcd");
ts.add("aaa");
ts.add("zz");
ts.add("kkkkkkk");
Iterator it = ts.iterator();
while(it.hasNext())
{
sop(it.next());
}
//sop(list);
//Collections.replaceAll(list,"aaa","pp");
//sop(list);
//int index = Collections.binarySearch(list,"aaa");
//sop("index= "+index);
}
public static void replaceAllDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkkkk");
sop(list);
Collections.replaceAll(list,"aaa","pp");
sop(list);
//int index = Collections.binarySearch(list,"aaa");
//sop("index= "+index);
}
/*
练习。fill方法可以将list集合中所有元素替换成指定元素。
将list集合中部分元素替换成指定元素。
*/
public static void fillDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkkkk");
list.add("qq");
list.add("z");
sop(list);
Collections.fill(list,"pp");
sop(list);
//int index = Collections.binarySearch(list,"aaa");
//sop("index= "+index);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
注意：
①将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，则会产生 UnsupportedOperationException的编译异常。
③如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
2.binarySearch()：二分查找方法，fill()：替换方法，sort()：排序方法等
特点：可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还 可以对指定元素的范围，并可根据指定比较器进行相应的操作。
如：sort(T[]a,Comparator<? super T> c)
fill(int[]a,int from,int to)等
3.String toString();//可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。
import java.util.*;
class ArraysDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//int[] arr = {2,4,5};
//sop(Arrays.toString(arr));
String[] arr = {"abc","cc","kkkkk"};
//把数组变成list集合有什么好处？
/*
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法。
因为数组的长度是固定。
contains.
get
indexOf()
subList();
如果你增删，那么会反生UnsupportedOperationException，
*/
List<String> list = Arrays.asList(arr);
//sop("contains:"+list.contains("cc"));
//list.add("qq");//UnsupportedOperationException不支持的操作异常
//sop(list);
//int[] nums = {2,4,5};
Integer[] nums = {2,4,5};
//Arrays.asList(nums);
List<Integer> li = Arrays.asList(nums);
/*
如果数组中的元素都是对象时，那么变成集合时，数组中的元素直接转变成集合中的元素。
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。*/
sop(li);
}
}
好处：可以使用集合的方法操作数组。
如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储。
如果数组中的元素是基本类型数值，那么会将该数组作为集合中的元素进行存储。
import java.util.*;
class CollectionToArray
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
a1.add("abc4");
String[] arr = a1.toArray(new String[6]);
sop(Arrays.toString(arr));
}
}
当指定类型的数组长度小于集合的size，那么该方法内部就会创建一个新的数组，长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组，而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
2.为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。
高级for循环
1.格式：
for(数据类型 变量名:被遍历的集合(Collection)或数组)
{
执行语句；
}
2.对集合进行遍历，只能获取集合元素，但是不能对集合进行操作，迭代器除了遍历，还可以进行remove集合中元素的动作，如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作；
3.与传动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){
//s = "kk";
System.out.println(s);
}
System.out.println(al);
/*
Iterator<String> it = al.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
*/
int[] arr = {3,5,1};
for(int x=0; x<arr.length; x++){
System.out.println(arr[x]);
}
for(int i : arr){
System.out.println("i:"+i);
}
HashMap<Integer,String> hm = new HashMap<Integer,String>();
hm.put(1,"a");
hm.put(2,"b");
hm.put(3,"c");
Set<Integer> keySet = hm.keySet();
for(Integer i : keySet){
System.out.println(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()){
System.out.println(me.getKey()+"------"+me.getValue());
}
}
}可变参数
概述：可变参数是函数的另一种表现形式，传递的参数个数可变；
格式：
返回值类型 函数名(参数类型...形式参数) {
执行语句；
}
1.可变参数其实接收的是一个数组，可以指定实际参数个数；
2.可变参数一定要定义在参数列表最后面，因为当传入的参数有多种类型时，会将前面的先匹配完，剩下的参数封装成数组，如果在前面将会出现类型匹配异常；
3.调用show函数：show(“hahaha”,2,3,4,5…);该函数在调用时,第一个参数为String类型(只能有一个，因为形式参数String只有一个)匹配给str，后面的2，3,4,5…为int类型自动封装为数组传递给arr，因为arr为可变参数的，所以函数调用传递时int形式参数不固定，传多少就是多少，注：可变参数必须是同一数据类型，有形参类型决定；
静态导入
1.当import后边跟static的时候，导入的是某一个类中的所有的静态成员，故：当某一类中的方法都是静态的时候可以使用静态导入该类，那么在调用该类中的方法时就不用再在前面加上“类名.”了；
2.静态导入可简化书写；
3.静态导入的格式：
import static java.包名.类名.*；
例：导入Arrays类中的所有静态成员；
import static java.util.Arrays.*;
注意：
当类名重名时，需要指定具体的包名；
当方法重名时，指定具备所属的对象或者类；
例：toString()方法，所有类中都有，使用时需注明类名或对象；
4.常用如：Collections，Arrays，System类都可使用静态导入方式简化书写；
1430
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
