java排序

最新推荐文章于 2024-07-24 17:49:50 发布
最新推荐文章于 2024-07-24 17:49:50 发布
阅读量414 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43451521/article/details/105403654
版权

1-找出这组数据中最大的数[1-3-8-9-4-5-8],要求:(1)用冒泡排序法计算,(2)自己写一个解决这个问题的代码。

// An highlighted block
package test.work.sort;
/*1-找出这组数据中最大的数[1-3-8-9-4-5-8],要求:(1)用冒泡排序法计算,
(2)自己写一个解决这个问题的代码。*/
public class Main {
	/**
	 * 方法1：冒泡排序
	 * @param a
	 */
	public static void sort(int[] a){
		int temp;
		boolean b = true;
		for(int i=0;i<a.length;i++){
			b = true;
			for(int j=0;j<(a.length-1-i);j++){
				if(a[j]-a[j+1]>0){
					b= false;
					temp = a[j+1];
					a[j+1] = a[j];
					a[j] =temp;
				}
			}
			if(b){
				break;
			}
		}
	}
	/**
	 * 方法2
	 * @param a
	 * @return max
	 */
	public static int getMax(int[] a){
		int max = a[0];
		for(int i=1;i<a.length;i++){
			if(max<a[i]){
				max = a[i];
			}
		}
		return max;
	}
	public static void main(String[] args) {
		int[] arr = {1,3,8,9,4,5,8};
		sort(arr);
		int max = arr[arr.length-1];
		int maxs = getMax(arr);
		System.out.println(max);
		System.out.println(maxs);
	}
}

2-compareTo 函数总结
如果是数字，compareTo 用来比较2个数的大小；如果是字符串就比首字母的大小（ASCII码值），首字母相同就比第二个字母，以此类推；第一个数大于第二个数返回1，小于返回-1，等于返回0

// An highlighted block
package test.work.sort;

public class Test01 {
	public static void main(String[] args) {
		Integer a1 = 5;
		Integer b1 = 6;
		System.out.println(a1.compareTo(b1));//-1
		String a2 = "ac";
		String b2 = "ab";
		System.out.println(a2.compareTo(b2));//1
		Double a3 = 2.3;
		Double b3 = 2.3;
		System.out.println(a3.compareTo(b3));//0
	}
}

3-Connections.sort 总结(升序和降序).
Connections.sort(List list) 的源码，默认按照升序排序
在这里插入图片描述
采用默认排序

// An highlighted block
package test.work.sort;

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

public class Test01 {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(4);
		list.add(2);
		list.add(6);
		Collections.sort(list);
		System.out.println(Arrays.toString(list.toArray()));
	}
}

打印结果：
在这里插入图片描述
sort(List list, Comparator<? super T> c)的源码，可以自定义一个Comparator实现类排序
在这里插入图片描述
下面自定义1个实现类来排序

// An highlighted block
package test.work.sort;

import java.util.Comparator;


public class TestCollections implements Comparator<Integer>{

	@Override
	public int compare(Integer o1, Integer o2) {
		return -(o1-o2);//降序
	}
}


// An highlighted block
package test.work.sort;

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

public class Test01 {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(4);
		list.add(2);
		list.add(6);
		Collections.sort(list,new TestCollections());
		System.out.println(Arrays.toString(list.toArray()));
	}
}

打印结果：
在这里插入图片描述

4-TreeSet和TreeMap 总结,要求有代码辅助总结.
1、TreeSet提供1个有序的Set集合，共有2中排序方式；
2、TreeSet在添加的时候排序，若添加后再修改元素内容，则不改变排序
代码解释：
实体类News

// An highlighted block
package test.work.sort;

public class News implements Comparable<News>{
	private String title;
	private Integer hit; 
	public News(){}
	
	public News(String title, Integer hit) {
		super();
		this.title = title;
		this.hit = hit;
	}

	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public Integer getHit() {
		return hit;
	}
	public void setHit(Integer hit) {
		this.hit = hit;
	}
	@Override
	public int compareTo(News o) {
		return (this.hit-o.hit)==0?0:((this.hit-o.hit)>0?1:-1);
	}
	
}

第一种排序：自然排序，这种排序要求TreeSet里添加的类必须实现Comparable接口，否则运行会报错

// An highlighted block
package test.work.sort;

import java.util.TreeSet;

public class App {
	public static void main(String[] args) {
	/**
	* 按照News的hit大小排序
	*/
		TreeSet<News> ts = new TreeSet<News>();
		ts.add(new News("news1aaa",100));
		ts.add(new News("news2aa",80));
		ts.add(new News("news3a",200));
		ts.add(new News("news4",120));
		for(News n :ts){
			System.out.println(n.getTitle()+"------"+n.getHit());
		}
	}
}
打印结果：news2aa------80
news1aaa------100
news4------120
news3a------200

第二种排序：自定义排序

// An highlighted block
package test.work.sort;

import java.util.TreeSet;

public class App {
	public static void main(String[] args) {
		TreeSet<News> ts = new TreeSet<News>(
		new java.util.Comparator<News>(){
		/**
		*按照News的title字符长度排序
		*/
			@Override
			public int compare(News o1, News o2) {
				return (o1.getTitle().length()-o2.getTitle().length())==0?
						0:((o1.getTitle().length()-o2.getTitle().length())>0?1:-1);
			}
			
		});
		ts.add(new News("news1aaa",100));
		ts.add(new News("news2aa",80));
		ts.add(new News("news3a",200));
		ts.add(new News("news4",120));
		for(News n :ts){
			System.out.println(n.getTitle()+"------"+n.getHit());
		}
	}
}
打印结果：news4------120
news3a------200
news2aa------80
news1aaa------100

2、TreeSet在添加的时候排序，若添加后再修改元素内容，则不改变排序

// An highlighted block
package test.work.sort;

import java.util.TreeSet;

public class App {
	public static void main(String[] args) {
		TreeSet<News> ts = new TreeSet<News>();
		News n1 = new News("news1aaa",100);
		News n2 = new News("news2aa",80);
		News n3 = new News("news3a",200);
		News n4 = new News("news4",120);
		ts.add(n1);
		ts.add(n2);
		ts.add(n3);
		ts.add(n4);
		for(News n :ts){
			System.out.println(n.getTitle()+"------"+n.getHit());
		}
		n1.setHit(10);
		System.out.println("========================");
		for(News n :ts){
			System.out.println(n.getTitle()+"------"+n.getHit());
		}
	}
}
打印结果：news2aa------80
news1aaa------100
news4------120
news3a------200
========================
news2aa------80
news1aaa------10
news4------120
news3a------200

TreeMap:根据键值排序，排序方式跟TreeSet同理，有2种排序方式，在添加元素时排序，添加完元素再改动元素，不改变排序。

// An highlighted block
package test.work.sort;

import java.util.Map.Entry;
import java.util.TreeMap;

public class TestTreeMap {
	public static void main(String[] args) {
		TreeMap<News,String> map = new TreeMap<News,String>();
		News n1 = new News("news1aaa",100);
		News n2 = new News("news2aa",80);
		News n3 = new News("news3a",200);
		News n4 = new News("news4",120);
		map.put(n1, "aaa");
		map.put(n2, "aaa");
		map.put(n3, "aaa");
		map.put(n4, "aaa");
		for(Entry<News,String> entry : map.entrySet()){
			System.out.println(entry.getKey().getTitle()+entry.getKey().getHit());
		}
	}
}
打印结果：news2aa---80
news1aaa---100
news4---120
news3a---200

通过TreeSet的底层代码也能看出，TreeSet其实就是通过TreeMap容器来实现的。
在这里插入图片描述
5-TreeSet实现代码:实体类实现Comparable接口,按照实体类的某一列排序(升序),并将排序后的结果集打印.
见上一段代码

6-TreeSet实现代码:实体类存放到TreeSet容器中,使用Comparator排序(降序)的业务类(匿名内部类).

// An highlighted block
package test.work.sort;

import java.util.Comparator;
import java.util.TreeSet;

public class App {
	public static void main(String[] args) {
		TreeSet<News> ts = new TreeSet<News>(new Comparator<News>() {
			/**
			 * 匿名内部类
			 * @param o1
			 * @param o2
			 * @return -1,1,0
			 */
			@Override
			public int compare(News o1, News o2) {
				return o1.getHit()-o2.getHit()==0?
						0:(o1.getHit()-o2.getHit()<0?1:-1);
			}
			
		});
		News n1 = new News("news1aaa",100);
		News n2 = new News("news2aa",80);
		News n3 = new News("news3a",200);
		News n4 = new News("news4",120);
		ts.add(n1);
		ts.add(n2);
		ts.add(n3);
		ts.add(n4);
		for(News n :ts){
			System.out.println(n.getTitle()+"------"+n.getHit());
		}
	}
}
打印结果：news3a------200
news4------120
news1aaa------100
news2aa------80

7-TreeMap实现代码:实体类存放到TreeMap容器中,使用Comparator排序(降序)的业务类(匿名内部类).

// An highlighted block
package test.work.sort;

import java.util.Map.Entry;
import java.util.Comparator;
import java.util.TreeMap;

public class TestTreeMap {
	public static void main(String[] args) {
		TreeMap<News,String> map = new TreeMap<News,String>(new Comparator<News>() {
			/**
			 * 匿名内部类
			 * @param o1
			 * @param o2
			 * @return 0、1、-1
			 */
			@Override
			public int compare(News o1, News o2) {
				int len1 = o1.getTitle().length();
				int len2 = o2.getTitle().length();
				return -(len1-len2);//按照字符长度降序
			}
		});
		News n1 = new News("news1aaa",100);
		News n2 = new News("news2aa",80);
		News n3 = new News("news3a",200);
		News n4 = new News("news4",120);
		map.put(n1, "aaa");
		map.put(n2, "aaa");
		map.put(n3, "aaa");
		map.put(n4, "aaa");
		for(Entry<News,String> entry : map.entrySet()){
			System.out.println(entry.getKey().getTitle()+"---"+entry.getKey().getHit());
		}
	}
}
打印结果：news1aaa---100
news2aa---80
news3a---200
news4---120

8-Collections.shuffle 和 Collections.reverse 掌握用法。

// An highlighted block
package test.work.sort;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestCollections {
	/**
	 * Collections.shuffle 和 Collections.reverse 掌握用法。
	 * @param args
	 */
	public static void main(String[] args) {
//		shuffle();
		reverse();
	}
	/**
	 * 集合元素反转
	 */
	public static void reverse(){
		List<String> list = new ArrayList<String>();
		//list添加A-Z
		for(char i ='A';i<='Z';i++){
			list.add(i+"");
		}
		//正序打印
		for(int i=0;i<list.size();i++){
			System.out.print(list.get(i)+" ");
		}
		System.out.println();
		//反转后再打印
		Collections.reverse(list);
		for(int i=0;i<list.size();i++){
			System.out.print(list.get(i)+" ");
		}
	}
	打印结果：
	A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 
	Z Y X W V U T S R Q P O N M L K J I H G F E D C B A 
	/**
	 * 模拟斗地主 洗牌、发牌
	 */
	public static void shuffle(){
		List<String> list = new ArrayList<String>();
		Map<Integer,String> map = new HashMap<Integer,String>();
		map.put(0, "红桃");
		map.put(1, "黑桃");
		map.put(2, "方块");
		map.put(3, "梅花");
		for(int i=0;i<4;i++){
			for(int j=1;j<14;j++){
				list.add(map.get(i)+j);
			}
		}
		list.add("大王");
		list.add("小王");
		//洗牌
		Collections.shuffle(list);
		//发牌
		List<String> list1 = new ArrayList<String>();
		List<String> list2 = new ArrayList<String>();
		List<String> list3 = new ArrayList<String>();
		for(int j=0;j<list.size()-5;j+=3){
			list1.add(list.get(j));
			list2.add(list.get(j+1));
			list3.add(list.get(j+2));		
		}
		System.out.println("第一家："+Arrays.toString(list1.toArray()));
		System.out.println("第二家："+Arrays.toString(list2.toArray()));
		System.out.println("第三家："+Arrays.toString(list3.toArray()));
		System.out.print("底牌：");
		for(int i=0;i<3;i++){
			System.out.print(list.get(list.size()-1-i)+" ");
		}
	}
打印结果：
第一家：[红桃8, 方块5, 方块4, 红桃13, 梅花11, 梅花3, 梅花12, 黑桃11, 方块3, 梅花7, 梅花13, 黑桃9, 梅花10, 方块10, 方块1, 梅花6, 黑桃10]
第二家：[黑桃3, 红桃10, 红桃7, 黑桃4, 黑桃2, 方块11, 黑桃1, 梅花8, 红桃11, 红桃5, 大王, 方块2, 红桃9, 红桃1, 梅花5, 红桃4, 红桃12]
第三家：[红桃6, 黑桃8, 方块13, 方块8, 黑桃12, 黑桃6, 黑桃5, 方块6, 黑桃7, 梅花1, 梅花2, 方块12, 梅花9, 方块9, 红桃2, 梅花4, 黑桃13]
底牌：方块7 小王 红桃3 
}
Chow星星
关注
Java排序实现的心得分享
09-04
Java排序实现是一个重要的编程技能，尤其对于处理大量数据的场景来说。本文主要探讨了Java中排序算法的心得，特别是JRE7中的优化。首先，排序和查找是编程基础，多种经典算法如快速排序、插入排序等被广泛使用。在...
JAVA排序汇总
热门推荐
lenotang的专栏
11-29 2万+
package com.wepull.jbs.lesson4; import java.util.Random; /** *  * 排序测试类 *  *  *  * 排序算法的分类如下： *  * 1.插入排序（直接插入排序、折半插入排序、希尔排序）； *  * 2.交换排序（冒泡泡排序、快速排序）； *  * 3.选择排序（直接选择
java常用8大排序
最新发布
zzp1224的博客
07-24 929
Java中的八大排序算法是编程中常用的排序方法，每种排序算法都有其独特的特点和应用场景。
【经典】Java排序汇总
天外有天的专栏
05-31 1036
Java排序
残忍的刀刀--专栏
06-05 214
8种排序之间的关系: 1，直接插入排序 （1）基本思想：在要排序的一组数中，假设前面(n-1)[n&gt;=2] 个数已经是排 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数 也是排好顺序的。如此反复循环，直到全部排好顺序。 （2）实例 （3）用java实现 package com.njue; public class insertSort { pu...
Java数组排序总结（冒泡，选择，插入，希尔）
null!
11-09 145
[code="java"]package org.idcn.jse; public class SortAll { /** * 冒泡排序，选择排序，插入排序，希尔（Shell）排序 Java的实现 * 2008.11.09 * @author YangL. （http://www.idcn.org） */ public static void main(...
java排序算法之_选择排序(实例讲解)
08-29
java排序算法之选择排序 选择排序是一种简单的排序算法，它的工作原理是从未排序好的序列中选择出最小（或最大）的元素，然后与第i趟排序的第i-1个位置的元素进行交换。整个排序过程只需要遍历n-1趟便可排好，最后...
Java排序算法大全
11-16
Java排序算法大全是一份专为Java开发者准备的学习资源，涵盖了各种经典的排序算法，旨在帮助初学者和有经验的程序员深入理解排序的原理和实现。排序是计算机科学中的基础且重要的概念，它在数据处理、数据库操作、...
Java排序算法实现：冒泡与选择排序示例代码
01-04
Java排序算法实现主要涉及到两种经典的算法：冒泡排序和选择排序。这两种算法都是基于比较的排序方法，适用于小规模或教学目的的数据排序。 **冒泡排序（Bubble Sort）** 是一种简单直观的排序算法，其核心思想是...
JAVA 排序
03-25 145
1. 插入排序 插入排序（Insertion sort）是一种简单直观且稳定的排序算法。如果有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法。 算法适用于少量数据的排序，时间复杂度O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（...
Java——排序
eve8888888的博客
10-25 1081
一、冒泡排序 冒泡排序的原理是相邻元素进行比较，如果第一个元素比第二个元素大，那么交换第一个元素和第二个元素；再第二个元素和第三个元素比，如果第二个元素比第三个元素大，那么交换第二个元素和第三个元素；知道比较到最后一个元素，那么这一趟下类，数组中最大元素就在最后一个。再进行第二趟比较，方式和上面一样只是不用再比较最后一个元素了，因为第一趟最后一个元素就是最大的了。通过循环进行这样的比较直到没有元...
Java排序算法详解与比较
"Java排序算法的种类、特点与选择策略" 在Java中，排序算法是数据处理的关键技术之一，不同的排序算法有不同的优劣点。以下是对各种Java排序算法的详细说明： 1. 插入排序： - 直接插入排序：通过将每个元素插入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值