黑马程序员——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;
			}
			else
				return 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;//   /2
		
			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;
		}</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学习型技术博客、期待与您交流！------------