集合框架——工具类——排序、折半、最值、逆序、替换

最新推荐文章于 2022-09-09 09:02:58 发布
最新推荐文章于 2022-09-09 09:02:58 发布
阅读量269 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhanshixiang/article/details/82720985
本文深入探讨了Java中Collections工具类的功能与应用，包括排序、折半搜索、获取最大值等核心方法的实现原理，以及如何使用比较器自定义排序规则。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

工具类里封装了一些实现小功能的方法，在实现需求的时候，不需要自己去写功能，直接调用即可。

工具类是Collections 。

首先看一下API里工具类的方法大纲图。

工具类里所有的方法都是静态的。

 

下面将展示以下几个方法的实现原理代码

static
<T extends Comparable<? super T>>
void
sort(List<T> list)
          根据元素的自然顺序 对指定列表按升序进行排序。
static
<T> void
sort(List<T> list, Comparator<? super T> c)
          根据指定比较器产生的顺序对指定列表进行排序。
static voidswap(List<?> list, int i, int j)
          在指定列表的指定位置处交换元素。

 一、排序

package cn.itcast.p2.comparator;

import java.util.Comparator;

public class ComparatorByLength implements Comparator<String> {

	@Override
	public int compare(String o1, String o2) {

		int temp = o1.length() - o2.length();
		
		return temp==0?o1.compareTo(o2): temp;
	}

}

package cn.itcast.p2.toolclass.collections.demo;

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

import cn.itcast.p2.comparator.ComparatorByLength;

public class CollectionsDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		
		/*
		 * Collections：是集合框架的工具类。
		 * 里面的方法都是静态的。
		 * 
		 * 
		 */
		
		demo_4();
	}
	
	public static void demo_4() {
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("zhangsan");
		list.add("zhaoliu");
		list.add("xiaoqiang");
		
		System.out.println(list);
//		Collections.replaceAll(list, "cba", "nba"); // set(indexOf("cba"),"nba");
		Collections.shuffle(list);
//		Collections.fill(list, "cc");
		System.out.println(list);
	}

	public static void demo_3() {
		/*
		TreeSet<String> ts = new TreeSet<String>(new Comparator<String>(){

			@Override
			public int compare(String o1, String o2) {
				
				int temp = o2.compareTo(o1);
				return temp;
			}
			
		});
		*/
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));	
		
		ts.add("abc");
		ts.add("hahaha");
		ts.add("zzz");
		ts.add("aa");
		ts.add("cba");
		
		System.out.println(ts);
		
	}

	public static void demo_2(){
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("aa");
		list.add("zzz");
		list.add("cba");
		list.add("nbaa");
//		Collections.sort(list);
		System.out.println(list);
		
//		int index = Collections.binarySearch(list, "cba");		
//		System.out.println("index="+index);
		
		//获取最大值。
		String max = Collections.max(list,new ComparatorByLength());
		System.out.println("max="+max);
	}
	
	
	
	public static void demo_1(){
		
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("aa");
		list.add("zzz");
		list.add("cba");
		list.add("nbaa");
		System.out.println(list);
		
		
		//对list集合进行指定顺序的排序。
//		Collections.sort(list);
//		mySort(list);
//		mySort(list,new ComparatorByLength());
		Collections.sort(list,new ComparatorByLength());//传入一个长度比较器。按照元素的长度进行比较排序。
		System.out.println(list);
	}
	
	
	//Sort()方法的实现原理。
	public static <T> void mySort(List<T> list,Comparator<? super T> comp){// 定义泛型<T>扩展传入类型的类型范围。
		//同时也限制了传入的类型必须具备有比较方法。
		
		for (int i = 0; i < list.size()-1; i++) {
			
			for (int j = i+1; j < list.size(); j++) {
				
				if(comp.compare(list.get(i), list.get(j))>0){
					
					//swap()方法的实现原理
//					T temp = list.get(i);
//					list.set(i, list.get(j));
//					list.set(j, temp);
					Collections.swap(list, i, j);
					
				}
			}
		}
	}
	
	
	public static <T extends Comparable<? super T>> void mySort(List<T> list){
		
		for (int i = 0; i < list.size()-1; i++) {
			
			for (int j = i+1; j < list.size(); j++) {
				
				if(list.get(i).compareTo(list.get(j))>0){
					
//					T temp = list.get(i);
//					list.set(i, list.get(j));
//					list.set(j, temp);
					Collections.swap(list, i, j);
					
				}
			}
		}
	}

}

 

二、折半

static
<T> int
binarySearch(List<? extends Comparable<? super T>> list, T key)
          使用二分搜索法搜索指定列表，以获得指定对象。

折半使用二分法搜索，前提是该集合必须是有序的，所以先排序。代码在上面。

三、获取最大值

四、获取最长元素

传入一个长度比较器

五、 逆序

（一）、   首先按照自然顺序长度从小到大进行排序。

public static void demo_3() {
		
		
		//逆序原理
		/*
		TreeSet<String> ts = new TreeSet<String>(new Comparator<String>(){

			@Override
			public int compare(String o1, String o2) {
				
				int temp = o2.compareTo(o1);
				return temp;
			}
			
		});
		*/
		TreeSet<String> ts = new TreeSet<String>();	//对指定的比较器进行顺序逆转
		
		ts.add("abc");
		ts.add("hahaha");
		ts.add("zzz");
		ts.add("aa");
		ts.add("cba");
		
		System.out.println(ts);
		
	}

 （二）、然后按照逆序排序长度从大到小

 

static
<T> Comparator<T>
reverseOrder()
          返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。

 

	public static void demo_3() {
		
		
		//逆序原理
		/*
		TreeSet<String> ts = new TreeSet<String>(new Comparator<String>(){

			@Override
			public int compare(String o1, String o2) {
				
				int temp = o2.compareTo(o1);
				return temp;
			}
			
		});
		*/
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());	//对指定的比较器进行顺序逆转
		
		ts.add("abc");
		ts.add("hahaha");
		ts.add("zzz");
		ts.add("aa");
		ts.add("cba");
		
		System.out.println(ts);
		
	}

 （三）、将比较器的原有排序方式逆序排序

 

static
<T> Comparator<T>
reverseOrder(Comparator<T> cmp)
          返回一个比较器，它强行逆转指定比较器的顺序。

 

	public static void demo_3() {
		
		
		//逆序原理
		/*
		TreeSet<String> ts = new TreeSet<String>(new Comparator<String>(){

			@Override
			public int compare(String o1, String o2) {
				
				int temp = o2.compareTo(o1);
				return temp;
			}
			
		});
		*/
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));	//对指定的比较器进行顺序逆转
		
		ts.add("abc");
		ts.add("hahaha");
		ts.add("zzz");
		ts.add("aa");
		ts.add("cba");
		
		System.out.println(ts);
		
	}

六、替换

(一)、  使用另一个值替换列表中出现的所有某一指定值。

static
<T> boolean
replaceAll(List<T> list, T oldVal, T newVal)
          使用另一个值替换列表中出现的所有某一指定值。

 

public static void demo_4() {
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("zhangsan");
		list.add("zhaoliu");
		list.add("xiaoqiang");
		
		System.out.println(list);
		Collections.replaceAll(list, "cba", "nba"); // set(indexOf("cba"),"nba");首先调用indexof查询“cba”的位置，然后把"nba"放到cba的位置
//		Collections.shuffle(list);
//		Collections.fill(list, "cc");
		System.out.println(list);
	}

(二)、 使用指定元素替换指定列表中的所有元素。

static
<T> void
fill(List<? super T> list, T obj)
          使用指定元素替换指定列表中的所有元素。

 

	public static void demo_4() {
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("zhangsan");
		list.add("zhaoliu");
		list.add("xiaoqiang");
		
		System.out.println(list);
//		Collections.replaceAll(list, "cba", "nba"); // set(indexOf("cba"),"nba");首先调用indexof查询“cba”的位置，然后把"nba"放到cba的位置
//		Collections.shuffle(list);//将集合中的元素随机安放在不同的位置上，每一次的顺序都是随机大乱斗
		Collections.fill(list, "cc");//将指定集合中的元素全部替换成"cc"。
		System.out.println(list);
	}

(三)、 使用默认随机源对指定列表进行置换。

 

static voidshuffle(List<?> list)
          使用默认随机源对指定列表进行置换。

 

	public static void demo_4() {
		List<String> list = new ArrayList<String>();
		
		list.add("abcde");
		list.add("cba");
		list.add("zhangsan");
		list.add("zhaoliu");
		list.add("xiaoqiang");
		
		System.out.println(list);
//		Collections.replaceAll(list, "cba", "nba"); // set(indexOf("cba"),"nba");首先调用indexof查询“cba”的位置，然后把"nba"放到cba的位置
		Collections.shuffle(list);//将集合中的元素随机安放在不同的位置上，每一次的顺序都是随机大乱斗
//		Collections.fill(list, "cc");//将指定集合中的元素全部替换成"cc"。
		System.out.println(list);
	}

 每一次出现的顺序都是不一样的。

 

Java集合框架是什么？说出一些集合框架的优点？
李人
11-20 8381
干货太重，且文字比较多。需要花费时间与耐心细细咀嚼，但是真的能收获到很多。 每种编程语言中都有集合，最初的Java版本包含几种集合类：Vector、Stack、HashTable和Array。随着集合的广泛使用，Java1.2提出了囊括所有集合接口、实现和算法的集合框架。在保证线程安全的情况下使用泛型和并发集合类，Java已经经历了很久。它还包括在Java并发包中，阻塞接口以及它们的实现。 1...
Java——API
qq_51733711的博客
08-30 724
javaAPI文档
集合工具类和排序
黄钻高级会员的专栏
03-25 872
一、Collections类集合工具类     1.Collections类里面全部都是静态方法，其中的sort(List list)方法可以实现对List对象排序，前提是list里面的所有元素都必须实现了Comparable接口，也就是实现了接口里面的compareTo(Object o)方法。（Arrays的sort（Object[ ] object）要求一样）    2.compar
折半查找以及逆序输出
weixin_45410402的博客
07-23 350
将一个数逆序输出。` 主要程序为： for (i = 0; i < len/2; i++) { t = a[i]; a[i] = a[len - 1 - i]; a[len - 1 - i] = t; }` 例题：将一个数组中的值按逆序重新存放。例如，原来顺序为8,6,5,4,1。要求改为1,4,5,6,8 int a[] = { 8,6,5,4,1 },i,t; ...
集合框架——Collectios之替换翻转方法
sinat_37580076的博客
08-02 314
import java.util.*; class StrComparator implements Comparator { public int compare(String s1,String s2) { /* int num = s1.compareTo(s2); if(num>0) return -1; if( num<0) return 1; re
C/C++预习：数字逆序输出（2，折半）
Asleny的博客
04-25 773
/* *Copyright(c)2016,烟台大学计算机与控制工程学院 *All right reserved. *文件名称：77.cpp *作 者：董凯琦 *完成日期：2016年4月25日 *版 本 号：v1.0 * *问题描述：将n个数输入时顺序的逆序排列，用函数实现 *输入描述：n和n个整数 *程序输出：逆序输出，空格分开 */ #include using
14-常用对象API(集合框架-工具类-Collections-折半&最值)1 2 15-工具类-Collections-逆序&替换) 1 2 3
insiston0635的博客
12-02 178
C++冒泡排序及折半查找.docx
最新发布
10-17
在计算机科学中，数据处理是一项基础且重要的任务，而C++作为一种强大的编程语言，提供了丰富的工具和方法来处理数组这类数据结构。本篇将围绕冒泡排序、折半查找以及数组的插入、删除、修改和查找等基本操作展开...
MFC多视图演示排序过程实现教程
- **排序算法选择**：题目要求至少实现两种排序算法，这可能包括但不限于：快速排序、折半插入排序、希尔排序、直接选择排序和堆排序等。 #### 5. 视图显示与用户交互 - **客户区显示**：在MFC中，客户区指的是视图...
Java开发面试题——很有帮助的
m0_46891419的博客
06-19 3471
面试题 一、Java 1.运行机制 1)Java跨平台原理 Java实现跨平台是JVM(Java虚拟机)起的作用。如果是C/C++的编译方式，一旦换了一个平台，那么就需要重新编译一份对应的可执行代码，但是Java则不同，编译好了一份Java字节码，换到不同的平台上时，并不需要重新编译，前提是这些平台上都安装了相应平台的JVM，JVM不是跨平台的。 2)垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？ 垃圾回收器通常是作为一个单独的低级别的线程运行，在不可预知的
list 集合倒叙排序
weixin_30681615的博客
03-05 238
Collections.reverse(rights); 转载于:https://www.cnblogs.com/awh-wangpf/p/10475994.html
给list中的集合进行倒叙排序
热门推荐
qq_20670449的博客
01-29 3万+
今天遇到list的倒序问题,以前是自己写for循环来手动倒序,其实JAVA 已经为我们提供了类似的功能,Collections类是一个java的工具类,在JAVA.UTIL包下面,提供了集合的复制和倒序,求集合元素的最大值,最小值等专门针对集合操作的功能,list也属于java集合框架中的重要的一员.Collections.copy()就是对java list的复制,Collections.r
JAVA数组的倒序排序
yygr的博客
09-09 4752
同时呢，Comparator接口提供了一个静态方法reverseOrder，提供自然顺序的逆序比较器，举个简单的例子，一般不会用这个方法对基本类型进行排序，因为第一个参数需要提供一个对象。Arrays工具类中没有提供直接的倒序排序方法，只有默认的sort，但是提供了重载方法。第二个参数提供一个比较器就可以按照自己定义的规则进行排序（内部比较器和外部比较器）
集合排序工具类
方圆几里的博客
09-05 1222
package com.yufei.core.util; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; import org...
2021-04-07
dameizizizi123的博客
04-07 104
java.util 类 Collections static <T extends Comparable<? super T>> void sort(List<T>list) 根据元素的自然顺序 对指定列表按升序进行排序。 static <T> void sort(List<T>list, Comparator<? super T>c...
ArrayList用集合工具类实现反转
诚
09-17 1275
借助Collections工具类： import java.util.ArrayList;import java.util.Collections; public class TTEST { public static void main(Str...
java:通过 commons-beanutils 封装对list逆序排序
lzcwds的博客
12-21 522
  通过 commons-beanutils 封装List排序     maven：   &lt;dependency&gt; &lt;groupId&gt;commons-beanutils&lt;/groupId&gt; &lt;artifactId&gt;commons-beanutils&lt;/artifactId&gt; &lt;...
List集合元素排序——倒序的方法
weixin_47369565的博客
09-28 4383
List集合元素排序——倒序 Collections.reverse(list); System.out.println(list); 使用还是用list
java泛型详解
qq_44986561的博客
12-04 176
泛型 泛型技术：是给编译器使用的技术，编译器进行类型安全检查。将运行时发生的不可解决的异常，在编译检查时期就 制止住。 < 参数 > 也相当于传参数，E也是变量，相当于把类型传进去进行一个限定。 案例 public class GenericTest { public static void main(String[]args) { Set set=new TreeSet(ne...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

真香号

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值