java排序

最新推荐文章于 2021-05-06 22:10:39 发布

cc_0101

最新推荐文章于 2021-05-06 22:10:39 发布

阅读量209

点赞数

分类专栏： java开发文章标签： java

本文链接：https://blog.csdn.net/cc_0101/article/details/105382360

版权

java开发专栏收录该内容

5 篇文章 1 订阅

订阅专栏

一、基本类型排序
1、自定义实现冒泡排序

import java.util.Arrays;

/**
 * 冒泡排序
 */
public class BubbleSort {
	
	public static void sort(int[] arr){
		int len = arr.length;
		boolean sort = true;
		for(int j=0;j<len-1;j++){ //总共需要比较的趟数
			System.out.println("第"+(j+1)+"趟");
			sort = true; // 假定有序
			for(int i=0;i<len-1-j;i++){ //每趟需要比较的次数
				int temp;
				if(arr[i]>arr[i+1]){
					temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
					sort = false; //如果发生交换，则说明还是无序
				}
				System.out.println("第"+(i+1)+"次："+Arrays.toString(arr));
			}
			if(sort){  //如果有序，则不做下一趟的比较
				break;
			}
		}
	}
	
	public static void main(String[] args) {
		int[] arr = {2,3,9,8,7};
		sort(arr);
		System.out.println("最终结果："+Arrays.toString(arr));
	}
}

2、找出一组数中最大值
（1）冒泡排序法

/**
 * 冒泡排序求最大值
 */
public class BubbleSort {
	
	public static int findMax(int[] arr){
			for(int i=0;i<arr.length-1;i++){
				int temp;
				if(arr[i]>arr[i+1]){
					temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
				}
			}
			return arr[arr.length-1];
		}
	
	public static void main(String[] args) {
		int[] arr = {1,3,8,9,4,5,8};
		int result = findMax(arr);
		System.out.println("最大值为："+result);
	}
}

（2）设置一个最大值，挨个跟数组中的值做比较

public class FindMax {
	public static void main(String[] args) {
		int[] arr = {1,3,8,9,4,5,8};
		int max = arr[0];
		for(int i=0;i<arr.length;i++){
			if(max-arr[i]<0){
				max = arr[i];
			}
		}
		System.out.println("最大值为："+max);
	}
}

二、引用类型的排序策略
1、Comparable接口
实体类实现java.lang.Comparable接口，重写compareTo()方法

（1）compareTo()方法：比较同类型的两个对象

a、比较字符串（String）类型对象：str1.compareTo(str2)，按照最短的字符串长度，逐个比较str1和str2对应位置的字符，若对应位置的字符相等，则比较下一个字符，若对应位置的字符不相等，则返回str1该位置字符 - str2该位置字符的差值，如果全部相等，则返回str1长度 - str2长度的差值
b、比较时间类型（Date）对象：date1.compareTo(date2)，如果date1毫秒数 > date2毫秒数返回1，若 < 返回 -1，若 = 返回 0
c、比较整数型（Integer）对象：int1.compareTo(int2)，如果int1 > int2返回1，若 < 返回 -1，若 = 返回0

import java.util.Date;

/**
 * 内置类比较大小
 */
public class TestComparable {

	public static void main(String[] args) {
		String str1 = "abc";
		String str2 = "f";
		int result = str1.compareTo(str2);
		System.out.println(result);
		
		Date date1 = new Date();
		Date date2 = new Date(System.currentTimeMillis()-1000*60*60);
		result = date1.compareTo(date2);
		System.out.println(result);
		
		Integer lnter1 = 300;
		Integer lnter2 = 500;
		result = lnter1.compareTo(lnter2);
		System.out.println(result);
	}
}

（2）内置类排序：常用内置类里已经实现了Comparable接口，重写了compareTo()方法，如String，Date、Integer等

import java.util.Comparator;
import java.util.List;

/**
 * 使用compareTo()排序
 */
public class SortUtil {
	
	//数组排序(使用泛型方法) Comparable排序类
	public <T extends Comparable<T>> void arrSort(T[] arr){
		int len = arr.length;
		boolean sort = true;
		for(int j=0;j<len-1;j++){
			sort = true;
			for(int i=0;i<len-1-j;i++){
				T temp;
				if(((Comparable)arr[i]).compareTo(arr[i+1])<0){
					temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
					sort = false;
				}
			}
			if(sort){
				break;
			}
		}
	}
	
	//数组排序(降序排列) Comparable排序类
	public void arrSort(Object[] arr){
		int len = arr.length;
		boolean sort = true;
		for(int j=0;j<len-1;j++){
			sort = true;
			for(int i=0;i<len-1-j;i++){
				Object temp;
				if(((Comparable)arr[i]).compareTo(arr[i+1])<0){
					temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
					sort = false;
				}
			}
			if(sort){
				break;
			}
		}	
	}
	public static void main(String[] args) {
		SortUtil util = new SortUtil();
		String[] str = {"cdfee","acda","efg","a"};
		util.arrSort(str);
		System.out.println(Arrays.toString(str));
}

（3）自定义实体类,实现Compareble接口

import java.util.Date;
/**
 * 新闻类，按照点击量降序、发布时间降序、标题升序；实现Compareble接口
 */
public class NewsItem implements Comparable<NewsItem>{
	private int hits; //点击量
	private Date pubDate; //发布时间
	private String title; //标题
	
	public NewsItem(){
	}
	
	public NewsItem(int hits, Date pubDate, String title) {
		super();
		this.hits = hits;
		this.pubDate = pubDate;
		this.title = title;
	}

	public int getHits() {
		return hits;
	}
	public void setHits(int hits) {
		this.hits = hits;
	}
	public Date getPubDate() {
		return pubDate;
	}
	public void setPubDate(Date pubDate) {
		this.pubDate = pubDate;
	}
	public String getTitle() {
		return title;
	}
	public void setTitile(String title) {
		this.title = title;
	}

	@Override
	public int compareTo(NewsItem o) { //重写compareTo()
		int hits2 = o.hits;
		Date pubDate2 = o.pubDate;
		String title2 = o.title;
		int result = hits-hits2;
		
		if(result==0){
			result = pubDate.compareTo(pubDate2);
			if(result==0){
				result = title.compareTo(title2);
				if(result!=0){
					return -result;
				}
			}
		}
		return result;
	}
}

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 对新闻对象进行排序
 */
public class NewsSortTest {
	
	//容器排序（转换成数组比较，使用泛型），使用Comparable类
	public static <T extends Comparable<T>> void listSort(List<T> list){
		Object[] arr = list.toArray();
		arrSort(arr);
		for(int i=0;i<arr.length;i++){
			list.set(i, (T) arr[i]);
		}
	}
	
	//数组排序，使用Comparable类
	public static void arrSort(Object[] arr){
		int len = arr.length;
		boolean sort = true;
		for(int j=0;j<len-1;j++){
			sort = true;
			for(int i=0;i<len-1-j;i++){
				Object temp;
				if(((Comparable)arr[i]).compareTo(arr[i+1])<0){
					temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
					sort = false;
				}
			}
			if(sort){
				break;
			}
		}	
	}
	
	public static void main(String[] args){
		List<NewsItem> list = new ArrayList<NewsItem>();
		list.add(new NewsItem(5000,new Date(),"这是一个自定义类比较大小测试"));	
		list.add(new NewsItem(1000,new Date(System.currentTimeMillis()-1000*60*60),"测试测试"));
		list.add(new NewsItem(5000,new Date(),"我是自定义类"));
		list.add(new NewsItem(1000,new Date(),"这是一个自定义类比较大小测试"));
		list.add(new NewsItem(100,new Date(),"这是一个自定义类比较大小测试"));	
		
		listSort(list);
		NewsItem item = new NewsItem();
		DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		for(int i=0;i<list.size();i++){
			item = list.get(i);
			System.out.println("标题："+item.getTitle() +"\t"+"点击量："+item.getHits()+"\t"+"发布时间:"+format.format(item.getPubDate()));
		}
	}
}

2、Comparator接口（比较器）
业务排序类实现java.util.Comparator接口，重写compare()方法
优点：a、解耦：与实体类分离 2、方便：应对多变的排序规则（如果有不同的排序规则再写一个业务排序类就可以了）
（1）自定义类实现Comparator接口
此处依然定义新闻类，但是与排序类是分离的，实现效果与上面相同

import java.util.Date;

/**
 * 新闻类
 */
public class NewsItem2{
	private int hits; //点击量
	private Date pubDate; //发布时间
	private String title; //标题
	
	public NewsItem2(){
	}
	
	public NewsItem2(int hits, Date pubDate, String title) {
		super();
		this.hits = hits;
		this.pubDate = pubDate;
		this.title = title;
	}

	public int getHits() {
		return hits;
	}
	public void setHits(int hits) {
		this.hits = hits;
	}
	public Date getPubDate() {
		return pubDate;
	}
	public void setPubDate(Date pubDate) {
		this.pubDate = pubDate;
	}
	public String getTitle() {
		return title;
	}
	public void setTitile(String title) {
		this.title = title;
	}
}

import java.util.Comparator;

/**
 * 新闻排序类：按照点击量降序、发布时间降序、标题升序
 * 实现Comparator接口，与实体类分离
 */
public class NewsSort implements Comparator<NewsItem2>{
	
	@Override
	public int compare(NewsItem2 o1, NewsItem2 o2) {
		int result = o1.getHits() - o2.getHits();	
		if(result==0){
			result = o1.getPubDate().compareTo(o2.getPubDate());
			if(result==0){
				result = o1.getTitle().compareTo(o2.getTitle());
				if(result!=0){
					return -result;
				}
			}
		}
		return result;
	}	
}

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

/**
* 测试新闻排序
*/
public class NewsSortTest {
	//容器+Comparator接口，比较器
	public static <T> void listSort(List<T> list,Comparator<T> com){ 
		Object[] arr = list.toArray();
		arrSort(arr,com);
		for(int i=0;i<arr.length;i++){
			list.set(i, (T) arr[i]);
		}
	}
	//数组排序，Comparator接口，比较器
	public static <T> void arrSort(Object[] arr,Comparator<T> com){
		int len = arr.length;
		boolean sort = true;
		for(int j=0;j<len-1;j++){
			sort = true;
			for(int i=0;i<len-1-j;i++){
				Object temp;
				if(com.compare((T)arr[i], (T)arr[i+1])<0){
					temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
					sort = false;
				}
			}
			if(sort){
				break;
			}
		}
	}
	
	public static void main(String[] args){
		List<NewsItem2> list = new ArrayList<NewsItem2>();
		list.add(new NewsItem2(5000,new Date(),"这是一个自定义类比较大小测试"));	
		list.add(new NewsItem2(1000,new Date(System.currentTimeMillis()-1000*60*60),"测试测试"));
		list.add(new NewsItem2(5000,new Date(),"我是自定义类"));
		list.add(new NewsItem2(1000,new Date(),"这是一个自定义类比较大小测试"));
		list.add(new NewsItem2(100,new Date(),"这是一个自定义类比较大小测试"));	
		
		listSort(list,new NewsSort());
		NewsItem2 item = new NewsItem2();
		DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		for(int i=0;i<list.size();i++){
			item = list.get(i);
			System.out.println("标题："+item.getTitle() +"\t"+"点击量："+item.getHits()+"\t"+"发布时间:"+format.format(item.getPubDate()));
		}
	}
}

3、排序容器类：TreeSet和TreeMap是可以排序的容器
（1）总结
TreeSet：数据元素可以排序且不可重复，要求元素可以排序，否则需要给元素提供业务排序类
添加数据时排序，数据更改不会改变原来的顺序；
不要修改数据，否则可能重复
TreeMap：要求键可以排序，或者给键提供业务排序类；
其他与TreeSet同理

（2）TreeSet排序

import java.util.Comparator;
import java.util.Date;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

/**
 * 1、给NewsItem对象排序，NewsItem已经实现Comparable接口可以排序，所以可以直接用TreeSet进行排序
 * 2、给NewsItem2对象排序，NewsItem2不可以排序，所以需要业务排序类进行排序，这里使用匿名内部类实现Comparator接口
 *
 */
public class TreeSetTest1 {
	public static void test1(){
		NewsItem item1 = new NewsItem(500,new Date(),"这是一个TreeSet排序测试");	
		NewsItem item2 = new NewsItem(3000,new Date(),"这是一个TreeSet排序测试");
		NewsItem item3 = new NewsItem(20,new Date(),"这是一个TreeSet排序测试");
		
		Set<NewsItem> set = new TreeSet<NewsItem>();
		set.add(item1);
		set.add(item2);
		set.add(item3);
		
		for(Iterator iter = set.iterator();iter.hasNext();){ //对点击量做升序排序了
			System.out.println(((NewsItem)iter.next()).getHits());			
		}
	}
	
	public static void test2(){
		NewsItem2 item1 = new NewsItem2(500,new Date(),"这是一个TreeSet排序测试");	
		NewsItem2 item2 = new NewsItem2(3000,new Date(),"这是一个TreeSet排序测试");
		NewsItem2 item3 = new NewsItem2(20,new Date(),"这是一个TreeSet排序测试");
		
		Set<NewsItem2> set = new TreeSet<NewsItem2>(new Comparator<NewsItem2>(){

			@Override
			public int compare(NewsItem2 o1, NewsItem2 o2) {
				int result = o1.getHits() - o2.getHits();	
				if(result==0){
					result = o1.getPubDate().compareTo(o2.getPubDate());
					if(result==0){
						result = o1.getTitle().compareTo(o2.getTitle());
						if(result!=0){
							return -result;
						}
					}
				}
				return result;
			}
			
		});
		set.add(item1);
		set.add(item2);
		set.add(item3);
		
		for(Iterator iter = set.iterator();iter.hasNext();){ //对点击量做升序排序了
			System.out.println(((NewsItem2)iter.next()).getHits());			
		}
	}
	public static void main(String[] args) {
		test1();
		test2();
	
	}
}

（3）TreeMap排序

import java.util.Comparator;
import java.util.Date;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
 * 1、给NewsItem对象排序，NewsItem已经实现Comparable接口可以排序，所以可以直接用TreeSet进行排序
 * 2、给NewsItem2对象排序，NewsItem2不可以排序，所以需要业务排序类进行排序，这里使用匿名内部类实现Comparator接口
 */
public class TreeMapTest {
	public static void test1(){
		NewsItem item1 = new NewsItem(500,new Date(),"这是一个TreeSet排序测试");	
		NewsItem item2 = new NewsItem(3000,new Date(),"这是一个TreeSet排序测试");
		NewsItem item3 = new NewsItem(20,new Date(),"这是一个TreeSet排序测试");
		
		Map<NewsItem,String> map = new TreeMap<NewsItem,String>();
		map.put(item1, "Test");
		map.put(item2, "Test");
		map.put(item3, "Test");
		
		Set<NewsItem> set = map.keySet();
		for(Iterator iter = set.iterator();iter.hasNext();){ //对点击量做升序排序了
			System.out.println(((NewsItem)iter.next()).getHits());			
		}
	}
	
	public static void test2(){
		NewsItem2 item1 = new NewsItem2(500,new Date(),"这是一个TreeSet排序测试");	
		NewsItem2 item2 = new NewsItem2(3000,new Date(),"这是一个TreeSet排序测试");
		NewsItem2 item3 = new NewsItem2(20,new Date(),"这是一个TreeSet排序测试");
		
		Map<NewsItem2,String> map = new TreeMap<NewsItem2,String>(new Comparator<NewsItem2>(){

			@Override
			public int compare(NewsItem2 o1, NewsItem2 o2) {
				int result = o1.getHits() - o2.getHits();	
				if(result==0){
					result = o1.getPubDate().compareTo(o2.getPubDate());
					if(result==0){
						result = o1.getTitle().compareTo(o2.getTitle());
						if(result!=0){
							return -result;
						}
					}
				}
				return result;
			}
			
		});
		map.put(item1, "Test");
		map.put(item2, "Test");
		map.put(item3, "Test");
		
		Set<NewsItem2> set = map.keySet();
		for(Iterator iter = set.iterator();iter.hasNext();){ //对点击量做升序排序了
			System.out.println(((NewsItem2)iter.next()).getHits());			
		}
	}
	public static void main(String[] args) {
		test1();
		test2();
	}
}

4、工具类java.util.Collections
sort(List list):升序
sort(List list,Comparator c)：自定义排序
reverse(List list):反转
shuffle(list)：洗牌，打乱顺序

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

/**
 * Collections类的方法测试
 *1、  sort(List<T> list):升序
 *	 sort(List<T> list,Comparator<T> c)：自定义排序
 *2、reverse(List<T> list):反转
 *3、shuffle(list)：洗牌，打乱顺序
 */
public class CollectionsTest {
	
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(5);
		list.add(7);
		list.add(3);
		list.add(8);
		list.add(0);
		System.out.println("原始顺序："+list.toString());
		
		/**
		 * 反转
		 */
		Collections.reverse(list);
		System.out.println("反转顺序："+list.toString());
				
		 /**
		  * 排序：升序和降序
		  */
		//升序排序
		Collections.sort(list); //升序
		System.out.println("升序排序"+list.toString()); 
		//匿名内部类降序排序
		Collections.sort(list, new Comparator<Integer>(){
			@Override
			public int compare(Integer o1, Integer o2) {
				if(o1 > o2){
					return -1;
				}else if(o1 == o2){
					return 0;
				}else{
					return 1;
				}
			}
			
		});
		System.out.println("降序排序"+list.toString());
		
		/**
		 * 洗牌，打乱顺序
		 */
		//洗牌
		List<Integer> cards = new ArrayList<Integer>();
		for(int i=0;i<54;i++){
			cards.add(i);
		}
		Collections.shuffle(cards);
		
		//发牌
		List<Integer> p1 = new ArrayList<Integer>();
		List<Integer> p2 = new ArrayList<Integer>();
		List<Integer> p3 = new ArrayList<Integer>();	
		
		for(int i=0;i<54;i+=3){
			p1.add(cards.get(i));
			p2.add(cards.get(i+1));
			p3.add(cards.get(i+2));
		}

		System.out.println("P1:"+p1.toString());
		System.out.println("P2:"+p2.toString());
		System.out.println("P2:"+p3.toString());
		
	}
}

cc_0101

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java排序

一、基本类型排序1、自定义实现冒泡排序import java.util.Arrays;/** * 冒泡排序 */public class BubbleSort { public static void sort(int[] arr){ int len = arr.length; boolean sort = true; for(int j=0;j<len-1;...
复制链接

扫一扫