Lesson_for_java_day14--java中的工具类：Collections和Arrays

最新推荐文章于 2014-05-13 11:02:11 发布

记得要幸福56

最新推荐文章于 2014-05-13 11:02:11 发布

阅读量715

点赞数

分类专栏： lessonForJava 文章标签： Collections Arrays java

本文链接：https://blog.csdn.net/u013233075/article/details/24383183

版权

lessonForJava 专栏收录该内容

40 篇文章 1 订阅

订阅专栏

Collections：

package collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/*
	集合框架的工具类：
		collections：
 */
public 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("ad");
		list.add("a");
		list.add("qq");
		list.add("zzz");
		list.add("dsd");
		
		Collections.sort(list);
		System.out.println(list);//
		int index = Collections.binarySearch(list, "aa");
		System.out.println("index:" + index);
		
		int index1 = halfSearch(list,"qq");
		System.out.println("index1:" + index1);
		
		Collections.sort(list,new strLengthSort());
		System.out.println(list);
		int index2 = halfSearch2(list,"qq",new strLengthSort());
		System.out.println("index2:" + index2);
	}
	
	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-1;
	}
	
	public static int halfSearch2(List<String> list,String key,Comparator<String> cmp){
		int max,min,mid;
		max = list.size()-1;
		min = 0;
		while(min <= max){
			mid = (max + min)>>1;
			String str = list.get(mid);
			int num = cmp.compare(str, key);
			if(num > 0)
				max = mid - 1;
			else if(num < 0)
				min = mid + 1;
			else 
				return mid;
		}
		return -min-1;
	}
	
	public static void  maxDemo(){
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("ad");
		list.add("a");
		list.add("qq");
		list.add("zzz");
		list.add("dsd");
		
		String max = Collections.max(list);//调用工具，获取最大值
		System.out.println(max);
		
		String max1 = Collections.max(list,new strLengthSort());//特点比较（按长度）获取最大值
		System.out.println(max1);	
	}
	
	
	public static void sortDemo(){
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("ad");
		list.add("a");
		list.add("qq");
		list.add("zzz");
		list.add("dsd");
			
		System.out.println(list);//无排序
		//Collections.sort(list);//调用工具，自然排序
		Collections.swap(list, 1, 2);//置换集合内两元素。
		System.out.println(list);	
		
		Collections.sort(list,new strLengthSort());//特点排序（按照字符串长度排序）
		System.out.println(list);	
	}
}

//创建比较器，按照字符串长度比较
class strLengthSort implements Comparator<String>{

	public int compare(String o1, String o2) {
		// TODO Auto-generated method stub
		if(o1.length() == o2.length())
			return o1.compareTo(o1);
		else return o1.length() - o2.length();
	}
}

package collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;

/*
	课下练习：
		fill方法可以将list集合中所有元素替换成指定元素。
			将list集合中部分元素替换成指定元素
 * 
 */
public class CollectionsDemo2 {

	public static void main(String[] args) {
		//fillDemo();
		//replaceAllDemo();
		//orderDemo();
		shuffleDemo();
	}
	
	public static void shuffleDemo(){
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("ad");
		list.add("a");
		list.add("qq");
		list.add("zzz");
		list.add("dsd");
		
		System.out.println(list);
		Collections.shuffle(list);//将集合中的元素按照随机性进行再次排列
		System.out.println(list);
	}
	
	public static void orderDemo(){
		//两种方式将集合按自然顺序的反序排序
		//TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder()/*new StrComparator()*/);
		//自定义排序方式（按长度排序），将集合按照自定义排序的反序排序
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new strLengthSort()));
		
		ts.add("abced");
		ts.add("aa");
		ts.add("kkk");
		ts.add("c");
		
		Iterator<String> it = ts.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		
	
	}
	
	public static void replaceAllDemo(){
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("ad");
		list.add("a");
		list.add("qq");
		list.add("zzz");
		list.add("dsd");
		
		System.out.println(list);
		Collections.replaceAll(list, "ad", "kkk");//替换
		System.out.println(list);
		
		Collections.reverse(list);//反转
		System.out.println(list);
	}
	
	public static void fillDemo(){
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("ad");
		list.add("a");
		list.add("qq");
		list.add("zzz");
		list.add("dsd");
		
		System.out.println(list);
		Collections.fill(list, "qq");//将集合中元素，全部替换成指定值
		System.out.println(list);
	}

}

//自定义反序排序
class StrComparator implements Comparator<String>{
	public int compare(String s1, String s2){
		return s2.compareTo(s1);
	}
}

Arrays:

1、ArraysDemo:

package arrays;

import java.util.Arrays;
import java.util.List;

/*
	Arrays:用于操作数组的工具类。里面都是静态方法
		
	asList:将数组变成list集合
 */
public class ArraysDemo {

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

		
		String[] a = {"abc","cc","kkkk"};
		/*
		 * 把数组变成list集合
		 * 好处：可以使用集合的思想和方法来操作数组中的元素
		 * 注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。
		 * 		可以用：contains();get();indexOf();subList();等。。
		 * 		如果增删了，那么会发生UnsupportedOperationException(不支持操作)异常
		 */
		List<String> list = Arrays.asList(a);
		//list.add("qq");//java.lang.UnsupportedOperationException
		System.out.println(list);
		
		
		/*
		 * 如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转换成集合中的元素
		 * 如果数组中的元素都是基本数据类型，那么会将数组作为集合中的元素存在
		 */
		int[] num = {2,4,5};//数组的元素是基本数据类型
		List<int[]> li = Arrays.asList(num);//注意泛型是int[]
		System.out.println(li);
		
		Integer[] num1 = {2,4,5};//数组的元素是对象
		List<Integer> li1 = Arrays.asList(num1);//注意泛型是Integer
		System.out.println(li1);
		
	}

}

2、CollectionToArray:

package arrays;

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("abd--1");
		al.add("abd--2");
		al.add("abd--3");
		
		/*
		 * 1、指定类型的数组到底要定义多长呢？
		 * 		当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。
		 * 			长度为集合的size。
		 * 		当指定类型的数组长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组。
		 * 		所以创建一个刚刚好的数组最优。
		 * 
		 * 2、为什么要将集合变数组？
		 * 		为了限定对元素的操作。不需要进行增删。
		 */
		String[] arr = al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(arr));		
	}
}

3、ForEachDemo:

package arrays;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
	高级for循环：
		格式：
			for(数据类型 变量名：被遍历的集合(collection)或者数组){
			}
			
		对集合进行遍历：
			只能获取元素，但是不能对集合进行操作。
			而迭代器除了遍历还可以进行remove集合中元素的动作。
			如果使用ListIterator,还可以在遍历过程中对集合进行增删改查的动作。
			
		传统for和高级for有什么区别？
			高级for有一个局限性。必须有被遍历的目标。
			建议：在遍历数组的时候，还是希望使用传统for。因为传统for可以定义角标。     
 */
public class ForEachDemo {
	public static void main(String[] args) {
		ArrayList<String> al = new ArrayList<String>();
		al.add("abd--1");
		al.add("abd--2");
		al.add("abd--3");
		
		//1、高级for循环，用迭代的都可以用高级for循环
		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());
		}
		*/
		
		//2、遍历数组中元素
		int[] arr = {3,5,1};
		for(int i : arr){
			System.out.println("i:" + i);
		}
		
		
		//3、遍历集合中元素
		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());
		}
	}
}

4、ParamMethodDemo:

package arrays;

import java.util.Arrays;

/*
	JDK1.5版本出现的新特性：
		方法的可变参数新特性：
			注意：在使用时，可变参数一定要定义在参数列表的最后面。
		
 */
public class ParamMethodDemo {
	public static void main(String[] args) {
		//方式一：
//		show(2,3);
//		show(2,3,4);
		
		//方式二：虽然少定义了多个方法。但是每次都有定义一个数组，作为实际参数
//		int[] arr = {3,4};
//		show(arr);
//		System.out.println();
//		int[] arr1 = {3,4,5};
//		show(arr1);
		
		
		//方式三：可变参数，其实就是上一种数组参数的简写形式。不用每次都手动建立数组对象。
		//	只要将要操作的元素作为参数传递即可，隐式将这些参数封装成数组。
		show(1);
		System.out.println();
		show(1,2,3);
		System.out.println();
		show("hehehe",2,3);
	}
	
	
	//方式三：
	public static void show(int... arr){
		for(int i : arr){
			System.out.print(i + ", ");
		}
	}
	//注意：在使用时，可变参数一定要定义在参数列表的最后面。
	public static void show(String s, int... arr){
		System.out.print(s + " ");
		System.out.println(Arrays.toString(arr));
	}
	
	
	//方式二：
	/*
	public static void show(int[] arr){
		for(int i : arr){
			System.out.print(i + ", ");
		}
	}
	*/
	
	//方式一：
	/*
	public static void show(int a ,int b){
		System.out.println(a + ":" + b);
	}
	public static void show(int a ,int b, int c){
		System.out.println(a + ":" + b + ":" + c);
	}
	*/

}

5、StaticImport:

package arrays;

/*
	StaticImport:静态导入：
		当类名重名时，需要指定具体的包名。
		当方法重名时，需要指定所属的对象或者类。
 */
import java.util.Arrays;
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.lang.System.*;//导入System类中的所有静态成员

public class StaticImport {
	public static void main(String[] args) {
		//未静态导入时的操作
		int[] arr = {3,1,5};
		Arrays.sort(arr);
		int index = Arrays.binarySearch(arr, 3);
		System.out.println(Arrays.toString(arr));
		System.out.println("Index:" + index);
		
		//静态导入后的操作
		int[] arr1 = {4,7,3,1,5};
		sort(arr1);//省略Arrays.
		int index1 = binarySearch(arr1, 3);//省略Arrays.
		System.out.println(Arrays.toString(arr1));//不能省略Arrays.因为toString重名。
		out.println("Index1:" + index1);//省略System

	}

}