黑马程序员集合--工具类

最新推荐文章于 2022-01-27 22:49:26 发布

亲雨泽

最新推荐文章于 2022-01-27 22:49:26 发布

阅读量493

点赞数

本文链接：https://blog.csdn.net/u011550142/article/details/12966371

版权

　　-------android培训 java培训、期待与您交流！ ----------

第一节 Collections类

一．概述：

1.Collections上的方法都是静态的。且没有构造函数。

2.特有方法：

排序：

static <T extends Comparable<? super T>> void sort(List<T> list) ：根据元素的自然顺序对指定列表按升序进行排序。注意：元素本身必须具备比较性即使Comparable的子类，元素可以是T的父类。

static <T> void sort(List<T> list ,Comparator<? super T> c) ：根据指定比较器产生的顺序对指定列表进行排序。

比大小：

static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)：根据元素的自然顺序，返回给定collection的最大元素。Collection中的所有元素必须实现Comparable接口。

根据二分搜索法查询：

static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)：使用二分搜索法搜索指定列表，以获得指定对象。在进行此调用之前，必须根据列表元素的自然顺序对列表进行升序排序（通过 sort(List) 方法）。如果没有对列表进行排序，则结果是不确定的。如果列表包含多个等于指定对象的元素，则无法保证找到的是哪一个。

返回：如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。

替换：

static <T> void fill(List<? super T> list ,T obj) ; ：使用指定元素替换指定列表中的所有元素。

练习：fill方法可以将list集合中所有元素替换成指定元素。将list集合中部分元素替换成指定元素。

static <T> boolean replaceAll(List<T> list,T oldVal,T newVal); : 将集合中的旧值换成新值。

反转：

static void reverse(List<?> list) ：反转指定列表中元素的顺序。

static <T> Comparator<T> reverseOrder()：返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

static <T> Comparator<T> reverseOrder(Comparator<T> cmp)：返回一个比较器，它强行逆转指定比较器的顺序。如果指定比较器为 null，则此方法等同于 reverseOrder()（换句话说，它返回一个比较器，该比较器将强行逆转实现了 Comparable 接口的对象 collection 的自然顺序）。

给集合加锁，让其同步：

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

置换集合中的元素位置：void swap(List<?> list,int i,int j); : 在指定列表的指定位置处交换元素。（如果指定位置相同，则调用此方法不会更改列表。）

其实reverse这个方法内部就是调用了这个方法。

static void shuffle(List<?> list)：使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。

示例代码：

package Collection;
import java.util.*;
public class CollectionsSortDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//sortDemo();
		binarySearchDemo();
	}
	public static void binarySearchDemo(){
		List<String> list = new ArrayList<String>();
		list.add("qq");
		list.add("z");
		list.add("aaa");
		list.add("fdsfee");
		list.add("aaa");
		list.add("gifyhgui");
		
		sop(list);
		//sop(Collections.binarySearch(list, "abb"));
		sop(halfSearchDemo(list,"aaa"));
		
	}
	public static int halfSearchDemo(List<String> list,String str){
		int max,mid,min;
		max = list.size()-1;
		min =0;
		while(min<=max){
			 mid = (min+max)>>1;
		     String s = list.get(mid);
		     int num = s.compareTo(str);
		     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("abc");
		list.add("z");
		list.add("fdsfee");
		list.add("qq");
		list.add("aaa");
		list.add("gifyhgui");
		Collections.sort(list);
		sop(list);
		sop(Collections.max(list,new stlenComparator()));
	}
	public static void sortDemo(){
		List<String> list = new ArrayList<String>();
		list.add("abc");
		list.add("z");
		list.add("fdsfee");
		list.add("qq");
		list.add("aaa");
		list.add("gifyhgui");
		sop(list);
		Collections.sort(list);
		//Collections.sort(list, new stlenComparator());
		sop(list);
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}
class	stlenComparator implements Comparator<String>{

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

第二节 Arrays类

一．概述：

1.用于操作数组的工具类。里面都是静态方法。

2.static <T> List<T> asList(T... a) ：将数组变成list集合。

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

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

注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的。

如果增删了。那么会发生UnsupportedOperationException异常。

如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转变成集合中的元素。如果数组中德元素都是基本数据类型，那么会将该数组作为集合中德元素存在。

数组变集合示例代码：

package Collection;

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

public class ArraysDemo {
	 public static void main(String[] args){
		  String[] str ={"aaa","bcd","zqd"};
		  //sop(Arrays.toString(str));
		  List<String> list =Arrays.asList(str);
		  //sop("contains:"+list.contains("bcd"));
		  //sop(list);
		  //int[] num = {4,5,9};
		  Integer[] num ={4,5,9};
		  List<Integer> list2=Arrays.asList(num);
		  sop(list2);
	 }
	 public static void sop(Object o){
		 System.out.println(o);
	 }

}

3.集合变数组：<T> T[] toArray(T[] a);

1.指定类型的数组到底要定义多长呢？当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。

当指定类型的数组长度大于了集合的size，就不会新创建数组。而是使用传递进来的数组。所以创建一个刚刚好的数组最优。

2.为什么要将集合变成数组？

为了限定对元素的操作。

示例代码：

package Collection;

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

public class CollectionToArray {
	public static void main(String[] args){
		List<String> list = new ArrayList<String>();
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		String[] str = list.toArray(new String[5]);
		System.out.println(Arrays.toString(str));
	}

}

增强for循环：

格式：for(数据类型变量名:被操作的集合(collection)或数组){};

对集合进行遍历的时候，只能获取元素。但是不能对集合进行过多操作。

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

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

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

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

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

示例代码：

package Collection;

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

public class ForEachDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
         ArrayList<String> list = new ArrayList<String>();
         list.add("java01");
         list.add("java02");
         list.add("java03");
         //使用增强for循环取出集合中的元素。
         for(String str:list){
        	 System.out.println(str);
         }
         HashMap<String,String> hm = new HashMap<String,String>();
         hm.put("1", "java01");
         hm.put("2", "java02");
         hm.put("3", "java03");
         //第一种方式取出map集合中的元素。
         Set<String> keyset = hm.keySet();
         for(String s :keyset){
        	 System.out.println(s+":::"+hm.get(s));
         }
         //第二种方式取出map集合中的元素。
         for(Map.Entry<String, String> entry:hm.entrySet()){
        	 System.out.println(entry.getKey()+":::"+entry.getValue());
         }
	}

}

可变参数：如果在参数列表中传入多个参数，个数不确定，每次都要复写该方法，可变参数的出现就可以省去复写的麻烦，而直接对数组进行操作

在使用时注意：可变参数一定要定义在参数列表的最后面。

示例代码：

package Collection;

import java.util.Arrays;

public class Demo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		showDemo(2,3,4,5,6);
	}
	//jdk1.5之前的做法
	public static void show(int a ,int b){
		sop(a+":"+b);
	}
	//jdk1.5版本之后的做法
	public static void  showDemo(int...arr){
		sop(arr.length);
		sop(Arrays.toString(arr));
	}
	public static void sop(Object o){
		System.out.println(o);
	}

}

静态导入：

当类名重名时，需要指定具体的包名。

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

示例代码：

package Collection;

import static java.util.Arrays.*; //静态导入Arrays类中的所有静态成员
import static java.lang.System.*;
import java.util.Arrays;
public class StaticImportDemo {
	 public static void main(String[] args){
		 int[] arr ={2,8,4,55,12,99,74};
		 sort(arr);
		 out.println(Arrays.toString(arr));
		 
	 }

}