黑马程序员：Collections：集合框架工具类介绍及二分法原理介绍

时间：2023-02-12 11:54:34

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

Collections 集合框架工具类，不同于Collection（接口）

常用方法：

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
public static <T extends Comparable<? super T>> void sort(List<T> list)
public static <T> void sort(List<T> list, Comparator<? super T> 
public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)                          
public static <T> int binarySearch(List<? extends T> list,T key, Comparator<? super T> c)    

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

public static <T> boolean replaceAll(List<T> list,T oldVal,T newVal)
public static void reverse(List<?> list)
public static <T> Comparator<T> reverseOrder()
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
public static <T> List<T> synchronizedList(List<T> list)
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
public static <T> Set<T> synchronizedSet(Set<T> s)
public static void swap(List<?> list,int i, int j)
public static void shuffle(List<?> list) //随即置换顺序 比如应用到洗牌上

更多方法可以查看API


练习题：fill方法可以将list集合中所有元素替换成指定元素，将list集合中部分
元素替换成指定元素 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("abcd");
list.add("abcde");
list.add("abce");
list.add("abcs");
System.out.println(list);
Collections.fill(list, "kkk");
System.out.println(list); //[kkk,kkk,kkk,kkk,kkk]
}
}

binarySearch()原理：
/*
 * binarySearch（二分法）查找字符串 ，原理就是折半查找
 * binarySearch使用的前提：容器中的元素是有序的；
 */ 
import java.util.ArrayList;
import java.util.List;
public class binarySearchTheory {
public static void main(String[] args) {
List<String> li = new ArrayList<String>();
li.add("java01");
li.add("java02");
li.add("java03");
li.add("java04");
sop(li);
sop(halfSearch(li,"java02"));

}
public static void sop(Object obj) {
System.out.println(obj);
}
public static int halfSearch(List<String> list, String key) {
int min=0,max=list.size()-1,mid;
while(min<=max) {
mid = (min+max)>>1;
String str = list.get(mid);
int num = key.compareTo(str);
if (num>0)
min = mid+1;
else if (num<0)
max = mid-1;
else
return mid;
}
return -min-1;
}

}

Arrays:用于操作的工具类，里面都是静态方法
asList(T... t):将数组变成List集合
String[] str = {"ac","aa","cc"};
List<String> list = Arrays.asList(str);
把数组变成list集合的好处？
可以使用集合的思想和方法来操作数组中的元素
注意：将数组变成集合，不可以使用集合的增删方法
因为数组的长度是固定的。
可以用的有，比如contains，get，indexOf()，subList();
如果增删，会发生UnsupportOperationException
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在
示例：
int[] num = {4,5,6};
List<int[]> list = li.asList(num); //数组中的元素是基本类型，所以将数组作为集合中的元素，所以泛型为int[]
Integer[] num = {4,5,6}
List<Integer> list = li.asList(num); //数组中的元素是对象（Integer自动装箱操作），所以泛型是Integer

示例： 
import java.util.Arrays;
import java.util.List;
public class ArraysMethodasList {
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] str = {"java01","java02","java03","java04"};
List<String> al = Arrays.asList(str);
sop(al); //[java01, java02, java03, java04]
int[] num = {1,3,4,5,6};
List<int[]> intal = Arrays.asList(num);
sop(intal); //[[I@6774a144]
Integer[] numIn = {1,3,4,5,6};
List<Integer> alIn = Arrays.asList(numIn);
sop(alIn); //[1, 3, 4, 5, 6]
}
public static void sop(Object obj) {
System.out.println(obj);
}
}

其他方法操作API  util中的Arrays类

集合变数组
Collection接口中的toArray方法
1.当指定类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组，长度为集合size
当指定类型的数组长度大于集合size，就不会新创建数组，而使用传递进来的数组，若集合中的元素个数少于
数组长度，则用null自动补上
所以创建一个刚刚好的数组最优，即 String[] arr = al.toArray(new String[al.size()]);

2.为什么要将集合变数组？
目的是为了限定对元素的操作，不需要调用这对其进行增删（数组的长度是固定的，集合的长度是不固定的）

高级for循环： 
格式：
for(数据类型 变量 : 被遍历的集合(Collection)或者数组)
{
}
示例：
ArrayList<String> al = new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
for(String s : al)  //第一次s指向abc1，第二次指向abc2... 若al没定义泛型，String应改成Object
{
s = "kk"; //若这里将s指向kk，那么循环打印出来的全是kk
System.out.println(s);
}
高级for循环：遍历的时候，只能获取元素，不能对集合进行其他操作
Iterator除了遍历，还可以进行remove集合中元素的操作
如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的操作

传统for和高级for有什么区别？
高级for有一个局限性，必须有被遍历的目标；
建议在遍历数组的时候，还是使用传统for，传统for可以定义角标

JDK1.5后的新特性：可变参数
示例：
老方法
int[] arr = {3,4};
show(arr);

int[] arr1 = {2,3,4,5};
show(arr);

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

新方法
show(3,4)
show(2,3,4,5)
public static void show(int... arr)
{}

新方法其实是老方法的简写形式，不用每一次都建立数组对象，只要将要操作的元素作为参数传递即可，隐式将这些参数封装成了数组

注意：在使用时，可变参数一定要定义在参数列表的最后面
示例：
public static void show(String str,int... arr)
{}

静态导入 
import static java.util.Arrays.*; //导入的是Arrays这个类中的所有静态成员
import static java.lang.System.*;//导入了System类中的所有静态成员
System.out.println(""); 就可以简写成 out.println("");
Arrays.sort(arr);可以简写成 sort(arr);
注意点：Arrays.toString(arr);不能简写成toString(arr);
原因：所有类都默认 extends Object 而Object中也有toString方法，而且是不带参数的，当方法名相同的时候，一定要指定具体的对象或者类
注：
当类名重名时，需要指定具体的包名

同理，当方法重名时，指定具备所属的对象或者类

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net

标签：

相关文章