cname_1
cname_1

RxJava2『使用』

基础概念

RxJava是一个在基于Java VM扩展的使用可观测的序列来组成异步的、基于事件的程序的库。它基于观察者模式支持数据和事件的流式流通处理，并增加了多种运算符以在多种场景下整合事件和数据。抽象了低级别的线程、同步、并发API。

  • 响应式编程(Reactive Programming)是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。
  • 函数式编程是也一种编程范式，它将函数视为一等公民，意味着函数和其他类型数据有同等的地位，可以作为函数的参数、返回值使用(高阶函数)。
  • 被观察者，Observable/Flowable
  • 观察者，Observer/Consumer/Subscriber
  • 上游：发射事件的地方，对应的是被订阅者(Observable/Flowable)
  • 下游：接收事件的地方，对应的是观察者(Observer/Subscriber)

使用

1. 创建被观察者(上游对象，Observable/Flowable)
Observable observable = Observable.fromArray(new String[]{"A","B","C"});
2.创建观察者（下游对象，Observer/Consumer)
//创建一个Observer
Observer observer = new Observer() {
    @Override
    public void onSubscribe(Disposable d) {
    }
    @Override
    public void onNext(String s) {
        System.out.println("Thread:" + Thread.currentThread() + "|" + "accept:"+ s);
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onComplete() {
    }
};
//创建一个Consumer
Consumer consumer = new Consumer() {
    @Override
    public void accept(String s) throws Exception {
        System.out.println("Thread:" + Thread.currentThread() + "|" + "onNext:"+ s);
    }
};

Consumer和Observer的不同之处在于Consumer不关心onNext()和onError()方法，它只管处理上游发送的数据。

3.订阅

订阅通过方法subscribe()实现，当一个被观察者收到一个订阅请求时，他就会开始发送一遍事件。所以下面2次subscribe动作，observable发送了2遍事件。

observable.subscribe(observer);
observable.subscribe(consumer);
>>>输出：
Thread:Thread[main,5,main]|onNext:A
Thread:Thread[main,5,main]|onNext:B
Thread:Thread[main,5,main]|onNext:C
Thread:Thread[main,5,main]|accept:A
Thread:Thread[main,5,main]|accept:B
Thread:Thread[main,5,main]|accept:C
4.使用调度器(Schedulers)指定上下游执行线程

在开发过程中，我们经常需要把一些耗时动作放在后台线程中进行，然后将结果放到主线程中处理。

在RxJava中可以使用调用器的subscribeOn指定在哪个线程发生订阅(及上游)和observeOn用于指定在哪个线程发生观察(即下游)从而实现这样的功能。我们先把上游指定到newThread中执行，任务为每隔一秒发送一个数字。

Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter emitter) throws Exception {
        for (int i = 0; i < 3; i++) {
            System.out.println("Thread:" + Thread.currentThread() + "|" + "emit:" + i);
            emitter.onNext(i + "");
            Thread.sleep(1000);
        }
    }
}).subscribeOn(Schedulers.newThread()).subscribe(new Consumer() {
    @Override
    public void accept(String s) throws Exception {
        System.out.println("Thread:" + Thread.currentThread() + "|" + "accept:"+ s);
    }
});
>>>输出：

Process finished with exit code 0

奇怪的是根据console看到上游发送任何事件，下游更没有接收到任何事件。这是因为：

在RxJava中默认的调度器运行在守护线程上，这意味着只要Java主线程退出，所有这些默认的调度器会停止。本段代码中上游运行在子线程中处理耗时操作，下游运行在主线程中，上游还没开始发送消息，下游的主线程已经结束任务了，所以调度器来不及调度也就停止了。现在我们让上游运行在默认的主线程中，下游运行在子线程中：

Observable.create(new ObservableOnSubscribe() {
    @Override
    public void subscribe(ObservableEmitter emitter) throws Exception {
        for (int i = 0; i < 3; i++) {
            System.out.println("Thread:" + Thread.currentThread() + "|" + "emit:" + i);
            emitter.onNext(i + "");
            Thread.sleep(1000);
        }
    }
}).observeOn(Schedulers.newThread()).subscribe(new Consumer() {
    @Override
    public void accept(String s) throws Exception {
        System.out.println("Thread:" + Thread.currentThread() + "|" + "accept:"+ s);
    }
});
>>>输出：
Thread:Thread[main,5,main]|emit:0
Thread:Thread[RxNewThreadScheduler-1,5,main]|accept:0
Thread:Thread[main,5,main]|emit:1
Thread:Thread[RxNewThreadScheduler-1,5,main]|accept:1
Thread:Thread[main,5,main]|emit:2
Thread:Thread[RxNewThreadScheduler-1,5,main]|accept:2
5.结合操作符实现数据操作

我们知道RxJava有多种操作符可以操作流中的数据，下面是一个例子，假设学生的姓名和成绩来自两个接口，我们需要等这个接口都返回结果时，才刷新界面，看用下面这demo代码，需要注意将2个接口请求放到子线程中，否则2个模拟请求默认会在主线程中，进行串行调用。(可以看两个log的时间间隔)

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;
import java.util.HashMap;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.BiFunction;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;

public class TestOperatorActivity extends Activity {

    private String TAG = "TestOP";

    class Stu {
        String name;
        int scoreMath, scoreEnglish;

        public Stu(String name, int scoreMath, int scoreEnglish) {
            this.name = name;
            this.scoreMath = scoreMath;
            this.scoreEnglish = scoreEnglish;
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.rx_act_test_operator);
        findViewById(R.id.btnTestZip).setOnClickListener(v -> testZip());
    }

    void testZip() {
        TextView tvName = findViewById(R.id.tvName);
        TextView tvScoreEnglish = findViewById(R.id.tvScoreEnglish);
        TextView tvScoreMath = findViewById(R.id.tvScoreMath);

        Observable nameTask = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                 //模拟请求耗时
                Thread.sleep(1000);
                emitter.onNext("小王");
                Log.d(TAG, "Thread:" + Thread.currentThread() + "发送姓名");
            }
        }).subscribeOn(Schedulers.newThread()); //注意将该模拟请求指定到子线程中，模拟并行请求
        Observable scoreTask = Observable.create(new ObservableOnSubscribe>() {
            @Override
            public void subscribe(ObservableEmitter> emitter) throws Exception {
                //模拟请求耗时
                Thread.sleep(5000);
                HashMap map = new HashMap();
                map.put("scoreEnglish", 80);
                map.put("scoreMath", 95);
                Log.d(TAG, "Thread:" + Thread.currentThread() + "发送成绩");
                emitter.onNext(map);

            }
        }).subscribeOn(Schedulers.newThread()); //注意将该模拟请求指定到子线程中，模拟并行请求
        Observable.zip(nameTask, scoreTask, new BiFunction, Stu>() {
            @Override
            public Stu apply(String s, HashMap stringIntegerHashMap) throws Exception {
                Log.d(TAG, "Thread:" + Thread.currentThread() + "合并数据");
                return new Stu(s, stringIntegerHashMap.get("scoreMath"), stringIntegerHashMap.get("scoreEnglish"));
            }
        }).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer() {
            @Override
            public void accept(Stu stu) throws Exception {
                Log.d(TAG, "Thread:" + Thread.currentThread() + "收到最终数据");
                tvName.setText(stu.name);
                tvScoreEnglish.setText(stu.scoreEnglish + "");
                tvScoreMath.setText(stu.scoreMath + "");
            }
        });
    }
}
>>>输出，观察“发送姓名”和“发送成绩”的时间间隔为4秒，且不再同一线程中执行，说明他们是并行进行的。
14:12:35.455 20450-20516/com.ebm.rxjava D/TestOP: Thread:Thread[RxNewThreadScheduler-2,5,main]发送姓名
14:12:39.456 20450-20517/com.ebm.rxjava D/TestOP: Thread:Thread[RxNewThreadScheduler-3,5,main]发送成绩
14:12:39.456 20450-20517/com.ebm.rxjava D/TestOP: Thread:Thread[RxNewThreadScheduler-3,5,main]合并数据
14:12:39.461 20450-20450/com.ebm.rxjava D/TestOP: Thread:Thread[main,5,main]收到最终数据

调度器

RxJava操作符不直接和Threads或者ExecutorServices打交道，而是通过Schedulers(调度器)的通用API来实现对具体并发代码的抽象。RxJava通过工具类Schedulers提供了几个标准的调度方式

RxJava operators don't work with Threads or ExecutorServices directly but with so called Schedulers that abstract away sources of concurrency behind a uniform API. RxJava 2 features several standard schedulers accessible via Schedulers utility class.

  • Schedulers.computation(): 在后台的固定数量的专用线程上运行计算密集型工作。大多数异步操作符使用这个作为默认的调度器

    Run computation intensive work on a fixed number of dedicated threads in the background. Most asynchronous operator use this as their default Scheduler.

  • Schedulers.io(): 在一个动态线程集合上运行类似I/O或阻塞的操作。

    Run I/O-like or blocking operations on a dynamically changing set of threads.

  • Schedulers.single(): 以顺序和FIFO方式在单个线程上运行工作。

    Run work on a single thread in a sequential and FIFO manner.

  • Schedulers.trampoline(): ???在一个参与线程中以顺序和FIFO方式运行工作，通常用于测试目的。

    Run work in a sequential and FIFO manner in one of the participating threads, usually for testing purposes.

其他

Consumer、Observer、Publisher

Consumer和Observer都是接口，只是Consumer中只有一个accept方法，而Observer中有onNex、onComplete、onError、onSubsribe(Disposable d)四个个方法。其中onSubscribe中的Disposable可以用来作为上下游的开关，调用Disposable.dispose()可以停止接收上游发送的事件。

Publisher能够提供一个无边际数量的对象序列，当收到订阅请求时发布这些无数量限制的元素。Flowable继承自Publisher。

onNext、onComplete、onError

​ 这三个方法是Emitter(发射器)接口中定义的三个方法，分别表示事件发送、完成、异常。

  • 上游可以发送无限个onNext, 下游也可以接收无限个onNext.
  • 当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件.
  • 当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件.
  • 上游可以不发送onComplete或onError.
  • 最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然
  • 注: 关于onComplete和onError唯一并且互斥这一点, 是需要自行在代码中进行控制, 如果你的代码逻辑中违背了这个规则, **并不一定会导致程序崩溃. ** 比如发送多个onComplete是可以正常运行的, 依然是收到第一个onComplete就不再接收了, 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃。
并行处理

在RxJava中并行处理，体现在在不同的独立的flow中进行计算的结果，最终被合并到一个flow中去。以flowMap为例：

Flowable.range(1, 10)
  .flatMap(v -> Flowable.just(v).subscribeOn(Schedulers.computation()).map(w -> w * w) )
  .blockingSubscribe(v -> Log.d(TAG, String.valueOf(v)));
>>>输出：
05:58:40.317 D/TestOP: 1
05:58:40.317 D/TestOP: 9
05:58:40.317 D/TestOP: 25
05:58:40.317 D/TestOP: 49
05:58:40.318 D/TestOP: 81
05:58:40.318 D/TestOP: 4
05:58:40.318 D/TestOP: 16
05:58:40.320 D/TestOP: 36
05:58:40.321 D/TestOP: 64
05:58:40.321 D/TestOP: 100
背压

当上下游在不同的线程中，发射和接收数据的速率可能有所不同，为了避免超出预期的内存开销，或者为了满足跳过、舍弃某些数据的需求，所谓的背压就产生了。背压是一种不同操作能够表达他们能处理多少数据的流控制机制。背压用来在不知道上游将会发送多少数据量的时候，用来限制内存开销的。RxJava的Flowable是专门用来处理背压的。

Flowable.create(new FlowableOnSubscribe(){
  @Override
  public void subscribe(FlowableEmitter emitter) throws Exception {
    for(int i=0;i<1000;i++) {
      emitter.onNext(i + "");
    }
  }
}, BackpressureStrategy.ERROR).subscribeOn(Schedulers.newThread())
  .observeOn(Schedulers.newThread())
  .subscribe(new Consumer() {
    @Override
    public void accept(String s) throws Exception {
      Thread.sleep(1000);
      Log.e(TAG,"处理数据" + s);
    }
  });

Flowable将数据对象发送到一个大小为128的缓冲区内，等待下游线程从该缓存区中取出数据对象进行处理后，等缓冲区有空闲位置时，再将数据对象放置到缓冲区内。如果此时，下游对象没有使用request(long n)从缓存区拉取数据，那么此时有几种不同的背压策略(BackpressureStrategy可供选择)：

/**
 * Represents the options for applying backpressure to a source sequence.
 */
public enum BackpressureStrategy {
    /**
     * OnNext events are written without any buffering or dropping.
     * Downstream has to deal with any overflow.
     * 
Useful when one applies one of the custom-parameter onBackpressureXXX operators.
     */
    MISSING,
    /**
     * Signals a MissingBackpressureException in case the downstream can't keep up.
     */
    ERROR,
    /**
     * Buffers all onNext values until the downstream consumes it.
     */
    BUFFER,
    /**
     * Drops the most recent onNext value if the downstream can't keep up.
     */
    DROP,
    /**
     * Keeps only the latest onNext value, overwriting any previous value if the
     * downstream can't keep up.
     */
    LATEST
}
RxJavaPlugins

API文档定义：Utility class to inject handlers to certain standard RxJava operations.

简单来说，RxJavaPlugins提供了一种让我们通过hook的方式自定义RxJava行为的途径。首先查看该类的源码，可以看到所有的方法对象都是static的，我们通过如下方式设置RxJavaPlugins的静态成员变量：

RxJavaPlugins.setOnMaybeSubscribe(new BiFunction() {
  @Override
  public MaybeObserver apply(Maybe maybe, MaybeObserver maybeObserver) throws Exception {
    return new MyCustomMaybeObserver(maybeObserver); //这个maybeObserver就是我们真正的下游
  }
});

再来看一段Maybe的最终subscribe的源码：

//Maybe.subscribe(MaybeObserver observer)
public final void subscribe(MaybeObserver observer) {
  ObjectHelper.requireNonNull(observer, "observer is null");
  observer = RxJavaPlugins.onSubscribe(this, observer);
  ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null MaybeObserver. Please check the handler provided to RxJavaPlugins.setOnMaybeSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");

  try {
    subscribeActual(observer);
  } catch (NullPointerException ex) {
    throw ex;
  } catch (Throwable ex) {
    Exceptions.throwIfFatal(ex);
    NullPointerException npe = new NullPointerException("subscribeActual failed");
    npe.initCause(ex);
    throw npe;
  }
}

从上面可以看出，subscriberActural(observer)中的observer是经过RxJavaPlugins进行处理后得到的observer，再看RxJavaPlugins.onSubscribe(this,observer)代码：

//RxJavaPlugins.onSubscribe(@NonNull Maybe source, @NonNull MaybeObserver observer)
public static  MaybeObserver onSubscribe(@NonNull Maybe source, @NonNull MaybeObserver observer) {
  BiFunction f = onMaybeSubscribe; //这个onMaybeSubscribe就是前面说的RxJavaPlugins的静态变量
  if (f != null) {
    return apply(f, source, observer);
  }
  return observer;
}

所以，可以把RxJavaPlugins理解为一个存储自定义observe行为的地方，在对Observerable、Maybe、Single等进行observe时，会判断RxJavaPlugins中是否定义过自定义的Observer，如果有就进行apply操作之后返回新的Observer，否则原样返回。

本段参考：给初学者的RxJava2.0教程(十)

RxJava与RxAndroid
  • RxAndroid是RxJava的一个针对Android平台的扩展，主要用于 Android 开发。
  • RxAndroid只是在RxJava的基础上添加了少数的几个类，目的是能够在Android中更简单的使用RxJava，特别提供了可以指定到Android主线程的Scheduler，除此之外还增加了基于RxJavaPlugins的扩展RxAndroidPlugins。

操作符

操作符分为创建、转换、延时、条件、过滤这几大类。

转换操作符
map

将输入对象经过Function从SourceType转换为TargetType：

Observable.fromArray(new String[]{"A","B","C"})
    .map(new Function() {
      @Override
      public String apply(String s) throws Exception {
        return s + "_" + s;
      }
      }).subscribe(new Consumer() {
     @Override
     public void accept(String s) throws Exception {
       System.out.println(s);
     }
});
>>>输出：
A_A
B_B
C_C
flatMap

和map类似对流过的数据做转换，只是flatMap会将数据转换成ObservableSource类型的数据对象，被转换的流被分散到多个并行执行的ObservableSource中，所以不能保证执行的顺序。

Flowable.range(1, 10)
    .flatMap(v -> Flowable.just(v).subscribeOn(Schedulers.computation()).map(w -> w * w) )
    .subscribe(new Consumer() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.d(TAG, String.valueOf(integer));
        }
    });
>>>输出：
D/TestOP: 1
D/TestOP: 9
D/TestOP: 4
D/TestOP: 16
D/TestOP: 49
D/TestOP: 64
D/TestOP: 81
D/TestOP: 100
D/TestOP: 25
D/TestOP: 36
concatMap
Flowable.range(1, 10)
    .concatMap(v -> Flowable.just(v).subscribeOn(Schedulers.computation()).map(w -> w * w) )
    .subscribe(new Consumer() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.d(TAG, String.valueOf(integer));
        }
    });
D/TestOP: 1
D/TestOP: 4
D/TestOP: 9
D/TestOP: 16
D/TestOP: 25
D/TestOP: 36
D/TestOP: 49
D/TestOP: 64
D/TestOP: 81
D/TestOP: 100
zip

合并多个事件流(Observable)，生成一个新的事件流(Observable)。最终合并的事件流的事件数有前面被合并的事件流中事件个数最少的决定。举一个请求两个耗时数据的例子：

void testZip() {
        TextView tvName = findViewById(R.id.tvName);
        TextView tvScoreEnglish = findViewById(R.id.tvScoreEnglish);
        TextView tvScoreMath = findViewById(R.id.tvScoreMath);

        Observable nameTask = Observable.create((ObservableOnSubscribe)
                emitter -> {
            Thread.sleep(1000); //模拟耗时
            emitter.onNext("小王");
            Log.d(TAG, "Thread:" + Thread.currentThread() + "发送姓名");
        }).subscribeOn(Schedulers.newThread());
        Observable scoreTask = Observable.create((ObservableOnSubscribe>)
                emitter -> {
            Thread.sleep(5000); //模拟耗时
            HashMap map = new HashMap();
            map.put("scoreEnglish", 80);
            map.put("scoreMath", 95);
            Log.d(TAG, "Thread:" + Thread.currentThread() + "发送成绩");
            emitter.onNext(map);
        }).subscribeOn(Schedulers.newThread());
        Observable.zip(nameTask, scoreTask, (BiFunction, Stu>)
                (s, stringIntegerHashMap) -> {
            Log.d(TAG, "Thread:" + Thread.currentThread() + "合并数据");
            return new Stu(s, stringIntegerHashMap.get("scoreMath"), stringIntegerHashMap.get("scoreEnglish"));
        }).subscribeOn(Schedulers.newThread()).observeOn(AndroidSchedulers.mainThread())
                .subscribe((Consumer) stu -> {
            Log.d(TAG, "Thread:" + Thread.currentThread() + "收到最终数据");
            tvName.setText(stu.name);
            tvScoreEnglish.setText(stu.scoreEnglish + "");
            tvScoreMath.setText(stu.scoreMath + "");
        });
    }
merge

将2个并行进行的事件流合并到一个事件流中，按时间顺序执行。

void testMerge() {
    Observable observable1 = Observable.interval(1000l,TimeUnit.MILLISECONDS).take(3);
    Observable observable2 = Observable.interval(2000l,TimeUnit.MILLISECONDS).take(3);
    Observable.merge(observable1,observable2).subscribe(new Consumer() {
        @Override
        public void accept(Long i) throws Exception {
            Log.d(TAG,i.toString());
        }
    });
}
//输出：
17:42:42.555 D/TestOP: 0
17:42:43.554 D/TestOP: 1
17:42:43.555 D/TestOP: 0
17:42:44.555 D/TestOP: 2
17:42:45.555 D/TestOP: 1
17:42:47.555 D/TestOP: 2
concat
Observable observable1 = Observable.interval(1000l,TimeUnit.MILLISECONDS).take(3);
Observable observable2 = Observable.interval(2000l,TimeUnit.MILLISECONDS).take(3);
Observable.concat(observable1,observable2).subscribe(new Consumer() {
    @Override
    public void accept(Long i) throws Exception {
        Log.d(TAG,i.toString());
    }
});

>>>输出：
17:46:18.587 D/TestOP: 0
17:46:19.587 D/TestOP: 1
17:46:20.587 D/TestOP: 2
17:46:22.588 D/TestOP: 0
17:46:24.588 D/TestOP: 1
17:46:26.588 D/TestOP: 2
延时操作符
delay

使事件流经过一段时间延迟后再开始执行

void testDelay() {
  Log.d(TAG,"TestDelay");
  Observable.fromArray(new String[]{"A","B","C"})
    .delay(2000, TimeUnit.MILLISECONDS)
    .subscribe(s -> Log.d(TAG,s));
}
>>>输出：
05:53:34.615 D/TestOP: TestDelay
05:53:36.643 D/TestOP: A
05:53:36.643 D/TestOP: B
05:53:36.643 D/TestOP: C
interval

在经过最初的延时(initialDelay)开始从0L发送数据，每次经过一个时间间隔(period)，发送一个增大的数字。

Returns an Observable that emits a {@code 0L} after the {@code initialDelay} and ever increasing numbers after each {@code period} of time thereafter, on a specified {@link Scheduler}.

Observable.interval(1000l,TimeUnit.MILLISECONDS).subscribe(new Consumer() {
  @Override
  public void accept(Long aLong) throws Exception {
    Log.d(TAG, String.valueOf(aLong));
  }
});
>>>输出：
0
1
2
4
5
6
...
skip

跳过事件序列的前n项，以interval的代码为基础，跳过前面10项

Observable.interval(1000l,TimeUnit.MILLISECONDS).skip(10).subscribe(new Consumer() {
  @Override
  public void accept(Long aLong) throws Exception {
    Log.d(TAG, String.valueOf(aLong));
  }
});
>>>输出：
10
11
12
13
14
15
...
take

只取事件序列的前N项，以skip的代码为基础，跳过前10项后，取5项

Observable.interval(1000l,TimeUnit.MILLISECONDS).skip(10).take(5)subscribe(new Consumer() {
  @Override
  public void accept(Long aLong) throws Exception {
    Log.d(TAG, String.valueOf(aLong));
  }
});
>>>输出：
10
11
12
13
14
defer

**直到有观察者(Observer)订阅时，才动态创建观察者对象(Observable) **

int i = 1;
void testDefer() {
  Observable observable = Observable
    .defer((Callable>) () -> Observable.just(i));
  i = 2;
  observable.subscribe(it -> Log.d(TAG,it.toString()));
}
>>>输出：2
过滤操作符
filter
Flowable.range(0,10).filter(new Predicate() {
    @Override
    public boolean test(Integer integer) throws Exception {
        if(integer.intValue() % 2 == 0) {
            return true;
        }
        return false;
    }
}).subscribe(new Consumer() {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d(TAG,integer.toString());
    }
});
>>>输出：
0
2
4
6
8
组合使用
定时发送自定义事件
//可以使用from+interval+zip实现
/**
     * 测试固定时间间隔发送自定义消息
     */
void testIntervalCustomMsg() {
    Observable.zip(Observable.fromArray(new String[]{"A","B","C"})
                   ,Observable.interval(3000l,TimeUnit.MILLISECONDS)
                   ,new BiFunction(){
                       @Override
                       public String apply(String s, Long aLong) throws Exception {
                           return s;
                       }
                   }).subscribe(new Consumer() {
        @Override
        public void accept(String o) throws Exception {
            Log.d(TAG,o.toString());
        }
    });
}

最后，来一张别人整理的操作符大全图片(原地址：https://www.jianshu.com/p/12883e1b59f9)

avatar

参考：

Rxjava操作符大全

你可能感兴趣的:(RxJava2『使用』)

  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • html 中如何使用 uniapp 的部分方法 某公司摸鱼前端 htmluni-app前端
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • Google earth studio 简介 陟彼高冈yu 旅游
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • LLM 词汇表 落难Coder LLMsNLP大语言模型大模型llama人工智能
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
  • 下载github patch到本地 小米人er 我的博客gitpatch
    以下是几种从GitHub上下载以.patch结尾的补丁文件的方法：通过浏览器直接下载打开包含该.patch文件的GitHub仓库。在仓库的文件列表中找到对应的.patch文件。点击该文件，浏览器会显示文件的内容，在页面的右上角通常会有一个“Raw”按钮，点击它可以获取原始文件内容。然后在浏览器中使用快捷键（如Ctrl+S或者Command+S）将原始文件保存到本地，选择保存的文件名并确保后缀为.p
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 直返最高等级与直返APP：无需邀请码的返利新体验 古楼
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
  • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • 2020-04-12每天三百字之连接与替代 冷眼看潮
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
  • 【加密社】Solidity 中的事件机制及其应用 加密社 闲侃区块链智能合约区块链
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchaineasyui前端python
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • 使用LLaVa和Ollama实现多模态RAG示例 llzwxh888 python人工智能开发语言
    本文将详细介绍如何使用LLaVa和Ollama实现多模态RAG（检索增强生成），通过提取图像中的结构化数据、生成图像字幕等功能来展示这一技术的强大之处。安装环境首先，您需要安装以下依赖包：!pipinstallllama-index-multi-modal-llms-ollama!pipinstallllama-index-readers-file!pipinstallunstructured!p
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • 使用Apify加载Twitter消息以进行微调的完整指南 nseejrukjhad twittereasyui前端python
    #使用Apify加载Twitter消息以进行微调的完整指南##引言在自然语言处理领域，微调模型以适应特定任务是提升模型性能的常见方法。本文将介绍如何使用Apify从Twitter导出聊天信息，以便进一步进行微调。##主要内容###使用Apify导出推文首先，我们需要从Twitter导出推文。Apify可以帮助我们做到这一点。通过Apify的强大功能，我们可以批量抓取和导出数据，适用于各类应用场景。
  • HQL之投影查询 归来朝歌 HQLHibernate查询语句投影查询
            在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？ 针对上面的场景，如果需要将一个对象查出来： HQL语句写“from 对象”即可 Session session = HibernateUtil.openSession();
  • Spring整合redis bylijinnan redis
    pom.xml <dependencies> <!-- Spring Data - Redis Library --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redi
  • org.hibernate.NonUniqueResultException: query did not return a unique result: 2 0624chenhong Hibernate
    参考：http://blog.csdn.net/qingfeilee/article/details/7052736 org.hibernate.NonUniqueResultException: query did not return a unique result: 2         在项目中出现了org.hiber
  • android动画效果 不懂事的小屁孩 android动画
    前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 Android 平台提供了两类动画。 一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。 第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。
  • js delete 删除机理以及它的内存泄露问题的解决方案 换个号韩国红果果 JavaScript
    delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露  （其实还未删除） 举例： var person={name:{firstname:'bob'}} var p=person.name delete person.name p.firstname -->'bob' // 依然可以访问p.firstname，存在内存泄露
  • Oracle将零干预分析加入网络即服务计划 蓝儿唯美 oracle
    由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
  • spring学习——springmvc（二） a-john springMVC
    Spring MVC提供了非常方便的文件上传功能。 1，配置Spring支持文件上传： DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
  • POJ-2828-Buy Tickets aijuans ACM_POJ
    POJ-2828-Buy Tickets http://poj.org/problem?id=2828 线段树，逆序插入 #include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
  • Java Ant build.xml详解 asia007 build.xml
    1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台   --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
  • android按钮监听器的四种技术 百合不是茶 androidxml配置监听器实现接口
    android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方;    1,activity中使用内部类实现接口 ,创建内部类实例  使用add方法  与java类似   创建监听器的实例 myLis lis = new myLis();   使用add方法给按钮添加监听器  
  • 软件架构师不等同于资深程序员 bijian1013 程序员架构师架构设计
            本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。         如今很多的公司
  • TeamForge Wiki Syntax & CollabNet User Information Center sunjing TeamForgeHow doAttachementAnchorWiki Syntax
    the CollabNet user information center http://help.collab.net/   How do I create a new Wiki page? A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
  • 【Redis四】Redis数据类型 bit1129 redis
    概述 Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
  • SSH2整合-附源码 白糖_ eclipsespringtomcatHibernateGoogle
    今天用eclipse终于整合出了struts2+hibernate+spring框架。 我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。     补充1：项目中部分jar包不是最新版的，可能导
  • [转]开源项目代码的学习方法 braveCS 学习方法
    转自： http://blog.sina.com.cn/s/blog_693458530100lk5m.html http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html   1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
  • 编程之美-子数组的最大和（二维） bylijinnan 编程之美
    package beautyOfCoding; import java.util.Arrays; import java.util.Random; public class MaxSubArraySum2 { /** * 编程之美 子数组之和的最大值（二维） */ private static final int ROW = 5; private stat
  • 读书笔记-3 chengxuyuancsdn jquery笔记resultMap配置ibatis一对多配置
    1、resultMap配置 2、ibatis一对多配置 3、jquery笔记 1、resultMap配置 当<select resultMap="topic_data"> <resultMap id="topic_data">必须一一对应。 (1)<resultMap class="tblTopic&q
  • [物理与天文]物理学新进展 comsci
          如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境       怎么办呢?  
  • Oracle 11g新特性:Automatic Diagnostic Repository daizj oracleADR
    Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。 在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。 这两份log文
  • 简单排序:选择排序 dieslrae 选择排序
    public void selectSort(int[] array){ int select; for(int i=0;i<array.length;i++){ select = i; for(int k=i+1;k<array.leng
  • C语言学习六指针的经典程序，互换两个数字 dcj3sjt126com c
    示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 # include <stdio.h> void swap_1(int, int); void swap_2(int *, int *); void swap_3(int *, int *); int main(void) { int a = 3; int b =
  • php 5.4中php-fpm 的重启、终止操作命令 dcj3sjt126com PHP
    php 5.4中php-fpm 的重启、终止操作命令: 查看php运行目录命令：which php/usr/bin/php 查看php-fpm进程数：ps aux | grep -c php-fpm 查看运行内存/usr/bin/php  -i|grep mem 重启php-fpm/etc/init.d/php-fpm restart 在phpinfo()输出内容可以看到php
  • 线程同步工具类 shuizhaosi888 同步工具类
    同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）   闭锁（CountDownLatch） public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin
  • bleeding edge是什么意思 haojinghua DI
    不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。  我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。   In computer science, bleeding edge is a term that
  • c中实现utf8和gbk的互转 jimmee ciconvutf8&gbk编码
    #include <iconv.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> int code_c
  • 大型分布式网站架构设计与实践 lilin530 应用服务器搜索引擎
    1.大型网站软件系统的特点？ a.高并发，大流量。 b.高可用。 c.海量数据。 d.用户分布广泛，网络情况复杂。 e.安全环境恶劣。 f.需求快速变更，发布频繁。 g.渐进式发展。 2.大型网站架构演化发展历程？ a.初始阶段的网站架构。 应用程序，数据库，文件等所有的资源都在一台服务器上。 b.应用服务器和数据服务器分离。 c.使用缓存改善网站性能。 d.使用应用
  • 在代码中获取Android theme中的attr属性值 OliveExcel androidtheme
    Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西.   在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: int defaultColor = 0xFF000000; int[] attrsArray = { andorid.r.
  • 基于Zookeeper的分布式共享锁 roadrunners zookeeper分布式共享锁
    首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。   共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。   官
  • 两个容易被忽略的MySQL知识 tomcat_oracle mysql
    1、varchar(5)可以存储多少个汉字，多少个字母数字？ 　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。 　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
  • zoj 3827 Information Entropy(水题) 阿尔萨斯 format
    题目链接：zoj 3827 Information Entropy 题目大意：三种底，计算和。 解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 #include <cstdio> #include <cstring> #include <cmath&
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他