MinicupSimon
MinicupSimon

RxJava入门

RxJava Github地址：https://github.com/ReactiveX/RxJava

首先引入库文件(当前最新版本为2.1.4)

dependencies {
    ...
    compile 'io.reactivex.rxjava2:rxjava:2.1.4'
}

先来一个简单例子

例1

        //创建被观察者
        Observable observable = Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext("1");
                subscriber.onNext("2");
                subscriber.onNext("3");
                subscriber.onCompleted();
            }
        });

        //创建观察者
        Observer observer = new Observer() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println(e);
            }

            @Override
            public void onNext(String s) {
                System.out.println(s);
            }
        };
        
        //订阅
        observable.subscribe(observer);

 结果：
1
2
3
onCompleted
（1）我们先来看看第一步，创建被观察者：

Observable.create方法（2.0后已经Deprecated）

    @Deprecated
    public static  Observable create(OnSubscribe f) {
        return new Observable(RxJavaHooks.onCreate(f));
    }

OnSubscribe是接口， 继承了Action1
注意这里的参数从转换为了Subscriber

    public interface OnSubscribe extends Action1> {

    }

Action1接口，只有一个call方法 有一个参数，无返回值

public interface Action1 extends Action {
    void call(T t);
}

这就与以上例1中的创建观察者相对应了， Observable.create()传入泛型为String的onSubscribe, 并实现接口call(T t),这里的T也变为了Subscriber类型

Observable observable = Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
            }
});
（2）我们再来看看Observer
public interface Observer {

    //通知观察者,被观察者完成了基于推送的通知。onCompleted()与onError()设计上只会有一个被调用
    void onCompleted();

    //通知观察者，出错了，一但出错，被观察者将不再继续调用接下来的步骤，如onNext, onCompleted
    void onError(Throwable e);

    //向观察者提供新的观察事件
    void onNext(T t);
}
（3）最后实现订阅关系，以原代码角度来分析，如何将Observable与Observer相关联

Observable.create()时，新建了一个Observable实例

    @Deprecated
    public static  Observable create(OnSubscribe f) {
        return new Observable(RxJavaHooks.onCreate(f));
    }

构造方法中只是将onSubscribe对象保存起来

    protected Observable(OnSubscribe f) {
        this.onSubscribe = f;
    }

我们再来看看Observable.subscribe()方法， 这里判断observer是不是Subscriber的实例，不是的话通过新建ObserverSubscriber类来转换成为Subscriber，所以最终都是调用subscribe(Subscriber)

Subscriber 与Observer类似， 实现了Observer, 同时也实现了Subscription, 多了两个方法：unsubscribe(), isUnsubscribed()

    public final Subscription subscribe(final Observer observer) {
        if (observer instanceof Subscriber) {
            return subscribe((Subscriber)observer);
        }
        if (observer == null) {
            throw new NullPointerException("observer is null");
        }
        return subscribe(new ObserverSubscriber(observer));
    }


    public final class ObserverSubscriber extends Subscriber {
        final Observer observer;
        public ObserverSubscriber(Observer observer) {
            this.observer = observer;
        }
       @Override
        public void onNext(T t) {
            observer.onNext(t);
        }
        @Override
        public void onError(Throwable e) {
            observer.onError(e);
        }
        @Override
        public void onCompleted() {
            observer.onCompleted();
        }
   }

最后调用 了Observable.subscribe(subscriber, this)，注意这里关键的this

    public final Subscription subscribe(Subscriber subscriber) {
        return Observable.subscribe(subscriber, this);
    }

    static  Subscription subscribe(Subscriber subscriber, Observable observable) {
        //......

        // Subscriber类中的onStart()为空实现， 在Observer所有方法之前被调用。
        subscriber.onStart();

        //......
        try {
            //这里的observable实际就是当前对象,在这里调用了当前对象中onSubscribe的call.并将例一中的observer 以Subscriber封装后的实例作为call的参数返回。
            RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
            return RxJavaHooks.onObservableReturn(subscriber);
        } catch (Throwable e) {
            //......
            subscriber.onError(RxJavaHooks.onObservableError(e));
            //最后返回未取消订阅的Subscription对象
            return Subscriptions.unsubscribed();
        }
    }

简单来看一看RxJavaHooks中的onObservableStart方法

    public static  Observable.OnSubscribe onObservableStart(Observable instance, Observable.OnSubscribe onSubscribe) {
        Func2 f = onObservableStart;
        if (f != null) {
            //经过一系列调用， 最终还是返回的onSubscribe本身，参考下面的分析
            return f.call(instance, onSubscribe);
        }
        //如果onObservableStart为null便将传进来的onSubscribe原封返回
        return onSubscribe;
    }

来简单分析一下f.call();

static void init() {
        //......
        onObservableStart = new Func2() {
            @Override
            public Observable.OnSubscribe call(Observable t1, Observable.OnSubscribe t2) {
                return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeStart(t1, t2);
            }
        };
        //......
}

    @Deprecated
    public  OnSubscribe onSubscribeStart(Observable observableInstance, final OnSubscribe onSubscribe) {
        return onSubscribe;//将传进来的onSubscribe原封返回
    }
至此，例1所有代码便分析完成。

例1步骤可以简化成以下

        Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext("1");
                subscriber.onNext("2");
                subscriber.onNext("3");
                subscriber.onCompleted();
            }
        }).subscribe(new Observer() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }                            
            @Override
            public void onError(Throwable e) {
                System.out.println(e);
            }
            @Override
            public void onNext(String s) {
                System.out.println(s);
            }
        });

或lambda表达式：

        Observable.create((Observable.OnSubscribe) subscriber -> {
            subscriber.onNext("1");
            subscriber.onNext("2");
            subscriber.onNext("3");
            subscriber.onCompleted();
        }).subscribe(new Observer() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }
            @Override
            public void onError(Throwable e) {
                System.out.println(e);
            }
            @Override
            public void onNext(String s) {
                System.out.println(s);
            }
        });

操作符

这和java8中的Stream很相似，可参考我的另一篇文章《函数式编程 Lambda及Stream》

下面举几个常用的例子

from

RxJava入门_第1张图片
Paste_Image.png

接收数组，实现Iterable的子类对象，及Future对象

        String[] array = new String[]{"a", "b", "c"};
        Observable.from(Arrays.asList(array))
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
a
b
c
onCompleted

just

看原码也是调用的 from((T[])new Object[] { })

RxJava入门_第2张图片
Paste_Image.png 
        Observable.just("1", "2", "3")
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
1
2
3
onCompleted

defer 延迟

  • 即用普通的创建Observable方法
    private static String string = "0";
    public static void main(String[] args) {
        Observable observable = Observable.just(string);
        string = "1";
        observable.subscribe(System.out::println);
    }

结果：0
  • 使用defer创建Observable
    private static String string = "0";
    public static void main(String[] args) {
        Observable observable = Observable.defer(() -> Observable.just(string));
        string = "1";
        observable.subscribe(System.out::println);
    }
结果：1

封装时可先使用defer,后面调用时便会根据不同的参数创建相应的新的Observable

map 变换

接收一个Func1类型的参数（一个参数，一个返回值 ）

RxJava入门_第3张图片
Paste_Image.png 
        String[] array = new String[]{"a", "b", "c"};
        Observable.from(array)
                .map(String::toUpperCase)
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
A
B
C
onCompleted

flatMap变换

以原有Observable为基础，将发射的每一条数据再分成若干个Observable,最后合并，这就是flat的意思，压平
注意这里与map不同的是，返回值是一个Observable对象。


RxJava入门_第4张图片 
        String[] array = new String[]{"aa", "bbb", "cc"};
        Observable.from(array)
                .map(String::toUpperCase)
                .flatMap(s -> {
                    List singleLetter = new ArrayList();
                    for (int i = 0; i < s.length(); i++) {
                        singleLetter.add(String.valueOf(s.charAt(i)));
                    }
                    return Observable.from(singleLetter);
                })
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
A
A
B
B
B
C
C
onCompleted

scan 累加器

由初始值与累加器构成

RxJava入门_第5张图片
Paste_Image.png
  • 接收一个Func2 类型参数
        String[] array = new String[]{"aa", "bbb", "cc"};
        Observable.from(array)
                .map(String::toUpperCase)
                .flatMap(s -> {
                    List singleLetter = new ArrayList();
                    for (int i = 0; i < s.length(); i++) {
                        singleLetter.add(String.valueOf(s.charAt(i)));
                    }
                    return Observable.from(singleLetter);
                })
                .scan(((s1, s2) -> s1 + s2)) 
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
A
AA
AAB
AABB
AABBB
AABBBC
AABBBCC
onCompleted
在未赋初值的情况下，是不调用该方法的（看下图，scan方法被调用前，Console面板中已经显示出发射的第一条数据。）
发射的第一条数据会作为初始值，发射第二条数据时调用该方法并将初始值传给s1, 将第二条数据传给s2
并将结果作为下一条数据的初始值。
RxJava入门_第6张图片
Paste_Image.png
  • 接收（R initialValue, Func2 accumulator） 两个参数
        String[] array = new String[]{"aa", "bbb", "cc"};
        Observable.from(array)
                .map(String::toUpperCase)
                .flatMap(s -> {
                    List singleLetter = new ArrayList();
                    for (int i = 0; i < s.length(); i++) {
                        singleLetter.add(String.valueOf(s.charAt(i)));
                    }
                    return Observable.from(singleLetter);
                })
                .scan("-", ((s1, s2) -> s1 + s2))
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });


结果：
- //在scan被第一次调用前，已经被打印出来
-A
-AA
-AAB
-AABB
-AABBB
-AABBBC
-AABBBCC
onCompleted

filter 过滤出符合条件的

参数为Func1， 返回布尔值

        Observable.from(array)
                .filter(s -> s.length()<=2)
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
aa
cc
onCompleted

take

        String[] array = new String[]{"aa", "bbb", "cc"};
        Observable.from(array)
                .map(String::toUpperCase)
                .flatMap(s -> {
                    List singleLetter = new ArrayList();
                    for (int i = 0; i < s.length(); i++) {
                        singleLetter.add(String.valueOf(s.charAt(i)));
                    }
                    return Observable.from(singleLetter);
                })
                .take(5)//取出5个数据
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
A
A
B
B
B
onCompleted

takeFirst

        String[] array = new String[]{"aa", "bbb", "cccc", "dddd"};
        Observable.from(array)
                .map(String::toUpperCase)
                .takeFirst(s -> s.length()==4)
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
CCCC
onCompleted

takeLast

        Observable.from(array)
                .map(String::toUpperCase)
                .flatMap(s -> {
                    List singleLetter = new ArrayList();
                    for (int i = 0; i < s.length(); i++) {
                        singleLetter.add(String.valueOf(s.charAt(i)));
                    }
                    return Observable.from(singleLetter);
                })
                .takeLast(2) // 取出最后2个数据
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
C
C
onCompleted

take与takeLast以时间为限制取数据

public final Observable take(long time, TimeUnit unit) //只取time时间内发射的数据
public final Observable takeLast(long time, TimeUnit unit) //只取time时间结束前的数据

first

  • public final Observable first() {
        String[] array = new String[]{"aa", "bbb", "cccc", "dddd"};
        Observable.from(array)
                .map(String::toUpperCase)
                .first()
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
AA
onCompleted
  • public final Observable first(Func1 predicate) {
        String[] array = new String[]{"aa", "bbb", "cccc", "dddd"};
        Observable.from(array)
                .map(String::toUpperCase)
                .first(s -> s.length()==4)
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
CCCC
onCompleted
  • public final Observable firstOrDefault(T defaultValue) {
        String[] array = new String[]{};
        Observable.from(array)
                .map(String::toUpperCase)
                .firstOrDefault("null")
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
null
onCompleted
  • public final Observable firstOrDefault(T defaultValue, Func1 predicate) {
        String[] array = new String[]{"aa", "bbb", "cccc", "dddd"};
        Observable.from(array)
                .map(String::toUpperCase)
                .firstOrDefault("null", s -> s.equals("fuck"))
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
null
onCompleted

skip

        String[] array = new String[]{"aa", "bbb", "cccc", "dddd"};
        Observable.from(array)
                .map(String::toUpperCase)
                .skip(2)
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
CCCC
DDDD
onCompleted

skipLast

        String[] array = new String[]{"aa", "bbb", "cccc", "dddd"};
        Observable.from(array)
                .map(String::toUpperCase)
                .skipLast(2)
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
AA
BBB
onCompleted

skipWhile

        String[] array = new String[]{"aa", "bbb", "cccc", "dddd"};
        Observable.from(array)
                .map(String::toUpperCase)
                .skipWhile(s -> s.length()<4)
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果： 
CCCC
DDDD
onCompleted

distinct 去重

        String[] array = new String[]{"aa", "aa", "cccc", "dddd"};
        Observable.from(array)
                .map(String::toUpperCase)
                .distinct()
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
AA
CCCC
DDDD
onCompleted

elementAt

        String[] array = new String[]{"a", "bb", "ccc", "dddd"};
        Observable.from(array)
                .map(String::toUpperCase)
                .elementAt(2)
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
CCC
onCompleted

merge 合并数据源

        Observable justA = Observable.just("a1", "a2", "a3");
        Observable justB = Observable.just("b1", "b2", "b3");
        Observable.merge(justB,justA)
                .map(String::toUpperCase)
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
B1
B2
B3
A1
A2
A3
onCompleted

zip 合并数据

        Observable justA = Observable.just("a1", "a2", "a3");
        Observable justB = Observable.just("b1", "b2", "b3", "b4");
        Observable.zip(justA,justB,(s1, s2) -> s1+s2)
                .map(String::toUpperCase)
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
A1B1
A2B2
A3B3
onCompleted

startWith

        Observable justA = Observable.just("a1", "a2", "a3");
        Observable justB = Observable.just("b1", "b2", "b3", "b4");
        Observable.zip(justA,justB,(s1, s2) -> s1+s2)
                .map(String::toUpperCase)
                .startWith("fuck")
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        System.out.println("onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                    }
                    @Override
                    public void onNext(String s) {
                        System.out.println(s);
                    }
                });
结果：
fuck
A1B1
A2B2
A3B3
onCompleted

empty

创建一个不发射任何数据但是正常终止的Observable

        Observable.empty().subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println(e);
            }

            @Override
            public void onNext(Object o) {
                System.out.println(o);
            }
        });
结果：
onCompleted

简单分析一下原码：

public static  Observable empty() {
    return EmptyObservableHolder.instance();
}

public enum EmptyObservableHolder implements OnSubscribe {
    INSTANCE
    ;

    static final Observable EMPTY = Observable.unsafeCreate(INSTANCE);

    public static  Observable instance() {
        return (Observable)EMPTY;
    }

    @Override
    public void call(Subscriber child) {
        child.onCompleted();//只调用了onCompleted()方法
    }
}
 
 
 
  
never
 
 
 
 
        Observable.never().subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println(e);
            }

            @Override
            public void onNext(Object o) {
                System.out.println(o);
            }
        });
结果什么都没有
原码分析：
public static  Observable never() {
    return NeverObservableHolder.instance();
}

public enum NeverObservableHolder implements OnSubscribe {
    INSTANCE
    ;

    static final Observable NEVER = Observable.unsafeCreate(INSTANCE);

    @SuppressWarnings("unchecked")
    public static  Observable instance() {
        return (Observable)NEVER;
    }

    @Override
    public void call(Subscriber child) {
        // deliberately no op //什么也没做
    }
}

 
 
 
  
range
 
 
 
 
        Observable.range(10, 4).subscribe(System.out::println);
结果：
10
11
12
13

 
 
 
  
interval
 
 
 
 
        Observable.interval(1, TimeUnit.SECONDS, Schedulers.trampoline()).subscribe(System.out::println);
结果：从0开始每一秒按顺序输出
注意，这里需要设置Schedulers.trampoline(),在当前线程将任务插入队列中。

 
 
 
  
timer
 
 
 
 
        Observable.timer(3, TimeUnit.SECONDS, Schedulers.trampoline()).subscribe(System.out::println);
结果：三秒后输出0后结束


 
 
 
  
delay
 
 
 
 
        String[] arrays = new String[]{"1", "2", "3", "4"};
        Observable.from(arrays).delay(1, TimeUnit.SECONDS, Schedulers.trampoline()).subscribe(System.out::println);
结果：运行后，一秒后输出1， 每一少输出下一个，输出4再一秒后结束


 
 
 
  
contains
 
 
 
 
        String[] arrays = new String[]{"1", "2", "3", "4"};
        Observable.from(arrays).contains("1").subscribe(System.out::println);
结果：true

 
 
 
  
all
 
 
 
 
        Integer[] ints = new Integer[]{1, 2, 3, 4};
        Observable.from(ints).all(integer -> integer < 3).subscribe(System.out::println);
结果：false

 
 
 
  
isEmpty
 
 
 
 
        String[] arrays = new String[]{};
        Observable.from(arrays).isEmpty().subscribe(System.out::println);
结果：true

 
 
 
  
exists
 
 
 
 
        Integer[] ints = new Integer[]{1, 2, 3, 4};
        Observable.from(ints).exists(integer -> integer > 3).subscribe(System.out::println);
结果：true

 
 
 
  
count
 
 
 
 
        Integer[] ints = new Integer[]{1, 2, 3, 4, 1};
        Observable.from(ints).count().subscribe(System.out::println);
结果：5


 
 
 
  
reduce 与scan相似，不同的是直接输出结果。
 
 
 
 
        Integer[] ints = new Integer[]{1, 2, 3, 4};
        Observable.from(ints).reduce((integer, integer2) -> integer + integer2).subscribe(System.out::println);
        Observable.from(ints).reduce(10, (integer, integer2) -> integer + integer2).subscribe(System.out::println);
结果：
10
20

 
 
 
  
collect
 
 
 
 
与reduce相似, 但collect是用来将源Observable发射的数据给收集到一个数据结构里面
 
 
        Integer[] ints = new Integer[]{1, 2, 3, 4};
        Observable.from(ints)
//                .collect((Func0>) ArrayList::new, (list, integer) -> list.add(integer))
                .collect((Func0>) ArrayList::new, ArrayList::add)
                .subscribe(System.out::println);


 
 
 
  
buffer
 
 
 
 
 
  
 
   
 
    RxJava入门_第7张图片 
   
 
  
 
  

    Paste_Image.png 
  
 
 
 
 
        Observable.interval(1, TimeUnit.SECONDS, Schedulers.trampoline())
                .buffer(3)
                .subscribe(System.out::println);

结果：每三个放入缓存再输出
[0, 1, 2]
[3, 4, 5]
[6, 7, 8]
[9, 10, 11]
[12, 13, 14]
[15, 16, 17]
。。。

 
 
        Observable.interval(1, TimeUnit.SECONDS, Schedulers.trampoline())
                .buffer(3, 2) //（多少为一组， 生成新的buffer的间隔）
                .subscribe(System.out::println);
结果：
[0, 1, 2]
[2, 3, 4]
[4, 5, 6]
[6, 7, 8]
[8, 9, 10]
[10, 11, 12]
。。。

 
 
RxJava1.0 与RxJava2.0区别：
 
 
     
  
  1. Rxjava1.0资源库都在rx包下,而RxJava2.0都在io.reactivex包下
    2.  
 
 
 
import rx.Observable;
import rx.Subscriber;
---------------------
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.annotations.NonNull;


 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(RxJava入门)

        

            

                
    
                    
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖
                        陟彼高冈yu
基于Googleearthstudio的旅游规划和预览旅游
                        
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
    
                    
    • 
                    
  • linux中sdl的使用教程,sdl使用入门
                        Melissa Corvinus
linux中sdl的使用教程
                        
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • Python快速入门 —— 第三节：类与对象
                        孤华暗香
Python快速入门python开发语言
                        
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
    
                    
    • 
                    
  • C++菜鸟教程 - 从入门到精通 第二节
                        DreamByte
c++
                        
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
    
                    
    • 
                    
  • STM32中的计时与延时
                        lupinjia
STM32stm32单片机
                        
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
    
                    
    • 
                    
  • Python实现简单的机器学习算法
                        master_chenchengg
pythonpython办公效率python开发IT
                        
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
    
                    
    • 
                    
  • 2019考研 | 西交大软件工程
                        笔者阿蓉

                        
    本科背景：某北京211学校电子信息工程互联网开发工作两年录取结果：全日制软件工程学院分数：初试350+复试笔试80+面试85+总排名：100+从五月份开始脱产学习，我主要说一下专业课和复试还有我对非全的一些看法。【数学100+】张宇，张宇，张宇。跟着张宇学习，入门视频刷一遍，真题刷两遍，错题刷三遍。书刷N多遍。从视频开始学习，是最快的学习方法。5-7月份把主要是数学学好，8-9月份开始给自己每个周
    
                    
    • 
                    
  • esp32开发快速入门 8 : MQTT 的快速入门，基于esp32实现MQTT通信
                        z755924843
ESP32开发快速入门服务器网络运维
                        
    MQTT介绍简介MQTT（MessageQueuingTelemetryTransport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的"轻量级"通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联
    
                    
    • 
                    
  • Armv8.3 体系结构扩展--原文版
                        代码改变世界ctw
ARM-TEE-Androidarmv8嵌入式arm架构安全架构芯片TrustzoneSecureboot
                        
    快速链接:.ARMv8/ARMv9架构入门到精通-[目录]付费专栏-付费课程【购买须知】:个人博客笔记导读目录(全部)TheArmv8.3architectureextensionTheArmv8.3architectureextensionisanextensiontoArmv8.2.Itaddsmandatoryandoptionalarchitecturalfeatures.Somefeat
    
                    
    • 
                    
  • Python入门之Lesson2:Python基础语法
                        小熊同学哦
Python入门课程python开发语言算法数据结构青少年编程
                        
    目录前言一.介绍1.变量和数据类型2.常见运算符3.输入输出4.条件语句5.循环结构二.练习三.总结前言欢迎来到《Python入门》系列博客的第二课。在上一课中，我们了解了Python的安装及运行环境的配置。在这一课中，我们将深入学习Python的基础语法，这是编写Python代码的根基。通过本节内容的学习，你将掌握变量、数据类型、运算符、输入输出、条件语句等Python编程的基础知识。一.介绍1
    
                    
    • 
                    
  • 摄影小白，怎么才能拍出高大上产品图片？
                        是波妞唉

                        
    很多人以为文案只要会码字，会排版就OK了！说实话，没接触到这一行的时候，我的想法更简单，以为只要会写字就行！可是真做了文案才发现，码字只是入门级的基本功。一篇文章离不开排版、配图，说起来很简单！从头做到尾你就会发现，写文章用两个小时，找合适的配图居然要花掉半天的时间，甚至更久！图片能找到合适的就不怕，还有找不到的，比如产品图，只能亲自拍。拿着摆弄了半天，就是拍不出想要的效果，光线不好、搭出来丑破天
    
                    
    • 
                    
  • 2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题 （第三大题：完善程序 代码）
                        mmz1207
c++csp
                        
    最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
    
                    
    • 
                    
  • Vue( ElementUI入门、vue-cli安装)
                        m0_l5z
elementuivue.js
                        
    一.ElementUI入门目录：1.ElementUI入门1.1ElementUI简介1.2Vue+ElementUI安装1.3开发示例2.搭建nodejs环境2.1nodejs介绍2.2npm是什么2.3nodejs环境搭建2.3.1下载2.3.2解压2.3.3配置环境变量2.3.4配置npm全局模块路径和cache默认安装位置2.3.5修改npm镜像提高下载速度2.3.6验证安装结果3.运行n
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • 入门MySQL——查询语法练习
                        K_un

                        
    前言：前面几篇文章为大家介绍了DML以及DDL语句的使用方法，本篇文章将主要讲述常用的查询语法。其实MySQL官网给出了多个示例数据库供大家实用查询，下面我们以最常用的员工示例数据库为准，详细介绍各自常用的查询语法。1.员工示例数据库导入官方文档员工示例数据库介绍及下载链接：https://dev.mysql.com/doc/employee/en/employees-installation.h
    
                    
    • 
                    
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能
                        小康师兄
ESP32-C3入门教程https服务器esp32OTAMQTT
                        
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
    
                    
    • 
                    
  • 2023最详细的Python安装教程（Windows版本）
                        程序员林哥
Pythonpythonwindows开发语言
                        
    python安装是学习pyhon第一步，很多刚入门小白不清楚如何安装python，今天我来带大家完成python安装与配置，跟着我一步步来，很简单，你肯定能完成。第一部分：python安装（一）准备工作1、下载和安装python(认准官方网站)当然你不想去下载的话也可以分享给你，还有入门学习教程，点击下方卡片跳转进群领取（二）开始安装对于Windows操作系统，可以下载“executableins
    
                    
    • 
                    
  • 【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】
                        汉子萌萌哒
CCFnoi算法数据结构c++
                        
    一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
    
                    
    • 
                    
  • 现金贷“租系统”产业崛起：租金3000，本金10万，一月回本
                        Dayon

                        
    最近，地下现金贷的全面崛起，已成了不可阻挡的趋势。大量民间资本开始涌入，民间高利贷、炒房团、土豪的钱，都裹挟其中。而地下现金贷的入门门槛正在不断降低，一条新的产业链开始崛起：租现金贷系统。现在，只需要10万本金，花3000元租个系统，两个人的团队，一个月就能回本。大量的小本金玩家进场了，为了急速获利，他们甚至将利率调到1600%以上。业内人士称，真实的现金贷用户，现在大概只有200多万。整个行业几
    
                    
    • 
                    
  • 【树一线性代数】005入门
                        Owlet_woodBird
算法
                        
    Index本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376分析实现总结本文稍后补全，推荐阅读：https://blog.csdn.net/weixin_60702024/article/details/141874376已知非空二叉树T的结点值均为正整数，采用顺序存储方式保存，数据结构定义如下:t
    
                    
    • 
                    
  • 如何自学软件编程？零基础自学编程入门指南
                        _pangzi

                        
    前言零基础自学编程的动力是什么?在开启学习编程之路的时候必须搞清楚自己为什么要学编程?是因为工资高?还是对编程有浓厚的兴趣？还有自己有一定的编程基础想要继续提升自己？其实对于这个问题需要具体分析，如果是单纯看到程序员工资高，而自己本身并没有什么兴趣，那我不建议自学，可以选择参加培训或者不要进入编程领域不然自己学不会没有获得高薪，反而浪费了大把的时间，如果方法不对，反而会打击自信心。下面小编针对学习
    
                    
    • 
                    
  • Linux CTF逆向入门
                        蚁景网络安全
linux运维CTF
                        
    1.ELF格式我们先来看看ELF文件头，如果想详细了解，可以查看ELF的manpage文档。关于ELF更详细的说明：e_shoff：节头表的文件偏移量（字节）。如果文件没有节头表，则此成员值为零。sh_offset：表示了该section（节）离开文件头部位置的距离+-------------------+|ELFheader|---++--------->+-------------------
    
                    
    • 
                    
  • python简单好玩的编程代码,python有哪些好玩的代码
                        2301_81900439
pygamepython开发语言
                        
    大家好，小编来为大家解答以下问题，20行python代码的入门级小游戏，python有什么好玩的代码嘛，今天让我们一起来看看吧！哈喽铁子们表弟最近在学Python，总是跟我抱怨很枯燥无味，其实，他有没有认真想过，可能是自己学习姿势不对？比方说，可以通过打游戏来学编程！今天给大家分享100个Python小游戏，一定要收藏！1、简易飞机大战飞机大战相信大家都玩过吧，非常简单有意思的游戏，咱们通过Pyt
    
                    
    • 
                    
  • 思考成长
                        丁昆朋

                        
    这篇文章是加紧赶出来“应付”日更，一方面不想要再晚睡了；另一方面不想失去日更达人的称号，只能坐下来匆忙写下一点文字。既然标题是成长，先来总结一下这段时间的收获：1、整理箱子站着可以看电脑，坐着反而是一种享受，减少了坐着腰酸背痛的现象；2、使用讯飞输入法大大增加自己的输出量；3、Anaconda+“pythontutor.com"+Google算是简单入门python；4、英语的阅读文章能力、听力提
    
                    
    • 
                    
  • HarmonyOS开发实战（ Beta5.0）搜索框热搜词自动切换
                        让开，我要吃人了
OpenHarmonyHarmonyOS鸿蒙开发harmonyos华为鸿蒙移动开发鸿蒙系统前端开发语言
                        
    鸿蒙HarmonyOS开发往期必看：HarmonyOSNEXT应用开发性能实践总结最新版！“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线！（从零基础入门到精通）介绍本示例介绍使用TextInput组件与Swiper组件实现搜索框内热搜词自动切换。效果图预览使用说明页面顶部搜索框内热搜词条自动切换，编辑搜索框时自动隐藏。实现思路使用TextInput实现搜索框TextInput({te
    
                    
    • 
                    
  • mysql学习教程，从入门到精通，TOP 和MySQL LIMIT 子句（15）
                        知识分享小能手
大数据数据库MySQLmysql学习oracle数据库开发语言adb大数据
                        
    1、TOP和MySQLLIMIT子句内容在SQL中，不同的数据库系统对于限制查询结果的数量有不同的实现方式。TOP关键字主要用于SQLServer和Access数据库中，而LIMIT子句则主要用于MySQL、PostgreSQL（通过LIMIT/OFFSET语法）、SQLite等数据库中。下面将分别详细介绍这两个功能的语法、语句以及案例。1.1、TOP子句（SQLServer和Access）1.1
    
                    
    • 
                    
  • 【从问题中去学习k8s】k8s中的常见面试题（夯实理论基础）（二十八）
                        向往风的男子
k8s学习kubernetes容器
                        
    本站以分享各种运维经验和运维所需要的技能为主《python零基础入门》：python零基础入门学习《python运维脚本》：python运维脚本实践《shell》：shell学习《terraform》持续更新中：terraform_Aws学习零基础入门到最佳实战《k8》从问题中去学习k8s《docker学习》暂未更新《ceph学习》ceph日常问题解决分享《日志收集》ELK+各种中间件《运维日常》
    
                    
    • 
                    
  • Nginx从入门到实践(三)
                        听你讲故事啊

                        
    动静分离动静分离是将网站静态资源（JavaScript，CSS，img等文件）与后台应用分开部署，提高用户访问静态代码的速度，降低对后台应用访问。动静分离的一种做法是将静态资源部署在nginx上，后台项目部署到应用服务器上，根据一定规则静态资源的请求全部请求nginx服务器，达到动静分离的目标。rewrite规则Rewrite规则常见正则表达式Rewrite主要的功能就是实现URL的重写，Ngin
    
                    
    • 
                    
  • 【Python基础】Python迭代器与生成器（两种强大工具）
                        姑苏老陈
Python编程入门python开发语言python迭代器与生成器
                        
    本文收录于《Python编程入门》专栏，从零基础开始，分享一些Python编程基础知识，欢迎关注，谢谢！文章目录一、前言二、迭代器2.1创建迭代器2.2自定义迭代器2.3处理大型文件三、生成器四、生成器表达式五、实际应用案例5.1数据库查询5.2网络数据流处理六、总结一、前言在Python中，迭代器与生成器是两种非常强大的工具，它们可以帮助我们有效地处理大量数据，特别是在需要逐个访问元素的情况下。
    
                    
    • 
                                
  • C/C++Win32编程基础详解视频下载
                                    择善Zach
编程C++Win32
                                    
    课题视频：C/C++Win32编程基础详解 
视频知识：win32窗口的创建 
                  windows事件机制 
主讲：择善Uncle老师 
学习交流群：386620625 
验证码：625 
 
--
    
                                
    • 
                                
  • Guava Cache使用笔记
                                    bylijinnan
javaguavacache
                                    
    1.Guava Cache的get/getIfPresent方法当参数为null时会抛空指针异常 
 
我刚开始使用时还以为Guava Cache跟HashMap一样，get(null)返回null。 
实际上Guava整体设计思想就是拒绝null的，很多地方都会执行com.google.common.base.Preconditions.checkNotNull的检查。 
 
 
2.Guava
    
                                
    • 
                                
  • 解决ora-01652无法通过128（在temp表空间中）
                                    0624chenhong
oracle
                                    
    解决ora-01652无法通过128（在temp表空间中）扩展temp段的过程 
 
一个sql语句后，大约花了10分钟，好不容易有一个结果，但是报了一个ora-01652错误，查阅了oracle的错误代码说明：意思是指temp表空间无法自动扩展temp段。这种问题一般有两种原因：一是临时表空间空间太小，二是不能自动扩展。 
分析过程： 
   既然是temp表空间有问题，那当
    
                                
    • 
                                
  • Struct在jsp标签
                                    不懂事的小屁孩
struct
                                    
    非UI标签介绍： 
控制类标签： 
1：程序流程控制标签   if   elseif    else 
<s:if test="isUsed"> 
 <span class="label label-success">True</span> 
</
    
                                
    • 
                                
  • 按对象属性排序
                                    换个号韩国红果果
JavaScript对象排序
                                    
    利用JavaScript进行对象排序，根据用户的年龄排序展示 
 
<script>
var bob={
name;bob,
age:30
}
var peter={
name;peter,
age:30
}
var amy={
name;amy,
age:24
}
var mike={
name;mike,
age:29
}
var john={

    
                                
    • 
                                
  • 大数据分析让个性化的客户体验不再遥远
                                    蓝儿唯美
数据分析
                                    
    顾客通过多种渠道制造大量数据，企业则热衷于利用这些信息来实现更为个性化的体验。 
分析公司Gartner表示，高级分析会成为客户服务的关键，但是大数据分析的采用目前仅局限于不到一成的企业。 挑战在于企业还在努力适应结构化数据，疲于根据自身的客户关系管理（CRM）系统部署有效的分析框架，以及集成不同的内外部信息源。 
然而，面对顾客通过数字技术参与而产生的快速变化的信息，企业需要及时作出反应。要想实
    
                                
    • 
                                
  • java笔记4
                                    a-john
java
                                    
    操作符 
1，使用java操作符 
      操作符接受一个或多个参数，并生成一个新值。参数的形式与普通的方法调用不用，但是效果是相同的。加号和一元的正号（+）、减号和一元的负号（-）、乘号（*）、除号（/）以及赋值号（=）的用法与其他编程语言类似。 
      操作符作用于操作数，生成一个新值。另外，有些操作符可能会改变操作数自身的
    
                                
    • 
                                
  • 从裸机编程到嵌入式Linux编程思想的转变------分而治之：驱动和应用程序
                                    aijuans
嵌入式学习
                                    
        笔者学习嵌入式Linux也有一段时间了，很奇怪的是很多书讲驱动编程方面的知识，也有很多书将ARM9方面的知识，但是从以前51形式的（对寄存器直接操作，初始化芯片的功能模块）编程方法，和思维模式，变换为基于Linux操作系统编程，讲这个思想转变的书几乎没有，让初学者走了很多弯路，撞了很多难墙。 
    笔者因此写上自己的学习心得，希望能给和我一样转变
    
                                
    • 
                                
  • 在springmvc中解决FastJson循环引用的问题
                                    asialee
循环引用fastjson
                                    
              我们先来看一个例子： 
          
package com.elong.bms;

import java.io.OutputStream;
import java.util.HashMap;
import java.util.Map;

import co
    
                                
    • 
                                
  • ArrayAdapter和SimpleAdapter技术总结
                                    百合不是茶
androidSimpleAdapterArrayAdapter高级组件基础
                                    
    ArrayAdapter比较简单，但它只能用于显示文字。而SimpleAdapter则有很强的扩展性，可以自定义出各种效果 
  
ArrayAdapter;的数据可以是数组或者是队列 
  
     // 获得下拉框对象 
AutoCompleteTextView textview = (AutoCompleteTextView) this

    
                                
    • 
                                
  • 九封信
                                    bijian1013
人生励志
                                    
            有时候，莫名的心情不好，不想和任何人说话，只想一个人静静的发呆。有时候，想一个人躲起来脆弱，不愿别人看到自己的伤口。有时候，走过熟悉的街角，看到熟悉的背影，突然想起一个人的脸。有时候，发现自己一夜之间就长大了。         2014，写给人
    
                                
    • 
                                
  • Linux下安装MySQL Web 管理工具phpMyAdmin
                                    sunjing
PHPInstallphpMyAdmin
                                    
    PHP http://php.net/ 
phpMyAdmin http://www.phpmyadmin.net 
Error compiling PHP on CentOS x64 
  
一、安装Apache 
请参阅http://billben.iteye.com/admin/blogs/1985244 
  
二、安装依赖包 
sudo yum install gd 
    
                                
    • 
                                
  • 分布式系统理论
                                    bit1129
分布式
                                    
    FLP 
One famous theory in distributed computing, known as FLP after the authors Fischer, Lynch, and Patterson, proved that in a distributed system with asynchronous communication and process crashes, 
    
                                
    • 
                                
  • ssh2整合(spring+struts2+hibernate)-附源码
                                    白糖_
eclipsespringHibernatemysql项目管理
                                    
    最近抽空又整理了一套ssh2框架，主要使用的技术如下： 
spring做容器，管理了三层(dao,service,actioin)的对象 
struts2实现与页面交互(MVC)，自己做了一个异常拦截器，能拦截Action层抛出的异常 
hibernate与数据库交互 
BoneCp数据库连接池，据说比其它数据库连接池快20倍，仅仅是据说 
MySql数据库 
  
项目用eclipse
    
                                
    • 
                                
  • treetable bug记录
                                    braveCS
table
                                    
    // 插入子节点删除再插入时不能正常显示。修改：
//不知改后有没有错，先做个备忘
 Tree.prototype.removeNode = function(node) {
      // Recursively remove all descendants of +node+
      this.unloadBranch(node);

      // Remove
    
                                
    • 
                                
  • 编程之美-电话号码对应英语单词
                                    bylijinnan
java算法编程之美
                                    
    

import java.util.Arrays;

public class NumberToWord {

	/**
	 * 编程之美 电话号码对应英语单词
	 * 题目：
     *  手机上的拨号盘，每个数字都对应一些字母，比如2对应ABC，3对应DEF.........，8对应TUV，9对应WXYZ，
     *  要求对一段数字，输出其代表的所有可能的字母组合
    
                                
    • 
                                
  • jquery ajax读书笔记
                                    chengxuyuancsdn
jQuery ajax
                                    
    1、jsp页面 
 
<%@ page language="java" import="java.util.*" pageEncoding="GBK"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()
    
                                
    • 
                                
  • JWFD工作流拓扑结构解析伪码描述算法
                                    comsci
数据结构算法工作活动J#
                                    
      对工作流拓扑结构解析感兴趣的朋友可以下载附件，或者下载JWFD的全部代码进行分析 
 
 
  /*  流程图拓扑结构解析伪码描述算法 
 
        public java.util.ArrayList DFS(String graphid, String stepid, int j) 
    
                                
    • 
                                
  • oracle I/O 从属进程
                                    daizj
oracle
                                    
    I/O 从属进程 
 
　　I/O从属进程用于为不支持异步I/O的系统或设备模拟异步I/O.例如，磁带设备(相当慢)就不支持异步I/O.通过使用I/O 从属进程，可以让磁带机模仿通常只为磁盘驱动器提供的功能。就好像支持真正的异步I/O 一样，写设备的进程(调用者)会收集大量数据，并交由写入器写出。数据成功地写出时，写入器(此时写入器是I/O 从属进程，而不是操作系统)会通知原来的调用者，调用者则会
    
                                
    • 
                                
  • 高级排序:希尔排序
                                    dieslrae
希尔排序
                                    
    
    public void shellSort(int[] array){
        int limit = 1;
        int temp;
        int index;
        
        while(limit <= array.length/3){
            limit = limit * 3 + 1;
    
    
                                
    • 
                                
  • 初二下学期难记忆单词
                                    dcj3sjt126com
englishword
                                    
    kitchen 厨房 
cupboard 厨柜 
salt 盐 
sugar 糖 
oil 油 
fork 叉；餐叉 
spoon 匙；调羹 
chopsticks 筷子 
cabbage 卷心菜；洋白菜 
soup 汤 
Italian 意大利的 
  
Indian 印度的 
workplace  工作场所 
even 甚至；更 
Italy 意大利 
laugh 笑 
m
    
                                
    • 
                                
  • Go语言使用MySQL数据库进行增删改查
                                    dcj3sjt126com
mysql
                                    
    目前Internet上流行的网站构架方式是LAMP，其中的M即MySQL, 作为数据库，MySQL以免费、开源、使用方便为优势成为了很多Web开发的后端数据库存储引擎。MySQL驱动Go中支持MySQL的驱动目前比较多，有如下几种，有些是支持database/sql标准，而有些是采用了自己的实现接口,常用的有如下几种: 
 
  http://code.google.c...o-mysql-dri
    
                                
    • 
                                
  • git命令
                                    shuizhaosi888
git
                                    
    ---------------设置全局用户名：
git config --global user.name "HanShuliang" //设置用户名 
git config --global user.email "[email protected]" //设置邮箱

---------------查看环境配置
git config --li
    
                                
    • 
                                
  • qemu-kvm 网络 nat模式 (四)
                                    haoningabc
kvmqemu
                                    
    qemu-ifup-NAT 
 

#!/bin/bash
BRIDGE=virbr0
NETWORK=192.168.122.0
GATEWAY=192.168.122.1
NETMASK=255.255.255.0
DHCPRANGE=192.168.122.2,192.168.122.254
TFTPROOT=
BOOTP=
function check_bridge()

    
                                
    • 
                                
  • 不要让未来的你，讨厌现在的自己
                                    jingjing0907
生活 奋斗 工作 梦想
                                    
     故事one 
　23岁，他大学毕业，放弃了父母安排的稳定工作，独闯京城，在家小公司混个小职位，工作还算顺手，月薪三千，混了混，混走了一年的光阴。　　　　24岁，有了女朋友，从二环12人的集体宿舍搬到香山民居，一间平房，二人世界，爱爱爱。偶然约三朋四友，打扑克搓麻将，日子快乐似神仙；　　　　25岁，出了几次差，调了两次岗，薪水涨了不过百，生猛狂飙的物价让现实血淋淋，无力为心爱银儿购件大牌
    
                                
    • 
                                
  • 枚举类型详解
                                    一路欢笑一路走
enum枚举详解enumsetenumMap
                                    
    枚举类型详解 
一.Enum详解 
     1.1枚举类型的介绍 
  
JDK1.5加入了一个全新的类型的”类”—枚举类型，为此JDK1.5引入了一个新的关键字enum,我们可以这样定义一个枚举类型。 
  
   Demo:一个最简单的枚举类 
  
public enum ColorType {
   RED
    
                                
    • 
                                
  • 第11章 动画效果（上）
                                    onestopweb
动画
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • Eclipse中jsp、js文件编辑时，卡死现象解决汇总
                                    ljf_home
eclipsejsp卡死js卡死
                                    
    使用Eclipse编辑jsp、js文件时，经常出现卡死现象，在网上百度了N次，经过N次优化调整后，卡死现象逐步好转，具体那个方法起到作用，不太好讲。将所有用过的方法罗列如下： 
  
1、取消验证 
windows–>perferences–>validation 
把 除了manual 下面的全部点掉，build下只留 classpath dependency Valida
    
                                
    • 
                                
  • MySQL编程中的6个重要的实用技巧
                                    tomcat_oracle
mysql
                                    
    每一行命令都是用分号(;)作为结束 
对于MySQL，第一件你必须牢记的是它的每一行命令都是用分号(;)作为结束的，但当一行MySQL被插入在PHP代码中时，最好把后面的分号省略掉，例如： 
mysql_query("INSERT INTO tablename(first_name,last_name)VALUES('$first_name',$last_name')"); 

    
                                
    • 
                                
  • zoj 3820 Building Fire Stations(二分+bfs)
                                    阿尔萨斯
Build
                                    
     题目链接：zoj 3820 Building Fire Stations 
 题目大意：给定一棵树，选取两个建立加油站，问说所有点距离加油站距离的最大值的最小值是多少，并且任意输出一种建立加油站的方式。 
 解题思路：二分距离判断，判断函数的复杂度是o(n)，这样的复杂度应该是o(nlogn)，即使常数系数偏大，但是居然跑了4.5s，也是醉了。 判断函数里面做了3次bfs，但是每次bfs节点最多
    
                                
    •