黑马程序员——Collections、Arrays、增强for、可变参数、静态导入

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

工具类：Collections 、Arrays。全部是静态方法。

sort（）：对List集合排序。

public static <T extends Comparable<? super T>> void sort(List<T> list)

{

}

list必须实现Comparable接口的compareTo方法。

import java.util.ArrayList;import java.util.Collections;import java.util.List;public 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("z");list.add("kkkk");list.add("qq");list.add("z");System.out.println(list);<strong>Collections.sort(list);//String本身包含了CompareTo方法。</strong>System.out.println(list);}}

Static <T> void sort(List<T> list,Comparator<? super T> c) 

根据指定比较器产生的顺序对指定列表进行排序。

class myComparator implements Comparator<String>{public int compare(String o1, String o2){int num = ((Integer)o1.length()).compareTo(o2.length());if(num == 0)return o1.compareTo(o2);return num;}}

public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

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

String m = Collections.max(list);

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

使用二分搜索指定列表，已获得指定对象。必须是有序集合。

当元素存在比较方法时，可以传入一个比较器。

int index = Collections.binarySearch(list,"aaa");

如果传入的是aaaa，这返回的是(-(插入点) - 1)。

例如：aaa，abcd，kkkkk，qq，z，zz

index = -2；

则aaaa的插入点因该为1，也就是插在aaa与abcd之间。

用程序写一个二分搜索：

public static  int mybinarySearch(List<String> list,String key){int start = 0;int end = list.size()-1;int index=(end+start)/2;int num;do{num = list.get(index).compareTo(key);//比较if(num>0)//左边搜索{end = index-1;}else if(num<0)//右边搜索{start = index+1;}elsereturn index;index = (end+start)/2;//计算中点}while(end != start && end !=-1);num = list.get(index).compareTo(key);<span style="white-space:pre"></span>if(num>0)<span style="white-space:pre"></span>return (-(index))-1;<span style="white-space:pre"></span>else if(num<0)<span style="white-space:pre"></span>return (-(index+1))-1;<span style="white-space:pre"></span>else<span style="white-space:pre"></span>return index;}}

简便实现方法：

public static int halfSearch(List<String> list, String key){int max,min,mid;max = list.size()-1;min = 0;<strong>while(min<=max){mid = (max+min)>>1;//   /2String str = list.get(mid);int num = str.compareTo(key);if(num>0)max = mid -1;else if(num<0)min = mid +1;elsereturn mid;}</strong>return -min-1;}

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

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

Collections.fill(list,"pp");

用pp替换列表中所有元素。

练习：

将list集合中部分元素替换成指定元素。

public static void fillDemo(List<String> list,int start,int end,String str){List<String> list1 =list.subList(start, end);Collections.fill(list1, str);}

static <T> boolean replaceAll<List<T> list, T oldVal, T newVal)

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

Collections.replaceAll(list,"aaa","pp");

static void reverse(List<?> list)

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

static <T> Comparator<T> reversOrder() 

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

public static <T> Comparator<T> reverseOrder (Comparator<T> cmp)

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

TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new myComparator());

static <T> List<T> synchronizedList<List<T> list)

返回指定列表支持的同步（线程安全的）映射。

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

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

static void shuffle(List<?> list)

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

Arrays： 用于操作数组的工具类。

里面都是静态方法。

static String toString（数组 a）

返回指定数组内容的字符串表示形式。

public class ArraysDemo {public static void main(String[] args) {int[] arr = {1,2,3};System.out.println(Arrays.toString(arr));}}

打印结果：

[1, 2, 3]

asList：将数组变成list集合。

static <T> List<T> asList(T... a);

public class ArraysDemo {public static void main(String[] args) {String[] arr1 = {"abc","cc","kkkk"};List<String> list = Arrays.asList(arr1);System.out.println(list);}}

输出结果：

[abc, cc, kkkk]

//把数组变成list集合有什么好处？

可以使用集合的思想和方法来操作数组中的元素。

list.contains("cc");

判断cc是否存在于数组中。

list.add("qq").//UnsupportedOperationException  不支持的操作异常。

注意：将数组变成集合，不可以使用集合的增删方法。

因为数组的长度是固定的。

可以使用：

contains。

get

indexOf（）

subList（）

如果你增删了，那么会发生UnsupportedOperationException。

如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

例如：

int[] nums = {2,4,5};

List<int[]>  list = Arrays.asList(nums);

list集合中只有一个元素，这个元素就是这个nums数组。

Integer[] nums = {2,4,5};

List<Integer> list = Arrays.asList(nums);

list集合中存在三个元素。

集合变数组：

Collection接口中的toArray（）方法。

Object[] toArray()

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

<T> T[] toArray(T[] a )

返回包含此Collection中所有元素的数组；可以指定类型。

import java.util.ArrayList;import java.util.Arrays;/* * 集合变数组。 * Collection接口中的toArray方法。 */public class CollectionToArray {public static void main(String[] args) {ArrayList<String> al = new ArrayList<String>();al.add("abc1");al.add("abc2");al.add("abc3");/* * 1.指定类型的数组到底要定义多次呢？ * 当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。 * 当指定类型的数组长度大于了集合的size，就不会新创建数组。但是该数组多出的部分都为空。 * 所以得创建一个刚刚好的数组，达到最优。 * *2.为什么要将集合变数组？ *为了限定对元素的操作。限定对集合的增删。 * */String[] arr = al.toArray(new String[al.size()]);System.out.println(Arrays.toString(arr));}}

List类型的集合有两种元素取出方式，因为有角标。

 Set类型的集合只有一种取出方式，就是interator。

public interface Iterable<T> 

实现这个接口允许对象成为foreach语句的目标。    JDK1.5版本开始。

高级for循环

格式：

for（数据类型    变量名：  被遍历的集合(Collection)或者数组）

｛｝

//方法一for(String s : al)//s相当于指针，指向集合中的元素。System.out.println(s);//方法二Iterator<String> it = al.iterator();while(it.hasNext())System.out.println(it.next());

对集合进行遍历。

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

迭代器除了遍历还可以remove集合中的元素。

如果使用的是ListIterator，还可以在遍历过程中进行增删改查的动作。

传统for和高级for有什么区别？

高级for有一个局限性。必须有被遍历的目标。

建议在遍历数组的时候，还是希望使用传统for。因为传统for可以定义脚表。

//两种遍历Map集合的方法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));//方法二for(Map.Entry<Integer,String> me : hm.entrySet())System.out.println(me.getKey()+"::"+me.getValue());

/* * JDK1.5版本出现的新特性。 * 方法的可变参数。 * 在使用时注意：可变参数一定要定义在参数列表最后面。 */public class ParamMethodDemo {public static void main(String[] args) {/* * 可变参数。 * 一种数组参数的简写形式。 * 不用每一次都手动的建立数组对象。 * 只要将要操作的元素作为参数传递即可。 * 隐式的将这些参数封装成了数组。 */show(2,3,4,5,6,7);show("haha",2,3,4,5,6);}public static void show(int... arr){System.out.println(arr.length);}public static void show(String str,int... arr){System.out.println(str+"::"+arr.length);}}

静态导入：

/* * StaticImport 静态导入。 * 当类名重名时，需要指定具体的包名。 * 当方法重名时，指定具备所属的对象或者类。 */<strong>import static java.util.Arrays.*;//导入的是Arrays这个类中所有静态成员。import static java.lang.System.*;//导入System这个类中所有的静态成员。</strong>import java.util.Arrays;public class StaticImport {public static void main(String[] args) {int[] arr = {3,1,5};sort(arr);int index = binarySearch(arr,1);//当方法重名时，指定具备所属的对象或者类。out.println(<strong>Arrays.toString(arr)</strong>);out.println("Index="+index);}}

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------