链式编程 ( Java 8新特性 )

链式编程的原理：

• 链式编程的原理是返回一个this对象，也就是返回对象本身，从而达到链式效果。
  

什么情况下能用链式编程：

• 只要方法返回的是对象本身，那么就可以使用链式编程。

案例一

1、我们在使用StringBuilder 和 StringBuffer中的append()方法进行字符串拼接时，就经常用到链式编程。

public class Chain {
    
    public static void main() {
        StringBuilder buffer = new StringBuilder();
        buffer.append("你").append("好").append("!").append(" ").append("世").append("界");
    }
    
}
1
2
3
4
5
6
7
8

append()方法的源码：（append()方法返回的是对象本身，所以可以使用链式编程）

@Override
public StringBuilder append(String str) {
    super.append(str);
    return this;
}
1
2
3
4
5

案例二

2、使用 String 进行字符串操作时，也经常用到链式编程。

public class Chain {
    
    public static void main() {
        String string = String.valueOf("123").concat(",4567890").replace(',', '!').substring(2, 8);
    }
    
}
1
2
3
4
5
6
7

valueOf() 源码：（valueOf()方法返回的是对象本身，所以可以使用链式编程）

public static String valueOf(int i) {
    return Integer.toString(i);
}
1
2
3

concat() 源码：（concat()方法返回的是对象本身，所以可以使用链式编程）

public String concat(String str) {
     // 省略...
    return new String(buf, true);
}
1
2
3
4

replace() 源码：（replace()方法返回的是对象本身，所以可以使用链式编程）

public String replace(char oldChar, char newChar) {
    // 省略...
    return this;
}
1
2
3
4

substring() 源码：（substring()方法返回的是对象本身，所以可以使用链式编程）

public String substring(int beginIndex, int endIndex) {
    // 省略...
    return ((beginIndex == 0) && (endIndex == value.length)) ? this
        : new String(value, beginIndex, subLen);
}
1
2
3
4
5

案例三

3、在 Stream 流式计算中，使用链式编程。

public static void main(String[] args) {
    // 将数组变成一个列表集合
    List<Integer> list = Arrays.asList(5, 3, 7, 5, 4);

    // 获取集合的 Stream 流对象
    list.stream()
            // 相同元素去重
            .distinct()
            // 升序排序
            .sorted((c1, c2) -> c1.compareTo(c2))
            // 遍历
            .forEach(System.out::println);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

distinct() 源码：（distinct() 方法返回的是对象本身，所以可以使用链式编程）

/*
 * @return the new stream
 */
Stream<T> distinct();
1
2
3
4

distinct() 源码：（distinct() 方法返回的是对象本身，所以可以使用链式编程）

/*
 * @return the new stream
 */
Stream<T> sorted(Comparator<? super T> comparator);
1
2
3
4