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;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 list):升序
 *	 sort(List list,Comparator c):自定义排序
 *2、reverse(List 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());
		
	}
}

你可能感兴趣的:(java开发,java)