先说结论：在sorted方法中，o1是最后面的元素，o2是倒数第二个元素，以此类推，流是处理元素是从后面开始取值。 

1.  
   package com.br.itwzhangzx02.learn;
2.  
    
3.  
    
4.  
   import org.junit.Test;
5.  
    
6.  
   import java.util.ArrayList;
7.  
   import java.util.List;
8.  
    
9.  
   import com.br.itwzhangzx02.learn.POJO.User;
10.  
     
11.  
    public class StreamTest {
12.  
     
13.  
    /**
14.  
    * 1.id全部满足是偶数
15.  
    * 2.年龄大于10
16.  
    * 3.用户名大写
17.  
    * 4.用户名字母倒排序
18.  
    * 5.只输出一个用户名
19.  
    *
20.  
    *
21.  
    * */
22.  
    @Test
23.  
    public void testStream(){
24.  
    List<User> list = new ArrayList<User>(){
25.  
    {
26.  
    add(new User(1l,"q",10, "清华大学"));
27.  
    add(new User(2l,"f",12, "清华大学"));
28.  
    add(new User(3l,"b",15, "清华大学"));
29.  
    add(new User(4l,"a",12, "清华大学"));
30.  
    add(new User(5l,"d",25, "北京大学"));
31.  
    add(new User(6l,"c",16, "北京大学"));
32.  
    add(new User(7l,"t",14, "北京大学"));
33.  
    add(new User(8l,"g",14, "浙江大学"));
34.  
    add(new User(9l,"j",17, "浙江大学"));
35.  
    add(new User(10l,"l",10, "浙江大学"));
36.  
    }
37.  
    };
38.  
    list.stream()
39.  
    .filter(user -> user.getId()%2==0)
40.  
    .filter(user -> user.getAge()>10)
41.  
    .map(user -> user.getName().toUpperCase())
42.  
    .sorted((o1,o2)->{return 1;})
43.  
    .forEach(System.out::println);
44.  
     
45.  
    //sorted 方法中，我们重写compare方法：如果return是1，则是按照原先的排序排。-1则是按照逆序排
46.  
    //
47.  
    }
48.  
    /** a negative integer, zero, or a positive integer as the
49.  
    * first argument is less than, equal to, or greater than the
50.  
    * second.**/
51.  
     
52.  
    }

1.  
   package com.br.itwzhangzx02.learn.POJO;
2.  
    
3.  
   public class User {
4.  
   public Long getId() {
5.  
   return id;
6.  
   }
7.  
    
8.  
   public void setId(Long id) {
9.  
   this.id = id;
10.  
    }
11.  
     
12.  
    public String getName() {
13.  
    return name;
14.  
    }
15.  
     
16.  
    public void setName(String name) {
17.  
    this.name = name;
18.  
    }
19.  
     
20.  
    public Integer getAge() {
21.  
    return age;
22.  
    }
23.  
     
24.  
    public void setAge(Integer age) {
25.  
    this.age = age;
26.  
    }
27.  
     
28.  
    public String getSchool() {
29.  
    return school;
30.  
    }
31.  
     
32.  
    public void setSchool(String school) {
33.  
    this.school = school;
34.  
    }
35.  
     
36.  
    private Long id; //主键id
37.  
    private String name; //姓名
38.  
    private Integer age; //年龄
39.  
    private String school; //学校
40.  
     
41.  
    public User(Long id, String name, Integer age, String school) {
42.  
    this.id = id;
43.  
    this.name = name;
44.  
    this.age = age;
45.  
    this.school = school;
46.  
    }
47.  
    }

一开始的疑惑：

1.  
   * @param o1 the first object to be compared.
2.  
   * @param o2 the second object to be compared.
3.  
   * @return a negative integer, zero, or a positive integer as the
4.  
   * first argument is less than, equal to, or greater than the
5.  
   * second.
6.  
   * @throws NullPointerException if an argument is null and this
7.  
   * comparator does not permit null arguments
8.  
   * @throws ClassCastException if the arguments' types prevent them from
9.  
   * being compared by this comparator.
10.  
    */
11.  
    int compare(T o1, T o2);

上面是我拿到的Comparator接口中关于，compare方法的注释：

按照规则：第一个参数>第二个参数时，返回的是一个正数，那么返回正数，代表什么？

结论：正数的话，就是保持俩个元素的位置不变，负数的话俩元素位置互换。

首先，我们验证返回正数时，元素位置不变：

 返回为负数时，元素位置互换。比如：F,A--->A,F

sorted()方法，使用的是默认的自然顺序--升序排序。但是，stream中元素，需要实现comparable接口，重写了方法compareTo方法。查看string的这个方法：

1.  
   public int compareTo(String anotherString) {
2.  
   int len1 = value.length;
3.  
   int len2 = anotherString.value.length;
4.  
   int lim = Math.min(len1, len2);
5.  
   char v1[] = value;
6.  
   char v2[] = anotherString.value;
7.  
    
8.  
   int k = 0;
9.  
   while (k < lim) {
10.  
    char c1 = v1[k];
11.  
    char c2 = v2[k];
12.  
    if (c1 != c2) {
13.  
    return c1 - c2;
14.  
    }
15.  
    k++;
16.  
    }
17.  
    return len1 - len2;
18.  
    }

 比较规则很简单，就是从字符数组的char[0]开始，比较二者的值，然后返回 c1-c2.

比如我们的F，A比较的时候，F>A，返回值为正数，根据我们前面的结论，返回一个正数时，顺序是保持不变的才对，那么这里到底是怎么回事？

为了看问题方便，我只保留了F和A的数据，测试如下：

按照我们的结论：返回正数时，顺序是不变的，为啥现在顺序变了，而且刚好是逆序。

最后，仔细想是不是，流处理元素的时候顺序的问题。比如：o1代表的是我们的A那个元素，o2代表的是F那个元素。

怎么验证呢？

人为抛异常，先处理的那个元素，最先抛异常

正常我们的数据，在list中是F元素在前，A元素在后。然后我们的代码先，o1转Integer抛错，从异常看，说明o1是A元素。

所以，最后的结论是，o1是A，o2是F。也就是说我们处理流时，不是按我们的list的索引从0开始的处理，而是反向处理的。

另一种论证方式：直接打印出我们的o1和o2

结论：在sorted((o1,o2)->{return o1.compareTo(o2)})这个方法里，我们的参数是从后往前取的。o1是最后一个元素，o2是倒数第二个元素，依次类推。