java集合框架工具类Collections,集合的操作

1

import java.util.*;

public class asList
{
    public static void main(String args[])
    {
    //    int arr[] = {1,2,3,4,45};
    //    List<int[]> list = Arrays.asList(arr);
    //    list.add("qq");    这里不能添加,因为数组的长度是固定的

    //    Integer[] nums = {2,4,5,2};
    //    List<Integer> li = Arrays.asList(nums);

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

    String arr[] = {"abc","cc","kkk"};
    List<String> list = Arrays.asList(arr);
    list.contains("cc");
    }
    public static boolean myContains(String[] arr,String key)
    {
        for(int x=;x<arr.length;x++)
        {
            if(arr[x].equals(key))
                return true;
        }
        return false;
    }
}

数组变集合

import java.util.*;

public class asList
{
	public static void main(String args[])
	{
	//	int arr[] = {1,2,3,4,45};
	//	List<int[]> list = Arrays.asList(arr);
	//	list.add("qq");	这里不能添加,因为数组的长度是固定的

	//	Integer[] nums = {2,4,5,2};
	//	List<Integer> li = Arrays.asList(nums);

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

	String arr[] = {"abc","cc","kkk"};
	List<String> list = Arrays.asList(arr);
	list.contains("cc");
	}
	public static boolean myContains(String[] arr,String key)
	{
		for(int x=0;x<arr.length;x++)
		{
			if(arr[x].equals(key))
				return true;
		}
		return false;
	}
}

　　

package pack;

import java.util.*;

public class DemoTwo {
	public static void main(String args[]) {
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkk");
		list.add("qq");
		list.add("z");
		/*
		 * Collections.sort(list); System.out.println(list);
		 *
		 * int a1 =Collections.binarySearch(list,"z"); //用binarySeratch都必须是有序的
		 *
		 * int a2 =Collections.binarySearch(list,"aaaa"); //这里返回-2 -(1) -1
		 * 返回它应该插入的地方 System.out.println(a2);
		 *
		 * int index = halfSearch(list,"cc"); //这个和binarySearch一样功能
		 * System.out.println(index);
		 */

		Collections.sort(list, new MyComparator()); // 这里
		sop(list);
		int index = halfSearch2(list, "aaa", new MyComparator());// 这里要和排序的方法一样
		sop(index);
	}

	public static void sop(Object obj) {
		System.out.println(obj);
	}

	public static int halfSearch1(List<String> list, String key) // 这里是按照字母顺序排序
	{
		int max, min, mid;
		max = list.size() - 1;
		min = 0;
		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;
		}
		return min;
	}

	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; // /2
			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;
	}
}

class MyComparator implements Comparator<String> {
	public int compare(String s1, String s2) {
		if (s1.length() > s2.length())
			return 1;
		if (s1.length() < s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}

　　

package pack;

import java.util.*;

public class DemoTwo
{
	public static void main(String args[])
	{
		//TreeSet<String> ts= new TreeSet<String>(new MyComparator());
		//TreeSet<String> ts= new TreeSet<String>(Collections.reverseOrder());
		//将已知比较器顺序逆转
		TreeSet<String> ts= new TreeSet<String>(Collections.reverseOrder(new MyComparator()));

		ts.add("dsfdsf");
		ts.add("fssd");
		ts.add("wwsdf");
		ts.add("ysfd");
		ts.add("zdfdf");
		System.out.println(ts);
	}
}

class MyComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		return s2.compareTo(s1);
	}
}

　　

集合变数组

package pack;

import java.util.*;

public class DemoTwo
{
	public static void main(String args[])
	{
		/*
			1当指定类型的数组到底要定义多长呢?
			当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组,长度为集合的size.
			2,最好创建一个刚刚好的数组最好
		*/
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
	//	String arr[] = al.toArray(new String[5]);//这里是创建数组的对象和大小和类型
		String[] arr = al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(arr));
	}
}

// 为什么集合变数组 为了限定对元素的操作.

　　

List<String> list = new ArrayList<String>();
Collections.replaceAll(list,"aaa","litiepeng");//替换list集合里面的元素替
Collections.reverse(list);//倒转
Collections.fill(list,"pp");	//意思就是用东西替换集合里的所有元素
String max = Collections.max(list);		//找出最大的来

String max = Collections.max(list,new MyComparator());		//找出最长的来
Collections.sort(list);	//排序
Collections.sort(list,new MyComparator());	//按照自己的构造器排序
Collections.binarySearch(list,key);
Collections.binarySearch(list,key,new mycomparator());
Collections.fill(List<String> list,T obj);		//把集合全部换成别的
Collections.max(Collection c)
Collections.max(Collection c,new myComparator())
同理min

Collections.mix(Collection c)
Collections.mix(Collection c,new myComparator())

Collections.replaceAll(list,orld,new)用新的换旧的
Collections.reverse(List list);
Collections.reverseOrder()	//返回一个构造器
Collections.reverseOrder(new myComparator())
Collections.swap(List<?> list, int i, int j)

Collections.synchronizedList(list)

Collections.shuffle(List<?> list) 使用默认随机源对指定列表进行置换。 意思就是把集合里面的东西随机再次排列一遍

Arrays.asList(数组)	//数组变集合
Arrays.binarySearch()

数组变集合时
	//	int arr[] = {1,2,3,4,45};
	//	List<int[]> list = Arrays.asList(arr);
	//	list.add("qq");	这里不能添加,因为数组的长度是固定的

	//	Integer[] nums = {2,4,5,2};
	//	List<Integer> li = Arrays.asList(nums);

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

集合变数组
	//	String arr[] = al.toArray(new String[5]);//这里是创建数组的对象和大小和类型
		String[] arr = al.toArray(new String[al.size()]);
/*
			1当指定类型的数组到底要定义多长呢?
			当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组,长度为集合的size.
			2,最好创建一个刚刚好的数组最好
*/
/* 为什么集合变数组
为了限定对元素的操作.

String[] arr = {"abc","cc","kkkk"};
List<String> list = Arrays.asList(arr);
list.contains("cc");
list.add("qq");//异常 UnsupportedOperationException,因为数组的长度是固定.
注意:将数组变成集合,不可以使用集合的增删方法.
其他的都可以用
contains.get.indexOf(),subList()
如果你增删,会发生异常
把数组变成list集合后有什么好处?
答:当要判断数组中是否存在某个元素.可以把数组变成list
   可以使用集合的思想和方法来操作数组中的元素.

高级for循环
格式:
for(数组类型 变量名:被遍历的集合(Collection)或者数组)
{
}

对集合进行遍历.
只能获取集合元素,但是不能对集合进行操作.
迭代器除了遍历,还可以进行remove集合中元素的动作.
如果使用ListIterator,还可以在遍历过程中对集合进行增删改查的动作.

传统for和高级for有什么区别呢?
高级for有一个局限性,必须有被遍历的目标.

可变参数:

在使用时注意:可变参数一定要定义在参数列表的最后面
可变参数:其实就是上一种数组参数的简写形式.
不用每一次都手动的建立数组对象.
只要将要操作的元素作为参数传递即可
隐式将这些参数封装成了数组

public static void show(String str,int...  arr)