变换操作符
变换操作符的作用是对Observable发射的数据按照一定规则做一些变换操作,然后将变换后的数据发射出去
1 map
map错左幅通过制定一个Func对象,将Observable转换为一个新的Observable对象并发射
private void mapOb()
{
Observable.just("www.qq.com").map(new Func1<String, String>()
{//拼接成新的字符串
@Override
public String call(String s)
{
return Host + "//" + s;
}
}).subscribe(new Action1<String>()
{
@Override
public void call(String s)
{//输出新的字符串
Log.e(TAG, "map:" + s);
}
});
}
2 flatMap、cast
flatMap操作符将Observable发射的数据集合变换成Observable集合,然后将这些Observable发射的数据平摊化地放进一个单独的Observable。cast操作符的作用是强制将Observable发射的所有数据转换为指定类型。
private void flatOb()
{
List<String> mList = new ArrayList<>();
mList.add("111111");
mList.add("222222");
mList.add("333333");
Observable.from(mList).flatMap(new Func1<String, Observable<?>>()
{
@Override
public Observable<?> call(String s)
{//将Host循环拼接11111,2222,33333,。循环次数为size
return Observable.just(Host + s);
}
}).cast(String.class)//强制转换的数据类型
.subscribe(new Action1<String>()
{
@Override
public void call(String s)
{
Log.e(TAG, "flag:" + s);//输出拼接结果
}
});
}
3 concatMap
concatMao操作符与flag操作符一致,不过,他解决了flatMap交叉问题,提供了一种能够把发射的值连续在一起的函数,而不是合并他们。
private void caoncatOb()
{
final List<String> mList = new ArrayList<>();
mList.add("111111");
mList.add("222222");
mList.add("333333");
Observable.from(mList).concatMap(new Func1<String, Observable<?>>()
{
@Override
public Observable<?> call(String s)
{
return Observable.just(Host + s);
}
}).cast(String.class)
.subscribe(new Action1<String>()
{
@Override
public void call(String s)
{
Log.e(TAG, "caoncat:" + s);//输出拼接结果
}
});
}
5 buffer
buffer操作符将源Observable变换为一个新的Observable,这个新的Observable每次发射一组列表值而不是一个一个发射。和buffer操作弗雷斯的还有window操作符,只不过window操作符发射的是Observable而不是数据列表,
private void bufferOb()
{
Observable.just(1, 2, 3, 5, 6, 7)
.buffer(3)//缓存为3 每次发送三个
.subscribe(new Action1<List<Integer>>()
{
@Override
public void call(List<Integer> integers)
{
for (Integer i : integers)
{
Log.e(TAG, "buffer:" + i);//输出拼接结果
}
Log.e(TAG, "------------------------");//输出拼接结果
}
});
}
6 window
window用法与buffer相似,buffer发射的是一个集合列表,window发射的是一个Observable
private void windowOb()
{
Observable.just(1, 2, 3, 5, 6, 7)
.window(3)
.subscribe(new Action1<Observable<Integer>>()
{
@Override
public void call(Observable<Integer> integerObservable)
{
integerObservable.subscribe(new Action1<Integer>()
{
@Override
public void call(Integer integer)
{
Log.e(TAG, "window:" + integer);//输出拼接结果
}
});
}
});
}
7 groupBy
groupBy操作符用于分组元素,将源Observable变换成一个发射Observable的新Observable(分组后的)他们中的每一个新Observable都发射一组特定的数据。
private void grouupBy()
{
Swordsman s1 = new Swordsman("1", "A");
Swordsman s2 = new Swordsman("2", "SS");
Swordsman s3 = new Swordsman("3", "S");
Swordsman s4 = new Swordsman("4", "S");
Swordsman s5 = new Swordsman("5", "A");
Swordsman s6 = new Swordsman("6", "SS");
Swordsman s7 = new Swordsman("7", "S");
Swordsman s8 = new Swordsman("8", "A");
Observable<GroupedObservable<String, Swordsman>> groupedObservableObservable
= Observable.just(s1, s2, s3, s4, s5, s6, s7, s8)
.groupBy(new Func1<Swordsman, String>()
{
@Override
public String call(Swordsman swordsman)
{
return swordsman.getLevel();//将相同等级的进行分组
}
});
Observable.concat(groupedObservableObservable)
.subscribe(new Action1<Swordsman>()
{
@Override
public void call(Swordsman swordsman)
{
Log.e(TAG, "grouupBy:" + swordsman.getName() + "/-----/" + swordsman.getLevel());//输出拼接结果 ;
}
});
}