Java 8 如何使用可观察项遍历列表中的所有项

我正在学习如何使用rxjava。如下面的代码所示，我有

List

我计划做的是遍历

Person

并显示每个列表中有多少个

Person

类型的对象

我编码如下：

.map(p->p.get(0).getName().map(r->r.toUpperCase()).orElse("NULL_VALUE"))

但正如你看到的，我总是引用项目编号0。我如何引用列表中的所有项目，就好像我正在使用for loop as follows一样：

for (int i = 0; i< length; i++)
    p.get(i)

for（int i=0；i

我希望我的问题是清楚的

提前谢谢

代码：

public static void main(String[] args) {
    Observable<List<Person>> observables = Observable.create(e-> {
        for(List<Person> p : Main.getPersons()) {
            e.onNext(p);
        }
        e.onComplete();
    });
     observables
    .map(p->p.get(0).getName().map(r->r.toUpperCase()).orElse("NULL_VALUE"))
    .doOnNext(r->System.out.println("r: " + r))
    .observeOn(Schedulers.io())
    .subscribe(new Observer() {
        @Override
        public void onComplete() {
            // TODO Auto-generated method stub
            System.out.println("onCompleted");
        }

        @Override
        public void onError(Throwable arg0) {
            // TODO Auto-generated method stub

        }

        @Override
        public void onNext(Object arg0) {
            // TODO Auto-generated method stub
            System.out.println("onNextFromObserver: " + arg0);
        }

        @Override
        public void onSubscribe(Disposable arg0) {
            // TODO Auto-generated method stub
        }
    });
}

private static <T> Observable<T> toObservable(T s) {
    return Observable.just(s);
}
private static List<List<Person>> getPersons() {
    return Arrays.asList(
            Arrays.asList(new Person("Sanna1", 59, "EGY"), new Person(null, 59, "EGY"), new Person("Sanna3", 59, null)),
            Arrays.asList(new Person("Mohamed1", 59, "EGY"), new Person(null, 59, "EGY")),
            Arrays.asList(new Person("Ahmed1", 44, "QTR"), new Person("Ahmed2", 44, "QTR"), new Person(null, null, "QTR")),
                    Arrays.asList(new Person("Fatma", 29, "KSA")),
                    Arrays.asList(new Person("Lobna", 24, "EGY")));
}
}

publicstaticvoidmain（字符串[]args）{
可观察的可观察的=可观察的。创建（e->{
对于（列表p:Main.getPersons（））{
e、 onNext（p）；
}
e、 onComplete（）；
});
可观测
.map（p->p.get（0）.getName（）.map（r->r.toUpperCase（））.orElse（“空值”））
.doOnNext（r->System.out.println（“r:+r））
.observeOn（Schedulers.io（））
.订阅（新观察员）{
@凌驾
未完成的公共空间（）{
//TODO自动生成的方法存根
System.out.println（“未完成”）；
}
@凌驾
公共作废申报人（可丢弃arg0）{
//TODO自动生成的方法存根
}
@凌驾
public void onNext（对象arg0）{
//TODO自动生成的方法存根
System.out.println（“onNextFromObserver:+arg0”）；
}
@凌驾
订阅时的公共作废（一次性arg0）{
//TODO自动生成的方法存根
}
});
}
私有静态可观测到可观测（TS）{
可观察到的回报。仅（s）；
}
私有静态列表getPersons（）{
返回数组.asList(
数组.asList（新人（“Sanna1”，59，“EGY”）、新人（null，59，“EGY”）、新人（“Sanna3”，59，null）），
数组.asList（新人（“Mohamed1”，59，“EGY”）、新人（空，59，“EGY”），
数组.asList（新人（“艾哈迈德1”，44，“QTR”）、新人（“艾哈迈德2”，44，“QTR”）、新人（空，空，“QTR”），
数组。asList（新人（“Fatma”，29，“KSA”），
数组。asList（新人（“Lobna”，24，“EGY”）；
}
}

人

public class Person {
private String name = null;
private String address = null;
private int age;

private Optional<String> optName= null;
private Optional<Integer> optAge= null;
private Optional<String> optAddress = null;

public Person(String name, Integer age, String address) {
    this.optName = Optional.ofNullable(name);
    this.optAge = Optional.ofNullable(age);
    this.optAddress = Optional.ofNullable(address);
}

public Optional<String> getName() {
    return optName;
}

public void setName(String name) {
    this.optName = Optional.ofNullable(name);
}

public Optional<String> getAddress() {
    return this.optAddress;
}

public void setAddress(String address) {
    this.optAddress = Optional.ofNullable(address);
}

public Optional<Integer> getAge() {
    return this.optAge;
}

public void setAge(int age) {
    this.optAge = Optional.ofNullable(age);
}
}

公共类人物{
私有字符串名称=null；
私有字符串地址=null；
私人互联网；
私有可选optName=null；
私有可选optAge=null；
私有可选optAddress=null；
公众人物（字符串名称、整数年龄、字符串地址）{
this.optName=可选的.ofNullable（名称）；
this.optAge=可选的未满（年龄）；
this.optAddress=可选的空值（地址）；
}
公共可选getName（）{
返回optName；
}
公共void集合名（字符串名）{
this.optName=可选的.ofNullable（名称）；
}
公共可选getAddress（）{
把这件衣服还给我；
}
公共无效设置地址（字符串地址）{
this.optAddress=可选的空值（地址）；
}
公共可选getAge（）{
返回此.optAge；
}
公共无效设置（整数）{
this.optAge=可选的未满（年龄）；
}
}

更新

public static void main(String[] args) {
    Observable<List<Person>> observables = 
    Observable.fromIterable(Main.getPersons());
    observables
    //.subscribeOn(Schedulers.io())
    .observeOn(Schedulers.io())
    .concatMap(list->Observable.fromIterable(list)
            .map(p->p.getName()
                    .map(r->r.toUpperCase()).orElse("NULL_VALUE")))
    .observeOn(Schedulers.io())
    .blockingSubscribe(new Observer<String>() {

        @Override
        public void onComplete() {
            // TODO Auto-generated method stub
            System.out.println("onComplete: ");
        }

        @Override
        public void onError(Throwable arg0) {
            // TODO Auto-generated method stub
            System.out.println("onError: ");
        }

        @Override
        public void onNext(Object arg0) {
            // TODO Auto-generated method stub
            System.out.println("onNext: ");
        }

        @Override
        public void onSubscribe(Disposable arg0) {
            // TODO Auto-generated method stub
            System.out.println("onSubscribe: ");
        }
    });

}

publicstaticvoidmain（字符串[]args）{
可观测到的可观测值=
可观察的.fromIterable（Main.getPersons（））；
可观测
//.subscribeOn（Schedulers.io（））
.observeOn（Schedulers.io（））
.concatMap（列表->可观察.fromIterable（列表）
.map（p->p.getName（）
.map（r->r.toUpperCase（））.orElse（“空值”））
.observeOn（Schedulers.io（））
.封锁订阅（新观察员（）{
@凌驾
未完成的公共空间（）{
//TODO自动生成的方法存根
System.out.println（“onComplete:”）；
}
@凌驾
公共作废申报人（可丢弃arg0）{
//TODO自动生成的方法存根
System.out.println（“onError:”）；
}
@凌驾
public void onNext（对象arg0）{
//TODO自动生成的方法存根
System.out.println（“onNext:”）；
}
@凌驾
订阅时的公共作废（一次性arg0）{
//TODO自动生成的方法存根
System.out.println（“onSubscribe:”）；
}
});
}

使用ITERABLE中的

和
concatMap
：

publicstaticvoidmain（字符串[]args）{
可观测=
可观察的.fromIterable（Main.getPersons（））；
可观测
.concatMap（个人列表->
可观察。从可观察（personList）
.map（aPerson->
aPerson.getName（）
.map（name->name.toUpperCase（））.orElse（“空值”）
)
)
.doOnNext（aName->System.out.println（“aName:+aName））
.observeOn（Schedulers.io（））
.封锁订阅（新观察员（）{
@凌驾
未完成的公共空间（）{
System.out.println（“未完成”）；
}
@凌驾
公共无效申报人（可丢弃的ex）{
例如printStackTrace（）；
}
@凌驾
public void onNext（字符串项）{
System.out.println（“onNextFromObserver:+项）；
}
@凌驾
订阅时的公共作废（一次性）{
}
});
}
than代表你发布的代码..但根据你发布的消息，我没有从观察员的下一位收到任何东西..请参阅我问题中的更新部分。对我有用。从StackOverflow复制粘贴是否正确？是。在我将
对象arg0
更正为
字符串arg0
之后，我打印了一堆
onNext:
，您没有正确复制该字符串。