实现Comparator接口和Comparable接口，以及Map按value排序 ，map遍历

继承Comparator接口，重写compare()方法
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
 
class Student implements Comparator<Student>{
	String name;
	int age;
	int id;
	public Student(){}
	public Student(String name,int age,int id)
	{
		this.name=name;
		this.age=age;
		this.id=id;
	}
	@Override
	public int compare(Student o1, Student o2) {
		// TODO Auto-generated method stub
		return o1.age-o2.age;
	}
}
 
public class Test {
 
	public static void main(String[] args) {
		Random rand=new Random();
		List<Student> list=new ArrayList<Student>();
		for(int i=0;i<20;i++)
		{
			Student ss=new Student("long-jing-wen-"+i,rand.nextInt(100),rand.nextInt(1000));
			list.add(ss);
 
		}
 
		Student student=new Student();
		Collections.sort(list, student);

　　

继承Comparable，重写compareTo()方法
package thread;
 
public class stu implements  Comparable<stu>{
	public  int id;
	public stu() {
 
	}
	public stu(int id) {
 
		this.id = id;
	}
 
	public int getId() {
		return id;
	}
 
	public void setId(int id) {
		this.id = id;
	}
 
	@Override
	public String toString() {
		return "stu [id=" + id + "]";
	}
 
	public int compareTo(stu o1, stu o2) {
		// TODO Auto-generated method stub
		return o1.id-o2.id;
	}
 
	@Override
	public int compareTo(stu o) {
		// TODO Auto-generated method stub
		return this.id-o.id;
	}
 
}
 
		Random rand=new Random();
		stu[] stu=new stu[20];
 
		for(int i=0;i<20;i++)
		{
			stu ss2=new stu(rand.nextInt(100));
			stu[i]=ss2;
		}
 
		Arrays.sort(stu);
 
		for(int i=0;i<stu.length;i++)
		{
			System.out.print(stu[i]+" ");
		}
		System.out.println();

　　

Map按value排序
HashMap<String, Long> map = new HashMap<String, Long>();
 
		map.put("A", (long) 99);
		map.put("B", (long) 67);
		map.put("C", (long) 109);
		map.put("D", (long) 2);
 
		System.out.println("unsorted map: " + map);
 
		List<Map.Entry<String, Long>> list = new ArrayList<>(map.entrySet());
		Collections.sort(list, new Comparator<Map.Entry<String, Long>>() {
			public int compare(Map.Entry<String, Long> o1,
					Map.Entry<String, Long> o2) {
				return (int) (o2.getValue()-o1.getValue() );
			}
		});
 
		System.out.println("results: " + list);

　　

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
//遍历map中的键
for (Integer key : map.keySet()) {
  System.out.println("Key = " + key);
}
//遍历map中的值
for (Integer value : map.values()) {
  System.out.println("Value = " + value);
}
 
该方法比entrySet遍历在性能上稍好（快了10%），而且代码更加干净。
 
使用泛型：
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
  Map.Entry<Integer, Integer> entry = entries.next();
  System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}
 
不使用泛型：
Map map = new HashMap();
Iterator entries = map.entrySet().iterator();
while (entries.hasNext()) {
  Map.Entry entry = (Map.Entry) entries.next();
  Integer key = (Integer)entry.getKey();
  Integer value = (Integer)entry.getValue();
  System.out.println("Key = " + key + ", Value = " + value);
}
 
最常见的并且在大多数情况下也是最可取的遍历方式。在键值都需要时使用。
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
  System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}