排序，和基本接口的使用

Lambda和传统方法的对比

 //函数式节口里只能有一个方法
    public static void main(String[] args){
        Integer [] num =new Integer[]{1,4,2,7,3,9};//Integer是int的包装类
//        //Integer实际是对象的引用，当new一个Integer时，
//        // 实际上是生成一个指针指向此对象；而int则是直接存储数据值 。
//        System.out.println(Arrays.toString(num));
//
//        //从小到大排序
//        Arrays.sort(num);
//        System.out.println(Arrays.toString(num));

        //[1, 2, 3, 4, 7, 9]
        Arrays.sort(num,(a,b)->a-b);
        System.out.println(Arrays.toString(num));
        //[9, 7, 4, 3, 2, 1]
        Arrays.sort(num,(a,b)->b-a);
        System.out.println(Arrays.toString(num));

        //传统方式
        Arrays.sort(num, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
        System.out.println(Arrays.toString(num));
        //Comparator比较器接口
        Arrays.sort(num, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(num));
    }

 字符串排序

 public static void main(String[] args) {
        //List声明数组
        List<String> list =new ArrayList<>(List.of("java","c++","html","css","php"));
        List<Integer> in =new ArrayList<>(List.of(1,3,5,6,8));
//       不可用 String[] list=new String[]{"java","c++","html","css","php"};
        System.out.println(list);
        System.out.println(in);

        //降序,compareTo比较函数
        list.sort((a,b)->b.compareTo(a));
        System.out.println(list);
        //升序
        list.sort((a,b)->a.compareTo(b));
        System.out.println(list);
        //长度排序
        list.sort((a,b)->b.length()-a.length());
        System.out.println(list);
    }

对象类排序

public class User {
    private int id;
    private String name;
    private int score;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public User(int id, String name, int score) {
        this.id = id;
        this.name = name;
        this.score = score;
    }
    public User(){
        super();
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

java

  public static void main(String[] args) {
        //List声明数组,List.of,可以给集合一次性添加多个元素
        List<User> list =new ArrayList<>(List.of(new User(1,"jack",80),new User(2,"李四",90),new User(3,"张三",58),new User(4,"装三风",34),new User(5,"啊里",69)));
        System.out.println(list);
        //Score分数，多到少排序
        list.sort((a,b)->b.getScore()-a.getScore());
        System.out.println(list);
                                    //比较函数
        list.sort((a,b)->a.getName().compareTo(b.getName()));
        System.out.println(list);
    }

系统定义接口

接口	参数	返回内容	描述
Predicate<T>	T	boolean	用于判别一个对象。比如求一个人是否为男性
Consumer<T>  消费型	T	Void ：你给我，我输出	用于接收一个对象进行处理但没有返回，比如接收一个人并打印他的名字
Function<T, R>  函数型	T	R用于计算	转换一个对象为不同类型的对象
Supplier<T> 供给型	None	T 提供者	提供一个对象，也就是返回一个
UnaryOperator<T>	T	T	接收对象并返回同类型的对象
BinaryOperator<T>	(T, T)	T 一般用于比较	接收两个同类型的对象，并返回一个原类型对象

   public static void main(String[] args) {
        //List声明数组,List.of,可以给集合一次性添加多个元素，不是循环语句
        List<User> list =new ArrayList<>(List.of(new User(1,"jack",80),new User(2,"李四",90),new User(3,"张三",58),new User(4,"装三风",34),new User(5,"啊里",69),new User( 6,"李流",45)));

        //大于60,forEach列出：循环数组或集合中的对象
        list.stream().filter(e-> e.getScore()>=60).forEach(System.out::println);
        System.out.println("------------------------");
        list.stream().filter(e-> e.getScore()<60).forEach(e->{
            System.out.println(e);
        });
        System.out.println("-------------------------");//startsWith：从…开始
        list.stream().filter(e->e.getScore()<60&&!e.getName().startsWith("李")).forEach(System.out::println);
        System.out.println("-------------------------");//startsWith：从…开始
        //一个数组，里面有五个随机数
                //返回Supplier
        Random rand =new Random();
        IntStream.generate(()->rand.nextInt((100)+1)).limit(3).forEach(System.out::println);
        System.out.println("----------------------------------");
        //不随机
        IntStream.generate(()->5).limit(3).forEach(System.out::println);


    }