Anne_胖达
Anne_胖达

RxJava Operator之变换型操作符

RxJava变换型操作符

buffer

buffer

buffer操作符
定期将来自Observable的数据分拆成一些Observable，然后发射这些，而不是每次发射一项
支持Flowable,Observable 

        Observable.range(0,10)
            .buffer(4).subscribe(new Consumer>() {
            @Override
            public void accept(List integers) throws Throwable {
                LogUtils.d(TAG,
                    "RxJava Observable Operator buffer: integers = [" + integers + "]");
            }
        });

运行结果：

「Buffer」 -> RxJava Observable Operator buffer: integers = [[0, 1, 2, 3]] 「ThreadName ⇢ main」

「Buffer」 -> RxJava Observable Operator buffer: integers = [[4, 5, 6, 7]] 「ThreadName ⇢ main」

「Buffer」 -> RxJava Observable Operator buffer: integers = [[8, 9]] 「ThreadName ⇢ main」

cast

cast操作符
在发射之前强制将Observable发射的所有数据转换为指定类型
支持Flowable,Observable,Maybe,Single

     Observable numbers = Observable.just(1, 4.0, 3f, 7, 12, 4.6, 5);
        numbers.filter(new Predicate() {
            @Override
            public boolean test(Number number) throws Throwable {
                return Integer.class.isInstance(number);
            }
        }).cast(Integer.class).subscribe(new Consumer() {
            @Override
            public void accept(Integer integer) throws Throwable {
                LogUtils.d(TAG,
                    "RxJava Observable Operator cast: integer = [" + integer + "]");
            }
        });

运行结果：

「Cast」 -> RxJava Observable Operator cast: integer = [1] 「ThreadName ⇢ main」

「Cast」 -> RxJava Observable Operator cast: integer = [7] 「ThreadName ⇢ main」

「Cast」 -> RxJava Observable Operator cast: integer = [12] 「ThreadName ⇢ main」

「Cast」 -> RxJava Observable Operator cast: integer = [5] 「ThreadName ⇢ main」

concatMap

concatMap操作符
将Observable发射的数据集合变换为Observables集合，然后将这些数据放进一个Observable
支持Flowable,Observable,Maybe

      Observable.range(0,3)
            .concat(new Function>() {
                @Override
                public ObservableSource apply(Integer integer) throws Throwable {
                    return Observable.timer(Math.round(Math.random()* 2), TimeUnit.SECONDS).map(new Function() {
                        @Override
                        public Integer apply(Long aLong) throws Throwable {
                            return integer;
                        }
                    });
                }
            }).blockingSubscribe(new Consumer() {
            @Override
            public void accept(Object o) throws Throwable {
                LogUtils.d(TAG,
                    "RxJava Observable Operator concatMap: o = [" + o + "]");
            }
        });
 
 
 
  
运行结果：

 「ConcatMap」 -> RxJava Observable Operator concatMap: o = [0] 「ThreadName ⇢ main」

 「ConcatMap」 -> RxJava Observable Operator concatMap: o = [1] 「ThreadName ⇢ main」

 「ConcatMap」 -> RxJava Observable Operator concatMap: o = [2] 「ThreadName ⇢ main」
 
 
 
 
concatMapCompletable
 
 
concatMapCompletable操作符
 将Observable发射的数据集合变换为Observables集合，然后将这些数据放进一个Completable
 支持Flowable,Observable
 
 
        Observable source = Observable.just(2,1,3);
        Completable completable = source.concatMapCompletable(new Function() {
            @Override
            public CompletableSource apply(Integer integer) throws Throwable {
                return Completable.timer(integer,TimeUnit.SECONDS)
                    .doOnComplete(new Action() {
                        @Override
                        public void run() throws Throwable {
                            LogUtils.d(TAG,
                                "RxJava Observable Operator concatMapCompletable: integer = [" + integer + "]");
                        }
                    });
            }
        });
        completable.doOnComplete(new Action() {
            @Override
            public void run() throws Throwable {
                LogUtils.d(TAG,
                    "RxJava Observable Operator concatMapCompletable completable");
            }
        }).blockingAwait();

 
 
 
  
运行结果：

 「ConcatMap」 -> RxJava Observable Operator concatMapCompletable: integer = [2] 「ThreadName ⇢ RxComputationThreadPool-6」

 「ConcatMap」 -> RxJava Observable Operator concatMapCompletable: integer = [1] 「ThreadName ⇢ RxComputationThreadPool-7」

 「ConcatMap」 -> RxJava Observable Operator concatMapCompletable: integer = [3] 「ThreadName ⇢ RxComputationThreadPool-8」

 「ConcatMap」 -> RxJava Observable Operator concatMapCompletable completable 「ThreadName ⇢ RxComputationThreadPool-8」
 
 
 
 
concatMapCompletableDelayError
 
 
concatMapCompletableDelayError操作符
 将Observable发射的数据集合变换为Observables集合，然后将这些数据放进一个Completable,error延迟执行
 支持Flowable,Observable
 
 
        Observable source = Observable.just(2,1,3);
        Completable completable = source.concatMapCompletableDelayError(new Function() {
            @Override
            public CompletableSource apply(Integer integer) throws Throwable {
                if (integer.equals(2)){
                    return Completable.error(new IllegalArgumentException());
                }
                return Completable.timer(integer,TimeUnit.SECONDS)
                    .doOnComplete(new Action() {
                        @Override
                        public void run() throws Throwable {
                            LogUtils.d(TAG,
                                "RxJava Observable Operator concatMapCompletableDelayError: integer = [" + integer + "]");
                        }
                    });
            }
        });
        completable.doOnError(new Consumer() {
            @Override
            public void accept(Throwable throwable) throws Throwable {
                LogUtils.d(TAG,
                    "RxJava Observable Operator concatMapCompletableDelayError: throwable = [" + throwable + "]");
            }
        }).onErrorComplete().blockingAwait();

 
 
 
  
运行结果：

 「ConcatMap」 -> RxJava Observable Operator concatMapCompletableDelayError: integer = [1] 「ThreadName ⇢ RxComputationThreadPool-1」

 「ConcatMap」 -> RxJava Observable Operator concatMapCompletableDelayError: integer = [3] 「ThreadName ⇢ RxComputationThreadPool-2」

 「ConcatMap」 -> RxJava Observable Operator concatMapCompletableDelayError: throwable = [java.lang.IllegalArgumentException] 「ThreadName ⇢ RxComputationThreadPool-2」
 
 
 
 
concatMapDelayError
 
 
concatMapDelayError操作符
 将Observable发射的数据集合变换为Observables集合，然后将这些数据放进一个Observable,error延迟执行
 支持Flowable,Observable
 
 
     Observable.intervalRange(1,3,0,1,TimeUnit.SECONDS)
            .concatMapDelayError(new Function>() {
                @Override
                public ObservableSource apply(Long value) throws Throwable {
                    if (value.equals(1L)){
                        return Observable.error(new IllegalArgumentException());
                    }
                    return Observable.just(value,value * value);
                }
            }).blockingSubscribe(new Consumer() {
            @Override
            public void accept(Object o) throws Throwable {
                LogUtils.d(TAG,
                    "RxJava Observable Operator concatMapDelayError: o = [" + o + "]");
            }
        }, new Consumer() {
            @Override
            public void accept(Throwable throwable) throws Throwable {
                LogUtils.d(TAG,
                    "RxJava Observable Operator concatMapDelayError: throwable = [" + throwable + "]");
            }
        });
 
 
 
  
运行结果：

 「ConcatMap」 -> RxJava Observable Operator concatMapDelayError: o = [2] 「ThreadName ⇢ main」

 「ConcatMap」 -> RxJava Observable Operator concatMapDelayError: o = [4] 「ThreadName ⇢ main」

 「ConcatMap」 -> RxJava Observable Operator concatMapDelayError: o = [3] 「ThreadName ⇢ main」

 「ConcatMap」 -> RxJava Observable Operator concatMapDelayError: o = [9] 「ThreadName ⇢ main」

 「ConcatMap」 -> RxJava Observable Operator concatMapDelayError: throwable = [java.lang.IllegalArgumentException] 「ThreadName ⇢ main」
 
 
 
 
flatMap
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    flatMap 
  
 
 
 
 
 flatMap操作符 
 
 将Observable发射的数据集合变换为Observables集合，然后将这些数据放进一个Observable 
 
 支持Flowable,Observable,Maybe,Single 
 
 
 
flatMap与concatMap区别,flatMap是无序的,concatMap是有序的,concatMap最终输出的顺序与原序列保持一致,而flatMap则不一定,有可能出现交错
 
 
        Observable.just(1,2,3).flatMap(new Function>() {
            @Override
            public ObservableSource apply(Integer integer) throws Throwable {
                return Observable.intervalRange(1,3,0,1, TimeUnit.SECONDS)
                    .map(new Function() {
                        @Override
                        public String apply(Long aLong) throws Throwable {
                            return "(" + integer + "," +  aLong + ")";
                        }
                    });
            }
        }).blockingSubscribe(new Consumer() {
            @Override
            public void accept(Object o) throws Throwable {
                LogUtils.d(TAG,
                    "RxJava Observable Operator flatMap: o = [" +  o +
                        "]");
            }
        });
 
 
 
  
运行结果：

 「FlatMap」 -> RxJava Observable Operator flatMap: o = [(1,1)] 「ThreadName ⇢ main」

 「FlatMap」 -> RxJava Observable Operator flatMap: o = [(2,1)] 「ThreadName ⇢ main」

 「FlatMap」 -> RxJava Observable Operator flatMap: o = [(3,1)] 「ThreadName ⇢ main」

 「FlatMap」 -> RxJava Observable Operator flatMap: o = [(1,2)] 「ThreadName ⇢ main」

 「FlatMap」 -> RxJava Observable Operator flatMap: o = [(3,2)] 「ThreadName ⇢ main」

 「FlatMap」 -> RxJava Observable Operator flatMap: o = [(2,2)] 「ThreadName ⇢ main」

 「FlatMap」 -> RxJava Observable Operator flatMap: o = [(1,3)] 「ThreadName ⇢ main」

 「FlatMap」 -> RxJava Observable Operator flatMap: o = [(2,3)] 「ThreadName ⇢ main」

 「FlatMap」 -> RxJava Observable Operator flatMap: o = [(3,3)] 「ThreadName ⇢ main」
 
 
 
 
flatMapCompletable
 
 
flatMapCompletable操作符
 将Observable发射的数据集合变换为Observables集合，然后将这些数据放进一个Completable
 支持Flowable,Observable
 
 
      Observable source = Observable.just(2,1,3);
        source.flatMapCompletable(new Function() {
            @Override
            public CompletableSource apply(Integer integer) throws Throwable {
                return Completable.timer(integer,TimeUnit.SECONDS).doOnComplete(new Action() {
                    @Override
                    public void run() throws Throwable {
                        LogUtils.d(TAG,
                            "RxJava Observable Operator flatMapCompletable: integer = [" +  integer +
                                "]");
                    }
                });
            }
        }).doOnComplete(new Action() {
            @Override
            public void run() throws Throwable {
                LogUtils.d(TAG,
                    "RxJava Observable Operator flatMapCompletable complete");
            }
        }).blockingAwait();

 
 
 
  
运行结果：

 「FlatMap」 -> RxJava Observable Operator flatMapCompletable: integer = [1] 「ThreadName ⇢ RxComputationThreadPool-2」

 「FlatMap」 -> RxJava Observable Operator flatMapCompletable: integer = [2] 「ThreadName ⇢ RxComputationThreadPool-1」

 「FlatMap」 -> RxJava Observable Operator flatMapCompletable: integer = [3] 「ThreadName ⇢ RxComputationThreadPool-3」

 「FlatMap」 -> RxJava Observable Operator flatMapCompletable complete 「ThreadName ⇢ RxComputationThreadPool-3」
 
 
 
 
groupBy
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    groupBy 
  
 
 
 
 
 groupBy操作符 
 
 将Observable分拆为Observable集合，将原始Observable发射的数据按Key分组，每一个Observable发射一组不同的数据 
 
 支持Flowable,Observable 
 
 
 
        Observable animals = Observable.just(
            "Android", "Xiaomi", "Apple", "Huawei", "Sony");

        animals.groupBy(new Function() {
            @Override
            public String apply(String s) throws Throwable {
                return String.valueOf(s.charAt(0));
            }
        }, new Function() {
            @Override
            public String apply(String s) throws Throwable {
                return s.toUpperCase();
            }
        }).concatMapSingle(new Function, SingleSource>() {
            @Override
            public SingleSource apply(GroupedObservable observable) throws Throwable {
                return observable.toList();
            }
        }).subscribe(new Consumer() {
            @Override
            public void accept(Object o) throws Throwable {
                LogUtils.d(TAG, "RxJava Observable Operator groupBy: o = [" +  o + "]");
            }
        });
 
 
 
  
运行结果：

 「GroupBy」 -> RxJava Observable Operator groupBy: o = [[ANDROID, APPLE]] 「ThreadName ⇢ main」

 「GroupBy」 -> RxJava Observable Operator groupBy: o = [[XIAOMI]] 「ThreadName ⇢ main」

 「GroupBy」 -> RxJava Observable Operator groupBy: o = [[HUAWEI]] 「ThreadName ⇢ main」

 「GroupBy」 -> RxJava Observable Operator groupBy: o = [[SONY]] 「ThreadName ⇢ main」
 
 
 
 
map
 
 
map操作符
 对序列的每一项都应用一个函数来变换Observable发射的数据序列
 支持Flowable,Observable,Maybe,Single
 
 
       Observable.just(1,2,3).map(new Function() {
            @Override
            public Integer apply(Integer integer) throws Throwable {
                return integer * integer;
            }
        }).subscribe(new Consumer() {
            @Override
            public void accept(Integer integer) throws Throwable {
                LogUtils.d(TAG, "RxJava Observable Operator map: integer = [" +  integer + "]");
            }
        });

 
 
 
  
运行结果：

 「Map」 -> RxJava Observable Operator map: integer = [1] 「ThreadName ⇢ main」

 「Map」 -> RxJava Observable Operator map: integer = [4] 「ThreadName ⇢ main」

 「Map」 -> RxJava Observable Operator map: integer = [9] 「ThreadName ⇢ main」
 
 
 
 
scan
 
 
scan操作符
 对Observable发射的每一项数据应用一个函数，然后按顺序依次发射每一个值
 支持Flowable,Observable
 
 
        Observable.just(5,3,8,1,7)
            .scan(0,new BiFunction() {
                @Override
                public Integer apply(Integer a, Integer b) throws Throwable {
                    return a + b;
                }
            }).subscribe(new Consumer() {
            @Override
            public void accept(Integer integer) throws Throwable {
                LogUtils.d(TAG, "RxJava Observable Operator scan: integer = [" +  integer + "]");
            }
        });

 
 
 
  
运行结果：

 「Scan」 -> RxJava Observable Operator scan: integer = [0] 「ThreadName ⇢ main」

 「Scan」 -> RxJava Observable Operator scan: integer = [5] 「ThreadName ⇢ main」

 「Scan」 -> RxJava Observable Operator scan: integer = [8] 「ThreadName ⇢ main」

 「Scan」 -> RxJava Observable Operator scan: integer = [16] 「ThreadName ⇢ main」

 「Scan」 -> RxJava Observable Operator scan: integer = [17] 「ThreadName ⇢ main」

 「Scan」 -> RxJava Observable Operator scan: integer = [24] 「ThreadName ⇢ main」
 
 
 
 
switchMap
 
 
switchMap操作符
 将Observable发射的数据集合变换为Observables集合，然后只发射这些Observables最近发射的数据
 支持Flowable,Observable
 
 
     Observable.interval(0,1, TimeUnit.SECONDS)
            .switchMap(new Function>() {
                @Override
                public ObservableSource apply(Long a) throws Throwable {
                    return Observable.interval(0,750,TimeUnit.MILLISECONDS)
                        .map(new Function() {
                            @Override
                            public Long apply(Long b) throws Throwable {
                                return a;
                            }
                        });
                }
            }).takeWhile(new Predicate() {
            @Override
            public boolean test(Long value) throws Throwable {
                return value < 3;
            }
        }).blockingSubscribe(new Consumer() {
            @Override
            public void accept(Long value) throws Throwable {
                LogUtils.d(TAG, "RxJava Observable Operator switchMap: value = [" +  value + "]");
            }
        });

 
 
 
  
运行结果：

 「SwitchMap」 -> RxJava Observable Operator switchMap: value = [0] 「ThreadName ⇢ main」

 「SwitchMap」 -> RxJava Observable Operator switchMap: value = [0] 「ThreadName ⇢ main」

 「SwitchMap」 -> RxJava Observable Operator switchMap: value = [1] 「ThreadName ⇢ main」

 「SwitchMap」 -> RxJava Observable Operator switchMap: value = [1] 「ThreadName ⇢ main」

 「SwitchMap」 -> RxJava Observable Operator switchMap: value = [2] 「ThreadName ⇢ main」

 「SwitchMap」 -> RxJava Observable Operator switchMap: value = [2] 「ThreadName ⇢ main」
 
 
 
 
window
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    window 
  
 
 
 
 
 window操作符 
 
 定期将来自Observable的数据分拆成一些Observable窗口，然后发射这些窗口，而不是每次发射一项 
 
 支持Flowable,Observable 
 
 
 
        Observable.range(1,10)
            .window(2,3).flatMapSingle(new Function, SingleSource>() {
            @Override
            public SingleSource apply(Observable observable) throws Throwable {
                return observable.map(new Function() {
                    @Override
                    public String apply(Integer integer) throws Throwable {
                        return String.valueOf(integer);
                    }
                }).reduce(new StringJoiner(",", "[", "]"), new BiFunction() {
                    @Override
                    public StringJoiner apply(StringJoiner stringJoiner, String s) throws Throwable {
                        return stringJoiner.add(s);
                    }
                });
            }
        }).subscribe(new Consumer() {
            @Override
            public void accept(Object o) throws Throwable {
                LogUtils.d(TAG, "RxJava Observable Operator window: o = [" +  o + "]");
            }
        });
 
 
 
  
运行结果：

 「Window」 -> RxJava Observable Operator window: o = [[1,2]] 「ThreadName ⇢ main」

 「Window」 -> RxJava Observable Operator window: o = [[4,5]] 「ThreadName ⇢ main」

 「Window」 -> RxJava Observable Operator window: o = [[7,8]] 「ThreadName ⇢ main」

 「Window」 -> RxJava Observable Operator window: o = [[10]] 「ThreadName ⇢ main」
 
 
 
 
示例代码
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(RxJava Operator之变换型操作符)

        

            

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

                        
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
    
                    
    • 
                    
  • 【C语言】- 自定义类型：结构体、枚举、联合
                        Cavalier_01
C语言
                        
    【C语言】：操作符（https://mp.csdn.net/editor/html/115218055）数据类型（https://mp.csdn.net/editor/html/115219664）自定义类型：结构体、枚举、联合（https://mp.csdn.net/editor/html/115373785）变量、常量（https://mp.csdn.net/editor/html/11523
    
                    
    • 
                    
  • 重载new，delete ， RTTI，类成员指针
                        森龙安
C++c++
                        
    重载new，delete执行过程重载new，delete和普通的运算符重载不同，并非重载new，delete的行为，而是改变内存分配的方式，将对象放置在特定的内存空间中new运算符操作：调用STL标准模板库的重载operatornew或operatornew[]函数，分配足够大的未命名内存运行相应构造函数返回指向对象的指针delete运算符操作：运行相应折构函数、调用STL标准模板库的重载oper
    
                    
    • 
                    
  • 你在更新什么？
                        余衿笙

                        
    我在想，为什么现在好多了解到的东西更新得那么快？两三天前听到的流行歌，过几天就忘了，因为有新的流行歌代替;对上一个小鲜肉的了解还停留在他的名字和作品上，新的面孔就又出现了，人气不断高涨。好像我所了解的东西不去“更新”，不追上社会变化的步伐，就显得自己多落伍，随时会遭人鄙夷似的。但事实上，其实大可不必如此。一方面，我想，环境对个人的影响是确实存在的，时间久了必定会有随之变化的端倪。快节奏的生活，不断
    
                    
    • 
                    
  • 创设问题情境的策略
                        平常心666

                        
    创设情境要有情趣案例：可以圈多少地如何让孩子喜欢数学，是数学教师必须思考和解决的问题。有趣的情境会吸引学生，使学生主动走近数学学习。因此，教师要结合学生的年龄特点和实际生活，创造出富有数学情趣的情境。创设情境要有生活案例：克与千克的生活情境正如著名数学家华罗庚所说：“宇宙之大，粒子之微，火箭之速，化工之巧，地球之变，日月之繁，无处不用数学。”数学与现实生活有着密切的联系。创设情境要有问题案例：喝出
    
                    
    • 
                    
  • malloc和new的区别及联系
                        月夜星辉雪
数据结构
                        
    一.区别1.用法上malloc是一个函数，而new是C++一个操作符malloc需要手动计算开辟的空间大小，new后面只需跟上空间的类型，如果有多个对象，加上[]给个数即可malloc申请的空间不能初始化，而new可以malloc返回void*，需要强制类型转换，而new返回对应类型的指针malloc失败会返回空指针，需要手动检查；new失败抛出异常，要用catch捕获2.底层原理上申请自定义类型
    
                    
    • 
                    
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
                        erhtre
程序员androidjetpack架构sqlite
                        
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
    
                    
    • 
                    
  • 运算符、一元运算符、自增、自减
                        玖岁灬

                        
    运算符运算符也叫操作符通过运算符可以对一个或多个值进行运算,并获取运算结果比如：typeof就是运算符，可以来获得一个值的类型，它会将该值的类型以字符串的形式返回"number""string""boolean""undefined""object"算数运算符当对非Number类型的值进行运算时，会将这些值转换为Number然后在运算任何值和NaN做运算都得NaN++可以对两个值进行加法运算，并将
    
                    
    • 
                    
  • Prometheus运维六 PromQL查询语言详解及操作
                        安顾里
Prometheus监控类大数据kubernetes运维linux
                        
    海阔凭鱼跃，天高任鸟飞Prometheus官网：https://prometheus.io/文章目录1.什么是PromQL?2.PromQL的基本使用2.1时间序列选择器2.1.1瞬时向量选择器2.2区间向量选择器2.2.1范围向量选择器2.2.2时间位移操作2.2.3使用聚合操作2.3标量和字符串3.PromQL操作符4.内置常用函数5.HTTPAPI操作PromQL6.使用建议1.什么是Pro
    
                    
    • 
                    
  • JavaScript创建Object对象的方法
                        流落的小鬼
javascript前端
                        
    JavaScript创建Object对象的方法1、使用new操作符后跟Object构造函数varobj=newObject()person.name='AAA'person.age=192、对象字面量varobj={name:'BBB',age:20}3、与newObject相同varobj={}person.name="CCC"person.age=21
    
                    
    • 
                    
  • C#的linq语句
                        木生火18624
C#开发
                        
    /查询表达式必须以form子句开头，以select或者group子句结束，在这两个子句之间，可以使用///where、orderby、join、let和其他的from子句本章要点用列表在对象上执行传统查询扩展方法LINQ查询操作符平行LNQ表达式树本章源代码下载地址(wrox.com)打开网页www.wrox.com/go/procsharp,单击DownloadCode选项卡即可下载本章源代码。
    
                    
    • 
                    
  • [C++11] 移动语意和移动构造函数
                        图王大胜
计算机学科基础开发语言c++移动语意移动构造函数
                        
    说明：移动语义（MoveSemantics）是C++11引入的一个重要概念，旨在提高大型对象（特别是那些涉及资源管理的对象）的复制效率。移动语义允许资源从一个对象“移动”到另一个对象，而不是进行昂贵的复制操作。这种机制通过右值引用（right-valuereference）和移动构造函数（moveconstructor）以及移动赋值操作符（moveassignmentoperator）来实现。而移
    
                    
    • 
                    
  • 太阳与大海的早晨（北戴河观日出有感）
                        方圆_3b30

                        
    太阳给万物带来了无限生机，大海为世间创造了无数神奇，每天早晨太阳的光和大海的水又紧密的联系在一起，为我们描绘的蓝图更是绚烂无比。夏日的北戴河，早四时三十分左右，东方的朝霞开始显现，随着时间分秒的移动，霞光在迅速扩大，也愈来愈亮，使天边云彩的颜色也随之变幻，由桔红变桔黄，又改米黄，继而乳白，这变化没有明显刻度，没有突屼转折，只是在你一转眼或不经意时而为之。十五分钟后太阳开始从海平面出现，我惊叹，远在
    
                    
    • 
                    
  • el-table:根据 scope.row.type 的值来显示不同的类型
                        J不A秃V头A
前端vue.jselementuijavascript
                        
    想要根据scope.row.type的值来显示不同的房源类型（转租、短租、长租、招租）转租短租长租招租未知类型这里，我们使用了v-if和v-else-if指令来检查scope.row.type的值，并根据该值显示相应的文本。如果scope.row.type的值不是0、1、2或3，则通过v-else显示“未知类型”。注意，这里的===是严格等于操作符，它会检查两边的值和类型是否都相等。这是推荐的做法
    
                    
    • 
                    
  • 区块链之变：揭秘Web3对互联网的改变
                        清 晨
web3web3去中心化区块链人工智能
                        
    传统游戏中，玩家的虚拟资产（如角色、装备）通常由游戏公司控制，玩家无法真正拥有这些资产或进行交易。而在区块链游戏中，虚拟资产通过去中心化技术记录在区块链上，玩家对其拥有完全的所有权，并能够自由交易或转移。Web3的去中心化特点为区块链游戏带来了更高的透明性和公平性。智能合约自动执行游戏规则，确保所有玩家在相同条件下进行游戏，并消除了作弊和规则篡改的风险。这种透明性不仅增强了玩家的信任，也为开发者提
    
                    
    • 
                    
  • Elasticsearch之bool查询
                        cyt涛
javaelasticsearch大数据搜索引擎bool布尔查询全文检索
                        
    bool查询是Elasticsearch中最常用的复合查询类型，允许将多个查询组合在一起。它通过逻辑操作符（如must、should、must_not和filter）来构建复杂的查询条件，从而满足多条件匹配、逻辑与（AND）、或（OR）、非（NOT）的查询需求。bool查询主要由四个部分组成：must：必须满足的条件（类似于SQL中的AND）。should：应该匹配的条件（类似于SQL中的OR）。
    
                    
    • 
                    
  • SQL日期函数
                        dlwlrma ⥳
兴趣类sql数据库
                        
    目录引言：一：获取日期时间函数1.1获取当前时间1.2获取当前日期二：日期格式化2.1日期转指定格式字符串2.2字符串转日期三：日期间隔3.1增加日期间隔3.2减去一个时间间隔3.3日期相差天数3.4相差时间（小时）四：星期操作五：其他操作六：总结引言：在SQL中，日期函数具有多种重要作用：1.数据筛选和查询：可以根据特定的日期范围来获取所需的数据。例如，通过BETWEEN操作符和日期函数，筛选出
    
                    
    • 
                    
  • C++ 特殊类设计
                        元凌丶
开发语言
                        
    只能在栈上创建对象classStackOnly{public:staticStackOnlyCreateObj(){returnStackOnly();}//禁掉operatornew可以把下面用new调用拷贝构造申请对象给禁掉//StackOnlyobj=StackOnly::CreateObj();//StackOnly*ptr3=newStackOnly(obj);void*operator
    
                    
    • 
                    
  • 【Python】02.Python 的基础概念
                        卡戎-caryon
Pythonpython开发语言笔记
                        
    一、常量和表达式形如1+2-3这样的算式，在编程语言中称为表达式,算式的运算结果,称为表达式的返回值其中1,2,3这种称为字面值常量,+-*/这种称为运算符或者操作符二、变量与类型2.1变量的定义有的时候,我们需要进行的计算可能更复杂一些,需要把一些计算的中间结果保存起来.这个时候就需要用到变量变量可以视为是一块能够容纳数据的空间.这个空间往往对应到“内存”这样的硬件设备上2.2变量的语法2.2.
    
                    
    • 
                    
  • 赚钱的app哪个靠谱赚钱还快学生？4款靠谱还赚钱快的软件推荐!
                        氧惠评测

                        
    十大赚钱最快的app，近些年随着移动上网的普及，用手机赚钱也随之变得火热，手机赚钱app更是数不胜数，种类之多，数量之大。然而，这么多的手机赚钱app并不是随便挑选一款都能保证让你挣钱的，作为玩了多年手机赚钱的老司机有必要告诉你，网络上大部分手机赚钱软件是不怎么赚钱的，只有很少的一部分可以。赚钱可以让人快乐翻倍！推荐无门槛零投资一个人创业项目！氧惠（全网优惠上氧惠）——是与以往完全不同的抖客+淘客
    
                    
    • 
                    
  • python的高级特性
                        咸鱼有梦想呀

                        
    在python中，代码是越少越好，越简单越好。因此就有了python常用的高级特性。切片（Slice）切片操作符，用于经常取指定索引范围的操作。好处就是减少使用循环eg：list切片L[0:3]表示从索引0开始取，直到索引3为止，但不包括索引3。如果第一个索引是0还可以省略。list切片倒数切片。-1是倒数第一个元素的索引。切片不但可以取相邻的，还可以每两个取一次，或者每5个取一次。list切片t
    
                    
    • 
                    
  • MySQL之DQL子查询
                        忧郁的西红柿
mysql数据库
                        
    1.子查询概述1.1为什么使用子查询思考如下问题？查询工资比Jones工资高的员工信息？查询工资最低的员工姓名？“谁的薪水比Jones还高呢？”子查询语法SELECTselect_listFROMtableWHEREexproperator(SELECTselect_listFROMtable);括号内的查询叫做子查询，也叫内部查询，先于主查询执行。子查询的结果被主查询（外部查询）使用exprop
    
                    
    • 
                    
  • 第二章 SQL命令参考-VALUES
                        kygoal

                        
    VALUESComputesasetofrows.概要VALUES(expression[,...])[,...][ORDERBYsort_expression[ASC|DESC|USINGoperator][,...]][LIMIT{count|ALL}][OFFSETstart]描述VALUES计算由值表达式指定的行值或一组行值。它通常用于在更大的命令中生成“常量表”，但可以单独使用。当指定多
    
                    
    • 
                    
  • FPGA 编程基础, 赋值操作符, 运算符使用, 条件表达式, 信号操作方法
                        行者..................
fpga开发
                        
    1.**赋值符号**：-**"="**：阻塞赋值，即在`always`模块中该语句会被立即执行。-**""**：大于，如果A>B则结果为TRUE，否则为FALSE。-**">="**：大于等于，如果A>=B则结果为TRUE，否则为FALSE。-**"=="**：等于，如果A==B则结果为TRUE，否则为FALSE。-**"!="**：不等于，如果A!=B则结果为TRUE，否则为FALSE。4.**
    
                    
    • 
                    
  • 「中国奥数国家队夺冠」 数学虐我千百遍，我待数学如初恋
                        d35156f6a0a9

                        
    宇宙之大，粒子之微，火箭之速，化工之巧，地球之变，生物之谜，日用之繁，无处不用数学。2019年国际数学奥林匹克竞赛结果在英国巴斯出炉，中国队时隔4年后重登冠军宝座，以227分的总成绩与美国队并列世界第一，中国队全体队员获得金牌。这是一份迟来，但却令人骄傲的成绩单。这里附上前20名国家与地区成绩及排名IMO官网中国队6名成员个人成绩作为国际最高水平的数学竞赛，IMO一向以题目出其不意，选拔过程以严苛
    
                    
    • 
                    
  • Java基础：单例模式，Spring源码中有哪些单例模式
                        生活诙谐号
Java基础Spring源码设计模式单例模式javaspring
                        
    单例模式是一种常用的软件设计模式，其目的是确保一个类仅有一个实例，并提供一个全局访问点来获取这个唯一实例。在Java中，实现单例模式通常需要遵循以下几个关键原则：私有化构造器：将类的构造器声明为private，以防止外部代码通过new操作符直接创建该类的实例。静态工厂方法：提供一个静态方法（通常称为getInstance()），用于获取单例对象。这个方法负责检查是否已经创建过实例，如果尚未创建，则
    
                    
    • 
                    
  • Rxjava2你应该懂的源码，其实并不难（二）
                        kwbsky

                        
    接上篇继续。一、线程切换observeOnObservable.just("1").subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(observer)我们知道，当调用observeOn之后，后面执行的代码都将切换到他指定的线程，除非再次调用observeOn切换其他线程。上源码：@Ch
    
                    
    • 
                    
  • python基础：sort()函数
                        Galaxy.404
Python基础python开发语言
                        
    有字典内容classCount为：{'no':5,'yes':9}使用sort可以对其进行转化：sortedClassCount=sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)classCount.items()这一部分将字典classCount转换为一个由键值对组成的可迭代对象，每个项都是一个元组(key,va
    
                    
    • 
                    
  • C++STL库, 理解STL中的list
                        谐__律
c++list
                        
    文章目录前言一个梦想与一个坚定不移的意志一、list的介绍二、引入——构造方式，遍历方式1.代码观察2.我的疑问3.解答4.拓展（1）常见的容器的迭代器（2）sort排序三、迭代器失效的问题四、C++简单模拟实现list1.节点类的创建2.list的迭代器(1)实现方式(2)代码实现operator->()函数中编译器的优化行为三个模板参数问题3.list的实现(1)三个模板参数的问题前言一个梦想
    
                    
    • 
                                
  • mondb入手
                                    木zi_鸣
mongodb
                                    
    windows 启动mongodb  编写bat文件， 
 
mongod --dbpath D:\software\MongoDBDATA 
mongod --help  查询各种配置 
配置在mongob 
 
打开批处理，即可启动，27017原生端口，shell操作监控端口  扩展28017，web端操作端口 
 
启动配置文件配置， 
 
数据更灵活 
    
                                
    • 
                                
  • 大型高并发高负载网站的系统架构
                                    bijian1013
高并发负载均衡
                                    
            扩展Web应用程序 
一.概念 
        简单的来说，如果一个系统可扩展，那么你可以通过扩展来提供系统的性能。这代表着系统能够容纳更高的负载、更大的数据集，并且系统是可维护的。扩展和语言、某项具体的技术都是无关的。扩展可以分为两种： 
        1.
    
                                
    • 
                                
  • DISPLAY变量和xhost(原创)
                                    czmmiao
display
                                    
    DISPLAY 
在Linux/Unix类操作系统上, DISPLAY用来设置将图形显示到何处. 直接登陆图形界面或者登陆命令行界面后使用startx启动图形, DISPLAY环境变量将自动设置为:0:0, 此时可以打开终端, 输出图形程序的名称(比如xclock)来启动程序, 图形将显示在本地窗口上, 在终端上输入printenv查看当前环境变量, 输出结果中有如下内容:DISPLAY=:0.0
    
                                
    • 
                                
  • 获取B/S客户端IP
                                    周凡杨
java编程jspWeb浏览器
                                    
       最近想写个B/S架构的聊天系统，因为以前做过C/S架构的QQ聊天系统，所以对于Socket通信编程只是一个巩固。对于C/S架构的聊天系统，由于存在客户端Java应用，所以直接在代码中获取客户端的IP，应用的方法为： 
   String ip = InetAddress.getLocalHost().getHostAddress(); 
然而对于WEB
    
                                
    • 
                                
  • 浅谈类和对象
                                    朱辉辉33
编程
                                    
        类是对一类事物的总称，对象是描述一个物体的特征，类是对象的抽象。简单来说，类是抽象的，不占用内存，对象是具体的， 
占用存储空间。 
    类是由属性和方法构成的，基本格式是public  class 类名{ 
 
 //定义属性 
 private/public 数据类型 属性名； 
 
 //定义方法 
 publ
    
                                
    • 
                                
  • android activity与viewpager+fragment的生命周期问题
                                    肆无忌惮_
viewpager
                                    
    有一个Activity里面是ViewPager，ViewPager里面放了两个Fragment。 
第一次进入这个Activity。开启了服务，并在onResume方法中绑定服务后，对Service进行了一定的初始化，其中调用了Fragment中的一个属性。 
		super.onResume();
		bindService(intent, conn, BIND_AUTO_CREATE);

    
                                
    • 
                                
  • base64Encode对图片进行编码
                                    843977358
base64图片encoder
                                    
    /**
	 * 对图片进行base64encoder编码
	 * 
	 * @author mrZhang
	 * @param path
	 * @return
	 */
	public static String encodeImage(String path) {
		BASE64Encoder encoder = null;
		byte[] b = null;
		I
    
                                
    • 
                                
  • Request Header简介
                                    aigo
servlet
                                    
    当一个客户端(通常是浏览器)向Web服务器发送一个请求是，它要发送一个请求的命令行，一般是GET或POST命令，当发送POST命令时，它还必须向服务器发送一个叫“Content-Length”的请求头(Request   Header)   用以指明请求数据的长度，除了Content-Length之外，它还可以向服务器发送其它一些Headers，如：    
    
                                
    • 
                                
  • HttpClient4.3 创建SSL协议的HttpClient对象
                                    alleni123
httpclient爬虫ssl
                                    
    public class HttpClientUtils
{
	public static CloseableHttpClient createSSLClientDefault(CookieStore cookies){
		SSLContext sslContext=null;
		
		try
		{
			sslContext=new SSLContextBuilder().l
    
                                
    • 
                                
  • java取反 -右移-左移-无符号右移的探讨
                                    百合不是茶
位运算符 位移
                                    
    取反：
		在二进制中第一位，1表示符数，0表示正数
		byte a = -1;
		原码：10000001
		反码：11111110
		补码：11111111
      //异或: 00000000
		byte b = -2;
		原码：10000010
		反码：11111101
		补码：11111110
      //异或: 00000001
		
	
    
                                
    • 
                                
  • java多线程join的作用与用法
                                    bijian1013
java多线程
                                    
            对于JAVA的join，JDK 是这样说的：join public final void join （long millis ）throws InterruptedException Waits at most millis milliseconds for this thread to die. A timeout of 0 means t
    
                                
    • 
                                
  • Java发送http请求(get 与post方法请求)
                                    bijian1013
javaspring
                                    
    PostRequest.java 
package com.bijian.study;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURL
    
                                
    • 
                                
  • 【Struts2二】struts.xml中package下的action配置项默认值
                                    bit1129
struts.xml
                                    
    在第一部份，定义了struts.xml文件，如下所示： 
  
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
        "http://struts.apache.org/dtds/struts
    
                                
    • 
                                
  • 【Kafka十三】Kafka Simple Consumer
                                    bit1129
simple
                                    
    代码中关于Host和Port是割裂开的，这会导致单机环境下的伪分布式Kafka集群环境下，这个例子没法运行。 
实际情况是需要将host和port绑定到一起， 
  
package kafka.examples.lowlevel;

import kafka.api.FetchRequest;
import kafka.api.FetchRequestBuilder;
impo
    
                                
    • 
                                
  • nodejs学习api
                                    ronin47
nodejs api
                                    
    NodeJS基础 什么是NodeJS 
JS是脚本语言，脚本语言都需要一个解析器才能运行。对于写在HTML页面里的JS，浏览器充当了解析器的角色。而对于需要独立运行的JS，NodeJS就是一个解析器。 
每一种解析器都是一个运行环境，不但允许JS定义各种数据结构，进行各种计算，还允许JS使用运行环境提供的内置对象和方法做一些事情。例如运行在浏览器中的JS的用途是操作DOM，浏览器就提供了docum
    
                                
    • 
                                
  • java-64.寻找第N个丑数
                                    bylijinnan
java
                                    
    


public class UglyNumber {

	/**
	 * 64.查找第N个丑数
具体思路可参考 [url] http://zhedahht.blog.163.com/blog/static/2541117420094245366965/[/url]
	 * 
题目：我们把只包含因子
2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14
    
                                
    • 
                                
  • 二维数组（矩阵）对角线输出
                                    bylijinnan
二维数组
                                    
    

/**
二维数组 对角线输出 两个方向
例如对于数组：
{ 1, 2, 3, 4 }, 
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 }, 
{ 13, 14, 15, 16 },

slash方向输出：
1 
5 2 
9 6 3 
13 10 7 4 
14 11 8 
15 12 
16 

backslash输出：
4 
3
    
                                
    • 
                                
  • [JWFD开源工作流设计]工作流跳跃模式开发关键点(今日更新)
                                    comsci
工作流
                                    
       既然是做开源软件的,我们的宗旨就是给大家分享设计和代码,那么现在我就用很简单扼要的语言来透露这个跳跃模式的设计原理 
 
   大家如果用过JWFD的ARC-自动运行控制器,或者看过代码,应该知道在ARC算法模块中有一个函数叫做SAN(),这个函数就是ARC的核心控制器,要实现跳跃模式,在SAN函数中一定要对LN链表数据结构进行操作,首先写一段代码,把
    
                                
    • 
                                
  • redis常见使用
                                    cuityang
redis常见使用
                                    
    redis 通常被认为是一个数据结构服务器，主要是因为其有着丰富的数据结构 strings、map、 list、sets、 sorted sets 
 
引入jar包 jedis-2.1.0.jar  (本文下方提供下载) 
 
package redistest; 
 
import redis.clients.jedis.Jedis; 
 
public class Listtest
    
                                
    • 
                                
  • 配置多个redis
                                    dalan_123
redis
                                    
    配置多个redis客户端 
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi=&quo
    
                                
    • 
                                
  • attrib命令
                                    dcj3sjt126com
attr
                                    
         
attrib指令用于修改文件的属性.文件的常见属性有:只读.存档.隐藏和系统.      
  只读属性是指文件只可以做读的操作.不能对文件进行写的操作.就是文件的写保护.  
 
  存档属性是用来标记文件改动的.即在上一次备份后文件有所改动.一些备份软件在备份的时候会只去备份带有存档属性的文件.  
 
    
                                
    • 
                                
  • Yii使用公共函数
                                    dcj3sjt126com
yii
                                    
    在网站项目中，没必要把公用的函数写成一个工具类，有时候面向过程其实更方便。   在入口文件index.php里添加   require_once('protected/function.php');   即可对其引用，成为公用的函数集合。   function.php如下：   
   <?php   /**     * This is the shortcut to D
    
                                
    • 
                                
  • linux 系统资源的查看（free、uname、uptime、netstat）
                                    eksliang
netstatlinux unamelinux uptimelinux free
                                    
    linux 系统资源的查看 
转载请出自出处：http://eksliang.iteye.com/blog/2167081 
  
http://eksliang.iteye.com 一、free查看内存的使用情况 
语法如下： 
  
free [-b][-k][-m][-g] [-t]
参数含义
-b:直接输入free时，显示的单位是kb我们可以使用b(bytes),m
    
                                
    • 
                                
  • JAVA的位操作符
                                    greemranqq
位运算JAVA位移<<>>>
                                    
    最近几种进制，加上各种位操作符，发现都比较模糊，不能完全掌握，这里就再熟悉熟悉。 
  
1.按位操作符 ： 
   按位操作符是用来操作基本数据类型中的单个bit,即二进制位，会对两个参数执行布尔代数运算，获得结果。 
   与（&）运算： 
   1&1 = 1, 1&0 = 0, 0&0 &
    
                                
    • 
                                
  • Web前段学习网站
                                    ihuning
Web
                                    
      
Web前段学习网站 
菜鸟学习：http://www.w3cschool.cc/ 
  
JQuery中文网：http://www.jquerycn.cn/ 
  
内存溢出：http://outofmemory.cn/#csdn.blog 
  
http://www.icoolxue.com/ 
  
http://www.jikexue
    
                                
    • 
                                
  • 强强联合：FluxBB 作者加盟 Flarum
                                    justjavac
r
                                    
    原文：FluxBB Joins Forces With Flarum作者：Toby Zerner译文：强强联合：FluxBB 作者加盟 Flarum译者：justjavac  
FluxBB 是一个快速、轻量级论坛软件，它的开发者是一名德国的 PHP 天才 Franz Liedke。FluxBB 的下一个版本(2.0)将被完全重写，并已经开发了一段时间。FluxBB 看起来非常有前途的，
    
                                
    • 
                                
  • java统计在线人数（session存储信息的）
                                    macroli
javaWeb
                                    
    这篇日志是我写的第三次了 前两次都发布失败！郁闷极了！ 
  
由于在web开发中常常用到这一部分所以在此记录一下，呵呵，就到备忘录了！ 
我对于登录信息时使用session存储的，所以我这里是通过实现HttpSessionAttributeListener这个接口完成的。 
1、实现接口类，在web.xml文件中配置监听类，从而可以使该类完成其工作。 
public class Ses
    
                                
    • 
                                
  • bootstrp carousel初体验 快速构建图片播放
                                    qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象
                                    
    img{
			border: 1px solid white;
			box-shadow: 2px 2px 12px #333;
			_width: expression(this.width > 600 ? "600px" : this.width + "px");
			_height: expression(this.width &
    
                                
    • 
                                
  • SparkSQL读取HBase数据，通过自定义外部数据源
                                    superlxw1234
sparksparksqlsparksql读取hbasesparksql外部数据源
                                    
    关键字：SparkSQL读取HBase、SparkSQL自定义外部数据源 
  
  
前面文章介绍了SparSQL通过Hive操作HBase表。 
  
SparkSQL从1.2开始支持自定义外部数据源(External DataSource)，这样就可以通过API接口来实现自己的外部数据源。这里基于Spark1.4.0，简单介绍SparkSQL自定义外部数据源，访
    
                                
    • 
                                
  • Spring Boot 1.3.0.M1发布
                                    wiselyman
spring boot
                                    
        Spring Boot 1.3.0.M1于6.12日发布，现在可以从Spring milestone repository下载。这个版本是基于Spring Framework 4.2.0.RC1,并在Spring Boot 1.2之上提供了大量的新特性improvements and new features。主要包含以下： 
  
1.提供一个新的sprin
    
                                
    •