TestCollection.java

package comparator;

import comparator.Hero;

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


public class TestCollection {
    public static void main(String[] args) {
        Random r =new Random();
        List<Hero> heros = new ArrayList<Hero>();

        for (int i = 0; i < 10; i++) {
            //通过随机值实例化hero的hp和damage
            heros.add(new Hero("hero "+ i, r.nextInt(100), r.nextInt(100)));
        }
        System.out.println("初始化后的集合：");
        System.out.println(heros);

        //直接调用sort会出现编译错误，因为Hero有各种属性
        //到底按照哪种属性进行比较，Collections也不知道，不确定，所以没法排
        //Collections.sort(heros);
        Collections.sort(heros,Hero::CompareHero);
        System.out.println("按照血量排序后的集合：");
        System.out.println(heros);
    }
}



Hero.java

package comparator;

public class Hero  {
    public String name;
    public float hp;

    public int damage;

    public Hero() {

    }

    public Hero(String name) {

        this.name = name;
    }

    public String toString() {
        return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]\r\n";
    }

    public Hero(String name, int hp, int damage) {
        this.name = name;
        this.hp = hp;
        this.damage = damage;
    }


    public int CompareHero(Hero anotherHero) {
        //按照hp进行排序
        if(this.hp>=anotherHero.hp)
            return 1; 
        else
            return -1;
    }

}

import java.util.*;
import java.util.function.Supplier;

public class TsetLambda {
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> list =new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(new Hero("hero"+i,r.nextInt(100),r.nextInt(100)));
        }
        System.out.println(list);
        Collections.sort(list,TsetLambda::compareNumber);
        System.out.println("按照血量排序后的集合：");
        System.out.println(list);
        Collections.sort(list,Hero::compareHero);
        insertFirst(ArrayList::new,"Array");
        insertFirst(LinkedList::new,"LinkedList");


        /*HeroCheck hc =new HeroCheck() {
            @Override
            public boolean test(Hero h) {

                return h.hp>50&&h.damage<50;
            }
        };*/
        //fifter(list,d -> d.hp>50&&d.damage<50);
       /* Comparator<Hero> cm =new Comparator<Hero>() {
            @Override
            public int compare(Hero o1, Hero o2) {
                if(o1.hp>=o2.hp){
                    return 1;
                }else {
                    return -1;
                }
            }
        };*/
        /*Collections.sort(list,(h1,h2) ->h1.hp>=h2.hp?1:-1);
        System.out.println(list);
        TsetLambda tl =new TsetLambda();

        System.out.println("Lambda表达式中调用容器中的对象的matched方法：");
        fifter(list,h-> h.matched() );

        System.out.println("引用容器中对象的方法 之过滤结果：");
        fifter(list, Hero::matched);*/

       /* Supplier<List> s =new Supplier<List>() {
            @Override
            public List get() {
                return new ArrayList();
            }
        };

        List l =getList(s);

        List list =getList(() ->new ArrayList());

        List list1=getList(ArrayList::new );*/
    }
  static   void fifter(List<Hero> list,HeroCheck hc){
        for(Hero h:list){
            if(hc.test(h)){
                System.out.println(h);
            }
        }
    }

    public  boolean testHero(Hero h) {
        return h.hp>100 && h.damage<50;
    }

    public static List getList(Supplier<List> s){
      return  s.get();

    }

    public static int compareNumber(Hero h1, Hero h2) {
        return h1.hp<=h2.hp?-1:1;
    }

    static void insertFirst(Supplier<List> s,String type){
        int total = 1000 * 100;
        final int number = 5;
        long start = System.currentTimeMillis();
        List list =s.get();
        for(int i=0;i<total;i++){
            list.add(0,number);
        }
        long end = System.currentTimeMillis();
        System.out.printf("在%s 最前面插入%d条数据，总共耗时 %d 毫秒 %n", type, total, end - start);
    }
}

public boolean matched(){
   return this.hp>100 && this.damage<50;
}

public class TestCollection {
	
	public static void main(String[] args) {
		insertFirst(ArrayList::new, "ArrayList");
		insertFirst(LinkedList::new, "LinkedList");

	}
	
	private static void insertFirst(Supplier<List> s, String type) {
		// TODO 自动生成的方法存根
		int total = 1000 * 100;
		final int number = 10;
		if (type == "ArrayList") {
			ArrayList<Integer> l = (ArrayList<Integer>) s.get();
			long start = System.currentTimeMillis();
			for (int i = 0; i < total; i++) {
				l.add(0, number);
			}
			long end = System.currentTimeMillis();
			System.out.printf("在%s最前面插入%d条数据，总共耗时%d毫秒%n", type, total, end-start);
		}
		else {
			LinkedList<Integer> l = (LinkedList<Integer>) s.get();
			long start = System.currentTimeMillis();
			for (int i = 0; i < total; i++) {
				l.add(0, number);
			}
			long end = System.currentTimeMillis();
			System.out.printf("在%s最前面插入%d条数据，总共耗时%d毫秒%n", type, total, end-start);
		}
		
	}

//Hero add new method
public int compareHero(*,*) {
        if(h1.hp >= h2.hp)
            return 1;  
        else
            return -1;
}
public static void main(String[] args) {
		Random r =new Random();
        List<Hero> heros = new ArrayList<Hero>();
            
        for (int i = 0; i < 10; i++) {
            // *
            heros.add(new Hero("hero "+ i, r.nextInt(100), r.nextInt(100)));
        }
        System.out.println("初始化后的集合：");
        System.out.println(heros);
            
        
//        Collections.sort(heros,(h1,h2) -> (h1.hp >= h2.hp)? 1 : -1);
        Hero h = new Hero();
        Collections.sort(heros, *::compareHero);
        System.out.println("按照血量排序后的集合：");
        System.out.println(heros);

    }