如何使用Stream找到此行中所有整数的总和？
String line = "Test 15 lqlq 35 bad 99999 guess 34";
List<String> lineSplitted = Arrays.stream(line.split(" ")).collect(Collectors.toList());
int result = 0;
try {
result = lineSplitted.stream().filter(s -> Integer.parseInt(s)).sum();
}
catch (Exception e) {
}
System.out.println(result);
我有一个包含字符串和字符串列表的流,我想把所有值作为字符串列表.无论如何用一些流操作来做到这一点？
Stream stream = Stream.of("v1", Arrays.asList("v2, v3"));
我是Java 8的新手，试图了解Java8的splitIterator功能。
我已经编写了以下代码，我的要求是每当我调用get（）时；get方法应该从itr3返回一个值；是否有可能得到相同的？如何？
public class TestSplitIterator {
static List<Integer> list = new ArrayList<Integer>();
public static void main(String args[]) {
for (int i = 0; i < 100; i++) {
list.add(i);
}
// below method call should return only one value whenever i call it;
get(list);
}
private static int get(List<Integer> list) {
Collections.sort(list, Collections.reverseOrder());
System.out.println(list);
Spliterator<Integer> itr1 = list.spliterator();
Spliterator<Integer> itr2 = itr1.trySplit();
Spliterator<Integer> itr3 = itr2.trySplit();
// i want to return value from itr3 whenever get(List list ic called) …我有一个对象流,它根据它们拥有的id定义equals和hashcode.所以我知道使用stream.distinct()我会得到一个没有任何重复的流,但它会保留第一个外观,而不是最后一个.
这在文档中明确说明:
对于有序流,不同元素的选择是稳定的*(对于重复元素,将保留遇到*顺序中首先出现的元素.)
那么我怎么能有一个没有重复的流,但保持最后的外观呢？
例如,如果我有这个项目列表1,2,3,1,4,5.
如果我申请,distinct()我会得到1,2,3,4,5,我期待:2,3,1,4,5.我怎样才能做到这一点？
我有以下接口和类:
public interface Rule<T> {
Predicate<T> evaluate();
}
public interface Criteria<T> {
Predicate<T> evaluate();
}
public abstract class AbstractRule<T> implements Rule<T> {
...
Set<Criteria<T>> criteria;
...
@Override
@Nullable
public Predicate<T> evaluate() {
return criteria.stream().reduce((c1, c2) -> c1.evaluate().and(c2.evaluvate()))
.orElse(null);
}
}
AbstractRule类包含一组Criteria.我想通过评估每个标准来对规则进行评估.我在标题中提到的c1.evaluate().和(c2.evaluate())上遇到了编译错误.
我该如何解决这个问题？
谢谢.
我看不出我的流api逻辑有什么问题.它告诉我以下内容
[ERROR] mystuff/MandantContentFetcher.java:[67,23]不兼容的类型:java.lang.Object无法转换为java.util.List
这是我的流方法:
static List<MandantLinkCheckerEntry> createMandantLinkCheckerEntries(Struct struct) {
Map<String, Object> linkCheckerMandants = struct.toNestedMaps();
return linkCheckerMandants.values().parallelStream()
.map(Map.class::cast)
.map(MandantLinkCheckerEntry::convertMapToMandantCheckerEntry)
.collect(Collectors.toList());
}
它使用此方法参考:
private static MandantLinkCheckerEntry convertMapToMandantCheckerEntry(Map<String, Object> entryToConvert) {
return new MandantLinkCheckerEntry(String.valueOf(entryToConvert.get("mandant.path")),
String.valueOf(entryToConvert.get("mail.to")),
Boolean.valueOf(String.valueOf(entryToConvert.get("active"))));
}
他为什么看到一个物体？第二个映射中的方法引用确实返回MandantLinkCheckerEntry.另外我假设collect确实创建了一个List,其中流的值是泛型类型,但似乎他转换了流的类型(这里的Object是Stream启动器Map<String, Object).我该如何帮助他将其投入到列表中？
以下两个代码段产生相同的结果.
用flatMap:
Stream.iterate(2, n -> n + 4)
.flatMap(n -> Stream.of(n, -(n + 2)));
随着map其次是flatMap使用identity:
Stream.iterate(2, n -> n + 4)
.map(n -> Stream.of(n, -(n + 2)))
.flatMap(Function.identity());
因此flatten,在Stream接口中包含无参数方法(如Scala的Stream)似乎很自然,允许将前面的示例写成:
Stream.iterate(2, n -> n + 4)
.map(n -> Stream.of(n, -(n + 2)))
.flatten();
那么为什么API中没有flatten()方法Stream呢？
我有以下代码,这是我偶然发现的一个简化版本:
public class Transforming
{
static interface MyInterface<T>
{
void consume(T... toConsume);
}
static abstract class Mapper<T> implements MyInterface<String> {
MyInterface<T> delegate;
public Mapper(MyInterface<T> delegateTo)
{
delegate = delegateTo;
}
public void consume(String... transformFrom)
{
T[] array = (T[]) Arrays.stream(transformFrom)
.map(this::transform)
.toArray(); // can't toArray(T[]::new) here!
delegate.consume(array);
}
protected abstract T transform(String toTransform);
}
}
关于如何将流转换为数组的搜索明显不足,因为此时我没有生成的数组类型,并且Java不允许我创建泛型类型的数组...
我确实理解这个问题,但有关如何清理代码的任何输入？AFAICT,我的选择是
我缺少什么？你最喜欢什么？
以下代码输出始终为24.
public static void main(String[] args) throws InterruptedException {
List<String> list = new ArrayList<String>();
list.add("java");
list.add("php");
list.add("python");
list.add("perl");
list.add("c");
list.add("lisp");
list.add("c#");
int s = list.stream().reduce(0, (x, y) -> x + y.length(), (x, y) -> 0);
System.out.println(s);
s = list.stream().reduce(0, (x, y) -> x + y.length(), (x, y) -> x - y);
System.out.println(s);
s = list.stream().reduce(0, (x, y) -> x + y.length(), (x, y) -> x * y);
System.out.println(s);
}
问题是组合器影响我的代码的原因.
我有一个byte []的ArrayList,我想知道是否可以使用Java*中的流将其转换为byte [].ArrayList中的所有数组都具有相同的大小.
ArrayList<byte[]> buffer = new ArrayList();
byte[] output = buffer.stream(...)