我有一个List<Person>.我需要List从一个属性获得Person.
例如,我有一个Person班级:
class Person
{
private String name;
private String birthDate;
public String getName() {
return name;
}
public String getBirthDate() {
return birthDate;
}
Person(String name) {
this.name = name;
}
}
List<Person> personList = new ArrayList<>();
personList.add(new Person("David"));
personList.add(new Person("Joe"));
personList.add(new Person("Michel"));
personList.add(new Person("Barak"));
我想获得StreamAPI 的名称列表,如下所示:
List<String> names = personList.stream().somecode().collect(Collectors.toList());
names.stream().forEach(System.out::println);
#David
#Joe
#Michel
#Barak
此代码不起作用:
public class Main
{
public static void main(String[] args)
{
List<Person> personList …如何在以下代码中获取流或列表的最后一个元素？
哪里data.careas是List<CArea>:
CArea first = data.careas.stream()
.filter(c -> c.bbox.orientationHorizontal).findFirst().get();
CArea last = data.careas.stream()
.filter(c -> c.bbox.orientationHorizontal)
.collect(Collectors.toList()).; //how to?
正如你所看到的那样,获得第一个元素filter并不难.
然而,获得单行中的最后一个元素是一个真正的痛苦:
Stream.(它只对有限流有意义)first()和last()从List接口,这实在是一种痛苦.我没有看到任何关于不在接口中提供first()和last()方法的论据List,因为其中的元素是有序的,而且大小是已知的.
但根据原始答案:如何获得有限的最后一个元素Stream？
就个人而言,这是我能得到的最接近的:
int lastIndex = data.careas.stream()
.filter(c -> c.bbox.orientationHorizontal)
.mapToInt(c -> data.careas.indexOf(c)).max().getAsInt();
CArea last = data.careas.get(lastIndex);
然而,它确实涉及使用indexOf每个元素,这很可能不是您通常想要的,因为它可能会影响性能.
我想复制Java 8流,以便我可以处理它两次.我可以collect作为一个列表并从中获得新的流;
// doSomething() returns a stream
List<A> thing = doSomething().collect(toList());
thing.stream()... // do stuff
thing.stream()... // do other stuff
但我认为应该有一种更有效/更优雅的方式.
有没有办法复制流而不将其转换为集合？
我实际上正在使用Eithers 流,所以想要在移动到正确的投影之前以一种方式处理左投影并以另一种方式处理.有点像这样(到目前为止,我被迫使用这个toList技巧).
List<Either<Pair<A, Throwable>, A>> results = doSomething().collect(toList());
Stream<Pair<A, Throwable>> failures = results.stream().flatMap(either -> either.left());
failures.forEach(failure -> ... );
Stream<A> successes = results.stream().flatMap(either -> either.right());
successes.forEach(success -> ... );
什么是一个方法的Java 8功能接口什么都不带,什么都不返回？
即,相当于Action带void返回类型的C#参数？
如何获得与流中的条件匹配的第一个元素？我试过这个但是没用
this.stops.stream().filter(Stop s-> s.getStation().getName().equals(name));
该条件不起作用,filter方法在Stop之外的其他类中调用.
public class Train {
private final String name;
private final SortedSet<Stop> stops;
public Train(String name) {
this.name = name;
this.stops = new TreeSet<Stop>();
}
public void addStop(Stop stop) {
this.stops.add(stop);
}
public Stop getFirstStation() {
return this.getStops().first();
}
public Stop getLastStation() {
return this.getStops().last();
}
public SortedSet<Stop> getStops() {
return stops;
}
public SortedSet<Stop> getStopsAfter(String name) {
// return this.stops.subSet(, toElement);
return null;
}
}
import java.util.ArrayList;
import java.util.List;
public class Station {
private final …我有下面的代码,对于多次空检查有点难看.
String s = null;
if (str1 != null) {
s = str1;
} else if (str2 != null) {
s = str2;
} else if (str3 != null) {
s = str3;
} else {
s = str4;
}
所以我尝试使用Optional.ofNullable如下所示,但如果有人读取我的代码仍然很难理解.在Java 8中这样做的最佳方法是什么.
String s = Optional.ofNullable(str1)
.orElse(Optional.ofNullable(str2)
.orElse(Optional.ofNullable(str3)
.orElse(str4)));
在Java中9,我们可以使用Optional.ofNullable同OR,但在Java8还有没有其他办法？
鉴于如下的流{ 0, 1, 2, 3, 4 },
我怎样才能最优雅地将其转换为给定的形式:
{ new Pair(0, 1), new Pair(1, 2), new Pair(2, 3), new Pair(3, 4) }
(假设,当然,我已经定义了类对)？
编辑:这不是严格关于整数或原始流.对于任何类型的流,答案应该是通用的.
我在使用a List及其stream()方法时遇到了一个问题.虽然我知道如何使用它们,但我不确定何时使用它们.
例如,我有一个列表,包含到不同位置的各种路径.现在,我想检查一个给定路径是否包含列表中指定的任何路径.我想boolean根据条件是否得到满足返回.
当然,这本身并不是一项艰巨的任务.但我想知道我是应该使用流还是使用for(-each)循环.
列表
private static final List<String> EXCLUDE_PATHS = Arrays.asList(new String[]{
"my/path/one",
"my/path/two"
});
示例 - 流
private boolean isExcluded(String path){
return EXCLUDE_PATHS.stream()
.map(String::toLowerCase)
.filter(path::contains)
.collect(Collectors.toList())
.size() > 0;
}
示例 - For-Each循环
private boolean isExcluded(String path){
for (String excludePath : EXCLUDE_PATHS) {
if(path.contains(excludePath.toLowerCase())){
return true;
}
}
return false;
}
请注意,path参数始终为小写.
我的第一个猜测是for-each方法更快,因为如果条件满足,循环将立即返回.而流仍将循环遍历所有列表条目以完成过滤.
我的假设是否正确？如果是这样,为什么(或者更确切地说)何时使用stream()？
我一直在检查即将到来的Java update,即:Java 8 or JDK 8.是的,我很不耐烦,有很多新东西,但是,有一些我不明白的东西,一些简单的代码:
final Stream<Integer>stream = Stream.of(1,2,3,4,5,6,7,8,9,10);
stream.flatMap();
javadoc是
public <R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)返回一个流,该流包含将此流的每个元素替换为通过将提供的映射函数应用于每个元素而生成的映射流的内容的结果.每个映射的流在其内容放入此流后关闭.(如果映射的流为空,则使用空流.)这是一个中间操作.
如果有人创建了一些简单的现实生活示例flatMap,如何在以前的java版本Java[6,7]中编写代码以及如何使用相同的例程编写代码,我将不胜感激Java 8.
此代码有效(在Javadoc中使用):
List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
String commaSeparatedNumbers = numbers.stream()
.map(i -> i.toString())
.collect(Collectors.joining(", "));
这个不能编译:
int[] numbers = {1, 2, 3, 4};
String commaSeparatedNumbers = Arrays.stream(numbers)
.map((Integer i) -> i.toString())
.collect(Collectors.joining(", "));
IDEA告诉我,我在lambda表达式中有一个"不兼容的返回类型字符串".
为什么？以及如何解决这个问题？