集合框架工具笔记

集合框架工具类
Collections:



集合框架工具类
Collections:

import java.util.*;


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


	public static void main(String[] args)
	{
		//sortDemo();
		//maxDemo();
		binarySearchDemo();
	}


	public static void binarySearchDemo()
	{
		List<String> list = new ArrayList<String>();


		list.add("aaa");
		list.add("abcd");
		list.add("zzz");
		list.add("qqqqq");
		list.add("kkkkkk");
		list.add("zz");


		Collections.sort(list);//sort(); 根据指定的比较器产生的顺序对指定列表进行排序。
		sop(list);


		//int index = Collections.binarySearch(list,"zzz");
			//binarySearch();使用二分查找法搜索指定列表获取指定对象
		int index = halfSearch(list,"zzz");//二分查找发
		sop("index="+index);
	}


	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;  //(max+min)/2


			String str = list.get(mid);


			int num = str.compareTo(key);
			if(num>0)  //key<mid
				max = mid-1;
			else if(num<0)  //key>mid
				min = mid+1;
			else
				return mid;
		}
		return -1;
	}


	public static void maxDemo()
	{
		List<String> list = new ArrayList<String>();


		list.add("aaa");
		list.add("abcd");
		list.add("zzz");
		list.add("qqqqq");
		list.add("kkkkkk");
		list.add("zz");
		sop(list);
		Collections.sort(list);
		sop(list);
		String max = Collections.max(list);
		sop("max="+max);


		sop("Len max="+Collections.max(list,new StrLenComparator()));
	}


	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();


		list.add("aaa");
		list.add("abcd");
		list.add("zzz");
		list.add("qqqqq");
		list.add("kkkkkk");
		list.add("zz");
		//list是数组，数组中因有索引而可以出现重复元素


		sop(list);


		//1.
		//Collections.sort(list);


		//2.
		Collections.sort(list,new StrLenComparator());


		sop(list);
	}
}


class StrLenComparator 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);
	}
}

import java.util.*;


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


	public static void main(String[] args)
	{
		fillDemo();
		//replaceAllDemo();
		//orderDemo();
	}


	public static void orderDemo()
	{
		//TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());//reverseOrder() 返回一个比较器  倒序
		//TreeSet<String> ts = new TreeSet<String>(new StrComparator());//StrComparator() 比较器  倒序
		//TreeSet<String> ts = new TreeSet<String>(new StrLenComparator());//按长度排顺序 升序
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
		//Collections.reverseOrder(new StrLenComparator())  强行逆转指定比较器的顺序


		ts.add("xyza");
		ts.add("abcde");
		ts.add("gdf");
		ts.add("cc");


		//1.
		//sop(ts);
		//2.
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
	}


	public static void fillDemo()
	{
		List<String> list = new ArrayList<String>();


		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		sop(list);


		//Collections.fill(list,"pp");//将集合中的元素全部替换成指定元素。
		//sop(list);


		//Collections.swap(list,1,2);//swap(List,int x,int y) 交换指定列表中指定元素的位置
		//sop(list);
		//swap();  只能用于List中


		Collections.shuffle(list);//shuffle(List list); 使用默认随机源对指定列表进行置换。
		sop(list);
	}


	public static void replaceAllDemo()
	{
		List<String> list = new ArrayList<String>();


		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		sop(list);


		Collections.replaceAll(list,"aaa","qq");
		sop(list);


		Collections.reverse(list);//reverse()  反转
		sop(list);


		}
	}


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


class StrLenComparator 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);
	}
}

/*
Arrays：用于操作数组的工具类。
  里面都是静态方法。
*/


 import java.util.*;


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


	public static void main(String[] args)
	{
		//int[] arr = {2,4,6};
		//sop(Arrays.toString(arr));




		//把数组变成list集合的好处：
		//可以使用集合的思想和方法来操作数组中的元素。
		//注意：将数组变成集合不可以使用集合的增删方法。因为数组的长度是固定的。
		//可以使用：contains，get，indexOf(),subList()等方法。
		//String[] arr = {"abc","kkk","qq"};
		//List<String> list = Arrays.asList(arr);//aslist();  返回一个受指定数组支持的固定大小的列表，即将数组变为列表
		//sop("Contains:"+list.contains("qq"));
		//sop(list);




		/*
		如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素。
		如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
		*/
		//int[] nums = {1,2,3,4,5};
		//List list1 = Arrays.asList(nums);//基本数据类型
		//sop(list1);//[I@15db9742
		Integer[] num = {1,2,3,4,5};
		List<Integer> li = Arrays.asList(num);//对象
		sop(li);


	}
}


/*
高级for循环
格式：
for(数据类型 变量名:被遍历的集合(Collection)或者数组)
{
}
只能对集合中的元素进行取出.
for each遍历的局限性：必须有被遍历的目标。


迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
*/


import java.util.*;


class ForEachDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args)
	{
		ArrayList<String> a1 = new ArrayList<String>();


		a1.add("abc1");
		a1.add("abc2");
		a1.add("abc3");


		//sop(a1);


		/*
		Iterator<String> it = a1.iterator();


		while(it.hasNext())
		{
			sop(it.next());
		}*/


		/*
		for(String s:a1)
		{
			sop(s);
		}*/


		HashMap<Integer,String> hm = new HashMap<Integer,String>();


		hm.put(1,"abc01");
		hm.put(2,"abc02");
		hm.put(3,"abc03");


		/*
		Set<Integer> keySet = hm.keySet();
		for(Integer i:keySet)
		{
			sop(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())
		{
			sop(me.getKey()+"...."+me.getValue());
		}
	}
}










/*
JDK1.5版本出现的新特性。


方法的可变参数。
使用时注意：可变参数一定要定义在参数列表的最后面。
如：show("java",1,2,3);
	public static void show(String str,int... arr)
*/


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

	public static void main(String[] args)
	{
		/*
		int[] arr = {1,2,3,4,5};
		show(arr);
		虽然少定义了多个参数，但每次都要定义一个数组作为实际参数*/



		show(2);//[I@15db9742]  1
		show(1,2,3,4,5);//[I@6d06d69c] 5
		/*
		可变参数。
		其实就是上一种数组参数的简写形式。不用每次都手动的建立数组对象。
		只要将要操作的元素作为参数传递即可。隐式的将这些参数封装成了数组。
		*/
	}


	/*
	public static void show(int[] arr)
	{}*/


	public static void show(int... arr)
	{
		System.out.println(arr);
		System.out.println(arr.length);
	}
}












/*
StaticImport 静态导入。使用后导入的是某类中所有的静态成员


当类名重名时，需要指定具体的包名。即不同包中的同名类。需 包名.类名
当方法重名时，指定具备所属的对象或者类。
*/


/*
class StaticImport
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}


	public static void main(String[] args)
	{
		int[] arr = {3,1,5};


		java.util.Arrays.sort(arr);//升序排列


		sop(java.util.Arrays.toString(arr));//返回指定数组的字符串表达形式。


		sop("index:"+java.util.Arrays.binarySearch(arr,3));
	}
}*/


/*
import java.util.*;
class StaticImport
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}

	public static void main(String[] args)
	{
		int[] arr = {3,1,5};

		Arrays.sort(arr);


		sop(Arrays.toString(arr));


		sop(Arrays.binarySearch(arr,5));
	}
}*/


import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类中所有的静态成员。
import static java.lang.System.*;//导入了System类中所有的静态成员。


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


	public static void main(String[] args)
	{
		int[] arr = {3,1,5,8};


		//sort(arr);


		//sop(Arrays.toString(arr));
		/*
		sop(toString(arr));//错误，无法将Object中的方法toString应用到给定类型；
		原因：class StaticImport (原本) extends Object，Object中有toString方法。
		*/


		//sop("index="+binarySearch(arr,5));
		out.println("java");
	}
}