小白要超神
小白要超神

RxJava操作符（二）

注：只包含标准包中的操作符，用于个人学习及备忘
参考博客：http://blog.csdn.net/maplejaw_/article/details/52396175

本篇将介绍rxjava中的错误处理/重试机制、连接操作、阻塞操作以及工具集的使用，只针对用法不涉及原理，对RxJava不熟悉的可参考：http://gank.io/post/560e15be2dca930e00da1083

错误处理 / 重试机制

  • onErrorResumeNext:当原始的Observable在遇到错误时，使用备用的Observable

      Observable.just(1, 2, "3")
          .cast(Integer.class)    //强制转换成Integer类型，强转String类型数据时异常
          .onErrorResumeNext(new Func1>() {
              @Override
              public Observable call(Throwable throwable) {
                  return Observable.just(4, 5, 6);
              }
          })
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString()); //打印1，2，4，5，6
              }
          });

  Observable.just(1, 2, "3")
          .cast(Integer.class)    //强制转换成Integer类型，强转String类型数据时异常
          .onErrorResumeNext(Observable.just(4, 5, 6))
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString()); //打印1，2，4，5，6
              }
          });

  • onExceptionResumeNext:当原始Observable在遇到异常时，使用备用的Observable。与onErrorResumeNext类似，区别在于onErrorResumeNext可以处理所有的错误，onExceptionResumeNext只能处理异常。

      Observable.just(1, 2, "3")
          .cast(Integer.class)    //强制转换成Integer类型，强转String类型数据时异常
          .onExceptionResumeNext(Observable.just(4, 5, 6))
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString()); //打印1，2，4，5，6
              }
          });

  • onErrorReturn:当原始Observable在遇到错误时发射一个指定的数据

      Observable.just(1, 2, "3", 4)
          .cast(Integer.class)
          .onErrorReturn(new Func1() {
              @Override
              public Integer call(Throwable throwable) {
                  return 5;
              }
          })
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString()); //打印1，2，5
              }
          });

  • retry:当原始的Observable在遇到错误时进行重试

      Observable.just(1, 2, "3", 4)
          .cast(Integer.class)
          .retry()    //默认无限重试次数
          .observeOn(Schedulers.newThread())
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString()); //打印1，2，1，2，1，2 ...
              }
          }, new Action1() {
              @Override
              public void call(Throwable throwable) {
                  Log.d("debug", "onError");
              }
          });

  Observable.just(1, 2, "3", 4)
          .cast(Integer.class)
          .retry(2)    //设置最多重试2次
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString()); //打印1，2，1，2，1，2，onError
              }
          }, new Action1() {
              @Override
              public void call(Throwable throwable) {
                  Log.d("debug", "onError");
              }
          });

  Observable.just(1, 2, "3", 4)
          .cast(Integer.class)
          .retry(new Func2() {
              @Override
              public Boolean call(Integer count, Throwable throwable) {
                  Log.d("debug", "count:" + count); //count表示是第几次判断是否重试
                  return count != 2;    //返回true表示重试，返回false表示终止
              }
          })    
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString()); //打印1，2，count:1，1，2，count:2，onError
              }
          }, new Action1() {
              @Override
              public void call(Throwable throwable) {
                  Log.d("debug", "onError");
              }
          });

  • retryWhen:当原始Observable在遇到错误，将错误传递给另一个Observable来决定是否要重新订阅这个Observable,如果发送的是onCompleted或者onError事件，将不会触发重订阅。相对的，如果它发送onNext事件，则触发重订阅（不管onNext实际上是什么事件），内部调用的是retry
    参考博客：http://www.cnblogs.com/resentment/p/5988241.html

      Observable.just(1, 2, "3", 4)
          .cast(Integer.class)
          //官方例子：第一次等待1秒重试，第二次等待2秒，第三次等待3秒，第四次停止重试
          .retryWhen(new Func1, Observable>() {
              @Override
              public Observable call(Observable observable) {
                  return observable.zipWith(Observable.range(1, 3), new Func2() {
                      @Override
                      public Integer call(Throwable throwable, Integer integer) {
                          return integer;
                      }
                  }).flatMap(new Func1>() {
                      @Override
                      public Observable call(Integer integer) {
                          return Observable.timer(integer,TimeUnit.SECONDS);
                      }
                  });
              }
          })
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString()); //打印1，2，1，2，1，2，1，2
              }
          }, new Action1() {
              @Override
              public void call(Throwable throwable) {
                  Log.d("debug", "onError");
              }
          });
  /**
   * 注:输入的Observable必须作为输出Observable的源，必须对Observable做出反应，然后基于它发送事件。
   */
  Observable.just(1, 2, "3", 4)
          .subscribeOn(Schedulers.newThread())
          .cast(Integer.class)
          .retryWhen(new Func1, Observable>() {    //相当于retry()，即无限重试
              @Override
              public Observable call(Observable observable) {
                  return observable;
              }
          })
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString());
              }
          }, new Action1() {
              @Override
              public void call(Throwable throwable) {
                  Log.d("debug", "onError");
              }
          });

  Observable.just(1, 2, "3", 4)
          .cast(Integer.class)
          //重试3次，每次间隔1秒
          .retryWhen(new Func1, Observable>() {    
              @Override
              public Observable call(Observable observable) {
                  return observable.zipWith(Observable.interval(1, TimeUnit.SECONDS).take(3), new Func2() {
                      @Override
                      public Long call(Throwable throwable, Long aLong) {
                          return aLong;
                      }
                  });
              }
          })
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString());  //打印1，2，1，2，1，2，1，2
              }
          }, new Action1() {
              @Override
              public void call(Throwable throwable) {
                  Log.d("debug", "onError");
              }
          });

连接操作

  • ConnectableObservable：可连接的Observable,一种特殊的Observable对象，不会在订阅时就开始发射数据，而是调用connect操作符时才开始发射数据，可以用来灵活控制发射数据的时机，需要注意的是，如果实在开始发射数据后再进行订阅，就只能接收到订阅以后发射的数据

  • ConnectableObservable.connect()：指示一个可连接的Observable开始发射数据,没有订阅时也可发射数据

  • Observable.publish()：将一个Observable转换为可连接的Observable

  • ConnectableObservable.refCount()：将一个可连接的Observable转换成普通的Obervable

      /**
   * ConnectableObservable，ConnectableObservable转换成的普通Observable,以及普通的Observable之间的比较
   */

  //第一种：ConnectableObservable
  new Thread(new Runnable() {
      @Override
      public void run() {
          ConnectableObservable co = Observable.interval(1, TimeUnit.SECONDS)
                  .take(3).publish();//转换成可连接的Observable

          co.subscribe(new Action1() {
              @Override
              public void call(Long aLong) {
                  Log.d("debug", aLong.toString()); //没有接收到数据
              }
          });

          co.connect();   //开始发射数据，第一个订阅者接收到数据，每秒打印一次，分别打印 0，1，2

          //延迟1.5秒后开始订阅
          SystemClock.sleep(1500);
          co.subscribe(new Action1() {
              @Override
              public void call(Long aLong) {
                  Log.d("debug", aLong + 3 + ""); //只能接收到订阅以后发射的数据，打印4，5
              }
          });

          //再延迟2.5秒后再次订阅，此时数据已经发送完毕
          SystemClock.sleep(2500);
          co.subscribe(new Action1() {
              @Override
              public void call(Long aLong) {
                  Log.d("debug", aLong + 6 + ""); //没有接收到数据
              }
          });
      }
  }).start();

  //第二种：ConnectableObservable转换成的普通Observable
  new Thread(new Runnable() {
      @Override
      public void run() {
          ConnectableObservable co = Observable.interval(1, TimeUnit.SECONDS)
                  .take(3).publish();//转换成可连接的Observable

          co.subscribe(new Action1() {
              @Override
              public void call(Long aLong) {
                  Log.d("debug", aLong.toString()); //没有接收到数据
              }
          });

          co.connect();   //开始发射数据，第一个订阅者接收到数据，每秒打印一次，分别打印 0，1，2

          //延迟1.5秒后开始订阅
          SystemClock.sleep(1500);
          co.refCount()   //转换成普通Observable
                  .subscribe(new Action1() {
                      @Override
                      public void call(Long aLong) {
                          Log.d("debug", aLong + 3 + ""); //只能接收到订阅以后发射的数据，打印4，5
                      }
                  });

          //再延迟2.5后再次订阅，此时数据已经发送完毕
          SystemClock.sleep(2500);
          co.refCount()   //转换成普通Observable
                  .subscribe(new Action1() {
                      @Override
                      public void call(Long aLong) {
                          Log.d("debug", aLong + 6 + ""); //Observable重新发送数据，打印6，7，8
                      }
                  });
      }
  }).start();

  //第三种：普通的Observable
  new Thread(new Runnable() {
      @Override
      public void run() {
          Observable ob = Observable.interval(1, TimeUnit.SECONDS).take(3);

          ob.subscribe(new Action1() {
              @Override
              public void call(Long aLong) {
                  Log.d("debug", aLong.toString()); //打印0，1，2
              }
          });

          //延迟1.5秒后开始订阅
          SystemClock.sleep(1500);
          ob.subscribe(new Action1() {
              @Override
              public void call(Long aLong) {
                  Log.d("debug", aLong + 3 + ""); //Observable重新发射数据，打印3，4，5
              }
          });

          //再延迟2.5后再次订阅，此时数据已经发送完毕
          SystemClock.sleep(2500);
          ob.subscribe(new Action1() {
              @Override
              public void call(Long aLong) {
                  Log.d("debug", aLong + 6 + ""); //Observable重新发射数据，打印6，7，8
              }
          });
      }
  }).start();

  • Observable.replay()：返回一个可连接的Observable，并且可以缓存其发射过的数据，这样即使有订阅者在其发射数据之后进行订阅也能收到其之前发射过的数据，使用时最好设置其缓存大小，避免占用太多内存
    参考博客：http://blog.csdn.net/lizubing1992/article/details/51321422

//创建缓存2个数据的可连接的Observable
private ConnectableObservable relayCountObserver() {
    return Observable.interval(1, TimeUnit.SECONDS)
            .observeOn(Schedulers.newThread())
            .take(6)
            .replay(2);
}

//创建缓存3秒前的数据的可连接的Observable
private ConnectableObservable relayTimeObserver() {
    return Observable.interval(1, TimeUnit.SECONDS)
            .observeOn(Schedulers.newThread())
            .take(6)
            .replay(3, TimeUnit.SECONDS);
}

//创建缓存3秒前的最后2个数据的可连接的Observable
private ConnectableObservable relayTimeAndCountObserver() {
    return Observable.interval(1, TimeUnit.SECONDS)
            .observeOn(Schedulers.newThread())
            .take(6)
            .replay(2, 3, TimeUnit.SECONDS);
}

//创建两个观察者对可连接的Obserable进行订阅，第一个观察者直接订阅，
// 第二个观察者在Observable发射4个数据后再进行订阅
private void subscribe(ConnectableObservable cb) {
    Action1 action2 = new Action1() {
        @Override
        public void call(Long aLong) {
            Log.d("debug", "action2:" + aLong);
        }
    };

    Action1 action1 = new Action1() {
        @Override
        public void call(Long aLong) {
            Log.d("debug", "action1:" + aLong);
            if (aLong == 3) {   //发射第4个数据时(即过了4秒)，action2开始订阅
                cb.subscribe(action2);
            }
        }
    };

    cb.subscribe(action1);
    cb.connect();
}

    //创建不同的可连接的Obserable进行订阅，并观察打印结果
    //订阅缓存两个数据的可连接的Observable
    subscribe(relayCountObserver());
    /**
     * action1:打印0，1，2，3，4，5
     * action2:打印2，3，4，5（action2订阅前已经发射了4个数据，即0，1，2，3，
     * 其中2，3被可连接的Observable缓存，因此可获取到）
     */

    //订阅缓存3秒的可连接的Observable
    subscribe(relayTimeObserver());
    /**
     * action1:打印0，1，2，3，4，5
     * action2:打印1，2，3，4，5（action2订阅前已经发射了4秒，可连接的Observable缓存了3秒内的数据，
     * 即1，2，3，因此可获取到
     */

    //订阅缓存3秒前最后2个数据的可连接的Observable
    subscribe(relayTimeAndCountObserver());
    /**
     * action1:打印0，1，2，3，4，5
     * action2:打印2，3，4，5（action2订阅前已经发射了4秒，3秒内发射的数据为1，2，3，最后2位数据被
     * Observable缓存，即2，3，因此可获取到
     */

阻塞操作

BlockingObservable：一个阻塞的Observable，普通的Observable可使用Observable.toBlocking( )方法或者BlockingObservable.from( )方法转换成BlockingObservable

  • forEach:对BlockingObservable发射的每一项数据调用一个方法，会阻塞直到Observable完成

      Observable.interval(500, TimeUnit.MILLISECONDS,Schedulers.newThread())
          .take(3)
          .toBlocking()
          .forEach(new Action1() {
              @Override
              public void call(Long aLong) {
                  Log.d("debug", aLong.toString() + " " + Thread.currentThread().getName());
              }
          });
  
  Log.d("debug", Thread.currentThread().getName());  //打印当前线程名
  
  /**
   * 日志输出：阻塞的Observable会在Observable完成前阻塞当前线程
   * 0 RxNewThreadScheduler-1
   * 1 RxNewThreadScheduler-1
   * 2 RxNewThreadScheduler-1
   * main
   */

*first / firstOrDefault / last / lastOrDefault：这几个操作符的用法与在普通的Observable中用法相同，用于阻塞操作时会直接返回发射的数据(使用first或last时，找不到指定元素会报异常)

    Integer first = just(1, 2, 3).toBlocking().first();
    Log.d("debug", first.toString());   //打印1

    Integer first1 = just(1, 2, 3).toBlocking().first(new Func1() {
        @Override
        public Boolean call(Integer integer) {
            return integer > 2;
        }
    });
    Log.d("debug", first1.toString());  //打印3

    Integer first3 = Observable.just(1, 2, 3).toBlocking().firstOrDefault(4, new Func1() {
        @Override
        public Boolean call(Integer integer) {
            return integer > 3;
        }
    });
            
    Log.d("debug", first3.toString());  //打印4

    //last与lastOrDefault也是一样，不重复了

  • single / singleOrDefault：如果Observable终止时只发射了一个值或者满足条件的值只有一个，返回那个值，否则抛出异常或者发射默认值

      Integer single1 = Observable.just(1).toBlocking().single();
  Log.d("debug", single1.toString());     //打印1

  Integer single2 = Observable.just(1, 2, 3).toBlocking().single();
  Log.d("debug", single2.toString());     //报异常，发射的数据不止1个

  Integer single3 = Observable.from(new ArrayList()).toBlocking().single();
  Log.d("debug", single3.toString());  //报异常，没有发射数据

  Integer single4 = Observable.just(1, 2, 3).toBlocking().single(new Func1() {
      @Override
      public Boolean call(Integer integer) {
          return integer > 2;
      }
  });
  Log.d("debug", single4.toString());  //打印3

  Integer single5 = Observable.just(1, 2, 3).toBlocking().single(new Func1() {
      @Override
      public Boolean call(Integer integer) {
          return integer > 1;
      }
  });
  Log.d("debug", single5.toString());  //报异常，此时满足条件的有2,3

  Integer singleOrDefault1 = Observable.just(1, 2, 3).toBlocking().singleOrDefault(5);
  Log.d("debug", singleOrDefault1.toString()); //报异常，发射多个数据时报异常

  Integer singleOrDefault2 = Observable.from(new ArrayList()).toBlocking().singleOrDefault(5);
  Log.d("debug", singleOrDefault2.toString());  //打印5，没有发射数据时发射默认值

  • mostRecent:返回一个Iterable，Iterable返回的值总为Observable最后发射的数据，Observable未发射数据前总返回一个指定的默认值，Observable结束后不再返回

      new Thread(new Runnable() {
      @Override
      public void run() {
          BlockingObservable blockingObservable = Observable.create(new Observable.OnSubscribe() {
              @Override
              public void call(Subscriber subscriber) {
                  SystemClock.sleep(1000);
                  subscriber.onNext(1);
                  SystemClock.sleep(1000);
                  subscriber.onNext(2);
                  SystemClock.sleep(1000);
                  subscriber.onNext(3);
                  SystemClock.sleep(1000);
                  subscriber.onCompleted();
              }
          }).subscribeOn(Schedulers.newThread()).toBlocking();
          Iterable integers = blockingObservable.mostRecent(4);
          for (Integer integer : integers) {
              Log.d("debug", integer.toString());
              SystemClock.sleep(500);     //打印4，4，1，1，2，2，3，3
          }
      }
  }).start();

  • next:返回一个Iterable，每当Iterable准备返回一个值时，都会阻塞直到Observable发射下一个数据，然后返回这个值

      new Thread(new Runnable() {
      @Override
      public void run() {
          BlockingObservable blockingObservable = Observable.create(new Observable.OnSubscribe() {
              @Override
              public void call(Subscriber subscriber) {
                  SystemClock.sleep(1000);
                  subscriber.onNext(1);
                  SystemClock.sleep(1000);
                  subscriber.onNext(2);
                  SystemClock.sleep(1000);
                  subscriber.onNext(3);
                  SystemClock.sleep(1000);
                  subscriber.onCompleted();
              }
          }).subscribeOn(Schedulers.newThread()).toBlocking();
          Iterable integers = blockingObservable.next();
          Iterator iterator = integers.iterator();

          long startTime = System.currentTimeMillis();  //开始时间

          Integer next1 = iterator.next();    //阻塞了1秒
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next1);   //打印1003:1

          Integer next2 = iterator.next();
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next2);   //打印2004:2

          Integer next3 = iterator.next();
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next3);   //打印3004:3
      }
  }).start();

  • latest:返回一个Iterable，与next()操作符类似，但是它不会阻塞等待下一个值，而是立即返回最近发射的数据项，只在Observable未发出时阻塞

      new Thread(new Runnable() {
      @Override
      public void run() {
          Iterable latest = Observable.create(new Observable.OnSubscribe() {
              @Override
              public void call(Subscriber subscriber) {
                  SystemClock.sleep(1000);
                  subscriber.onNext(1);
                  SystemClock.sleep(1000);
                  subscriber.onNext(2);
                  SystemClock.sleep(1000);
                  subscriber.onNext(3);
                  SystemClock.sleep(1000);
                  subscriber.onCompleted();
              }
          }).subscribeOn(Schedulers.newThread()).toBlocking().latest();

          Iterator iterator = latest.iterator();
          long startTime = System.currentTimeMillis();

          Integer next1 = iterator.next();    //阻塞了1秒
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next1);   //打印1003:1

          Integer next2 = iterator.next();
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next2);   //打印2004:2

          Integer next3 = iterator.next();
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next3);   //打印3004:3
      }
  }).start();

  • toIterable:将一个发射数据序列的Observable转换为一个Iterable，通过这个Iterable可获取到Observable发射的所有数据，每当Iterable准备返回一个值时，如果Observable未发射该项数据，则阻塞直到Observable发射并返回该值，如果Observable已发射该项数据，则直接返回(与next, latest之间的差异见下面代码)

      BlockingObservable blockingObservable = Observable.create(new Observable.OnSubscribe() {
      @Override
      public void call(Subscriber subscriber) {
          SystemClock.sleep(1000);
          subscriber.onNext(1);
          SystemClock.sleep(1000);
          subscriber.onNext(2);
          SystemClock.sleep(1000);
          subscriber.onNext(3);
          SystemClock.sleep(1000);
          subscriber.onCompleted();
      }
  }).subscribeOn(Schedulers.newThread()).toBlocking();

  new Thread(new Runnable() {
      @Override
      public void run() {
          Iterable iterable  = blockingObservable.toIterable();

          Iterator iterator = iterable.iterator();
          long startTime = System.currentTimeMillis();

          Integer next1 = iterator.next();    //阻塞了1秒
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next1);   //打印1003:1

          SystemClock.sleep(3000);    //等待3秒，此时Observable的数据已经全部发射完成

          Integer next2 = iterator.next();    //直接返回
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next2);   //打印4002:2

          Integer next3 = iterator.next();    //直接返回
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next3);   //打印4004:3
      }
  }).start();

  new Thread(new Runnable() {
      @Override
      public void run() {
          Iterable integers = blockingObservable.next();
          Iterator iterator = integers.iterator();

          long startTime = System.currentTimeMillis();  //开始时间

          Integer next1 = iterator.next();    //阻塞了1秒
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next1);   //打印1003:1

          SystemClock.sleep(1500);    //阻塞1.2秒，此时数据2发射完成，数据3未发射

          Integer next2 = iterator.next();
          //（next返回的是Observable最近发射数据的下一个数据，下个数据发射完成前进行阻塞）
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next2);   //打印3004:3
      }
  }).start();

  new Thread(new Runnable() {
      @Override
      public void run() {
          Iterable integers = blockingObservable.latest();
          Iterator iterator = integers.iterator();

          long startTime = System.currentTimeMillis();  //开始时间

          Integer next1 = iterator.next();    //阻塞了1秒
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next1);   //打印1001:1

          SystemClock.sleep(2500);    //阻塞2.5秒，此时数据2和3发射完成

          Integer next2 = iterator.next();
          //（latest返回的是Observable最近发射的数据，数据未发射时进行阻塞）
          Log.d("debug", System.currentTimeMillis() - startTime + ":" + next2);   //打印3501:3
      }
  }).start();

  • getIterator:与toIterable类似，返回的是一个Iterator，不重复了

  • toFuture:将Observable转换为一个返回单个数据项的Future,如果原始Observable发射多个数据项，Future会收到一个IllegalArgumentException；如果原始Observable没有发射任何数据，Future会收到一个NoSuchElementException

      Future future = Observable.just(1).toBlocking().toFuture();
  try {
      Integer integer = future.get();
      Log.d("debug", integer.toString()); //打印1
  } catch (Exception e) {
      e.printStackTrace();
  }

工具集

  • materialize： 将Observable转换成一个通知列表

      Observable.just(1,2,3)
          .materialize()
          .subscribe(new Action1>() {
              @Override
              public void call(Notification integerNotification) {
                  Log.d("debug", integerNotification.getKind() + " " + integerNotification.getValue());
                  /**
                   * 打印
                   * OnNext 1
                   * OnNext 2
                   * OnNext 3
                   * OnCompleted null
                   */
              }
          });

  • dematerialize:与materialize作用相反，将通知逆转成一个Observable

      Observable.just(1, 2, 3)
          .materialize()      //转换成通知列表
          .dematerialize()    //逆转回Observable
          .subscribe(new Action1() {
              @Override
              public void call(Object o) {
                  Log.d("debug", o.toString());   //打印1，2，3
              }
          });
 

  •  
    timestamp:给Observable发射的每个数据项添加一个时间戳
     
      Observable.just(1, 2, 3)
          .timestamp()
          .subscribe(new Action1>() {
              @Override
              public void call(Timestamped integerTimestamped) {
                  Log.d("debug", integerTimestamped.getTimestampMillis() + " " + integerTimestamped.getValue());
                  /**
                   * 打印
                   * 1506740662707 1
                   * 1506740662707 2
                   * 1506740662708 3
                   */
              }
          });

     
    • 

  • serialize:强制Observable按次序发射数据并且要求功能是完好的
    • 

  •  
    cache:缓存Observable发射的数据序列并发射相同的数据序列给后续的订阅者
     
      new Thread(new Runnable() {
      @Override
      public void run() {
          Observable cache = Observable.interval(500, TimeUnit.MILLISECONDS)
                  .take(4)
                  .cache();

          cache.subscribe(new Action1() {
              @Override
              public void call(Long aLong) {
                  Log.d("debug", aLong.toString());   //打印0，1，2，3
              }
          });

          SystemClock.sleep(1200);
          cache.subscribe(new Action1() {
              @Override
              public void call(Long aLong) {
                  Log.d("debug", aLong.toString());   //打印0，1，2，3
              }
          });
      }
  }).start();

     
    • 

  • observeOn：指定观察者观察Observable的调度器
    • 

  • subscribeOn：指定Observable执行任务的调度器
    • 

  •  
    doOnEach：注册一个动作，对Observable发射的每个数据项使用
     
      Observable.just(1, 2, 3)
          .doOnEach(new Observer() {
              @Override
              public void onCompleted() {
                  Log.d("debug", "doOnEach: onCompleted");
              }

              @Override
              public void onError(Throwable e) {
                  Log.d("debug", "doOnEach: onError");
              }

              @Override
              public void onNext(Integer integer) {
                  Log.d("debug", "doOnEach: onNext " + integer);
              }
          })
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString());
              }
          });
  /**
   * 打印
   * doOnEach: onNext 1
   * 1
   * doOnEach: onNext 2
   * 2
   * doOnEach: onNext 3
   * 3
   * doOnEach: onCompleted
   */

  Observable.just(1, 2, 3)
          .doOnEach(new Action1>() {
              @Override
              public void call(Notification notification) {
                  Log.d("debug", "doOnEach: " + notification.getKind() + " " + notification.getValue());
              }
          })
          .subscribe(new Action1() {
              @Override
              public void call(Integer integer) {
                  Log.d("debug", integer.toString());
              }
          });
  /**
   * 打印
   * doOnEach: onNext 1
   * 1
   * doOnEach: onNext 2
   * 2
   * doOnEach: onNext 3
   * 3
   * doOnEach: onCompleted null
   */

     
    • 

  • doOnCompleted：注册一个动作，对正常完成的Observable使用（即在OnCompleted）
    • 

  • doOnError：注册一个动作，对发生错误的Observable使用（即在OnError）
    • 

  • doOnTerminate：注册一个动作，对完成的Observable使用，无论是否发生错误
    • 

  • doOnSubscribe：注册一个动作，在观察者订阅时使用（可通过subscribeOn指定发生的线程）
    • 

  • doOnUnsubscribe： 注册一个动作，在观察者取消订阅时使用
    • 

  • finallyDo / doAfterTerminate： 注册一个动作，在Observable完成时使用
    • 

  • delay：延时发射Observable的结果。即让原始Observable在发射每项数据之前都暂停一段指定的时间段。效果是Observable发射的数据项在时间上向前整体平移了一个增量（除了onError，它会即时通知）
    • 

  • delaySubscription：延时处理订阅请求
    • 

  •  
    using：创建一个只在Observable生命周期存在的资源，当Observable终止时这个资源会被自动释放
     
      Observable.using(new Func0() {//资源工厂
      @Override
      public File call() {  //创建资源

          File file = new File(getCacheDir(), "a.txt");
          if (!file.exists()) {
              try {
                  Log.d("debug", "--create--");
                  file.createNewFile();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
          return file;
      }
  }, new Func1>() { //返回生成的Observable
      @Override
      public Observable call(File file) {
          return Observable.just(file.exists() ? "exist" : "no exist");
      }
  }, new Action1() {//释放资源动作
      @Override
      public void call(File file) {
          if (file != null && file.exists()) {
              Log.d("debug", "--delete--");
              file.delete();
          }
      }
  })
          .subscribe(new Action1() {
              @Override
              public void call(String s) {
                  Log.d("debug", s);
              }
          });

  /**
   * 打印
   * --create--
   * exist
   * --delete--
   */

     
    • 

  • single / singleOrDefault：强制返回单个数据，与阻塞操作中的single基本相同，Observable发射多个数据时抛出异常，没有发射数据时，single抛出异常，singleOrDefault则返回默认数据
    • 


    最后
    

    

    Rxjava标准库的操作符已经介绍完毕
    

    






    



    


    


    




    

    你可能感兴趣的:(RxJava操作符（二）)
    

    

    

      

    • 情绪觉察日记第37天
露露_e800

      今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
      

      • 

    • 一百九十四章. 自相矛盾
巨木擎天

      唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
      

      • 

    • 10月|愿你的青春不负梦想-读书笔记-01
Tracy的小书斋

      本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
      

      • 

    • 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<

      • 

    • 谢谢你们，爱你们！
鹿游儿

      昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
      

      • 

    • c++ 的iostream 和 c++的stdio的区别和联系
黄卷青灯77
c++算法开发语言iostreamstdio

      在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
      

      • 

    • 爬山后遗症
璃绛

      爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
      

      • 

    • 《策划经理回忆录之二》
路基雅虎

      话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
      

      • 

    • 《大清方方案》| 第二话
谁佐清欢

      和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
      

      • 

    • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言

      提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
      

      • 

    • 本周第二次约练
2cfbdfe28a51

      中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
      

      • 

    • 2022-07-08
保利学府里李楚怡1307022

      ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
      

      • 

    • 直抒《紫罗兰永恒花园外传》
雷姆的黑色童话

      没看过《紫罗兰永恒花园》的我莫名的看完了《紫罗兰永恒花园外传》，又莫名的被故事中的姐妹之情狠狠地感动了的一把。感动何在：困苦中相依为命的姐妹二人被迫分离，用一个人的自由换取另一个人的幸福。之后，虽相隔不知几许依旧心心念念彼此牵挂。这种深深的姐妹情谊就是令我为之动容的所在。贝拉和泰勒分别影片开始，海天之间一个孩童凭栏眺望，手中拿着折旧的信纸。镜头一转，挑灯伏案的薇尔莉特正在打字机前奋笔疾书。这些片段
      

      • 

    • 基于社交网络算法优化的二维最大熵图像分割
智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言

      智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
      

      • 

    • 如果做到轻松在股市赚钱？只要坚持这三个原则。
履霜之人

      大A股里向来就有七亏二平一赚的说法，能赚钱的都是少数人。否则股市就成了慈善机构，人人都有钱赚，谁还要上班？所以说亏钱是正常的，或者说是应该的。那么那些赚钱的人又是如何做到的呢？普通人能不能找到捷径去分一杯羹呢？方法是有的，但要做到需要你有极高的自律。第一，控制仓位，散户最大的问题是追涨杀跌，只要涨起来，就把钱往股票上砸，然后被套，隔天跌的受不了，又一刀切，全部割肉。来来回回间，遍体鳞伤。所以散户首
      

      • 

    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业

      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
      

      • 

    • 特殊的拜年
飘雪的天堂

      文/雪儿大年初一，家家户户没有了轰响的鞭炮声，大街上没有了人流涌动的喧闹，几乎看不到人影，变得冷冷清清。天刚亮不大会儿，村里的大喇叭响了起来：由于当前正值疾病高发期，流感流行的高峰期。同时，新型冠状病毒感染的肺炎进入第二波流行的上升期。为了自己和他人的健康安全着想，请大家尽量不要串门拜年，不要在街里走动。可以通过手机微信，视频，电话，信息拜年……今年的春节真是特别。禁止燃放鞭炮，烟花爆竹，禁止出村
      

      • 

    • 398顺境，逆境
戴骁勇

      2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
      

      • 

    • python是什么意思中文-在python中%是什么意思
编程大乐趣

      Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
      

      • 

    • 想明白这个问题，你才能写下去
文自拾

      春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
      

      • 

    • 【JS】执行时长(100分) |思路参考+代码解析（C++）
l939035548
JS算法数据结构c++

      题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
      

      • 

    • 人工智能时代，程序员如何保持核心竞争力？
jmoych
人工智能

      随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
      

      • 

    • 其二
十八尾喵

      你知道吗？图片发自App我今天知道了你有喜欢的人，不是我。心空空的，整个人都不是我的了。可，怎么办？还是要好好的活着，毕竟你喜欢的人，我不能杀，可是我可以杀其他喜欢你的人呀！也罢，此生无缘，来世再见。鱼干
      

      • 

    • libyuv之linux编译
jaronho
Linuxlinux运维服务器

      文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
      

      • 

    • webpack图片等资源的处理
dmengmeng

      需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
      

      • 

    • ARM中断处理过程
落汤老狗
嵌入式linux

      一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
      

      • 

    • 如何成为段子手
欣雅阅读

      我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
      

      • 

    • Python爬虫解析工具之xpath使用详解
eqa11
python爬虫开发语言

      文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
      

      • 

    • 主题升华随机抽总结
木棉咕噜

      昨天晚上在火山灿教练那里抽了主题升华最后一关。一共抽了两个故事，现总结如下。第一个故事是《并不是你想象的那样》。主题一：有时候，面对别人一些貌似不合常情的行为，不要轻易的指责他，也许背后有我们所不知道的原因。在这一个主题里面，刚开始的时候，我没有加上貌似二字。所以就没有改动之后这么精准。主题二：有时候我们对他人善意的行为，可能会给我们带来一些意外的回报。主题三：面对同样一件事，因为不同的人看待问题
      

      • 

    • C++菜鸟教程 - 从入门到精通 第二节
DreamByte
c++

      一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
      

      • 

    • 多线程编程之理财
周凡杨
java多线程生产者消费者理财

            现实生活中，我们一边工作，一边消费，正常情况下会把多余的钱存起来，比如存到余额宝，还可以多挣点钱，现在就有这个情况：我每月可以发工资20000万元 （暂定每月的1号），每月消费5000（租房+生活费）元（暂定每月的1号），其中租金是大头占90%，交房租的方式可以选择（一月一交，两月一交、三月一交），理财：1万元存余额宝一天可以赚1元钱，
      

      • 

    • [Zookeeper学习笔记之三]Zookeeper会话超时机制
bit1129
zookeeper

      首先，会话超时是由Zookeeper服务端通知客户端会话已经超时，客户端不能自行决定会话已经超时，不过客户端可以通过调用Zookeeper.close()主动的发起会话结束请求，如下的代码输出内容
Created /zoo-739160015
CONNECTEDCONNECTED
.............CONNECTEDCONNECTED
CONNECTEDCLOSEDCLOSED

      

      • 

    • SecureCRT快捷键
daizj
secureCRT快捷键

      ctrl + a : 移动光标到行首ctrl + e ：移动光标到行尾crtl + b: 光标前移1个字符crtl + f: 光标后移1个字符crtl + h : 删除光标之前的一个字符ctrl + d ：删除光标之后的一个字符crtl + k ：删除光标到行尾所有字符crtl + u : 删除光标至行首所有字符crtl + w:  删除光标至行首
      

      • 

    • Java 子类与父类这间的转换
周凡杨
java 父类与子类的转换

          最近同事调的一个服务报错，查看后是日期之间转换出的问题。代码里是把 java.sql.Date 类型的对象 强制转换为 java.sql.Timestamp 类型的对象。报java.lang.ClassCastException。
 
    代码：
            
      

      • 

    • 可视化swing界面编辑
朱辉辉33
eclipseswing

            今天发现了一个WindowBuilder插件，功能好强大，啊哈哈，从此告别手动编辑swing界面代码，直接像VB那样编辑界面，代码会自动生成。
      首先在Eclipse中点击help，选择Install New Software,然后在Work with中输入WindowBui
      

      • 

    • web报表工具FineReport常用函数的用法总结（文本函数）
老A不折腾
finereportweb报表工具报表软件java报表

      文本函数
CHAR
CHAR(number):根据指定数字返回对应的字符。CHAR函数可将计算机其他类型的数字代码转换为字符。
Number:用于指定字符的数字，介于1Number:用于指定字符的数字，介于165535之间（包括1和65535）。
示例:
CHAR(88)等于“X”。
CHAR(45)等于“-”。
 
CODE
CODE(text):计算文本串中第一个字
      

      • 

    • mysql安装出错
林鹤霄
mysql安装

      [root@localhost ~]# rpm -ivh MySQL-server-5.5.24-1.linux2.6.x86_64.rpm Preparing...                #####################
      

      • 

    • linux下编译libuv
aigo
libuv

      下载最新版本的libuv源码，解压后执行：
./autogen.sh
 
这时会提醒找不到automake命令，通过一下命令执行安装（redhat系用yum，Debian系用apt-get）：
# yum -y install automake
# yum -y install libtool
 
 
如果提示错误：make: *** No targe
      

      • 

    • 中国行政区数据及三级联动菜单
alxw4616

      近期做项目需要三级联动菜单,上网查了半天竟然没有发现一个能直接用的!
呵呵,都要自己填数据....我了个去这东西麻烦就麻烦的数据上.
哎,自己没办法动手写吧.
现将这些数据共享出了,以方便大家.嗯,代码也可以直接使用
  文件说明
lib\area.sql -- 县及县以上行政区划分代码（截止2013年8月31日)来源：国家统计局 发布时间：2014-01-17 15:0
      

      • 

    • 哈夫曼加密文件
百合不是茶
哈夫曼压缩哈夫曼加密二叉树

       在上一篇介绍过哈夫曼编码的基础知识,下面就直接介绍使用哈夫曼编码怎么来做文件加密或者压缩与解压的软件,对于新手来是有点难度的,主要还是要理清楚步骤;
 
加密步骤:
 1,统计文件中字节出现的次数,作为权值
 
2,创建节点和哈夫曼树
 
3,得到每个子节点01串
 
4,使用哈夫曼编码表示每个字节
 

      

      • 

    • JDK1.5 Cyclicbarrier实例
bijian1013
javathreadjava多线程Cyclicbarrier

      CyclicBarrier类
一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。
CyclicBarrier支持一个可选的 Runnable 命令，
      

      • 

    • 九项重要的职业规划
bijian1013
工作学习

      一. 学习的步伐不停止        古人说，活到老，学到老。终身学习应该是您的座右铭。        世界在不断变化，每个人都在寻找各自的事业途径。        您只有保证了足够的技能储
      

      • 

    • 【Java范型四】范型方法
bit1129
java

      范型参数不仅仅可以用于类型的声明上，例如
 
package com.tom.lang.generics;
import java.util.List;
public class Generics<T> {
private T value;
public Generics(T value) {
this.value = 
      

      • 

    • 【Hadoop十三】HDFS Java API基本操作
bit1129
hadoop

       
package com.examples.hadoop;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoo
      

      • 

    • ua实现split字符串分隔
ronin47
lua split

      LUA并不象其它许多"大而全"的语言那样，包括很多功能，比如网络通讯、图形界面等。但是LUA可以很容易地被扩展：由宿主语言(通常是C或 C++)提供这些功能，LUA可以使用它们，就像是本来就内置的功能一样。LUA只包括一个精简的核心和最基本的库。这使得LUA体积小、启动速度快，从 而适合嵌入在别的程序里。因此在lua中并没有其他语言那样多的系统函数。习惯了其他语言的字符串分割函
      

      • 

    • java-从先序遍历和中序遍历重建二叉树
bylijinnan
java

      
public class BuildTreePreOrderInOrder {
/**
* Build Binary Tree from PreOrder and InOrder
* _______7______
/ \
__10__ ___2
/ \ /
4
      

      • 

    • openfire开发指南《连接和登陆》
开窍的石头
openfire开发指南smack

      第一步
    官网下载smack.jar包
    下载地址：http://www.igniterealtime.org/downloads/index.jsp#smack
第二步
    把smack里边的jar导入你新建的java项目中
开始编写smack连接openfire代码
p
      

      • 

    • [移动通讯]手机后盖应该按需要能够随时开启
comsci
移动

          看到新的手机，很多由金属材质做的外壳，内存和闪存容量越来越大，CPU速度越来越快，对于这些改进，我们非常高兴，也非常欢迎
     但是，对于手机的新设计，有几点我们也要注意
     第一：手机的后盖应该能够被用户自行取下来，手机的电池的可更换性应该是必须保留的设计,
      

      • 

    • 20款国外知名的php开源cms系统
cuiyadll
cms

      内容管理系统，简称CMS，是一种简易的发布和管理新闻的程序。用户可以在后端管理系统中发布，编辑和删除文章，即使您不需要懂得HTML和其他脚本语言，这就是CMS的优点。
在这里我决定介绍20款目前国外市面上最流行的开源的PHP内容管理系统，以便没有PHP知识的读者也可以通过国外内容管理系统建立自己的网站。
1. Wordpress
WordPress的是一个功能强大且易于使用的内容管
      

      • 

    • Java生成全局唯一标识符
darrenzhu
javauuiduniqueidentifierid

      How to generate a globally unique identifier in Java
http://stackoverflow.com/questions/21536572/generate-unique-id-in-java-to-label-groups-of-related-entries-in-a-log
http://stackoverflow
      

      • 

    • php安装模块检测是否已安装过, 使用的SQL语句
dcj3sjt126com
sql

      
SHOW [FULL] TABLES [FROM db_name] [LIKE 'pattern']
SHOW TABLES列举了给定数据库中的非TEMPORARY表。您也可以使用mysqlshow db_name命令得到此清单。
本命令也列举数据库中的其它视图。支持FULL修改符，这样SHOW FULL TABLES就可以显示第二个输出列。对于一个表，第二列的值为BASE T
      

      • 

    • 5天学会一种 web 开发框架
dcj3sjt126com
Web框架framework

      web framework层出不穷，特别是ruby/python,各有10+个,php/java也是一大堆 根据我自己的经验写了一个to do list,按照这个清单，一条一条的学习，事半功倍，很快就能掌握 一共25条，即便很磨蹭，2小时也能搞定一条，25*2=50。只需要50小时就能掌握任意一种web框架
各类web框架大同小异:现代web开发框架的6大元素，把握主线，就不会迷路
建议把本文
      

      • 

    • Gson使用三(Map集合的处理,一对多处理)
eksliang
jsongsonGson mapGson 集合处理

      转载请出自出处：http://eksliang.iteye.com/blog/2175532 一、概述
       Map保存的是键值对的形式，Json的格式也是键值对的，所以正常情况下，map跟json之间的转换应当是理所当然的事情。 二、Map参考实例
package com.ickes.json;
import java.lang.refl
      

      • 

    • cordova实现“再点击一次退出”效果
gundumw100
android

      基本的写法如下：
document.addEventListener("deviceready", onDeviceReady, false);
function onDeviceReady() {
//navigator.splashscreen.hide();
document.addEventListener("b
      

      • 

    • openldap configuration leaning note
iwindyforest
configuration

      hostname // to display the computer name
hostname <changed name> // to change
go to: /etc/sysconfig/network, add/modify HOSTNAME=NEWNAME to change permenately
dont forget to change /etc/hosts
      

      • 

    • Nullability and Objective-C
啸笑天
Objective-C

      https://developer.apple.com/swift/blog/?id=25
 
http://www.cocoachina.com/ios/20150601/11989.html
 
http://blog.csdn.net/zhangao0086/article/details/44409913
 
http://blog.sunnyxx
      

      • 

    • jsp中实现参数隐藏的两种方法
macroli
JavaScriptjsp

      在一个JSP页面有一个链接，//确定是一个链接?点击弹出一个页面，需要传给这个页面一些参数。//正常的方法是设置弹出页面的src="***.do?p1=aaa&p2=bbb&p3=ccc"//确定目标URL是Action来处理?但是这样会在页面上看到传过来的参数，可能会不安全。要求实现src="***.do"，参数通过其他方法传！//////
      

      • 

    • Bootstrap A标签关闭modal并打开新的链接解决方案
qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象

      Bootstrap里面的js modal控件使用起来很方便，关闭也很简单。只需添加标签 data-dismiss="modal" 即可。
可是偏偏有时候需要a标签既要关闭modal，有要打开新的链接，尝试多种方法未果。只好使用原始js来控制。
 
<a href="#/group-buy" class="btn bt
      

      • 

    • 二维数组在Java和C中的区别
流淚的芥末
javac二维数组数组

      Java代码：
 
public class test03 {
public static void main(String[] args) {
int[][] a = {{1},{2,3},{4,5,6}};
System.out.println(a[0][1]);
}
}
 运行结果：
Exception in thread "mai
      

      • 

    • systemctl命令用法
wmlJava
linuxsystemctl

      对比表，以 apache / httpd 为例 任务 旧指令 新指令 使某服务自动启动 chkconfig --level 3 httpd on systemctl enable httpd.service 使某服务不自动启动 chkconfig --level 3 httpd off systemctl disable httpd.service 检查服务状态 service h
      

      •