泡温泉的咸鱼
泡温泉的咸鱼

android 积累一些关于rxjava的知识点


rxjava在我看来就是一套比较先进的asynctask，用来处理异步请求的一种规范（得益于它的代码思路清晰），在android中可以用来代替asynctask甚至是handler。常与当前流行网络请求框架retrofit2一同使用。


rxjava的采用了观察者模式:Observer/Subscriber(观察者),Observable(主题)。个人喜欢把Observer/Subscriber当做事件的消费者，Observable当做是事件的产生者。


优点：线程切换（android 网络请求与UI刷新），逻辑清晰



android-studio 环境配置:


   compile 'io.reactivex:rxjava:1.0.14'
   compile 'io.reactivex:rxandroid:1.0.1'

Observer/Subscriber(观察者)

 Observer  observer=new Observer() {
            @Override
            public void onCompleted() {
                Log.i("rxjava::","onCompleted::");

            }

            @Override
            public void onError(Throwable e) {
                Log.i("rxjava::","onError::"+e.getMessage());

            }

            @Override
            public void onNext(String s) {

                /**
                 * 被观察者“发给” 观察者的消息
                 * 可以理解成 事件在这里消费
                 */

                Log.i("rxjava::","onNext::"+s);

            }
        };

 Subscriber  subscriber=new Subscriber() {
            @Override
            public void onCompleted() {
                Log.i("rxjava::","onCompleted::");

            }

            @Override
            public void onStart() {
                super.onStart();
                Log.i("rxjava::","onStart::");

            }

            @Override
            public void onError(Throwable e) {
                Log.i("rxjava::","onError::"+e.getMessage());

            }

            @Override
            public void onNext(String s) {
                Log.i("rxjava::","onNext::"+s);

            }
        };

观察者两种写法的区别:

1.Subscriber 对 Observer 接口进行了一些扩展,即Subscriber 里可以重写一个onstart的方法

2.onstart方法：在被观察者“发送”消息之前。我也不知道有什么软用，不能加载进度条（因为不在UI线程）


Observable(被观察者)

 Observable observable = Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                //事件中心
                subscriber.onNext("hasaki");

                subscriber.onNext("mianduijifengba");


                subscriber.onCompleted();//此句话要是不调用   观察者里的oncompleted方法就不会调用

            }
        });


Subject:也是一种事件的产生与发送者,可替代Observable

PublishSubject.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext("nihao");
            }
        }).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {

                Log.i("TTTTT:::",s+"???");
            }
        });












当然被观察者还可以使用固定的方法来“发送数据给观察者”

just(传入要发送的数据序列并用逗号隔开); 
/**
* 此方法默认在执行结束加上onCompleted();
*/
 Observable observable =  Observable.just("hasaki","mianduijifengba");

from(可传入对象数组); 

        String[]  requestArray={"hasaki","mianduijifengba"};
        /**
         * 此方法默认在执行结束加上onCompleted();
         */
        Observable observable = Observable.from(requestArray);

订阅:“被观察者去订阅观察者”：原因是:流式API设计(什么鬼？) 

 //订阅
 observable.subscribe(subscriber);

取消订阅:(对于异步请求结束后,要解除引用关系,避免内存泄漏)
一般订阅之后都会产生一个Subscription对象


        //订阅
        Subscription subscribe = observable.subscribe(subscriber);

        if(subscribe.isUnsubscribed()){
            //判断是否解除订阅
            Log.i("rxjava","没有解除订阅");

            subscribe.unsubscribe();//解除订阅


        }else{
            Log.i("rxjava","解除订阅");
        }

初级进阶(线程控制)

因为被观察者是"事件的产生者"，而观察者是"事件的消费者",通常在网络请求中，被观察者里开启子线程做网络请求，观察者里要在UI线程中跟新UI，主要运用到两个方法： 

 observable.subscribeOn();//设置被观察者里事件产生所处的线程,即：调用call方法所处的线程
        
 observable.observeOn();//观察者，事件消费所处的线程即：onNext
线程分类: 
Schedulers.immediate()//当前线程，即默认


Schedulers.newThread()//顾名思义，开启新线程




Schedulers.io()//相当于cacheThreadPool  维护一个不定数量的线程池，还可重复利用




AndroidSchedulers.mainThread()//android 专利，顾名思义，即主线程。




example:开启线程读取数据，UI线程跟新数据::






       String[] requestArray = {"hasaki", "面对疾风吧"};

        Observable.from(requestArray)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(String s) {

                        tv.setText(s);

                    }
                });


中级进阶(变换)

所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。




1.Map（转换类操作符）单个转换


什么是转成不同的事件?






说白了就是我要把现金存入支付宝，我的事件队列是现金，我最后想要的事件结果是支付宝里有钱，可是现金不能直接存支付宝，得先变换一下


，即先存银行卡转成电子货币，最后支付宝转账。（转单个事件）




/**
         * 假设字符串格式为现金
         * int格式为电子货币
         * func:字符串转int
         */
        Observable.just("100").map(new Func1() {
            @Override
            public Integer call(String s) {
                //先转电子货币
                return Integer.valueOf(s);
            }
        }).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Integer integer) {

                Log.i("电子货币转支付宝::", integer + "");

            }
        });


map的功能:即对象的一对一转换,当被观察者事件产生了，先执行map里的方法，再到观察者消费事件(对象的直接变换)





func1:提供了一个有形参和返回值的call方法（call方法？秀等麻袋，请自行对比一下之前被观察者里产生事件的call方法，先埋一个坑）








2.flatMap(转换类操作符)


那转不同的事件序列呢?(也就是转一堆)


example:假设一天马云爸爸闲的蛋疼，他想看看他的支付宝后台，他想知道每个人的名字，以及每个人都绑定了什么样的银行卡。就是循环打印人名和循环


打印card名,假设类该这么写：Person类里维护了一个name和card数组,card类里维护了cardname和cardmoney




 Person[] persons = {new Person("张三", new Card[]{new Card("工商", "100"), new Card("农行", "200")}),
                new Person("亚索", new Card[]{new Card("工商", "300"), new Card("农行", "400")})
        };

        Observable.from(persons).flatMap(new Func1>() {
            @Override
            public Observable call(Person person) {

                Log.i("rxjava::", person.getName());

                return Observable.from(person.getCards());
            }
        }).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Card card) {

                Log.i("rxjava::", card.toString());

            }
        });


flatMap：对象转新的事件序列，注意func1返回值的变换，他返回的是一个被观察者对象,然后又拿着这个对象去


请求新的序列。










这里的应用环境究竟是什么样的呢，假设你要读取列表中的某个key，然后拿着这key读取新的列表


会用到吧？我也没用过啊，我是边看别人的博客，写下自己的理解。






我的理解:将一堆事件序列转成一个Observerble再统一发出去




flatMap的交叉问题:假设现有一个数组person[3]{校长，老师，学生},经过flatMap要求得到每个人身上的钱，


也许取的第一个对象是校长，第二个是老师，也许取的第一个对象是校长，第二个对象是学生。也就是说只


保证铺平序列，不能保证发送序列的顺序。


问题：我写的例子里，都是正常发送的顺序未发现错乱，也许是数据源基数太小。


3.contatMap(转换类操作符) 



作用类似于flatMap但不会产生交叉问题，也就是正常按发送顺序发送











User[]  users=new User[]{new User("张三","22"),new User("李四","23"),new User("老王","24")};

        Observable.from(users).concatMap(new Func1>() {
            @Override
            public Observable call(User user) {
                return Observable.just(user.getFirstName());
            }
        }).subscribe(new Action1() {
            @Override
            public void call(String s) {
                Log.i("YYYYTTT::",s);
            }
        });







4.scan(转换类操作符)











Observable.just(1, 2, 3, 4, 5)
                .scan(new Func2() {
                    @Override
                    public Integer call(Integer integer, Integer integer2) {
                        Log.i("YYYYTTT????", integer+"/"+integer2);
                        return integer + integer2;
                    }
                }).subscribe(new Action1() {
            @Override
            public void call(Integer integer) {
                Log.i("YYYYTTT::", integer+"");
            }
        });






打印结果::


android 积累一些关于rxjava的知识点_第1张图片






先直接返回第一个结果，然后此结果作为下一个结果的第一个条件参数。




对一个序列的数据应用一个函数，并将这个函数的结果发射出去作为下个数据应用合格函数时的第一个参数使用。





5.filter(过滤操作符)




 List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).filter(new Func1() {
            @Override
            public Boolean call(User user) {
                if (user.getFirstName().equals("张三")){
                    return false;//过滤掉
                }else{
                    return true;//留着
                }
            }
        }).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
















6.take(过滤操作符)










//找出数据序列前三个数据





        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).take(3).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });










//找出第一项数据 first == take(1)





        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable.from(users).first().subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });







































//找出数据序列中最后三条数据





        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).takeLast(3).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
















//一直读，知道满足条件为止，包含满足条件的那条

















        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).takeUntil(new Func1() {
            @Override
            public Boolean call(User user) {
                if (user.getFirstName().equals("大锤")){
                    return true;//读到此处不再读取
                }else{
                    return  false;
                }

            }
        }).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });









7.skip(过滤操作符)



忽略掉数据序列中的前多少项











        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).skip(3).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });



//忽略后三项的数据





        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).skipLast(3).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });















8.elementAt(过滤操作符)



只获取数据序列中的某一项数据










//获取第四项数据





        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).elementAt(3).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });






















9.distinct(过滤操作符)










过滤掉重复的元素





        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable.from(users).distinct().subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::", user.toString());
            }
        });



android 积累一些关于rxjava的知识点_第2张图片












//可还是有两条数据相等，足以可见其判断相同的机制不满足于对象与对象之间的比较




//所有还可以更加细节的过滤





        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));
        
        Observable.from(users).distinct(new Func1() {
            @Override
            public String call(User user) {
                return user.getFirstName();//过滤掉重名
            }
        }).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
















10.last last == takeLast(1)










最后一项











        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable.from(users).last().subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });


11.merge(组合操作符)










将多个发射序列合并成一个发射序列，新序列里的数据是无序的











        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable ob1 = Observable.from(users);

        Observable ob2 = Observable.just(1, 2, 3, 4);


        Observable.merge(ob1, ob2).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Object o) {
                
                Log.i("TTGGG:::",o.toString());

            }
        });


android 积累一些关于rxjava的知识点_第3张图片





？？？说好无序的呢？难道测试数据过小？




12.startWith(组合操作符)




发射数据之前插入一条相同类型的新数据或者相同类型的新发射序列





        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable.from(users).startWith(new User("帅哥","18")).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("TTTDDDD::",user.toString());
            }
        });



android 积累一些关于rxjava的知识点_第4张图片












13.concat(组合操作符)




多个发射序列，逐个序列数据发出，接收的数据一定是顺序的





        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable ob1 = Observable.from(users);


        Observable ob2 = Observable.just(1, 2, 3, 4, 5);


        Observable.concat(ob1, ob2).subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i("TTGGGD:",o.toString());
            }
        });


android 积累一些关于rxjava的知识点_第5张图片





14.zip（组合操作符）




1+1组合,











        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable ob1 = Observable.from(users);


        Observable ob2 = Observable.just(1, 2, 3, 4, 5,6);


       Observable.zip(ob1, ob2, new Func2() {
           @Override
           public String call(User user, Integer integer) {
               return user.getFirstName()+integer;
           }
       }).subscribe(new Action1() {
           @Override
           public void call(String s) {
               Log.i("TGGDD::",s);
           }
       });


android 积累一些关于rxjava的知识点_第6张图片








15.combineLatest(组合操作符)










第一个发射序列的最后一个元素与第二个发射序列的所有元素组合





        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable ob1 = Observable.from(users);


        Observable ob2 = Observable.just(1, 2, 3, 4, 5,6);


       Observable.combineLatest(ob1, ob2, new Func2() {
           @Override
           public String call(User user, Integer integer) {
               return user.getFirstName()+integer;
           }
       }).subscribe(new Action1() {
           @Override
           public void call(String s) {
               Log.i("TGGDD::",s);
           }
       });



android 积累一些关于rxjava的知识点_第7张图片













































总结:既然rxjava里可以转换，那么转换处在哪个线程里呢，转换通通处在观察者的线程里


即你在转换之前observable.observeOn()设定的是什么线程，它就处在什么线程里。




高级进阶:


rxjava+retrofit2




关于retrofit2我也在学习中,先做简单的使用:


导入:




    compile 'com.squareup.retrofit2:retrofit:2.1.0'
    compile 'com.squareup.retrofit2:converter-scalars:2.0.0'
    compile 'com.squareup.retrofit2:adapter-rxjava:2.0.0'


别忘了添加网络权限,切记要添加



addCallAdapterFactory(RxJavaCallAdapterFactory.create())//让rxjava能使用retrofit2










 private void initData() {
        Retrofit retrofit = new Retrofit.Builder().baseUrl("http://fdj.abc5.cn")
                .addConverterFactory(ScalarsConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();
        HttpUser httpUser = retrofit.create(HttpUser.class);

        httpUser.getUsers("hcy", "1234")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        Log.i("网络请求的数据::", "onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.i("网络请求的数据::", "onError" + e.getMessage());
                    }

                    @Override
                    public void onNext(String s) {

                        Log.i("网络请求的数据::", s);
                        tv.setText(s);

                    }
                });
        
    }


    public interface HttpUser {
        @POST("/api/index/posttest")
        @FormUrlEncoded
        Observable getUsers(@Field("username") String username, @Field("password") String password);
    }


小结：



关于Action1,Action0,Func1使用与区别:


Func1:有形参，有返回


Func2:多个形参,有返回


Action1:有形参，无返回


Action0:无形参，无返回




Action1,Action0可以代替观察者里的三个方法,OnNext,OnError,OnCompleted;






Action1 onNextAction = new Action1() {
            // onNext()
            @Override
            public void call(String s) {
                Log.i("onNext:::",s);
            }
        };
        Action1 onErrorAction = new Action1() {
            // onError()
            @Override
            public void call(Throwable throwable) {
                Log.i("onError:::",throwable.getMessage());
            }
        };
        Action0 onCompletedAction = new Action0() {
            // onCompleted()
            @Override
            public void call() {
                Log.i("onCompleted","");
            }
        };
        Observable.just("hasaki","posigei").subscribe(onNextAction,onErrorAction,onCompletedAction);



































如何多次切换线程::

(线程切换容易出现的异常::java.lang.IllegalStateException: Fatal Exception thrown on Scheduler.Worker thread.


找到异常的最后一般又可以看到::Caused by: android.os.NetworkOnMainThreadException)


example:像我所在的公司要强求服务器的一条连接，要请求两次,第一次请求服务器的时间，然后按


字母顺序将请求的参数排序在最后加载请求的时间和appkey字段形成sign，再把sign和时间放入


参数map中请求第二个连接才能得到想要的数据，是不是贼几把麻烦，以前封装的时候因为要考虑到


其实是两次网络请求（不能放在主线程中，android基础），但请求得到的数据我又想能切换到主线程


跟新UI，以前的代码一大堆，现在贴出我第一次封装的代码，感受下rxjava切换线程的好处




package utils;

import android.util.Log;

import com.alibaba.fastjson.JSON;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import contact.Contact;
import okhttp3.RequestBody;
import retrofit2.Call;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
import retrofit2.converter.scalars.ScalarsConverterFactory;
import retrofit2.http.GET;
import retrofit2.http.Multipart;
import retrofit2.http.POST;
import retrofit2.http.PartMap;
import retrofit2.http.Url;
import rx.Observable;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Func1;
import rx.schedulers.Schedulers;

/**
 * Created by hcy on 2016/12/24.
 */

public class WytHttpUtils {

    public interface HttpServerTime {
        @GET("/api/getservicetime.php")
        Observable HttpTime();
    }


    public interface HttpResult {
        @POST
        @Multipart
        Observable httpResult(@Url String url, @PartMap Map params);
    }


    private Map map;


    public WytHttpUtils(Map map) {
        this.map = map;
    }


    public void HttpRequest(String url) {
        ServiceFactory.createServiceFrom(HttpServerTime.class, "http://iexue.quxue100.cn")
                .HttpTime()
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .flatMap(new Func1>() {
                    @Override
                    public Observable call(HttpTime httpTime) {

                        Log.i("DDDSSS222::", httpTime.toString());
                        if (httpTime.getStatus() == 1) {
                            //时间获取成功
                            String sign = getValueFromMap(map).append(httpTime.getResult()).append(Contact.APPKEY).toString();
                            map.put("time", httpTime.getResult() + "");
                            map.put("sign", md5Encode(sign));
                            getValueFromMap2(map);
                            Observable observable1 =  ServiceFactory.createServiceFrom(HttpResult.class,"http://iexue.quxue100.cn").httpResult(url, getValueFromMap2(map));
                            return observable1;
                        } else {
                            return null;
                        }

                    }
                }).observeOn(AndroidSchedulers.mainThread())//切换到主线程
                .subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                Log.i("rxjava::onCompleted:", "onCompleted");

            }

            @Override
            public void onError(Throwable e) {

                Log.i("rxjava::onError:", e.getMessage());

            }

            @Override
            public void onNext(String s) {

                Log.i("rxjava::onNext:", s);

            }
        });


        //return  observable;
    }


    private String md5Encode(String content) {
        //选择摘要算法
        MessageDigest md = null;
        try {
            md = MessageDigest.getInstance("md5");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        //设置要摘要的内容:
        md.update(content.getBytes());
        //生成摘要
        byte[] value = md.digest();
        //转16进制
        String md5Value = toHexString(value);
        return md5Value;
    }


    private String toHexString(byte[] value) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < value.length; i++) {
            //消除负数 我们认为每一个byte都是正数
            int values = value[i] & 255;
            if (values < 16) {
                //如果值小于16 那么使用Integer.toHexString算出来的值是0-f
                //必须补0
                sb.append("0");
            }
            sb.append(Integer.toHexString(values));
        }
        return sb.toString();
    }


    private StringBuffer getValueFromMap(Map map) {

        Iterator iter = map.entrySet().iterator();
        StringBuffer buffer = new StringBuffer();

        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();

            Object val = entry.getValue();

            buffer.append(val + "");


        }
        return buffer;
    }


    private Map getValueFromMap2(Map map) {

        Iterator iter = map.entrySet().iterator();
        Map requestBodyMap = new HashMap();
        Log.i("DSDSDS::", map.size() + "");
        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();

            String val = (String) entry.getValue();

            String key = (String) entry.getKey();

            Log.i("rxjava::", key + "???" + val);

            requestBodyMap.put(key, RequestBody.create(null, val));
            //photos.put("password",  RequestBody.create(null, "123456"));


        }
        return requestBodyMap;
    }

    private class HttpTime {


        public HttpTime(int status, String msg, int result) {
            this.status = status;
            this.msg = msg;
            this.result = result;
        }

        public HttpTime() {
        }


        @Override
        public String toString() {
            return "HttpTime{" +
                    "status=" + status +
                    ", msg='" + msg + '\'' +
                    ", result=" + result +
                    '}';
        }

        /**
         * status : 1
         * msg : 获取成功
         * result : 1482549878
         */

        private int status;
        private String msg;
        private int result;

        public int getStatus() {
            return status;
        }

        public void setStatus(int status) {
            this.status = status;
        }

        public String getMsg() {
            return msg;
        }

        public void setMsg(String msg) {
            this.msg = msg;
        }

        public int getResult() {
            return result;
        }

        public void setResult(int result) {
            this.result = result;
        }
    }

}






附录:


rxjava 正计时 与 倒计时








package utils;
import android.content.Context;

import com.orhanobut.logger.Logger;

import java.text.SimpleDateFormat;
import java.util.TimeZone;
import java.util.concurrent.TimeUnit;

import lessonmodule.LessonActivity;
import rx.Observable;
import rx.Subscription;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Func1;
import wytnewhttp.WytHttpUtils;


/**
 * Created by hcy on 2017/2/24.
 */

public class RxUtils {
    //倒计时
    public static Observable countDownTime(int time) {
        if (time < 0) {
            time = 0;
        }
        final int countTime = time;
        return Observable.interval(0,1, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Func1() {
                    @Override
                    public String call(Long aLong) {
                        //解决八小时的时区问题
                        String format = new SimpleDateFormat("HH:mm:ss").format((countTime - aLong.intValue()) * 1000- TimeZone.getDefault().getRawOffset());

                        Logger.i("倒计时：："+format);
                        return format;
                    }
                })
                .take(countTime + 1);

    }


    //正计时

    public static Observable countUpTime() {
        final int countTime = 0;
        return Observable.interval(0,1, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Func1() {
                    @Override
                    public String call(Long aLong) {
                        return new SimpleDateFormat("HH:mm:ss").format((countTime + aLong.intValue())*1000);
                    }
                });
    }


    public static void unsubscribe(Subscription subscription) {
        if (subscription != null && !subscription.isUnsubscribed()) {
            subscription.unsubscribe();
        }
    }


}


















      countTimeSubscription = RxUtils.countDownTime(60).subscribe(new Action1() {
                    @Override
                    public void call(String s) {
                        tv_countTime.setText(s);
                    }
                });




























































































你可能感兴趣的:(Android)






    

  • android系统selinux中添加新属性property
辉色投像

    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
    

    • 

  • 2.2.6 通知类控件 Toast、Menu
常思行

    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
    

    • 

  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
weixin_39762838
mac备份android手机通讯录导入iphone

    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
    

    • 

  • android 更改窗口的层次,浮窗开发之窗口层级
Ms.Bu
android更改窗口的层次

    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
    

    • 

  • Android应用性能优化
轻口味
Android

    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
    

    • 

  • Android实现监听事件的方法
Amy木婉清

    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
    

    • 

  • 高级UI<第二十四篇>：Android中用到的矩阵常识
NoBugException

    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
    

    • 

  • RK3229_Android9.0_Box 4G模块EC200A调试
suifen_
网络

    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
    

    • 

  • kt文件和java文件_Java与Kotlin之间怎样进行互操作
铭空间
kt文件和java文件

    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
    

    • 

  • Android shell 常用 debug 命令
晨春计
Audiodebugandroidlinux

    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
    

    • 

  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
2401_84544531
程序员android面试学习

    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
    

    • 

  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT)
计算机源码社
Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设

    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
    

    • 

  • android ndk 开发jni调用对象方法，数组参数
wulongkou
开发问题安卓的事ndkandroidstudiojni

    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
    

    • 

  • Android jni中数组参数的传递方式
lokeyme
Andriodandroid开发JNINDKjavac语言

    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
    

    • 

  • 1-1.Jetpack 之 Navigation 简单编码模板
我命由我12345
Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack

    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
    

    • 

  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
erhtre
程序员androidjetpack架构sqlite

    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
    

    • 

  • Android干净架构MVI模板使用指南
井美婵Toby

    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
    

    • 

  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件
惊鸿醉
Unityunityandroidxml

    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
    

    • 

  • 《Android进阶之光》读书笔记
soleil雪寂
读书笔记#Android进阶之光

    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
    

    • 

  • 《Android进阶之光》— Android 书籍
王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发

    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
    

    • 

  • 《android进阶之光》——多线程编程（上）
TAING要一直努力
读书笔记

    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
    

    • 

  • android进阶之光！Android面试必备的集合源码详解，系列篇
程序员Sunbu
程序员Android

    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
    

    • 

  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1)
egrhef
程序员androidjava开发语言

    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
    

    • 

  • Visual Studio中的Android模拟器使用详解
wurui8
androidandroidstudioandroidandroid应用

    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
    

    • 

  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示
仙魁XAN
Unity进阶unityHybirdCLRYooAssetHotUpdate热更新

    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
    

    • 

  • Android 用线程池实现一个简单的任务队列(Kotlin)
深海呐
Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务

    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
    

    • 

  • （小白入门）Windows环境下搭建React Native Android开发环境
码农老黑
前端ReactNative移动开发Androidstudio

    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
    

    • 

  • Android Dialog圆角设置无效的问题
ly969434341
android

    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
    

    • 

  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活
技术无疆
Androidandroiduiandroidstudioandroid-studiojavaandroidx

    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
    

    • 

  • Android界面特效全汇总
小飞鹤
Android开发详解android

    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
    

    • 

  • 怎么样才能成为专业的程序员？
cocos2d-x小菜
编程PHP

     
如何要想成为一名专业的程序员？仅仅会写代码是不够的。从团队合作去解决问题到版本控制，你还得具备其他关键技能的工具包。当我们询问相关的专业开发人员，那些必备的关键技能都是什么的时候，下面是我们了解到的情况。
 
关于如何学习代码，各种声音很多，然后很多人就被误导为成为专业开发人员懂得一门编程语言就够了？！呵呵，就像其他工作一样，光会一个技能那是远远不够的。如果你想要成为
    

    • 

  • java web开发 高并发处理
BreakingBad
javaWeb并发开发处理高

    java处理高并发高负载类网站中数据库的设计方法（java教程,java处理大量数据，java高负载数据） 一：高并发高负载类网站关注点之数据库 没错,首先是数据库,这是大多数应用所面临的首个SPOF。尤其是Web2.0的应用，数据库的响应是首先要解决的。 一般来说MySQL是最常用的，可能最初是一个mysql主机，当数据增加到100万以上，那么，MySQL的效能急剧下降。常用的优化措施是M-S（
    

    • 

  • mysql批量更新
ekian
mysql

    mysql更新优化：
一版的更新的话都是采用update set的方式，但是如果需要批量更新的话，只能for循环的执行更新。或者采用executeBatch的方式，执行更新。无论哪种方式，性能都不见得多好。
三千多条的更新，需要3分多钟。
查询了批量更新的优化，有说replace into的方式，即：
replace into tableName(id,status) values
    

    • 

  • 微软BI（3）
18289753290
微软BI SSIS

    1)
Q：该列违反了完整性约束错误；已获得 OLE DB 记录。源:“Microsoft SQL Server Native Client 11.0” Hresult: 0x80004005 说明:“不能将值 NULL 插入列 'FZCHID'，表 'JRB_EnterpriseCredit.dbo.QYFZCH'；列不允许有 Null 值。INSERT 失败。”。
A：一般这类问题的存在是 
    

    • 

  • Java中的List
g21121
java

            List是一个有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
        与 set 不同，列表通常允许重复
    

    • 

  • 读书笔记
永夜-极光
读书笔记

       1.  K是一家加工厂,需要采购原材料,有A,B,C,D 4家供应商,其中A给出的价格最低,性价比最高,那么假如你是这家企业的采购经理,你会如何决策?
   
     传统决策: A:100%订单  B,C,D:0%
 
  &nbs
    

    • 

  • centos 安装 Codeblocks
随便小屋
codeblocks

    1.安装gcc,需要c和c++两部分,默认安装下,CentOS不安装编译器的,在终端输入以下命令即可yum install gccyum install gcc-c++
 
2.安装gtk2-devel,因为默认已经安装了正式产品需要的支持库,但是没有安装开发所需要的文档.yum install gtk2*
3. 安装wxGTK
   yum search w
    

    • 

  • 23种设计模式的形象比喻
aijuans
设计模式

    1、ABSTRACT FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 　　工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：
    

    • 

  • 开发管理 CheckLists
aoyouzi
开发管理 CheckLists

    开发管理 CheckLists(23) -使项目组度过完整的生命周期
开发管理 CheckLists(22) -组织项目资源
开发管理 CheckLists(21) -控制项目的范围开发管理 CheckLists(20) -项目利益相关者责任开发管理 CheckLists(19) -选择合适的团队成员开发管理 CheckLists(18) -敏捷开发 Scrum Master 工作开发管理 C
    

    • 

  • js实现切换
百合不是茶
JavaScript栏目切换

    js主要功能之一就是实现页面的特效,窗体的切换可以减少页面的大小,被门户网站大量应用思路:
1,先将要显示的设置为display:bisible 否则设为none
2,设置栏目的id ,js获取栏目的id,如果id为Null就设置为显示
3,判断js获取的id名字;再设置是否显示
 
代码实现:
 
html代码:
<di
    

    • 

  • 周鸿祎在360新员工入职培训上的讲话
bijian1013
感悟项目管理人生职场

            这篇文章也是最近偶尔看到的，考虑到原博客发布者可能将其删除等原因，也更方便个人查找，特将原文拷贝再发布的。“学东西是为自己的，不要整天以混的姿态来跟公司博弈，就算是混，我觉得你要是能在混的时间里，收获一些别的有利于人生发展的东西，也是不错的，看你怎么把握了”，看了之后，对这句话记忆犹新。  &
    

    • 

  • 前端Web开发的页面效果
Bill_chen
htmlWebMicrosoft

    1.IE6下png图片的透明显示：
<img src="图片地址" border="0" style="Filter.Alpha(Opacity)=数值(100),style=数值(3)"/>
或在<head></head>间加一段JS代码让透明png图片正常显示。
2.<li>标
    

    • 

  • 【JVM五】老年代垃圾回收：并发标记清理GC(CMS GC)
bit1129
垃圾回收

      CMS概述
并发标记清理垃圾回收(Concurrent Mark and Sweep GC）算法的主要目标是在GC过程中，减少暂停用户线程的次数以及在不得不暂停用户线程的请夸功能，尽可能短的暂停用户线程的时间。这对于交互式应用，比如web应用来说，是非常重要的。
 
CMS垃圾回收针对新生代和老年代采用不同的策略。相比同吞吐量垃圾回收，它要复杂的多。吞吐量垃圾回收在执
    

    • 

  • Struts2技术总结
白糖_
struts2

     
必备jar文件
早在struts2.0.*的时候，struts2的必备jar包需要如下几个：
commons-logging-*.jar   Apache旗下commons项目的log日志包
freemarker-*.jar          
    

    • 

  • Jquery easyui layout应用注意事项
bozch
jquery浏览器easyuilayout

    在jquery easyui中提供了easyui-layout布局，他的布局比较局限，类似java中GUI的border布局。下面对其使用注意事项作简要介绍：
     如果在现有的工程中前台界面均应用了jquery easyui，那么在布局的时候最好应用jquery eaysui的layout布局，否则在表单页面（编辑、查看、添加等等）在不同的浏览器会出
    

    • 

  • java-拷贝特殊链表：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？
bylijinnan
java

    
public class CopySpecialLinkedList {
/**
* 题目：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？
拷贝pNext指针非常容易，所以题目的难点是如何拷贝pRand指针。
假设原来链表为A1 -> A2 ->... -> An，新拷贝
    

    • 

  • color
Chen.H
JavaScripthtmlcss

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"  "http://www.w3.org/TR/html4/loose.dtd">    <HTML>    <HEAD>&nbs
    

    • 

  • [信息与战争]移动通讯与网络
comsci
网络

          两个坚持:手机的电池必须可以取下来
               光纤不能够入户,只能够到楼宇
      建议大家找这本书看看:<&
    

    • 

  • oracle flashback query(闪回查询)
daizj
oracleflashback queryflashback table

    在Oracle 10g中，Flash back家族分为以下成员：
Flashback Database
Flashback Drop
Flashback Table
Flashback Query(分Flashback Query,Flashback Version Query，Flashback Transaction Query)
下面介绍一下Flashback Drop 和Flas
    

    • 

  • zeus持久层DAO单元测试
deng520159
单元测试

    zeus代码测试正紧张进行中,但由于工作比较忙,但速度比较慢.现在已经完成读写分离单元测试了,现在把几种情况单元测试的例子发出来,希望有人能进出意见,让它走下去.
本文是zeus的dao单元测试:
1.单元测试直接上代码
 
package com.dengliang.zeus.webdemo.test;
import org.junit.Test;
import o
    

    • 

  • C语言学习三printf函数和scanf函数学习
dcj3sjt126com
cprintfscanflanguage

    printf函数
/*
2013年3月10日20:42:32
地点：北京潘家园
功能：
目的：
测试%x %X %#x %#X的用法
*/
# include <stdio.h>
int main(void)
{
printf("哈哈！\n"); // \n表示换行
int i = 10;
printf
    

    • 

  • 那你为什么小时候不好好读书?
dcj3sjt126com
life

    dady, 我今天捡到了十块钱, 不过我还给那个人了
good girl! 那个人有没有和你讲thank you啊
没有啦....他拉我的耳朵我才把钱还给他的, 他哪里会和我讲thank you
 
爸爸, 如果地上有一张5块一张10块你拿哪一张呢....
当然是拿十块的咯...
爸爸你很笨的, 你不会两张都拿
 
爸爸为什么上个月那个人来跟你讨钱, 你告诉他没
    

    • 

  • iptables开放端口
Fanyucai
linuxiptables端口

    1，找到配置文件
vi /etc/sysconfig/iptables
 
2，添加端口开放，增加一行，开放18081端口
-A INPUT -m state --state NEW -m tcp -p tcp --dport 18081 -j ACCEPT
 
3，保存
ESC
:wq!
 
4，重启服务
service iptables 
    

    • 

  • Ehcache（05）——缓存的查询
234390216
排序ehcache统计query

    缓存的查询
目录
1.    使Cache可查询
1.1     基于Xml配置
1.2     基于代码的配置
2     指定可搜索的属性
2.1     可查询属性类型
2.2 &
    

    • 

  • 通过hashset找到数组中重复的元素
jackyrong
hashset

      如何在hashset中快速找到重复的元素呢?方法很多，下面是其中一个办法：
int[] array = {1,1,2,3,4,5,6,7,8,8};
Set<Integer> set = new HashSet<Integer>();
for(int i = 0
    

    • 

  • 使用ajax和window.history.pushState无刷新改变页面内容和地址栏URL
lanrikey
history

    后退时关闭当前页面
<script type="text/javascript">
jQuery(document).ready(function ($) {
        if (window.history && window.history.pushState) {
    

    • 

  • 应用程序的通信成本
netkiller.github.com
虚拟机应用服务器陈景峰netkillerneo

    应用程序的通信成本
什么是通信
一个程序中两个以上功能相互传递信号或数据叫做通信。
什么是成本
这是是指时间成本与空间成本。 时间就是传递数据所花费的时间。空间是指传递过程耗费容量大小。
都有哪些通信方式
全局变量
线程间通信
共享内存
共享文件
管道
Socket
硬件（串口，USB） 等等
全局变量
全局变量是成本最低通信方法，通过设置
    

    • 

  • 一维数组与二维数组的声明与定义
恋洁e生
二维数组一维数组定义声明初始化

    /**  *  */ package test20111005; /**  * @author FlyingFire  * @date:2011-11-18 上午04:33:36  * @author ：代码整理  * @introduce :一维数组与二维数组的初始化  *summary：  */ public c
    

    • 

  • Spring Mybatis独立事务配置
toknowme
mybatis

    在项目中有很多地方会使用到独立事务，下面以获取主键为例  
（1）修改配置文件spring-mybatis.xml  <!-- 开启事务支持 -->  <tx:annotation-driven transaction-manager="transactionManager" />   &n
    

    • 

  • 更新Anadroid SDK Tooks之后，Eclipse提示No update were found
xp9802
eclipse

    使用Android SDK Manager 更新了Anadroid SDK Tooks 之后，
打开eclipse提示 This Android SDK requires Android Developer Toolkit version 23.0.0 or above, 点击Check for Updates 
检测一会后提示 No update were found  
    

    •