RxJava 各種操作符（2） - Transforming Observables

buffer, FlatMap, GroupBy, Map, Scan, Window

buffer

buffer操作符週期性地收集源Observable產生的結果到列表中，並把這個列表提交給訂閱者，訂閱者處理後，清空buffer列表，同時接收下一次收集的結果並提交給訂閱者，周而復始。
一旦源Observable在產生結果的過程中出現異常，即使buffer已經存在收集到的結果，訂閱者也會馬上收到這個異常，並結束整個過程。

//定義郵件內容
        final String[] mails = new String[]{"Here is an email!", "Another email!", "Yet another email!"};
        //每隔1秒就隨機發布一封郵件
        Observable<String> endlessMail = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                try {
                    if (subscriber.isUnsubscribed()) return;
                    Random random = new Random();
                    while (true) {
                        String mail = mails[random.nextInt(mails.length)];
                        subscriber.onNext(mail);
                        Thread.sleep(1000);
                    }
                } catch (Exception ex) {
                    subscriber.onError(ex);
                }
            }
        }).subscribeOn(Schedulers.io());
        //把上面產生的郵件內容緩存到列表中，並每隔3秒通知訂閱者
        endlessMail.buffer(3, TimeUnit.SECONDS).subscribe(new Action1<List<String>>() {
            @Override
            public void call(List<String> list) {

                System.out.println(String.format("You've got %d new messages!  Here they are!", list.size()));
                for (int i = 0; i < list.size(); i++)
                    System.out.println("**" + list.get(i).toString());
            }
        });

運行結果如下：
You’ve got 3 new messages! Here they are!(after 3s)
**Here is an email!
**Another email!
**Another email!
You’ve got 3 new messages! Here they are!(after 6s)
**Here is an email!
**Another email!
**Here is an email!
……

flatMap操作符

flatMap操作符是把Observable產生的結果轉換成多個Observable，然後把這多個Observable“扁平化”成一個Observable，並依次提交產生的結果給訂閱者。
flatMap操作符通過傳入一個函數作爲參數轉換源Observable，在這個函數中，你可以自定義轉換規則，最後在這個函數中返回一個新的Observable，然後flatMap操作符通過合併這些Observable結果成一個Observable，並依次提交結果給訂閱者。
flatMap操作符在合併Observable結果時，有可能存在交叉的情況

private Observable<File> listFiles(File f){
        if(f.isDirectory()){
            return Observable.from(f.listFiles()).flatMap(new Func1<File, Observable<File>>() {
                @Override
                public Observable<File> call(File file) {
                    return listFiles(f);
                }
            });
        } else {
            return Observable.just(f);
        }
    }


    @Override
    public void onClick(View v) {
        Observable.just(getApplicationContext().getExternalCacheDir())
                .flatMap(new Func1<File, Observable<File>>() {
                    @Override
                    public Observable<File> call(File file) {
                        //參數file是just操作符產生的結果，這裏判斷file是不是目錄文件，如果是目錄文件，則遞歸查找其子文件flatMap操作符神奇的地方在於，返回的結果還是一個Observable，而這個Observable其實是包含多個文件的Observable的，輸出應該是ExternalCacheDir下的所有文件
                        return listFiles(file);
                    }
                })
                .subscribe(new Action1<File>() {
                    @Override
                    public void call(File file) {
                        System.out.println(file.getAbsolutePath());
                    }
                });

    }

concatMap操作符

cancatMap操作符與flatMap操作符類似，都是把Observable產生的結果轉換成多個Observable，然後把這多個Observable“扁平化”成一個Observable，並依次提交產生的結果給訂閱者。
與flatMap操作符不同的是，concatMap操作符在處理產生的Observable時，採用的是“連接(concat)”的方式，而不是“合併(merge)”的方式，這就能保證產生結果的順序性，也就是說提交給訂閱者的結果是按照順序提交的，不會存在交叉的情況。

switchMap操作符

switchMap操作符與flatMap操作符類似，都是把Observable產生的結果轉換成多個Observable，然後把這多個Observable“扁平化”成一個Observable，並依次提交產生的結果給訂閱者。
與flatMap操作符不同的是，switchMap操作符會保存最新的Observable產生的結果而捨棄舊的結果，舉個例子來說，比如源Observable產生A、B、C三個結果，通過switchMap的自定義映射規則，映射後應該會產生A1、A2、B1、B2、C1、C2，但是在產生B2的同時，C1已經產生了，這樣最後的結果就變成A1、A2、B1、C1、C2，B2被捨棄掉了！

以下是flatMap、concatMap和switchMap的運行實例對比：

        //flatMap操作符的運行結果
        Observable.just(10, 20, 30).flatMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                //10的延遲執行時間爲200毫秒、20和30的延遲執行時間爲180毫秒
                int delay = 200;
                if (integer > 10)
                    delay = 180;

                return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("flatMap Next:" + integer);
            }
        });

        //concatMap操作符的運行結果
        Observable.just(10, 20, 30).concatMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                //10的延遲執行時間爲200毫秒、20和30的延遲執行時間爲180毫秒
                int delay = 200;
                if (integer > 10)
                    delay = 180;

                return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("concatMap Next:" + integer);
            }
        });

        //switchMap操作符的運行結果
        Observable.just(10, 20, 30).switchMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                //10的延遲執行時間爲200毫秒、20和30的延遲執行時間爲180毫秒
                int delay = 200;
                if (integer > 10)
                    delay = 180;

                return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("switchMap Next:" + integer);
            }
        });

運行結果如下：
flatMap Next:20
flatMap Next:10
flatMap Next:30
flatMap Next:15
flatMap Next:10
flatMap Next:5

switchMap Next:30
switchMap Next:15

concatMap Next:10
concatMap Next:5
concatMap Next:20
concatMap Next:10
concatMap Next:30
concatMap Next:15

groupBy操作符

groupBy操作符是對源Observable產生的結果進行分組，形成一個類型爲GroupedObservable的結果集，GroupedObservable中存在一個方法爲getKey()，可以通過該方法獲取結果集的Key值（類似於HashMap的key)。
值得注意的是，由於結果集中的GroupedObservable是把分組結果緩存起來，如果對每一個GroupedObservable不進行處理（既不訂閱執行也不對其進行別的操作符運算），就有可能出現內存泄露。因此，如果你對某個GroupedObservable不進行處理，最好是對其使用操作符take(0)處理。

調用例子如下：

Observable.interval(1, TimeUnit.SECONDS).take(10).groupBy(new Func1<Long, Long>() {
            @Override
            public Long call(Long value) {
                //按照key爲0,1,2分爲3組
                return value % 3;
            }
        }).subscribe(new Action1<GroupedObservable<Long, Long>>() {
            @Override
            public void call(GroupedObservable<Long, Long> result) {
                result.subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long value) {
                        System.out.println("key:" + result.getKey() +", value:" + value);
                    }
                });
            }
        });

運行結果如下：
key:0, value:0
key:1, value:1
key:2, value:2
key:0, value:3
key:1, value:4
key:2, value:5
key:0, value:6
key:1, value:7
key:2, value:8
key:0, value:9

map操作符

map操作符是把源Observable產生的結果，通過映射規則轉換成另一個結果集，並提交給訂閱者進行處理。

Observable.just(1,2,3,4,5,6).map(new Func1<Integer, Integer>() {
            @Override
            public Integer call(Integer integer) {
                //對源Observable產生的結果，都統一乘以3處理
                return integer*3;
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("next:" + integer);
            }
        });

運行結果如下：
next:3
next:6
next:9
next:12
next:15
next:18

cast操作符

cast操作符類似於map操作符，不同的地方在於map操作符可以通過自定義規則，把一個值A1變成另一個值A2，A1和A2的類型可以一樣也可以不一樣；而cast操作符主要是做類型轉換的，傳入參數爲類型class，如果源Observable產生的結果不能轉成指定的class，則會拋出ClassCastException運行時異常。

        Observable.just(1,2,3,4,5,6).cast(Integer.class).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer value) {
                System.out.println("next:"+value);
            }
        });

運行結果如下：
next:1
next:2
next:3
next:4
next:5
next:6

scan操作符

scan操作符通過遍歷源Observable產生的結果，依次對每一個結果項按照指定規則進行運算，計算後的結果作爲下一個迭代項參數，每一次迭代項都會把計算結果輸出給訂閱者。

Observable.just(1, 2, 3, 4, 5)
    .scan(new Func2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer sum, Integer item) {
            //參數sum就是上一次的計算結果
            return sum + item;
        }
    }).subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

運行結果如下：
Next: 1
Next: 3
Next: 6
Next: 10
Next: 15
Sequence complete.

window操作符

window操作符非常類似於buffer操作符，區別在於buffer操作符產生的結果是一個List緩存，而window操作符產生的結果是一個Observable，訂閱者可以對這個結果Observable重新進行訂閱處理。

Observable.interval(1, TimeUnit.SECONDS).take(12)
                .window(3, TimeUnit.SECONDS)
                .subscribe(new Action1<Observable<Long>>() {
                    @Override
                    public void call(Observable<Long> observable) {
                        System.out.println("subdivide begin......");
                        observable.subscribe(new Action1<Long>() {
                            @Override
                            public void call(Long aLong) {
                                System.out.println("Next:" + aLong);
                            }
                        });
                    }
                });

運行結果如下：
subdivide begin……
Next:0
Next:1
subdivide begin……
Next:2
Next:3
Next:4
subdivide begin……
Next:5
Next:6
Next:7
subdivide begin……
Next:8
Next:9
Next:10
subdivide begin……
Next:11

RxJava 各種操作符（3） -Filtering Observables

Debounce, Distinct, ElementAt, Filter, First, IgnoreElements, Last, Sample, Skip, SkipLast, Take, TakeLast

debounce操作符

debounce操作符對源Observable每產生一個結果後，如果在規定的間隔時間內沒有別的結果產生，則把這個結果提交給訂閱者處理，否則忽略該結果。
值得注意的是，如果源Observable產生的最後一個結果後在規定的時間間隔內調用了onCompleted，那麼通過debounce操作符也會把這個結果提交給訂閱者。

Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if(subscriber.isUnsubscribed()) return;
                try {
                    //產生結果的間隔時間分別爲100、200、300...900毫秒
                    for (int i = 1; i < 10; i++) {
                        subscriber.onNext(i);
                        Thread.sleep(i * 100);
                    }
                    subscriber.onCompleted();
                }catch(Exception e){
                    subscriber.onError(e);
                }
            }
        }).subscribeOn(Schedulers.newThread())
          .debounce(400, TimeUnit.MILLISECONDS)  //超時時間爲400毫秒
          .subscribe(
                new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        System.out.println("Next:" + integer);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        System.out.println("Error:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        System.out.println("completed!");
                    }
                });

運行結果如下：
Next:4
Next:5
Next:6
Next:7
Next:8
Next:9
completed!

distinct操作符

distinct操作符對源Observable產生的結果進行過濾，把重複的結果過濾掉，只輸出不重複的結果給訂閱者，非常類似於SQL裏的distinct關鍵字。

Observable.just(1, 2, 1, 1, 2, 3)
          .distinct()
          .subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });



運行結果如下：
Next: 1
Next: 2
Next: 3
Sequence complete.

elementAt操作符

elementAt操作符在源Observable產生的結果中，僅僅把指定索引的結果提交給訂閱者，索引是從0開始的。

Observable.just(1,2,3,4,5,6).elementAt(2)
          .subscribe(
                new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        System.out.println("Next:" + integer);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        System.out.println("Error:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        System.out.println("completed!");
                    }
                });

運行結果如下：
Next:3
completed!

filter操作符

filter操作符是對源Observable產生的結果按照指定條件進行過濾，只有滿足條件的結果纔會提交給訂閱者

Observable.just(1, 2, 3, 4, 5)
          .filter(new Func1<Integer, Boolean>() {
              @Override
              public Boolean call(Integer item) {
                return( item < 4 );
              }
          }).subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

運行結果如下：
Next: 1
Next: 2
Next: 3
Sequence complete.

ofType操作符

ofType操作符類似於filter操作符，區別在於ofType操作符是按照類型對結果進行過濾

Observable.just(1, "hello world", true, 200L, 0.23f)
          .ofType(Float.class)
          .subscribe(new Subscriber<Object>() {
              @Override
              public void onNext(Object item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

運行結果如下：
Next: 0.23
Sequence complete.

first操作符

first操作符是把源Observable產生的結果的第一個提交給訂閱者，first操作符可以使用elementAt(0)和take(1)替代。

        Observable.just(1,2,3,4,5,6,7,8)
          .first()
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

運行結果如下：
Next: 1
Sequence complete.

single操作符

single操作符是對源Observable的結果進行判斷，如果產生的結果滿足指定條件的數量不爲1，則拋出異常，否則把滿足條件的結果提交給訂閱者

Observable.just(1,2,3,4,5,6,7,8)
          .single(new Func1<Integer, Boolean>() {
              @Override
              public Boolean call(Integer integer) {
                  //取大於10的第一個數字
                  return integer>10;
              }
          })
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

運行結果如下：
Error: Sequence contains no elements

last操作符

last操作符把源Observable產生的結果的最後一個提交給訂閱者，last操作符可以使用takeLast(1)替代。

Observable.just(1, 2, 3)
          .last()
          .subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

運行結果如下：
Next: 3
Sequence complete.

ignoreElements操作符

ignoreElements操作符忽略所有源Observable產生的結果，只把Observable的onCompleted和onError事件通知給訂閱者。ignoreElements操作符適用於不太關心Observable產生的結果，只是在Observable結束時(onCompleted)或者出現錯誤時能夠收到通知。

        Observable.just(1,2,3,4,5,6,7,8).ignoreElements()
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

運行結果如下：
Sequence complete.

sample操作符

sample操作符定期掃描源Observable產生的結果，在指定的時間間隔範圍內對源Observable產生的結果進行採樣

Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if(subscriber.isUnsubscribed()) return;
                try {
                    //前8個數字產生的時間間隔爲1秒，後一個間隔爲3秒
                    for (int i = 1; i < 9; i++) {
                        subscriber.onNext(i);
                        Thread.sleep(1000);
                    }
                    Thread.sleep(2000);
                    subscriber.onNext(9);
                    subscriber.onCompleted();
                } catch(Exception e){
                    subscriber.onError(e);
                }
            }
        }).subscribeOn(Schedulers.newThread())
          .sample(2200, TimeUnit.MILLISECONDS)  //採樣間隔時間爲2200毫秒
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

運行結果如下：
Next: 3
Next: 5
Next: 7
Next: 8
Sequence complete.

skip操作符

skip操作符針對源Observable產生的結果，跳過前面n個不進行處理，而把後面的結果提交給訂閱者處理

Observable.just(1,2,3,4,5,6,7).skip(3)
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

運行結果如下：
Next: 4
Next: 5
Next: 6
Next: 7
Sequence complete.

skipLast操作符

skipLast操作符針對源Observable產生的結果，忽略Observable最後產生的n個結果，而把前面產生的結果提交給訂閱者處理
值得注意的是，skipLast操作符提交滿足條件的結果給訂閱者是存在延遲效果的

可以看到skipLast操作符把最後的天藍色球、藍色球、紫色球忽略掉了，但是前面的紅色球等並不是源Observable一產生就直接提交給訂閱者，這裏有一個延遲的效果。

Observable.just(1,2,3,4,5,6,7).skipLast(3)
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

運行結果如下：
Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.

take操作符

take操作符是把源Observable產生的結果，提取前面的n個提交給訂閱者，而忽略後面的結果

Observable.just(1, 2, 3, 4, 5, 6, 7, 8)
          .take(4)
          .subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

運行結果如下：
Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.

takeFirst操作符

takeFirst操作符類似於take操作符，同時也類似於first操作符，都是獲取源Observable產生的結果列表中符合指定條件的前一個或多個，與first操作符不同的是，first操作符如果獲取不到數據，則會拋出NoSuchElementException異常，而takeFirst則會返回一個空的Observable，該Observable只有onCompleted通知而沒有onNext通知。

Observable.just(1,2,3,4,5,6,7).takeFirst(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                //獲取數值大於3的數據
                return integer>3;
            }
        })
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

運行結果如下：
Next: 4
Sequence complete.

takeLast操作符

takeLast操作符是把源Observable產生的結果的後n項提交給訂閱者，提交時機是Observable發佈onCompleted通知之時

Observable.just(1,2,3,4,5,6,7).takeLast(2)
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

運行結果如下：
Next: 6
Next: 7
Sequence complete.

站內首發文章

丶如一

發佈了36 篇原創文章 · 獲贊 2 · 訪問量 4萬+

私信關注

RxJava 各種操作符（2、3）

RxJava 各種操作符（2） - Transforming Observables

buffer

flatMap操作符

concatMap操作符

switchMap操作符

groupBy操作符

map操作符

cast操作符

scan操作符

window操作符

RxJava 各種操作符（3） -Filtering Observables

debounce操作符

distinct操作符

elementAt操作符

filter操作符

ofType操作符

first操作符

single操作符

last操作符

ignoreElements操作符

sample操作符

skip操作符

skipLast操作符

take操作符

takeFirst操作符

takeLast操作符

一個開源且全面的C#算法實戰教程

一款.NET開源、功能強大、跨平臺的繪圖庫 - OxyPlot

CORS error 但是 status code 是200 OK

壓縮上傳的GPU數據的方案

使用skopeo同步鏡像

終於找到了不用自定義一個activity棧，來關閉所有activity的方法了！！！

Volley全解析

Core Java 筆記（三） - 反射

Android 繪製漸變梯形，其他圖形同理

Core Java 學習（三） - 繼承設計技巧

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結