用Kotlin寫響應式編程RxAndroid

1.關於kotlin

---

先貼上官網的地址https://kotlinlang.org/
Kotlin是一門實用的編程語言，可用於JVM和Android程序開發，Kotlin結合了面向對象和函數式特性，致力於互操作性、安全、簡潔和工具支持。
Kotlin是一門通用的語言，只要能用Java的地方就能用Kotlin，包含：服務器程序開發、移動應用開發（Android）、桌面客戶端程序開發。 Kotlin支持所有主要的開發工具以及服務，比如：
* IntelliJ IDEA、Android Studio和Eclipse；
* Maven、Gradle和Ant；
* Spring Boot（Kotlin 支持今天正式發佈！）；
* GitHub，Slack，甚至Minecraft。
* Kotlin的主要特點之一是Java+Kotlin混合工程的互操作性以及無縫兼容，使引入Kotlin的過程簡單容易，並達成更少的重複性代碼（boilerplate code）和更佳的類型安全（type-safety）。
Kotlin還有一個擴展標準庫（extensive standard library）能讓日常工作變得簡單順暢，它能幫助保持低字節碼足跡 (bytecode footprint)。當然，Kotlin 中自然可以使用 Java 庫，反之亦然。
還是多看看資料瞭解吧!

2.關於RxAndroid

---

還是自己去看吧，相信大神不少，不要爲難菜逼了。
都閃開，我要裝逼了！

3.讓Kotlin與Android結合一下

我用的開發IDE是AndroidStudio，要先在AndroidStudio裏面安裝kotlin的插件：

然後重啓一下AS就好了
接下來要在app的build.gradle裏面加上這兩個庫：
compile “org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version”
compile ‘io.reactivex:rxandroid:0.24.0’
再sync一下gradle就好了

函數響應式編程基本特點

1、函數響應式編程
2、異步
3、事件驅動（事件作爲可觀察序列）
4、基於觀察者模式
5、組合式
6、專門出錯處理
7、適用於處理併發問題

基本概念

RxJava最核心的兩個東西是Observables（被觀察者，事件源）和Subscribers（觀察者）。Observables發出一系列事件，Subscribers處理這些事件。這裏的事件可以是任何你感興趣的東西（觸摸事件，web接口調用返回的數據。。。）
一個Observable可以發出零個或者多個事件，知道結束或者出錯。每發出一個事件，就會調用它的Subscriber的onNext方法，最後調用Subscriber.onCompleted()或者Subscriber.onError()結束。
我們主要關心的是 onNext 函數來處理業務邏輯

基本使用實例

事件源發出一個字符串

1. in java
   Observable observable = Observable.create(new OnSubscribe<String>({
   @Override
   public void call(Subscriber<? super String>subscriber) {
   subscriber.onNext(“hello rx android”);
   subscriber.onCompleted();
   } });

2. in kotlin
   Observable.create(object : Observable.OnSubscribe<String> {
   override fun call(subscriber: Subscriber<in String>) {
   subscriber.onNext(“hello rx android”)
   subscriber.onCompleted()
   }
   })

   訂閱着處理 onNext

   1. in java
      Subscriber<String> subscriber = new Subscriber<String>() {

   @Override
   public void onCompleted() {
   Log.i(TAG, “onCompleted”);
   }

   @Override
   public void onError(Throwable e) {
   //handler the error

   }

   @Override
   public void onNext(String t) {
   Log.i(TAG, t);
   }
   };
   2 in kotlin
   var subscriber = object : Subscriber<String>() {
   override fun onCompleted() {
   Log.i(“android”, “onCompleted”)
   }
   override fun onError(e: Throwable) {//handler the error
   }
   override fun onNext(t: String) {
   Log.i(“android”, t)
   }
   }

   注意一點：在kotlin中Throwable的源代碼是public open class Throwable {
   }這樣的，是一個空實現，其中open修飾符與final的意義相反，它允許別的類繼承，就像Effective java中說的：設計並顯示標註繼承，否則就禁止它。相應的允許繼承重寫的方法前也應該加上open

綁定事件和訂閱者

1 in java
observable.subscribe(subscriber);
2 in kotlin
ob.subscribe(subscriber)

簡單使用

1 in java
Observable.just(“hello rx Android 2”).subscribe(new Action<String>() {
@Override
public void call(String t) {
Log.i(TAG, t);
}
});
2 in Android
Observable.just(“hello rx Android 2”).subscribe({ t ->
Log.i(TAG, t);
});

輕量化

Observable只發出的事件
Subscribers只做事情是“響應”

操作符

操作符就是爲了解決對Observable對象的變換的問題，操作符用於在Observable和最終的Subscriber之間修改Observable發出的事件

字符串拼接實例

1 in java
Observable.just(“hello rx Android 3”)
.map(new Func1<String, String>() {
@Override
public String call(String t) {
return t + ” map 操作賦”;
}
})
.subscribe(new Action1<String>() {
@Override
public void call(String t) {
Log.i(TAG, t); //hello rx Android 3 map 操作賦
}
});
2 in kotlin
Observable.just(“hello rx Android 3”)
.map({ t -> return@map t + ” map 操作賦”; })
.subscribe({ t -> Log.i(TAG, t); });

類型轉換

1 in java
Observable.just(“hello rx Android 4”)
.map(new Func1<String, Integer>() {
@Override
public Integer call(String t) {
return t.hashCode();
}
})
.subscribe(new Action1() {
@Override
public void call(Integer t) {
Log.i(TAG, t + ” = ” + “hello rx Android 4”.hashCode());
}
});
2 in kotlin
Observable.just(“hello rx Android 4”)
.map { sg -> return@map sg.hashCode() }
.subscribe({
i ->
Log.i(TAG,i.toString()+ ” = ” + “hello rx Android 4”.hashCode())
})

from方法

Observable.from()方法，它接收一個集合作爲輸入，然後每次輸出一個元素給subscriber
1 in java
Observable.from(new String[]{“hello rx Android 5”, “hello rx Android 6”}).subscribe(new Action1<String>() {
@Override
public void call(String t) {
Log.i(TAG, t);//依次打印5， 6
}
});
2 in kotlin
Observable.from(arrayOf(“hello rx Android 5”, “hello rx Android 6”)).subscribe({
t ->
Log.i(TAG, t);
});

flatMap

Observable.flatMap()接收一個Observable的輸出作爲輸入，同時輸出另外一個Observable
1 in java
List<String> list = new ArrayList<String>();
list.add(“hello rx Android 7”);
list.add(“hello rx Android 8”);
Observable.just(list)
.flatMap(new Func1<List<String>, Observable<String>>() {
@Override
public Observable<String> call(List<String> t) {
return Observable.from(t);
}
})
.subscribe(new Action1<String>() {
@Override
public void call(String t) {
Log.d(TAG, t); // 依次打印7,8
}
});
2 in kotlin
var list = ArrayList<String>()
list.add(“hello rx Android 7”);
list.add(“hello rx Android 8”);
Observable.just(list)
.flatMap({
t ->
return@flatMap Observable.from(t);
})
.subscribe({
t ->
Log.i(TAG, t); // 依次打印7,8
}
);

filter 過濾

filter()輸出和輸入相同的元素，並且會過濾掉那些不滿足檢查條件的。
文／ben_speed（簡書作者）
原文鏈接：http://www.jianshu.com/p/51a8d2ff8697
著作權歸作者所有，轉載請聯繫作者獲得授權，並標註“簡書作者”。
1 in java
.filter(new Func1<String, Boolean>() {
@Override
public Boolean call(String t) {
return t != null;
}
})
2 in kotlin
var sss = arrayOf(“one”, null, “three”, null)
Observable.from(sss)
.filter { t -> return@filter t != null }
.subscribe({ t -> Log.i(TAG, t) })

take()

take()輸出最多指定數量的

doOnNext()

doOnNext()允許我們在每次輸出一個元素之前做一些額外的事情
1 in java
List<String> list = new ArrayList<String>();
list.add(“hello rx Android 7”);
list.add(“hello rx Android 8”);
list.add(null);
Observable.just(list)
.flatMap(new Func1<List<String>, Observable<String>>() {

    @Override
    public Observable<String> call(List<String> t) {
        return Observable.from(t);
    }

})
.filter(new Func1<String, Boolean>() {
    @Override
    public Boolean call(String t) {
        return t != null;
    }
})
.take(2)
.doOnNext(new Action1<String>() {

    @Override
    public void call(String t) {
        Log.e(TAG, t);
    }
})
.subscribe(new Action1<String>() {

    @Override
    public void call(String t) {
        Log.d(TAG, t);
    }
});

2 in kotlin
var list = ArrayList<String?>();
list.add(“hello rx Android 7”);
list.add(“hello rx Android 8”);
list.add(null);
Observable.just(list)
.flatMap({
t ->
return@flatMap Observable.from(t);
})
.filter({ t ->
return@filter t != null;
})
.take(2)
.doOnNext({
t ->
Log.i(TAG, t);
})
.subscribe({
t-> Log.i(TAG, t);
});

總結

kotlin相對於java是簡潔大量的代碼量的，好了今天就到這裏了