黑马程序员---Java基础--17天(集合之二)

最新推荐文章于 2024-04-19 02:33:49 发布

MsLinux386

最新推荐文章于 2024-04-19 02:33:49 发布

阅读量1.3k

点赞数

分类专栏： Java基础文章标签： string list arrays class integer

本文链接：https://blog.csdn.net/MsLinux386/article/details/7686605

版权

Java基础专栏收录该内容

26 篇文章 0 订阅

订阅专栏

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

1.集合(Collections-sort).

2.集合(Collections-max).

3.集合(Collections-binarySearch).

/*
集合框架的工具类.
Collections:集合框架的工具类.里面定义的都是静态方法.


Collections和Collection有什么区别?
Collection是集合框架中的一个顶层接口,它里面定义了单列集合的共性方法.
	它有两个常用的子接口,
	List:对元素都有定义索引.有序的.可以重复元素.
	Set:不可以重复元素.无序.


Collections是集合框架一个工具类.该类中的方法都是静态的.
	提供的方法中有可以对list集合进行排序,二分法查找等方法.
	通常常用的集合都是线程操作这些集合时,可以通过该工具类中的同步方法,
	将线程不安全的集合,转换成安全的.




*/
import java.util.*;


class CollectionDemo
{
	public static void main(String[] args) 
	{
		
	}
	public static void binarySearchDemo()
	{
		List<String> list = new ArrayList<String>();


		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		Collection.sort(list,new StrLenComparator());


		sop(list);


		//int index = Collection.binarySearch(list,"aaaa");
		//int index = hashSearch(list,"cc");
		int index = halfSearch2(list,"aaaa",new StrLenComparator());
		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;//   /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-1;




	}
	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-1;
	}
	public static void maxDemo()
	{
		List<String>  list = new ArrayList<String>();


		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		Collections.sort(list);
		sop(list);
		String max = Collections.max(list/*new StrLenComparator()*/);
		sop("max"+max);
	}
	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();


		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");


		sop(list);


		//Collections.sort(list);
		Collections.sort(list,new StrLenComparator());
		//Collections.swap(list,1,2);
		sop(list);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
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);
	}
}

4.集合(Collections-替换反转).

5.集合(Collections-reverseOrder).

6.集合(Collections-SynList).

import java.util.*;
class StrComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		/*
		int num = s1.compareTo(s2);
		if(num>0)
			return -1;
		if(num<0)
			return 1;
		return num;
		*/
		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);
	}
}
class  CollectionsDemo2
{
	public static void main(String[] args) 
	{
		shuffleDemo();
		orderDemo();
		replaceAllDemo();
		fillDemo();
	}
	public static void shuffleDemo()
	{
		List<String> list = new ArrayList<String>();


		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");


		sop(list);
		Collections.shuffle(list);
		sop(list);


	}
	public static void orderDemo()
	{
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));


		ts.add("abcde");
		ts.add("aaa");
		ts.add("k");
		ts.add("cc");


		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}


	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","pp");


		sop(list);
		Collections.reverse(list);
		sop(list);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	/*
	练习:
	fill方法可以将list集合中所有元素替换成指定元素.
	将list集合中部分元素替换成指定元素.
	*/
	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);
	}


}

7.集合(Arrays).

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


asList:将数组变成list集合.


*/
import java.util.*;


class  ArraysDemo
{
	public static void main(String[] args) 
	{
		/*
		int[] arr = {2,3,5};
		System.out.println(Arrays.toString(arr));//{2,3,5}
		System.out.println(arr);//数组首地址.
		*/
		String[] arr = {"abc","cc","kkkk"};


		//把数组编程list集合有什么好处?
		/*
		可以使用集合思想和方法来操作数组中的元素.


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


		contains.
		get.
		indexOf();
		subList();


		如果你增删,那么会发生UnsupportedOperationException.
		*/


		List<String> list = Arrays.asList(arr);
		sop("contains:"+list.contains("cc"));
		//list.add("qq");//UnsupportedOperationException


		sop(list);
		//int[] num = {2,4,5};
		Integer[] num = {2,4,5};


		List<Integer> li = Arrays.asList(num);
		sop(li);


		/*
		1.如果数组中的元素都是对象.那么变成集合时,
			数组中的元素就直接转成集合中的元素.
		2如果数组中的元素都是基本数据类型,那么会将该数组作为
			集合中的元素存在.
		*/
	}
	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;
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

8.集合(集合转成数组).

/*
集合变数组
Collection接口中toArray方法.
*/
import java.util.*;
class  CollectionToArray
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();


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


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


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


		2.为什么讲集合变数组?
		为了限定对元素的操作.不需要进行增删了.
		*/


		String[] arr = al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(arr));
	}
}

9.集合(增强for循环).

/*
高级for循环


格式:
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{


}
对集合进行遍历.
只能获取集合元素.但是不能对集合进行操作.


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


传统for和高级for有什么区别?
高级for有一个局限性.必须有被遍历的目标.
建议在遍历数组的时候,还是希望是用传统for.因为传统for可以定义角标.


*/
import java.util.*;
class  ForEachDemo
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();


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


		for(String s : al)
		{
			//s = "kk";不允许操作
			System.out.println(s);
		}
		System.out.println(al);


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


		while(it.hasNext())
		{
			System.out.println(it.next());
		}
		*/
		int[] arr = {3,5,1};


		for(int x=0; x<arr.length;x++)
		{
			System.out.println(arr[x]);
		}
		for(int i : arr)
		{
			System.out.println("i:"+i);
		}


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


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


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




	}
}

10.集合(可变参数).

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


方法的可变参数.
在使用时注意:可变参数一定要定义在参数列表最后面.
*/
class  ParamMethodDemo
{
	public static void main(String[] args) 
	{
		//show(3,4);
		/*
		虽然少定义了多个方法,
		但是每次都要定义一个数组,作为实际参数.


		int[] arr = {3,4};
		show(arr);


		int[] arr1 = {2,3,4,5};
		show(arr1);
		*/
		/*
		可变参数.
		其实就是上一中数组参数的简写形式.
		不用每一次都手动的建立数组对象.
		只要将要操作的元素作为参数传递即可.
		隐式将这些参数封装成了数组.
		*/
		show("haha",2,3,4,5,6);




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

11.集合(静态导入).

/*
StaticImport 静态导入


当类名重名时,需要制定具体的包名.
当方法重名时,指定具备所属的对象或者类.
*/
import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员.
import static java.util.Collections.*;


/*
packa/Demo.class
packb/Demo.class


import packa.*;
import packb.*;
*/
import static java.lang.System.*;//导入了System类中所有静态成员.
class  StaticImport  //extends Object
{
	public static void main(String[] args) 
	{
		out.println("haha");
		int[] arr = {3,1,5};


		sort(arr);
		int index = binarySearch(arr,1);
		out.println(Arrays.toString(arr));
		out.println("Index="+index);//1的角标是0;


		ArrayList al = new ArrayList();
		al.add(1);
		al.add(3);
		al.add(2);


		out.println(al);


		sort(al);
		out.println(al);
	}
}

---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima