JAVASE----12----集合零散知识

1，Collections：操作集合

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


public class CollectionsDemo {

	/**
	 * 集合框架的工具类
	 * Collections
	 */
	public static void main(String[] args) {
		
		Demo();
	}
	
	public static void Demo()
	{
		List<String>list=new ArrayList<String>();
		list.add("ffffff");
		list.add("adsas");
		list.add("sdf");
		list.add("b");
		list.add("b");
		System.out.println(list);//[ffffff, adsas, sdf, b, b]
		//按自然顺序排序
		Collections.sort(list);
		System.out.println(list);//[adsas, b, b, ffffff, sdf]
		//查询最大值
		String max=Collections.max(list); 
		System.out.println(max);  //sdf
		//重载sort
		//按长度排序，实现比较器。
		Collections.sort(list,new StrLenComparator());
		System.out.println(list); //[b, b, sdf, adsas, ffffff]
		
		//查找
		int  index=Collections.binarySearch(list, "sdf");
//		int index=halfSearch(list," bb", new StrLenComparator() {
//		});  //-2
		System.out.println(index);  //2 找不到返回-min-1
	}
	
	public static int halfSearch(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=str.compareTo(key);
	      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;
	}

}

class StrLenComparator implements Comparator<String>
{

	@Override
	public int compare(String s1, String s2) {
		if(s1.length()>s2.length())
                return 1;
		if(s1.length()<s2.length())
            return -1;
		else 
			return  s1.compareTo(s2);
	}
	
/*
class Student
{
}
 list.add(new Sudent());
 
 public static<T extends Comparable<? super T>> void sort<List<T>list>
 {
 }
*/



}


//Collections.fill()--将集合中的元素全部替换成某一个
//Collections.replaceAll(list,oldValue,newValue)--替换某一个元素
//Collections.reverse(list);  //反转。 

import java.util.Collections;
import java.util.Iterator;
import java.util.TreeSet;


public class CollectionsDemo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		orderDemo();
	}
	
	public static void orderDemo()
	{
		//逆向反转自然顺序的比较器
		//重载方法--强行逆转比较器的顺序
		TreeSet<String>ts=new TreeSet<String>(Collections.reverseOrder());
		ts.add("absdsd");
		ts.add("aaa");
		ts.add("kkk");
		ts.add("ccc");
		Iterator<String> it=ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
			//kkk
			//ccc
			//absdsd
			//aaa

		}
		// 随机排序
		//Collections.shuffle();
	}

}

2，Arrays ：操作数组

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


public class ArraysDemo {

	/**
	 * asList: 将数组变成list集合
	 */
	public static void main(String[] args) {
		int []arr={2,4,5};
		System.out.println(Arrays.toString(arr));//[2, 4, 5]
		String[] arrs={"abc","cc","kkk"};
		List<String> list=Arrays.asList(arrs);
		System.out.println(list); //[abc, cc, kkk]
		/*把数组变成list集合的好处。
		可以使用集合的思想和方法来操作数组中的元素。
		注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。
		可以使用contains,get,indexof() sublist();
		如果增删了，会发生UnsupportedOperationException
		*/
		//list.add("qq");//UnsupportedOperationException
        
		List<int[]>li=Arrays.asList(arr);//[[I@61de33]
		List ll=Arrays.asList(arr);  //[[I@61de33] 
		System.out.println(li); 
		
		
		Integer [] inte={2,4,6,7};
		List Li=Arrays.asList(inte);
	//	List<Integer> Li=Arrays.asList(inte);
		System.out.println(Li);  //[2, 4, 6, 7]

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

}

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


public class CollectiontoArray {

	/**
	 * 集合变数组，
	 * Collection 接口中的toArray方法
	 */
	public static void main(String[] args) {
	ArrayList<String>al=new ArrayList<String>();
	al.add("abc");
	al.add("asdsd");
	al.add("sdff");
	al.add("a");
	/*
	 * 1，指定类型的数组到底定义多长呢？当指定类型的数组的长度小于了集合的size，那么该方法内部
	 * 会创建一个新数组，长度为集合的size。
	 * 当指定类型的数组的长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组
	 * 所以使用一个刚刚好的数组最优。
	 * 
	 * 2，为什么要将集合变数组：
	 * 为了限定对元素的操作，不需要进行增删了。
	 */
	
	String []arr=al.toArray(new String[al.size()]);
	System.out.println(Arrays.toString(arr)); //[abc, asdsd, sdff, a]

	}

}

3，foreach：

import java.util.ArrayList;


public class ForEachDemo {

	/**
	 * foreach：
	 * 格式：
	 * for(数据类型 变量名：被遍历的集合(Collection)或者数组)
	 * {}
	 * 
	 * 对集合进行遍历:
	 * 只能获取集合元素，但是不能对集合进行操作。
	 * 迭代器除了遍历，还可以进行remove集合中元素的操作。
	 * 如果使用ListIterator，还可以在遍历过程中进行增删改查的操作。
	 * 
	 * for 和foreach 有什么区别？
	 * foreach 有一个局限性，必须有被遍历的目标。
	 * 建议在遍历数组的时候，使用for，因为可以定义脚标。
	 * 
	 */
	public static void main(String[] args) {
		ArrayList<String>al=new ArrayList<String>();
		al.add("abc");
		al.add("asdsd");
		al.add("sdff");
		al.add("a");
		
		for(String s:al)
		{
			System.out.println(s); 
			//abc
			//asdsd
			//sdff
			//a

		}

	}

}

4， 可变参数

        show(1,2,3,4,5);
             show(1,2,3,4,5,6,7);
	}
	
	/*
	 * 可变参数：
	 * 不用每一次都手动的建立数组对象。
	 * 只要将要操作的元素作为参数传递即可
	 * 隐式将这些参数封装成了数组。 

           在使用时注意：可变参数一定要定义在参数列表最后面。
	 */
	public static void show(int...arr)
	{
		System.out.println(arr.length);
	}

}