枫爻筝
枫爻筝

RxJava2.0的使用代码

MainActivity

package com.think.rxjava;

import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    protected Button btn1;
    protected Button btn2;
    protected Button btn3;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        super.setContentView(R.layout.activity_main);
        initView();
    }

    @Override
    public void onClick(View view) {
        if (view.getId() == R.id.btn1) {
            startActivity(new Intent(this, RxJavaDemo1Activity.class));
        } else if (view.getId() == R.id.btn2) {
            startActivity(new Intent(this, RxJavaDemo2Activity.class));
        } else if (view.getId() == R.id.btn3) {
            startActivity(new Intent(this, RxJavaDemo3Activity.class));
        }
    }

    private void initView() {
        btn1 = (Button) findViewById(R.id.btn1);
        btn1.setOnClickListener(MainActivity.this);
        btn2 = (Button) findViewById(R.id.btn2);
        btn2.setOnClickListener(MainActivity.this);
        btn3 = (Button) findViewById(R.id.btn3);
        btn3.setOnClickListener(MainActivity.this);
    }
}

RxJavaDemo1Activity

package com.think.rxjava;

import android.content.DialogInterface;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;

import com.example.demonstrate.DemonstrateUtil;
import com.example.demonstrate.DialogUtil;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.functions.Predicate;

public class RxJavaDemo1Activity extends AppCompatActivity implements View.OnClickListener {

    protected Button btnSend1;
    protected Button btnSend2;
    protected Button btnSend3;
    protected Button btnSend4;
    protected Button btnSend5;
    protected Button btnSend6;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        super.setContentView(R.layout.activity_rx_java_demo1);
        initView();
    }

    @Override
    public void onClick(View view) {
        if (view.getId() == R.id.btn_send1) {
            test1();//普通使用
        } else if (view.getId() == R.id.btn_send2) {
            test2();//链式调用
        } else if (view.getId() == R.id.btn_send3) {
            test3();//发送中,中断.
        } else if (view.getId() == R.id.btn_send4) {
            test4();//只关心onnext事件的操作
        } else if (view.getId() == R.id.btn_send5) {
            test5();//
        } else if (view.getId() == R.id.btn_send6) {
            test6();
        }
    }

    private void test6() {
        DialogUtil.showListDialog(this, "rxjava的操作符号使用", new String[]{
                "0map()操作符",
                "1flatMap()操作符",
                "2filter()操作符",
                "3take()操作符",
                "4doOnNext()操作符",
        }, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                switch (which) {
                    case 0:
                        map0();
                        break;
                    case 1:
                        map1();
                        break;
                    case 2:
                        map2();
                        break;
                    case 3:
                        map3();
                        break;
                    case 4:
                        map4();
                        break;
                }
            }
        });
    }

    private void map4() {
        Observable.just(new ArrayList(){
            {
                for (int i = 0; i < 6; i++) {
                    add("data"+i);
                }
            }
        }).flatMap(new Function, ObservableSource>() {
            @Override
            public ObservableSource apply(List strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).take(5).doOnNext(new Consumer() {
            @Override
            public void accept(Object o) throws Exception {
                DemonstrateUtil.showLogResult("额外的准备工作!");
            }
        }).subscribe(new Consumer() {
            @Override
            public void accept(Object s) throws Exception {
                DemonstrateUtil.showLogResult(s.toString());
            }
        });
    }

    private void map3() {
        Observable.just(new ArrayList(){
            {
                for (int i = 0; i < 8; i++) {
                    add("data"+i);
                }
            }
        }).flatMap(new Function, ObservableSource>() {
            @Override
            public ObservableSource apply(List strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).take(5).subscribe(new Consumer() {
            @Override
            public void accept(Object s) throws Exception {
                DemonstrateUtil.showLogResult(s.toString());
            }
        });
    }

    private void map2() {
        Observable
                .just(new ArrayList(){
                    {
                        for (int i = 0; i < 5; i++) {
                            add("data"+i);
                        }
                    }
                })
                .flatMap(new Function, ObservableSource>() {
                    @Override
                    public ObservableSource apply(List strings) throws Exception {
                        return Observable.fromIterable(strings);
                    }
                }).filter(new Predicate() {
            @Override
            public boolean test(Object s) throws Exception {
                String newStr = (String) s;
                if (newStr.contains("3")){
                    return true;
                }
                return false;
            }
        }).subscribe(new Consumer() {
            @Override
            public void accept(Object o) throws Exception {
                DemonstrateUtil.showLogResult((String)o);
            }
        });
    }

    private void map1() {
        Observable.just(new ArrayList(){
            {
                for (int i = 0; i < 3; i++) {
                    add("data"+i);
                }
            }
        }).flatMap(new Function, ObservableSource>() {
            @Override
            public ObservableSource apply(List strings) throws Exception {
                return Observable.fromIterable(strings);
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Object o) {
                DemonstrateUtil.showLogResult("flatMap转换后,接收到的"+o);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void map0() {
        Observable.just("hellorxjava")
                .map(new Function() {
                    @Override
                    public Integer apply(String s) throws Exception {
                        return s.length();
                    }
                }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("接收到被转换的数据结果:"+integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void test5() {
        DialogUtil.showListDialog(this, "rxjava的其他操作", new String[]{
                "0just()方式创建Observable",
                "1fromIterable()方式创建Observable",
                "2defer()方式创建Observable",
                "3interval( )方式创建Observable",
                "4timer( )方式创建Observable",
                "5range( )方式创建Observable",
                "6repeat( )方式创建Observable",
        }, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                switch (which) {
                    case 0:
                        other0();
                        break;
                    case 1:
                        other1();
                        break;
                    case 2:
                        other2();
                        break;
                    case 3:
                        other3();
                        break;
                    case 4:
                        other4();
                        break;
                    case 5:
                        other5();
                        break;
                    case 6:
                        other6();
                        break;
                }
            }
        });
    }

    private void other6() {
        Observable.just(123).repeat().subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("重复integer" + integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other5() {
        Observable.range(1, 5).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("连续收到:" + integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other4() {
        Observable.timer(5, TimeUnit.SECONDS).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Long aLong) {
                DemonstrateUtil.showLogResult("延迟5s后调用了:onNext");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other3() {
        Observable.interval(3, TimeUnit.SECONDS).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Long aLong) {
                DemonstrateUtil.showLogResult("数字是:" + aLong);
                //DemonstrateUtil.showToastResult(RxJavaDemo1Activity.this,"数字是:"+aLong);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other2() {
        Observable observable = Observable.defer(new Callable>() {
            @Override
            public ObservableSource call() throws Exception {
                return Observable.just("hello,defer");
            }
        });

        //上游衔接下游!
        observable.subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                DemonstrateUtil.showLogResult(s);
                DemonstrateUtil.showToastResult(RxJavaDemo1Activity.this, s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other1() {
        Observable.fromIterable(new ArrayList() {
            {
                for (int i = 0; i < 5; i++) {
                    add("Hello," + i);
                }
            }
        }).subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                DemonstrateUtil.showToastResult(RxJavaDemo1Activity.this, s);
                DemonstrateUtil.showLogResult(s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void other0() {
        Observable.just("hello,you hao!").subscribe(new Observer() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                DemonstrateUtil.showLogResult(s);
                DemonstrateUtil.showToastResult(RxJavaDemo1Activity.this, s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

    private void test4() {
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                DemonstrateUtil.showLogResult("emitter 1");
                emitter.onNext(1);

                DemonstrateUtil.showLogResult("emitter 2");
                emitter.onNext(2);

                DemonstrateUtil.showLogResult("emitter 3");
                emitter.onNext(3);

                DemonstrateUtil.showLogResult("complete");
                emitter.onComplete();

                DemonstrateUtil.showLogResult("emitter 4");
                emitter.onNext(4);
            }
        }).subscribe(new Consumer() {
            @Override
            public void accept(Integer integer) throws Exception {
                DemonstrateUtil.showLogResult("accept:" + integer);
            }
        });
    }

    private void test3() {
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                DemonstrateUtil.showLogResult("emitter 1");
                emitter.onNext(1);

                DemonstrateUtil.showLogResult("emitter 2");
                emitter.onNext(2);

                DemonstrateUtil.showLogResult("emitter 3");
                emitter.onNext(3);

                DemonstrateUtil.showLogResult("complete");
                emitter.onComplete();

                DemonstrateUtil.showLogResult("emitter 4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer() {
            private Disposable mDisposable;
            private int i;

            @Override
            public void onSubscribe(Disposable d) {
                DemonstrateUtil.showLogResult("subscribe");
                mDisposable = d;
            }

            @Override
            public void onNext(Integer value) {
                DemonstrateUtil.showLogResult("onNext:" + value);
                i++;
                if (i == 2) {
                    DemonstrateUtil.showLogResult("dispose:" + value);
                    mDisposable.dispose();
                    DemonstrateUtil.showLogResult("isDisposed : " + mDisposable.isDisposed());
                }
            }

            @Override
            public void onError(Throwable e) {
                DemonstrateUtil.showLogResult("error:");
            }

            @Override
            public void onComplete() {
                DemonstrateUtil.showLogResult("complete");
            }
        });

    }

    private void test2() {
        //链式调用
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        }).subscribe(new Observer() {

            @Override
            public void onSubscribe(Disposable d) {
                DemonstrateUtil.showLogResult("onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("onNext-->integer" + integer);
            }

            @Override
            public void onError(Throwable e) {
                DemonstrateUtil.showLogResult("onError");
            }

            @Override
            public void onComplete() {
                DemonstrateUtil.showLogResult("onComplete");
            }
        });
    }

    private void test1() {

        //创建上游,数据发射源!
        //ObservableOnSubscribe对象作为参数，它的作用相当于一个计划表，当 Observable被订阅的时候，
        // ObservableOnSubscribe的subscribe()方法会自动被调用，事件序列就会依照设定依次触发
        //ObservableEmitter,发射器,触发事件.
        Observable observable = Observable.create(new ObservableOnSubscribe() {

            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        });

        //创建下游,数据接收处!
        Observer observer = new Observer() {

            @Override
            public void onSubscribe(Disposable d) {
                DemonstrateUtil.showLogResult("onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("onNext--integer" + integer);
            }

            @Override
            public void onError(Throwable e) {
                DemonstrateUtil.showLogResult("onError");
            }

            @Override
            public void onComplete() {
                DemonstrateUtil.showLogResult("onComplete");
            }
        };

        //数据源连接接收处,上游衔接下游!
        //只有当上游和下游建立连接之后, 上游才会开始发送事件
        observable.subscribe(observer);
    }

    private void initView() {
        btnSend1 = (Button) findViewById(R.id.btn_send1);
        btnSend1.setOnClickListener(RxJavaDemo1Activity.this);
        btnSend2 = (Button) findViewById(R.id.btn_send2);
        btnSend2.setOnClickListener(RxJavaDemo1Activity.this);
        btnSend3 = (Button) findViewById(R.id.btn_send3);
        btnSend3.setOnClickListener(RxJavaDemo1Activity.this);
        btnSend4 = (Button) findViewById(R.id.btn_send4);
        btnSend4.setOnClickListener(RxJavaDemo1Activity.this);
        btnSend5 = (Button) findViewById(R.id.btn_send5);
        btnSend5.setOnClickListener(RxJavaDemo1Activity.this);
        btnSend6 = (Button) findViewById(R.id.btn_send6);
        btnSend6.setOnClickListener(RxJavaDemo1Activity.this);
    }
}
 
  
RxJavaDemo2Activity
 
  
package com.think.rxjava;

import android.content.DialogInterface;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;

import com.example.demonstrate.DemonstrateUtil;
import com.example.demonstrate.DialogUtil;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;

public class RxJavaDemo2Activity extends AppCompatActivity implements View.OnClickListener {

    protected Button btn;
    protected ImageView iv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        super.setContentView(R.layout.activity_rx_java_demo2);
        initView();
    }

    @Override
    public void onClick(View view) {
        if (view.getId() == R.id.btn) {
            DialogUtil.showListDialog(this, "rxJava操作！", new String[]{
                    "0发送事件io线程并变换主线程接收",
                    "1子线程发送事件主线程接收",
                    "2默认线程发送事件默认线程接收",
            }, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    switch (which) {
                        case 0:
                            show0();
                            break;
                        case 1:
                            show1();
                            break;
                        case 2:
                            show2();
                            break;
                    }
                }
            });
        }
    }

    private void show2() {
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                DemonstrateUtil.showLogResult("发送的线程名称：" + Thread.currentThread().getName());
                DemonstrateUtil.showLogResult("发送的线程id：" + Thread.currentThread().getId());

                DemonstrateUtil.showLogResult("发送的数据:" + 1);
                e.onNext(1);
            }
        }).subscribe(new Consumer() {
            @Override
            public void accept(Integer integer) throws Exception {
                DemonstrateUtil.showLogResult("接收的线程：" + Thread.currentThread().getName());
                DemonstrateUtil.showLogResult("接收的线程id：" + Thread.currentThread().getId());
                DemonstrateUtil.showLogResult("接收到的数据:-integer:" + integer);
            }
        });
    }

    private void show1() {
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                DemonstrateUtil.showLogResult("发送的线程名称：" + Thread.currentThread().getName());
                DemonstrateUtil.showLogResult("发送的线程id：" + Thread.currentThread().getId());

                DemonstrateUtil.showLogResult("发送的数据:" + 1);
                e.onNext(1);
            }
        }).subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        DemonstrateUtil.showLogResult("接收的线程：" + Thread.currentThread().getName());
                        DemonstrateUtil.showLogResult("接收的线程id：" + Thread.currentThread().getId());
                        DemonstrateUtil.showLogResult("接收到的数据:-integer:" + integer);
                    }
                });
    }

    private void show0() {
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                DemonstrateUtil.showLogResult("所在的线程：", Thread.currentThread().getName());
                DemonstrateUtil.showLogResult("发送的数据:", 1 + "");
                e.onNext(1);
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        DemonstrateUtil.showLogResult("所在的线程：", Thread.currentThread().getName());
                        DemonstrateUtil.showLogResult("接收到的数据:", "integer:" + integer);
                    }
                });
    }

    private void initView() {
        btn = (Button) findViewById(R.id.btn);
        btn.setOnClickListener(RxJavaDemo2Activity.this);
        iv = (ImageView) findViewById(R.id.iv);
    }
}

 
  
RxJavaDemo3Activity
 
  
package com.think.rxjava;

import android.content.DialogInterface;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;

import com.example.demonstrate.DemonstrateUtil;
import com.example.demonstrate.DialogUtil;

import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

import io.reactivex.BackpressureStrategy;
import io.reactivex.Flowable;
import io.reactivex.FlowableEmitter;
import io.reactivex.FlowableOnSubscribe;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.functions.Consumer;
import io.reactivex.schedulers.Schedulers;

public class RxJavaDemo3Activity extends AppCompatActivity implements View.OnClickListener {

    protected Button btnBackpressure;
    private Flowable mFlowable;
    private Subscriber mSubscriber;
    private Subscription mSubscription;
    private Flowable flowableLATEST;
    private Subscriber subscriberLatest;
    private Subscription subscriptionLatest;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        super.setContentView(R.layout.activity_rx_java_demo3);
        initView();
        init4();
        init6();
    }

    private void init6() {
        flowableLATEST = Flowable.create(new FlowableOnSubscribe() {
            @Override
            public void subscribe(FlowableEmitter emitter) throws Exception {

                for (int i = 1; i<=200; i++) {
                    emitter.onNext(i);
                    DemonstrateUtil.showLogResult("LATEST生产onNext:"+i);
                }
            }
        }, BackpressureStrategy.LATEST);

        //mSubscription = s;
        subscriberLatest = new Subscriber() {
            @Override
            public void onSubscribe(Subscription s) {
                subscriptionLatest = s;
                s.request(100);
            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("Latest消费onNext:" + integer);
            }

            @Override
            public void onError(Throwable t) {
                DemonstrateUtil.showLogResult("onError");
                DemonstrateUtil.showLogResult(t.getMessage());
                DemonstrateUtil.showLogResult(t.toString());
            }

            @Override
            public void onComplete() {
                DemonstrateUtil.showLogResult("onComplete");
            }
        };
    }

    private void init4() {
        mFlowable = Flowable.create(new FlowableOnSubscribe() {
            @Override
            public void subscribe(FlowableEmitter emitter) throws Exception {

                for (int i = 1; i <= 200; i++) {
                    emitter.onNext(i);
                    DemonstrateUtil.showLogResult("生产onNext:"+i);
                }
            }
        }, BackpressureStrategy.DROP);

        //mSubscription = s;
        mSubscriber = new Subscriber() {
            @Override
            public void onSubscribe(Subscription s) {
                mSubscription = s;
                s.request(100);
            }

            @Override
            public void onNext(Integer integer) {
                DemonstrateUtil.showLogResult("消费onNext:" + integer);
            }

            @Override
            public void onError(Throwable t) {
                DemonstrateUtil.showLogResult("onError");
                DemonstrateUtil.showLogResult(t.getMessage());
                DemonstrateUtil.showLogResult(t.toString());
            }

            @Override
            public void onComplete() {
                DemonstrateUtil.showLogResult("onComplete");
            }
        };

    }


    @Override
    public void onClick(View view) {
        if (view.getId() == R.id.btn_backpressure) {
            DialogUtil.showListDialog(this, "Flowable的理解使用", new String[]{
                    "0事件堆积现象",
                    "1正常使用策略ERROR!",
                    "2使用策略ERROR出现的异常!",
                    "3使用策略BUFFER,更大的缓存池",
                    "4使用策略DROP,事件关联100",
                    "5使用策略DROP,再申请100",
                    "6使用策略LATEST,事件关联100",
                    "7使用策略LATEST,再申请100",
                    "8使用策略MISSING",
            }, new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    switch (which) {
                        case 0:
                            show0();
                            break;
                        case 1:
                            show1();
                            break;
                        case 2:
                            show2();
                            break;
                        case 3:
                            show3();
                            break;
                        case 4:
                            show4();
                            break;
                        case 5:
                            show5();
                            break;
                        case 6:
                            show6();
                            break;
                        case 7:
                            show7();
                            break;
                        case 8:
                            show8();
                            break;
                    }
                }
            });
        }
    }

    private void show8() {
        Flowable.create(new FlowableOnSubscribe() {
            @Override
            public void subscribe(FlowableEmitter emitter) throws Exception {
                for (int i = 0; i < 200; i++) {
                    DemonstrateUtil.showLogResult("MISSING-生成emitter" + i);
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.MISSING).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        //mSubscription = s;
                        //s.request(0);
                    }

                    @Override
                    public void onNext(Integer integer) {
                        DemonstrateUtil.showLogResult("MISSING-消费onNext" + integer);
                    }

                    @Override
                    public void onError(Throwable t) {
                        DemonstrateUtil.showLogResult("onError" + t.getMessage());
                        DemonstrateUtil.showLogResult("onError" + t.toString());
                        t.printStackTrace();
                    }

                    @Override
                    public void onComplete() {
                        DemonstrateUtil.showLogResult("onComplete");
                    }
                });
    }

    private void show7() {
        subscriptionLatest.request(100);
    }

    private void show6() {
        flowableLATEST.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(subscriberLatest);
    }

    private void show5() {
        //128-100-100=  -72.
        mSubscription.request(100);
    }

    private void show4() {
        mFlowable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(mSubscriber);
    }


    private void show3() {
        Flowable.create(new FlowableOnSubscribe() {
            @Override
            public void subscribe(FlowableEmitter emitter) throws Exception {
                for (int i = 0; i < 200; i++) {
                    DemonstrateUtil.showLogResult("emitter" + i);
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.BUFFER).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        //mSubscription = s;
                        //s.request(0);
                    }

                    @Override
                    public void onNext(Integer integer) {
                        DemonstrateUtil.showLogResult("onNext" + integer);
                    }

                    @Override
                    public void onError(Throwable t) {
                        DemonstrateUtil.showLogResult("onError" + t.getMessage());
                        DemonstrateUtil.showLogResult("onError" + t.toString());
                        t.printStackTrace();
                    }

                    @Override
                    public void onComplete() {
                        DemonstrateUtil.showLogResult("onComplete");
                    }
                });
    }

    private void show2() {
        Flowable.create(new FlowableOnSubscribe() {
            @Override
            public void subscribe(FlowableEmitter emitter) throws Exception {
                for (int i = 0; i < 200; i++) {
                    DemonstrateUtil.showLogResult("emitter" + i);
                    emitter.onNext(i);
                }
            }
        }, BackpressureStrategy.ERROR).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        //mSubscription = s;
                        //s.request(0);
                    }

                    @Override
                    public void onNext(Integer integer) {
                        DemonstrateUtil.showLogResult("onNext" + integer);
                    }

                    @Override
                    public void onError(Throwable t) {
                        DemonstrateUtil.showLogResult("onError" + t.getMessage());
                        DemonstrateUtil.showLogResult("onError" + t.toString());
                        t.printStackTrace();
                    }

                    @Override
                    public void onComplete() {
                        DemonstrateUtil.showLogResult("onComplete");
                    }
                });
    }

    private void show1() {
        Flowable.create(new FlowableOnSubscribe() {
            @Override
            public void subscribe(FlowableEmitter emitter) throws Exception {
                for (int i = 0; i < 127; i++) {//128
                    DemonstrateUtil.showLogResult("emitter " + i);
                    emitter.onNext(i);
                }
                DemonstrateUtil.showLogResult("emitter complete");
                emitter.onComplete();
            }
        }, BackpressureStrategy.ERROR) //增加了一个参数,设置处理策略.
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        DemonstrateUtil.showLogResult("onSubscribe");
                        //用来向生产者申请可以消费的事件数量,这样我们便可以根据本身的消费能力进行消费事件.
                        s.request(Long.MAX_VALUE);
                    }

                    @Override
                    public void onNext(Integer integer) {
                        DemonstrateUtil.showLogResult("onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable t) {
                        DemonstrateUtil.showLogResult("onError: " + t.getMessage());
                        DemonstrateUtil.showLogResult("onError: " + t.toString());
                        t.printStackTrace();
                    }

                    @Override
                    public void onComplete() {
                        DemonstrateUtil.showLogResult("onComplete: ");
                    }
                });
    }

    private void show0() {
        Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                while (true) {
                    for (int i = 0; i < 129; i++) {
                        e.onNext(1);
                    }
                }
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Thread.sleep(5000);
                        DemonstrateUtil.showLogResult("接受到" + integer);
                    }
                });
    }

    private void initView() {
        btnBackpressure = (Button) findViewById(R.id.btn_backpressure);
        btnBackpressure.setOnClickListener(RxJavaDemo3Activity.this);
    }
}

 
  
GetBitmapForURL
 
  
package com.think.rxjava;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;

import java.io.BufferedInputStream;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;

/**
 * Created by think on 2017/11/28.
 */

public class GetBitmapForURL {

    public static Bitmap getBitmap(String url) {
        //获取传进来的参数
        Bitmap bitmap = null;
        URLConnection connection;
        InputStream is;
        BufferedInputStream bis;
        try {
            connection = new URL(url).openConnection();
            is = connection.getInputStream();
            //为了更清楚的看到加载图片的等待操作,将线程休眠2秒钟
            Thread.sleep(2000);
            bis = new BufferedInputStream(is);
            //通过decodeStream方法解析输入流
            bitmap = BitmapFactory.decodeStream(bis);
            is.close();
            bis.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bitmap;
    }
}

 
  
MyObserver
 
  
package com.think.rxjava;

import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

/**
 * Created by think on 2017/11/29.
 */

public class MyObserver implements Observer {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(Object o) {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
}

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Android随手记)

        

            

                
    
                    
  • Android Jetpack
                        qq_39892855

                        
    AndroidJetpack翻译Jetpack是一套让开发者更容易开发出完美安卓应用的组件。这个组件帮助你遵循最好的实践，让你减少写一些模板代码，简化复杂的task任务，能让你更加专注自己的业务代码。Jetpack使用的是androidx.*包名，与旧的android.*分开。这意味着它提供向后兼容性并且他会更频繁地更新，确保您始终可以访问最新和最好的Jetpack组件版本。特点加速开发组件可以单
    
                    
    • 
                    
  • Android Jetpack介绍
                        Gary.Mi
Android
                        
    1.文档背景本文是Jetpack介绍系列文档的开篇，是对Jetpack整体的介绍，后续会对其中的各个组件分别单独说明。2.官方简介Jetpack是一套库、工具和指南，可帮助开发者更轻松地编写优质应用。使用这些组件，可帮助开发者遵循最佳实践，摆脱编写样板代码的工作并简化复杂任务，使开发者将精力集中放在所需的代码上。Jetpack包含与平台API解除捆绑的androidx.*软件包库。这意味着，它可以
    
                    
    • 
                    
  • Android 架构MVC MVP MVVM+实例
                        2401_89284222
android架构mvc
                        
    1.View接收用户交互请求2.View将请求转交给ViewModel3.ViewModel操作Model数据更新4.Model更新完数据，通知ViewModel数据发生变化5.ViewModel更新View数据View/Model的变动，只要改其中一方，另一方都能够及时更新到MVVM的优点1.提高可维护性。DataBinding可以实现双向的交互，使得视图和控制层之间的耦合程度进一步降低，分离更
    
                    
    • 
                    
  • MVVM架构在Android中的DataBinding实现案例
                        朱佳顺

                        
    本文还有配套的精品资源，点击获取简介：本实例展示了如何利用Google官方DataBinding库在Android应用中实现MVVM架构模式。通过DataBinding库，开发者能够简洁地将数据绑定到UI元素，从而提高代码的可读性和可维护性。实例中包括了MVVM架构的核心概念，以及如何使用表达式语言、Observable对象、BindingAdapter、Layout文件和DataBindingU
    
                    
    • 
                    
  • 知识点专项整理
                        健忘的鱼
androidandroidstudiojava
                        
    跨进程通讯（IPC）参考Android通信机制消息队列：基于SystemV和Posix系统优点异步，解耦，缓冲，缺点：比信号和管道更加重，队列数据有上限（一般16KB）Android中代表handler，但handlerr只是进程内的通信方式：由消息轮询器（Looper）、消息队列（MessageQueue）、消息处理器（Handler）三部分组成，轮询器通过prepare()初始化消息队列，处理
    
                    
    • 
                    
  • HarmonyNext深度解析：ArkUI 3.0声明式开发与高性能渲染实践
                        披光人
harmonyOSharmonyos
                        
    第一章鸿蒙声明式UI架构演进与技术优势1.1从命令式到声明式的范式迁移HarmonyNext的ArkUI3.0标志着鸿蒙开发生态的重大革新，其核心在于采用声明式UI编程范式。相较于传统Android的XML+Java/Kotlin命令式开发模式，声明式UI具有以下技术特征：状态驱动视图：UI呈现完全由数据状态决定，开发者只需描述"UI应该是什么样子"，无需手动操作DOM元素单向数据流：采用Stat
    
                    
    • 
                    
  • Android第二次面试总结（项目拷打实战）
                        每次的天空
android
                        
    MVVM+Jetpack组件落地采用ViewModel+LiveData实现数据驱动开发，将UI逻辑与业务逻辑解耦，通过LiveData的生命周期感知能力避免内存泄漏。使用WorkManager替代传统Service处理后台任务（如数据同步），结合Room数据库实现任务持久化，确保应用被杀后仍能恢复任务。性能优化实战集成Glide加载国风插画，结合自定义三级缓存策略（内存LRU+磁盘缓存+本地资源
    
                    
    • 
                    
  • Qt+ffmpeg环境搭建
                        技术不支持
qtffmpeg开发语言
                        
    Qt+ffmpeg环境搭建各平台常见视频开发库举例:iOS：AVFoundationAudioUnitAndroid：MediaPlayer，MediaCodecWindows：DirectShowLinux：GStreamerFFmpeg库是一个跨平台的视频开发库,还有libVLC也是一个跨平台的视频开发库掌握了其中一个库,也能很快上手其它库,因为音视频解码的原理类似引入FFmpeg库有两种方式
    
                    
    • 
                    
  • android 新闻客户端和springboot后台开发-网络接口封装（三）
                        mmsx
android作业源码分享androidspringboot
                        
    一、前言android新闻客户端和springboot后台开发（一）-CSDN博客android新闻客户端和springboot后台开发（二）-CSDN博客这篇接前面，写android客户端接口这样方面的实现。okhttp简易封装，方便使用。二、例如注册接口示例UsermUser=newUser(account,password,UserTypeEnum.User.getDesc());Okhtt
    
                    
    • 
                    
  • Android自动化测试工具
                        海棠如醉
web技术自动化运维
                        
    细解自动化测试工具Airtest-CSDN博客以下是几种常见的Android应用自动化测试工具：Appium：支持多种编程语言，如Java、Python、Ruby、JavaScript等。可以用于Web应用程序和原生应用程序的自动化测试，并支持iOS和Android平台。Espresso：由Google开发的AndroidUI测试框架，可用于测试应用程序的用户界面和与用户的交互。Espresso支
    
                    
    • 
                    
  • Android文件选择器的优化之旅
                        t0_54manong
编程问题解决手册android个人开发
                        
    在Android开发中，我们经常需要用户从设备中选择文件。最近，我在处理一个项目时遇到了一个有趣的问题：如何限制用户只能选择一个文件，而不是多个。下面我将详细介绍如何实现这个功能，并提供一个实际的例子。问题描述通常，我们使用Intent.ACTION_OPEN_DOCUMENT来启动文件选择器。在默认情况下，这个选择器允许用户选择多个文件，但有时候我们希望用户只能选择一个文件。这不仅可以提高用户体
    
                    
    • 
                    
  • Android签名配置的最佳实践
                        t0_54program
编程问题解决手册android个人开发
                        
    在Android应用开发中，签名配置是一个经常会被忽略却又至关重要的环节。签名不仅能确保应用的完整性，还能验证应用的发布者身份。今天我们将通过一个实际的案例来探讨如何优化Android项目的签名配置。问题的起源在项目中，我们可能会遇到如下的错误：Executionfailedfortask':app:packageDebug'.>Afailureoccurredwhileexecuting>com
    
                    
    • 
                    
  • Android Dagger2 框架注入模块源码深度剖析(四)
                        &有梦想的咸鱼&
android
                        
    一、引言在Android开发中，依赖注入（DependencyInjection，简称DI）是一种重要的设计模式，它能够有效降低代码之间的耦合度，提高代码的可测试性和可维护性。Dagger2作为一款强大的依赖注入框架，在编译时生成依赖注入代码，避免了运行时反射带来的性能开销。注入模块是Dagger2的核心部分，负责将依赖对象注入到目标对象中。本文将深入分析Dagger2框架的注入模块，从源码级别详
    
                    
    • 
                    
  • MPAndroidChart的MarkerView和CursorLineChartRenderer同步显示当前触摸的数据点
                        yzpyzp
androidMPAndroidChart
                        
    MarkerView和CursorLineChartRenderer同步显示当前触摸的数据点触摸图表时，显示竖直的光标线，同时光标线和收益率曲线的交点绘制交点圆圈，交点圆圈跟随MarkerView同步显示，MarkerView显示在哪个数据点，就只需要绘制这个数据点对应的交点圆圈。问题在于如何确定当前MarkerView显示的是哪个数据点。通常，当用户点击图表时，会触发高亮（Highlight）事
    
                    
    • 
                    
  • Android - ViewPager 从基础到进阶
                        whd_Alive
Android基础AndroidViewPager
                        
    前言好记性不如烂笔头，学习的知识总要记录下来，通过本文来加深对ViewPager方方面面的理解：ViewPager的基础介绍PagerAdapter+FragmentPagerAdapter&FragmentStatePagerAdapter与Fragment+TabLayout的联动使用Banner轮播图自定义切换动画首次登录引导界面闲话少说，下面进入正题。基础介绍ViewPager是Andro
    
                    
    • 
                    
  • Flutter中沉浸式状态栏的设置
                        啦啦啦种太阳wqz
flutter沉浸式状态栏
                        
    Flutter中沉浸式状态栏的设置沉浸式状态栏是什么？状态栏是指Android手机顶部显示手机状态信息的位置，Android从4.4版本开始新增了透明状态栏功能，状态栏可以自定义颜色背景，是titleBar能够和状态栏融为一体，增进沉浸感。状态栏默认为黑色半透明，设置沉浸式状态栏后，可以与标题栏颜色一致，效果如上图。如何实现沉浸式状态栏在flutter项目目录下找到android主入口页面Main
    
                    
    • 
                    
  • Android实现动态切换环境配置3.0版本
                        windfallsheng
Androidandroidjavaapache
                        
    文章目录前言先上图启动初始化环境配置环境配置入口环境配置初始化静态URL配置手输URL配置开关配置快捷测试入口环境配置主页面其它总结且看《Android实现动态切换环境配置4.0版本》前言在上一篇幅《Android实现动态切换环境配置2.0版本》我们实现了可以动态切换环境配置的功能，但是一些不同类型的配置参数没有进行区别对待，造成实现逻辑比较耦合，当前3.0版本从页面结构和代码实现上进行了拆分，方
    
                    
    • 
                    
  • Android实现简易计算器
                        syy敬礼
android
                        
    importandroid.os.Bundle;importandroid.view.View;importandroid.widget.Button;importandroid.widget.EditText;importandroid.widget.Toast;importandroidx.appcompat.app.AppCompatActivity;publicclassMainActiv
    
                    
    • 
                    
  • 热修复框架Tinker与Robust原理剖析
                        Ya-Jun
android
                        
    热修复框架Tinker与Robust原理剖析一、热修复技术概述1.1什么是热修复热修复（HotFix）是Android平台上的一种动态修复机制，它允许应用在不重新发布版本的情况下，动态修复线上bug。这种技术对于快速修复线上问题、降低用户流失率具有重要意义。1.2热修复的应用场景紧急bug修复功能动态更新A/B测试动态功能控制1.3主流热修复方案对比方案优点缺点适用场景Tinker支持全量更新、性
    
                    
    • 
                    
  • 在uni-app中使用SQLite
                        today喝咖啡了吗
uni-appsqlite数据库
                        
    目录1、引入sqlite模块1.1、android权限申请1.2、权限配置1.3、打包，制作自定义基座运行2、sqlite文件结构3、初始化文件index.js4、打开数据库5、查询数据6、可视化测试SQLite是一个进程内的库，实现了自给自足的、无服务器的、零配置的、事务性的SQL数据库引擎。它是一个零配置的数据库，这意味着与其他数据库不一样，您不需要在系统中配置。就像其他数据库，SQLite引
    
                    
    • 
                    
  • Android数据存储:SQLite、Room
                        -风になる-
Android基础android
                        
    在Android平台上，集成了一个嵌入式关系型数据库—SQLite，SQLite3支持NULL、INTEGER、REAL（浮点数字）、TEXT(字符串文本)和BLOB(二进制对象)数据类型，虽然它支持的类型只有五种，但实际上sqlite3也接受varchar(n)、char(n)、decimal(p,s)等数据类型，只不过在运算或保存时会转成对应的五种数据类型。SQLite最大的特点是你可以把各种
    
                    
    • 
                    
  • 图片加载框架Glide与Picasso原理剖析
                        Ya-Jun
glideandroid
                        
    图片加载框架Glide与Picasso原理剖析一、前言图片加载是Android应用开发中的一个重要环节，良好的图片加载机制可以提升应用性能和用户体验。Glide和Picasso是目前最流行的两个图片加载框架，本文将深入分析这两个框架的核心原理和实现机制。二、图片加载基础2.1图片加载的挑战内存管理OOM（OutOfMemory）问题内存缓存策略图片复用性能优化异步加载图片压缩缓存机制用户体验加载占
    
                    
    • 
                    
  • ANR和Crash的监控与分析
                        Ya-Jun
android
                        
    ANR和Crash的监控与分析在Android应用开发中，应用的稳定性是用户体验的重要组成部分。ANR（ApplicationNotResponding）和Crash（应用崩溃）是影响应用稳定性的两大主要问题。本文将深入探讨ANR和Crash的原因、监控方法以及分析策略，帮助开发者构建更加稳定可靠的应用。一、理解ANR1.1什么是ANRANR（ApplicationNotResponding）是指
    
                    
    • 
                    
  • Android电量与流量优化
                        Ya-Jun
android
                        
    Android电量与流量优化一、电量优化基础1.1电量消耗原理Android设备的电量消耗主要来源于以下几个方面：屏幕显示：屏幕是耗电量最大的硬件之一，尤其是高亮度和高刷新率的屏幕。CPU处理：CPU执行计算任务时会消耗大量电量，尤其是高负载运算。网络通信：移动数据、Wi-Fi和蓝牙等网络通信会持续消耗电量。GPS定位：GPS定位是非常耗电的操作，尤其是高精度定位。传感器使用：加速度计、陀螺仪等传
    
                    
    • 
                    
  • Android 里SQLite和ROOM框架简单介绍
                        大林不要掉头发
android数据库
                        
    简单的AndroidSQLite使用最简单的SQLite在Android开发中，SQLite是一个轻量级的关系型数据库管理系统，经常用于存储和管理应用程序的数据。如果你刚刚学习Android数据库的使用，你一定要学习SQLite的使用。以下是一个简单的示例，展示了如何在Android应用中创建SQLite数据库、创建表、插入数据以及查询数据。创建SQLite数据库、创建表publicclassDB
    
                    
    • 
                    
  • 10分钟速通【uniapp面试题】
                        2501_91133311
uni-app
                        
    写在前面：铁子们，我有个长期项目，想搞点外快的宝子可以看看我GitHub！https://github.com/yuhan-9527/coder2retire1.什么是UniApp？它有什么特点？答案：UniApp是一个基于Vue.js的跨平台应用开发框架，可以使用Vue.js的开发语法编写一次代码，然后通过编译生成可以在多个平台（包括iOS、Android、H5等）上运行的应用。UniApp具有
    
                    
    • 
                    
  • 【Android】使用Room数据库解决本地持久化
                        吃汉堡吃到饱
android数据库jvm
                        
    【Android】使用Room数据库解决本地持久化Room概述Room是一个持久性库，属于AndroidJetpack的一部分。Room是SQLite数据库之上的一个抽象层。Room并不直接使用SQLite，而是负责简化数据库设置和配置以及与数据库交互方面的琐碎工作。此外，Room还提供SQLite语句的编译时检查。Room主要组件Room包含三个主要组件：数据实体表示应用的数据库中的表。数据实体
    
                    
    • 
                    
  • android 32位crc,android arm64硬件实现加速crc32算法
                        Luo Patrick
android32位crc
                        
    在androidarm64平台下，crc32，aes等常用算法有指令集实现。故在android下，可借助这些指令实现代码加速。如何判断自己的手机是否支持crc32呢？有三个方法:方法1，直接查看/proc/cpuinfo方法2，使用ELF辅助向量APIunsignedlonghwcap=getauxval(AT_HWCAP);if(hwcap&HWCAP_CRC32)return1;}return
    
                    
    • 
                    
  • 在Android Studio中通过CMake实现交叉编译生成动态so文件
                        H.ZWei
AndroidNDKandroidstudioandroidAndroidNDKCMake动态so文件交叉编译
                        
    文章目录NDK工具链基本步骤CMake配置文件aux_source_directoryinclude_directorieslink_directoriesadd_librarytarget_link_libraries将CMake配置文件依赖到Gradle中交叉编译生成动态库参考NDK工具链最近项目上需要将微信语音silk文件格式进行编解码，在silk、PCM、AMR、MP3间进行格式转换，将s
    
                    
    • 
                    
  • android 根目录 写文件路径,android app文件目录结构
                        weixin_39593498
android根目录写文件路径
                        
    转：https://blog.csdn.net/luoguopeng/article/details/72832567androidapp目录:SDCard/Android/data/你的应用的包名/原来，只要把文件写在这里的话，可以不用动态申请权限，只要在manifest里面声明权限就ok了；应用程序在运行的过程中如果需要向手机上保存数据，一般是把数据保存在SDcard中的。大部分应用是直接在S
    
                    
    • 
                                
  • windows下源码安装golang
                                    616050468
golang安装golang环境windows
                                    
             系统： 64位win7， 开发环境：sublime text 2，  go版本： 1.4.1 
  
 1.  安装前准备(gcc, gdb, git) 
       golang在64位系
    
                                
    • 
                                
  • redis批量删除带空格的key
                                    bylijinnan
redis
                                    
    redis批量删除的通常做法： 
 
 
redis-cli keys "blacklist*" | xargs redis-cli del 
 
上面的命令在key的前后没有空格时是可以的，但有空格就不行了： 
 

$redis-cli keys "blacklist*"
1) "blacklist:12: [email protected]
    
                                
    • 
                                
  • oracle正则表达式的用法
                                    0624chenhong
oracle正则表达式
                                    
      方括号表达示 
方括号表达式 
描述 
[[:alnum:]] 
字母和数字混合的字符 
[[:alpha:]] 
字母字符 
[[:cntrl:]] 
控制字符 
[[:digit:]] 
数字字符 
[[:graph:]] 
图像字符 
[[:lower:]] 
小写字母字符 
[[:print:]] 
打印字符 
[[:punct：]] 
标点符号字符 
[[:space:]]
    
                                
    • 
                                
  • 2048源码(核心算法有，缺少几个anctionbar，以后补上)
                                    不懂事的小屁孩
2048
                                    
    2048游戏基本上有四部分组成， 
1：主activity，包含游戏块的16个方格，上面统计分数的模块 
2：底下的gridview，监听上下左右的滑动，进行事件处理， 
3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字 
4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现) 
 
写代码的流程 
1：设计游戏的布局，基本是两块，上面是分
    
                                
    • 
                                
  • jquery内部链式调用机理
                                    换个号韩国红果果
JavaScriptjquery
                                    
    只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this  因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象） 

function  create(type){
var element=document.createElement(type);
    //this=element;

    
                                
    • 
                                
  • 你订酒店时的每一次点击 背后都是NoSQL和云计算
                                    蓝儿唯美
NoSQL
                                    
    全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。 
云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。 
Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
    
                                
    • 
                                
  • java笔记1
                                    a-john
java
                                    
    1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。 
2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。 
3，面向对象程序设计方式的特性： 
    3.1 万物皆为对象。 
   
    
                                
    • 
                                
  • C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题 必备考点（一）
                                    aijuans
C/C++求职面试必备考点
                                    
            找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。 
       后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
    
                                
    • 
                                
  • 程序员写代码时就不要管需求了吗？
                                    asia007
程序员不能一味跟需求走
                                    
          编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。 
      我的技术不是很好，但是就不代
    
                                
    • 
                                
  • Activity的四种启动模式
                                    百合不是茶
android栈模式启动Activity的标准模式启动栈顶模式启动单例模式启动
                                    
    android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ; 
  
启动模式xml中配置 
    <activity android:name=".MainActivity" android:launchMode="standard&quo
    
                                
    • 
                                
  • Spring中@Autowired标签与@Resource标签的区别
                                    bijian1013
javaspring@Resource@Autowired@Qualifier
                                    
    Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。 
  
1. @Autowired    @Autowired是Spring 提供的，需导入    Package:org.springframewo
    
                                
    • 
                                
  • Changes Between SOAP 1.1 and SOAP 1.2
                                    sunjing
ChangesEnableSOAP 1.1SOAP 1.2
                                    
    JAX-WS 
SOAP Version 1.2 Part 0: Primer (Second Edition) 
SOAP Version 1.2 Part 1: Messaging Framework (Second Edition) 
SOAP Version 1.2 Part 2: Adjuncts (Second Edition) 
  
Which style of WSDL
    
                                
    • 
                                
  • 【Hadoop二】Hadoop常用命令
                                    bit1129
hadoop
                                    
    以Hadoop运行Hadoop自带的wordcount为例， 
  
hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行 
  Hadoop HDFS相关命令 
 
  hadoop fs -ls 
 
 列出HDFS文件系统的第一级文件和第一级
    
                                
    • 
                                
  • java异常处理（初级）
                                    白糖_
javaDAOspring虚拟机Ajax
                                    
    从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。 
最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
    
                                
    • 
                                
  • 记录整理-工作问题
                                    braveCS
工作
                                    
    1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。 
2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
    
                                
    • 
                                
  • org.apache.tools.zip实现文件的压缩和解压，支持中文
                                    bylijinnan
apache
                                    
    刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦） 
后改用org.apache.tools.zip 
org.apache.tools.zip的使用网上有更简单的例子 
下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法 
 



import java.io.BufferedReader;
import java.io.BufferedWrit
    
                                
    • 
                                
  • 读书笔记-4
                                    chengxuyuancsdn
读书笔记
                                    
    1、JSTL 核心标签库标签 
2、避免SQL注入 
3、字符串逆转方法 
4、字符串比较compareTo 
5、字符串替换replace 
6、分拆字符串 
 
 
1、JSTL 核心标签库标签共有13个，
学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html
功能上分为4类：
(1)表达式控制标签：out
    
                                
    • 
                                
  • [物理与电子]半导体教材的一个小问题
                                    comsci
问题
                                    
     
 
      各种模拟电子和数字电子教材中都有这个词汇-空穴 
 
      书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴 
 
      我现在回过头翻大学时候的教材,觉得这个
    
                                
    • 
                                
  • Flashback Database --闪回数据库
                                    daizj
oracle闪回数据库
                                    
    Flashback 技术是以Undo segment中的内容为基础的， 因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。 
在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
    
                                
    • 
                                
  • 简单排序:插入排序
                                    dieslrae
插入排序
                                    
    
    public void insertSort(int[] array){
        int temp;
        
        for(int i=1;i<array.length;i++){
            temp = array[i];
            
            for(int k=i-1;k>=0;k--)
    
                                
    • 
                                
  • C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int main(void)
{
	int * p; //等价于 int *p 也等价于 int* p;
	int i = 5;
	char ch = 'A';

	//p = 5;	//error
	//p = &ch;	//error
	//p = ch;	//error

	p = &i;		// 
    
                                
    • 
                                
  • centos下php redis扩展的安装配置3种方法
                                    dcj3sjt126com
redis
                                    
    方法一 
1.下载php redis扩展包     代码如下 复制代码    
#wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz     
2 tar -zxvf 解压压缩包，cd /扩展包 （进入扩展包然后 运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
    
                                
    • 
                                
  • 线程池(Executors)
                                    shuizhaosi888
线程池
                                    
    在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦 
	public interface Executor {

	    void execute(Runnable command);
	}
 
  
public class RunMain implements Executor{

	@Override
	pub
    
                                
    • 
                                
  • openstack 快速安装笔记
                                    haoningabc
openstack
                                    
    前提是要配置好yum源 
版本icehouse，操作系统redhat6.5 
最简化安装，不要cinder和swift 
三个节点 
172 control节点keystone glance horizon 
173 compute节点nova 
173 network节点neutron 
 

control
/etc/sysctl.conf

net.ipv4.ip_forward =
    
                                
    • 
                                
  • 从c面向对象的实现理解c++的对象（二）
                                    jimmee
C++面向对象虚函数
                                    
    1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。 
2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数 
3. c++中类的析构函数，就时回收内存(free) 
4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。 
专门在
    
                                
    • 
                                
  • 如何让那个一个div可以拖动
                                    lingfeng520240
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/1999/xhtml
    
                                
    • 
                                
  • 第10章 高级事件（中）
                                    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/
    
                                
    • 
                                
  • 计算两个经纬度之间的距离
                                    roadrunners
计算纬度LBS经度距离
                                    
    要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。 
	/**
	 * 
	 * @param longitudeA
	 *            经度A点
	 * @param latitudeA
	 *            纬度A点
	 * @param longitudeB
	 *    
    
                                
    • 
                                
  • 最具争议的10个Java话题
                                    tomcat_oracle
java
                                    
    1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！   　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。   　 
　2、Java 9 即将到来   　　 
Oracle早在8月份就发布
    
                                
    • 
                                
  • zoj 3826 Hierarchical Notation(模拟)
                                    阿尔萨斯
rar
                                    
     题目链接：zoj 3826 Hierarchical Notation 
 题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。 
 解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。 这题是最后10分钟出的，因为没有考虑value为{}的情
    
                                
    •