黑马程序员--- 学习笔记(第十七天)

 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————
Collections:专门用于对集合进行操作的工具类
 这里只演示一些常用的:
排序:
sort();
取最值:
max();
min();
替换:
fill();
repalceAll();
反转:
reverse();
反转比较器:
reverseOrder();
随机置换表元素
shuffle();
交换元素位置:
swap();
同步集合:
synchronizedList()
synchronizedMap()
synchronizedSet()
二分查找:
binarySearch();


Arrays:用于操作数组的工具类,里面都是静态方法
常用操作:
二分查找:
binarySearch();
复制数组:
copyOf();
copyOfRange()
比较:
deepEquals();//深度比较两个数组是否相等
equals();
替换:
fill();
排序:
sort();
将数组内容变成字符串:
toString();
将数组变成List集合
asList();

/*
   静态导入, Collections工具类常用方法
*/
import java.util.*;
import static java.util.Collections.*;//静态导入Collections所有静态成员
class Demo1 
{
	public static void main(String[] args) 
	{
		ArrayList<String> al=new ArrayList<String>();
		al.add("bg");
		al.add("addffff");
		al.add("dsaggg");
		al.add("kadg");
		al.add("g");
		al.add("zkk");
//		static <T> int 
//	 binarySearch(List<? extends Comparable<? super T>> list, T key) 
//          使用二分搜索法搜索指定列表，以获得指定对象。 
			sop(binarySearch(al,"zkk"));
			sop(halfSearch(al,"zkk"));
//	static <T> int 
//	 binarySearch(List<? extends T> list, T key, Comparator<? super T> c) 
//          使用二分搜索法搜索指定列表，以获得指定对象。 
			sop(binarySearch(al,"bg",new LenSort()));
			sop(halfSearch(al,"bg",new LenSort()));
//	static <T> void 
// copy(List<? super T> dest, List<? extends T> src) 
//          将所有元素从一个列表复制到另一个列表。
		ArrayList<String> ll=new ArrayList<String>();
		copy(al,ll);

//			static <T> void 
// fill(List<? super T> list, T obj) 
//          使用指定元素替换指定列表中的所有元素。 
		fill(ll,"nihao");
//			static <T extends Object & Comparable<? super T>> 
//T 
// max(Collection<? extends T> coll) 
//          根据元素的自然顺序，返回给定 collection 的最大元素。 
		sop(max(al));
//static <T> T 
// max(Collection<? extends T> coll, Comparator<? super T> comp) 
//          根据指定比较器产生的顺序，返回给定 collection 的最大元素。 
		sop(max(al,new LenSort()));
//static <T extends Object & Comparable<? super T>> 
//T 
// min(Collection<? extends T> coll) 
//          根据元素的自然顺序 返回给定 collection 的最小元素。 
		sop(min(al));
//static <T> T 
// min(Collection<? extends T> coll, Comparator<? super T> comp) 
//          根据指定比较器产生的顺序，返回给定 collection 的最小元素。 
		sop(min(al,new LenSort()));
//static <T> boolean 
// replaceAll(List<T> list, T oldVal, T newVal) 
//          使用另一个值替换列表中出现的所有某一指定值。 
		sop(replaceAll(al,"bg","wobuhao"));
//static void reverse(List<?> list) 		
//          反转指定列表中元素的顺序。 
		reverse(al);
//static <T> Comparator<T> 
// reverseOrder() 
//          返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。 
		sort(al,reverseOrder());
//static <T> Comparator<T> 
// reverseOrder(Comparator<T> cmp) 
//          返回一个比较器，它强行逆转指定比较器的顺序。 
		sort(al,reverseOrder(new LenSort()));
//static void shuffle(List<?> list) 
//          使用默认随机源对指定列表进行置换。 
		shuffle(al);
//static <T extends Comparable<? super T>> 
//void 
// sort(List<T> list) 
//          根据元素的自然顺序 对指定列表按升序进行排序。 
		sort(al);
//static <T> void 
// sort(List<T> list, Comparator<? super T> c) 
//          根据指定比较器产生的顺序对指定列表进行排序。 
		sort(al,new LenSort());
//static void swap(List<?> list, int i, int j) 
//          在指定列表的指定位置处交换元素。 
		swap(al,1,2);
//static <T> List<T> 
// synchronizedList(List<T> list) 
//          返回指定列表支持的同步（线程安全的）列表。 
	List<String> li=synchronizedList(al);
//static <K,V> Map<K,V> 
// synchronizedMap(Map<K,V> m) 
//          返回由指定映射支持的同步（线程安全的）映射。 
	 Map<String,String> map=new HashMap<String,String>();
	 Map<String,String> m=synchronizedMap(map);
//static <T> Set<T> 
// synchronizedSet(Set<T> s) 
//          返回指定 set 支持的同步（线程安全的）set。 
	 Set<String> set=new HashSet<String>();
	 Set<String> s=synchronizedSet(set);

	}
	/*
	二分查找 原理  不需要比较器
	*/
	public static <T> int halfSearch(List<? extends Comparable<? super T>> list,T key){
		
		int min=0,max=list.size()-1,mid;
		while(min<=max){
			mid=(min+max)>>>1;
			if(list.get(mid).compareTo(key)<0)
				min=mid+1;
			else if(list.get(mid).compareTo(key)>0)
				max=mid-1;
			else 
				return mid;
		}
		return -min-1;
	}
	/*
	二分查找 需要比较器 原理
	*/
	public static <T >int halfSearch(List<? extends T> list,T key,Comparator<? super T> c){
		 int min=0,max=list.size()-1,mid;
		while(min<=max){
			mid=(min+max)>>>1;
			if(c.compare(list.get(mid),key)<0)
				min=mid+1;
			else if(c.compare(list.get(mid),key)>0)
				max=mid-1;
			else 
				return mid;
		}
		return -min-1;
	}

	public static void sop(Object o){
		System.out.println(o);
	}
}
/*
长度比较器
*/
class LenSort implements Comparator<String>
{
	public int compare(String s1,String s2){
		int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num==0)
			return s1.compareTo(s2);
		return num;
	}
}

/*
Arrays 数组工具类
*/
import java.util.*;
import static java.util.Arrays.*;
class Demo2 
{
	public static void main(String[] args) 
	{	
		int []one={5,9,19,133,9,888}; 
		int []two={19,3,27,14}; 
		Integer []i={111,222,333};
//		static <T> List<T> 
//		asList(T... a) 
//          返回一个受指定数组支持的固定大小的列表。 
		 /*只要Integer,Double等数据类型会将数组中的元素作为集合中的元素*/
		List<Integer> li=asList(i);
	//	li.add(5);//不能进行增删操作,会报:UnsupportedOperationException
			sop(li.get(2));//可以获取,判断等
		/*基本数据类型会将该数组作为集合中的元素*/
		//List<int[]> li=asList(one);
		sop(li);
//			static int binarySearch(int[] a, int key) 
//          使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。 
		sop(binarySearch(one,5));
//		static int binarySearch(int[] a, int fromIndex, int toIndex, int key) 
//          使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。 
		sop(binarySearch(one,0,one.length-1,9));
//		static int[] copyOf(int[] original, int newLength) 
//          复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。 
		int []co=copyOf(one,3);
		sop(Arrays.toString(co));
//			static int[] copyOfRange(int[] original, int from, int to) 
//          将指定数组的指定范围复制到一个新数组。 
		int []co1=copyOfRange(one,0,5);
		sop(Arrays.toString(co1));
//			static boolean equals(int[] a, int[] a2) 
//          如果两个指定的 int 型数组彼此相等，则返回 true。
		sop(Arrays.equals(one,two));
//			static void fill(int[] a, int val) 
//          将指定的 int 值分配给指定 int 型数组的每个元素。 
		fill(two,88);
		sop(Arrays.toString(two));
//		static void fill(int[] a, int fromIndex, int toIndex, int val) 
//          将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。 
//		
		fill(two,0,2,97);
		sop(Arrays.toString(two));
//		static void sort(int[] a) 
//          对指定的 int 型数组按数字升序进行排序。
		sort(two);
//		static void sort(int[] a, int fromIndex, int toIndex)
		sort(two,0,3);
//          对指定 int 型数组的指定范围按数字升序进行排序。 
//		static String toString(int[] a) 
//          返回指定数组内容的字符串表示形式。 
		sop(Arrays.toString(two));
	}
	public static void sop(Object o){
		System.out.println(o);
	}
}

把数组变成集合有什么好处?
可以使用集合的思想和方法来操作数组中的元素


注意:
将数组变成集合,不可以使用集合的增删方法,因为数组的长度的是固定的
,就会报不支持的操作异常:unSupportOperationException,能使用其他方法
例如:get(),contians();indexOf();subLift();


  数组==>集合


//数组中的对象会直接变成集合元素
String []strs={"ac","cc","ddd"};
List<String> li=Arrays.asList(strs);


//基本数据类型.会将数组变成集合元素
int []arr={1,2,3};
List<int[]> li=Arrays.asList(arr);


//只能用Integer等对象自动装箱
Integer []arr={1,2,3};
List<Integer> li=Arrays.asList(arr);


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


 集合==>数组


collection中的方法:
 Object[] toArray() 
          返回包含此 collection 中所有元素的数组。 
<T> T[] 
 toArray(T[] a) 
          返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。 

/*
集合变成数组

用集合的Collection的toArray方法

 ]高级for循环
*/
import java.util.*;
class Demo3 
{
	public static void main(String[] args) 
	{
		ArrayList<Integer> al=new ArrayList<Integer>();
		al.add(1);
		al.add(12);
		al.add(51);
		for(Integer/*int也行*/ i: al){
			//i=50; //不能改变集合中元素,只能获取,只有迭代才可以
			System.out.println(i);
		}
		/*打印集合*/
		System.out.println(al);
		/*集合变数组  不能是基本数据类型*/
		Integer []arr=al.toArray(new Integer[al.size()]);
		System.out.println("高级for遍历数组");	
		for(int i : arr)
			System.out.println(i);
		System.out.println(Arrays.toString(arr));

		 /*高级for 遍历Map集合*/
		HashMap<String,String> map=new HashMap<String,String>();

		map.put("a","1");
		map.put("b","2");
		map.put("c","3");

		for(String s: map.keySet())
		{
			System.out.println(s+"  "+map.get(s));
		}
		System.out.println("高级for遍历Map.Entry");
		for(Map.Entry<String,String> me : map.entrySet())
		{
			System.out.println(me.getKey()+"  "+me.getValue());
		}
	}
}

1.指定类型的数组到底定义多长呢?
当指定类型的数组长度小于了集合的size,那么该方法内部会创建一个新的
数组,长度为集合的size
当指定类型的数组长度大于了集合的size,就不会新建数组,而是使用传递进来的
数组
所以创建一个刚刚好的数组最优.就是集合.size()


2.为什么要将集合变成数组?
为了限定对元素的操作,不需要进行增删.
例如获取当前目录的文件,返回给用户,就不要用户进行操作


增强型for循环:


Collection集合实现了Iterable接口,具备迭代器


高级for循环语法:
for(数据类型 变量名: 被遍历的集合(Collection)或数组)


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


传统for循环和高级for循环的区别:
高级for循环有一个局限性,必须有被遍历的目标,建议遍历数组还是使用
传统for,因为传统for可以定义角标


//高级for遍历collection和Map

/*
可变参数
JDK1.5新特性

*/
class Demo4 
{
	public static void main(String[] args) 
	{
		show(5,5,6,7);
		show("重载",5,5,6,7);
		show("v","d","a");
		show(new Student("zhangsan"),new Student("lisi"));
	}
	/*基本数据类型*/
	public static void show(int... arr){
		for (int o: arr )
		{
			System.out.println(o);
		}
	}
	/*可变参数一定定义在参数列表后面*/
	public static void show(String s,int... arr){
		for (int o: arr )
		{
			System.out.println(s+"  "+o);
		}
	}
	/*
	//不能明确show方法执行
	public static void show(Integer... arr){
		for (int o: arr )
		{
			System.out.println(o);
		}
	}
	*/
	/*字符串*/
	public static void show(String... str){
		for (String s: str )
		{
			System.out.println(s);
		}
	}
	/*自定义类型*/
	public static void show(Student... ss){
		for (Student s: ss )
		{
			System.out.println(s.getName());
		}
	}
}
/*学生类*/
class Student
{
	private String name;
	public Student(String name){this.name=name;}
	public String getName(){
		return name;
	}
	
}

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


staticImport静态导入


例如
import static java.util.Arrays.*;
//静态导入Arrays类中的所有静态成员


当类名重名时,需要指定具体的包名
当方法名重名时,需要指定具体所属对象或类


 —————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流！——————————