黑马程序员—Java基础—集合框架4

最新推荐文章于 2024-06-19 11:00:59 发布

代码那点事

最新推荐文章于 2024-06-19 11:00:59 发布

阅读量362

点赞数 1

分类专栏： java-黑马程序员-基础文章标签：框架

本文链接：https://blog.csdn.net/LIUMING204900/article/details/49663689

版权

java-黑马程序员-基础专栏收录该内容

14 篇文章 0 订阅

订阅专栏

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

集合框架4

一、集合之Collection-sort方法

//泛型嵌套格式public static <T extends Comparable<? super T>> void sort(List<T> list)
举例
class Student{}

list.add(new Student());

public static <T extends Comparable<? super T>> void sort(List<T> list){}

集合框架的工具类
Collections：
//sort排序方法

<span style="font-size:18px;">import java.util.*;
 class CollectionsDemo
 {
	 public static void main(String[] args)
     {
		 sortDemo();
	 }

     public static void sortDemo()
     {
		 //泛型
	     List<String> list= new ArrayList<String>();
	     
		 list.add("adg");
	     list.add("ssg");//数组结构，存在索引，可以对重复元素排序
         list.add("ssg");
         list.add("dsgh");	 
	     //不排序，按加入顺序打印
		 sop(list);
	     
		 Collections.sort(list);
	     //排序
		 sop(list);
     }
     public static void sop(Object obj)
     {
	     System.out.println(obj);
     }
 }</span><span style="font-size: 24px;">
</span>

二、max方法
具备了比较性，才能排序，因此泛型为Comparator的子类

<span style="font-size:18px;">import java.util.*;
 class CollectionsDemo
 {
	 public static void main(String[] args)
     {
		 sortDemo();
	 }

     public static void sortDemo()
     {
		 //泛型
	     List<String> list= new ArrayList<String>();
	     
		 list.add("adggeg");
	     list.add("sg");
         list.add("ssggggg");
         list.add("dsgh");	 
	     //不排序，按加入顺序打印
	
	     
		 Collections.sort(list);//自然排序
		 sop(list);
		 String max = Collections.max(list);
         Collections.sort(list, new StrLenComparator());//指定比较器排序
	     //找出最长的字符
		 sop("max="+max);
     }
     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);
	    }
	 }</span>

三、binarySearch
数组长度用length，此处使用size
获取中间角标对应元素

<span style="font-family:SimSun;">import java.util.*;
 class CollectionsDemo
 {
	 public static void main(String[] args)
     {
		 binarySearchDemo();
	 }

     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");
		Collections.sort(list,new StrLenComparator());//按照长度排序

		sop(list);

		//int index = Collections.binarySearch(list,"aaaa");
		//int index = halfSearch(list,"cc");
		int index = halfSearch2(list,"aaaa",new StrLenComparator());
		sop("index="+index);
	}
    
	//binarySearch原理
	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);
           //元素可能不具备比较性或是不具备所需要的比较性，因此需要调用Comparator中的compare方法，比较方式为StrLenComparator
		     
			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; //如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
	}

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

 }

 //覆盖compare方法，按照元素长度比较
  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);
	    }
	 }</span>

四、替换和反转

fill(List<? super T> list, T obj)
使用指定元素替换指定列表中的所有元素。
list(Enumeration<T> e)
返回一个数组列表，它按返回顺序包含指定枚举返回的元素。

练习练习。fill方法可以将list集合中所有元素替换成指定元素。
，将list集合中部分元素替换成指定元素。

五、Collections—reversOrder

import java.util.*;

//定义比较器实现反转
/*
class StrComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		//方法一：if语句实现反转
		int num = s1.compareTo(s2);
		if(num>0)
			return -1;
		if( num<0)
			return 1;
		return num;
		
        //方法二：compareTo语句实现反转
		return s2.compareTo(s1);
	}
}
*/

class CollectionsDemo2
{
	public static void main(String[] args)
	{
		orderDemo();
	}

    public static void orderDemo()
	{    
		//比较器实现反转
		//TreeSet<String> ts= new TreeSet<String>(new StrComparator());
          
        //集合框架工具类reverseOrder实现字母反转排序
        //TreeSet<String> ts= new TreeSet<String>(Collections.reverseOrder());
		//实现字母和长度（从长到短）反转排序，将现有的长度比较器逆转
        TreeSet<String> ts= new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));


		ts.add("abceeg");
		ts.add("aaaa");
		ts.add("bb");
		ts.add("c");

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

//按照长度排序比较器
 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);
	    }
	 }

六、Collections——SynList
static <T> Set<T>
synchronizedSet(Set<T> s)
返回指定 set 支持的同步（线程安全的）set。
//静态方法只能访问静态内部类，
List中，添加和删除动作是两个动作，需要放到一个锁中，保证现场同步
static void shuffle(List<?> list)

使用默认随机源对指定列表进行置换，即list数组进行随机排列

七、Arrays
数组转换成集合，可以使用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法。
因为数组的长度是固定。
contains。
get
indexOf()
subList();
如果增删,那么会反生UnsupportedOperationException,
Arrays:用于操作数组的工具类,里面都是静态方法。

asList:将数组变成list集合

import java.util.*;
class  ArraysDemo
{
	public static void main(String[] args) 
	{
//		int[] arr = {2,4,5};
//
//		System.out.println(Arrays.toString(arr));

		String[] arr = {"abc","cc","kkkk"};

		//把数组变成list集合有什么好处？
		

		
		//static <T> List<T> asList(T... a)  返回一个受指定数组支持的固定大小的列表。 
		//可以使用集合中提供的方法操作数组
		//如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
		List<String> list = Arrays.asList(arr);
		//sop("contains:"+list.contains("cc"));
		//list.add("qq"); 
		//出现UnsupportedOperationException,注意将数组变成集合，不可以使用增删方法，因为数组长度固定

		sop(list);

		//int[] nums = {2,4,5};

		Integer[] nums = {2,4,5};//自动装箱

		//需要添加泛型
		List<Integer> li = Arrays2015/11/5.asList(nums);	
		//如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。
		//如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
		
		sop(li);

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

}

八、集合转换成数组

集合变数组。
Collection接口中的toArray方法。

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

2,为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。

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");
		
		String[] arr = al.toArray(new String[al.size()]);

		System.out.println(Arrays.toString(arr));



	}
}