标签: java-stream

说我有以下代码

public class A {
    int x;
    public boolean is() {return x%2==0;}
    public static boolean is (A a) {return !a.is();}
}

而在另一堂课......

List<A> a = ...
a.stream().filter(b->b.isCool());
a.stream().filter(A::is); 
//would be equivalent if the static method is(A a) did not exist

问题是如何使用A :: is类型表示法引用实例方法版本？非常感谢

我有一个元素列表,我需要找到满足条件的第一个元素然后使用Java 8流退出.

我认为下面的代码很遗憾地评估了所有可用的元素,这不是我需要的,我需要逐个评估项目,并break在找到第一个匹配时停止():

我在这里排序元素,然后将元素映射到它的url属性,然后尝试过滤,如果url不是null或空,然后找到first匹配!

Arrays.stream(dataArray)
.sorted(Comparator.comparing(d -> d.getPriority()))
.peek(o -> System.out.println("SORT: " + o))
.map(d -> d.getOriginalURL(shortUrl))
.peek(o -> System.out.println("MAP: " + o))
.filter(u -> u != null && !u.isEmpty())
.peek(o -> System.out.println("FILTER: " + o))
.findFirst().orElse("");

但输出显示,即使第一个项与ifcondition(filter)操作匹配,所有项也都会被评估.

Data[] data = new Data[] { new ParseData(), new InMemoryData() };
System.out.println(">>> " + getOriginalURL(data, ""));

OUTPUT:

SORT: mhewedy.usingspark.data.InMemoryData@7adf9f5f
MAP: InMemory URL
FILTER: InMemory URL
SORT: mhewedy.usingspark.data.ParseData@85ede7b
MAP: Parse.com URL …

使用相同的Random实例生成流(或并行流)并在其中一个部分中影响该流是否安全？

请考虑以下代码.这同样gen用于生成并行IntStream并且每几个字符生成一个随机空间.它成功运行并完成,没有异常抛出.

但这个代码线程安全吗？它似乎是,因为没有无效(超出范围)的字符值.我认为我应该破坏Random内部数据,因为它的方法没有被标记为synchronized,但显然情况并非如此.为什么？

public class RandomGenTest {

    Random gen = new Random();

    String getRandomText(int len, double spaceProb) {
        return gen.ints(len, 'a', 'z'+1)
                    .map(i-> gen.nextDouble()<spaceProb?' ':i)
                    .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append).toString();
    }

    @Test
    public void test() {
        for (int a=10000; a<10000000; a*=2) {
            String text = getRandomText(a, .2);
            Assert.assertTrue(text.chars().allMatch(c -> (c>='a' && c<='z') || c==' '));
        }
    }

}

我有以下课程.

class Person {

    String name;
    LocalDate birthday;
    Sex gender;
    String emailAddress;

    public int getAge() {
        return birthday.until(IsoChronology.INSTANCE.dateNow()).getYears();
    }

    public String getName() {
        return name;
    }
}

我希望能够按年龄分组,然后收集人名列表而不是Person对象本身; 所有这些都在一个很好的lamba表达式中.

为了简化所有这些,我将链接我当前的解决方案,该解决方案按年龄存储分组结果,然后迭代它以收集名称.

ArrayList<OtherPerson> members = new ArrayList<>();

members.add(new OtherPerson("Fred", IsoChronology.INSTANCE.date(1980, 6, 20), OtherPerson.Sex.MALE, "fred@example.com"));
members.add(new OtherPerson("Jane", IsoChronology.INSTANCE.date(1990, 7, 15), OtherPerson.Sex.FEMALE, "jane@example.com"));
members.add(new OtherPerson("Mark", IsoChronology.INSTANCE.date(1990, 7, 15), OtherPerson.Sex.MALE, "mark@example.com"));
members.add(new OtherPerson("George", IsoChronology.INSTANCE.date(1991, 8, 13), OtherPerson.Sex.MALE, "george@example.com"));
members.add(new OtherPerson("Bob", IsoChronology.INSTANCE.date(2000, 9, 12), OtherPerson.Sex.MALE, "bob@example.com"));

Map<Integer, List<Person>> collect = members.stream().collect(groupingBy(Person::getAge));

Map<Integer, List<String>> result = new …

以下代码适用于所有在线java编译器,但eclipse会抛出编译器错误.它是日食中的一个错误还是我错过了一些设置？一个简单的解决方法来沉默eclipse？在线:https://ideone.com/l0bbhz.注意:这是一个简化的简化示例,仅指出问题.flatMap在这种情况下,我理解没有必要.在实际情况下,我真的需要flatMap

package dummy;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import static java.util.stream.Collectors.toList;

public class LearnJava {

    public static void main(String[] args) {
        String[] sa = {"ne", "two", "three"};
        List<String> l = Arrays.stream(sa)
                .flatMap(s -> Collections.singleton(s).stream().map(c -> c.toUpperCase()))
                .collect(toList());
        System.out.println(l.get(0));
    }

}

eclipse控制台出错.

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Type mismatch: cannot convert from List<Object> to List<String>

    at dummy.LearnJava.main(LearnJava.java:13)

我的日食版:

面向Web开发人员的Eclipse Java EE IDE.

版本:Luna Service Release 2(4.4.2)Build id:20150219-0600

更新 …

哪个是从集合中创建流的最佳方法:

    final Collection<String> entities = someService.getArrayList();

1. entities.stream();

2. Stream.of(entities);

我有这样的代码:

List<Listing> Listings = new ArrayList<>();
Listings.add(listing1);
Listings.add(listing2);
...
...
...

Listing listing= listings.stream()
                .filter(l -> l.getVin() == 456)
                .findFirst();

我的问题是过滤过程的时间复杂度是多少？如果它是O(n),我的直觉是将它转换为HashSet,就像数据结构一样,这样时间复杂度就可以变成O(1),是否有一种优雅的方式来实现流？

如何IntStream在给定的顺序范围的中间开始,然后从中间开始流式传输下一个数字,并交替向左和向右.例如,对于数字的顺序给出的范围1 2 3 4 5,自定义序列会3 2 4 1 5或3 4 2 5 1取决于是否先从左边或右边第一.

我基本上试图从中间开始迭代一个数组并向外均匀地向外(不要先完​​全向左或向右).

我曾经尝试这样做只使用for循环但代码是凌乱的,我认为这将是多好,只是排队的不是检查它的飞行(因为所有指数指出,有界异常的数字集合或流待检查).这是原始代码,我认为作为预先计算的int流更好:

        int middle = myArray.length / 2;
        Object value = myArray[middle]; //have to reference middle since the for loop won't
        //do operation on value
        for (int offset = 1; true; offset++) {
            int nextRight = middle + offset;
            int nextLeft = middle - offset;
            if (nextRight < myArray.length) { // Have to guard against …

 Stream<String> a = Stream.of("one", "three", "five");
 Stream<String> b = Stream.of("two", "four", "six");

我需要做什么才能使输出如下？

// one
// two
// three
// four
// five
// six

我调查了concat但是正如javadoc解释的那样,它只是一个接一个地追加,它没有交错/散布.

Stream<String> out = Stream.concat(a, b);
out.forEach(System.out::println);

创建一个延迟连接的流,其元素是第一个流的所有元素,后跟第二个流的所有元素.

错误地给出了

 // one
 // three
 // five
 // two
 // four
 // six

可以这样做,如果我收集它们并迭代,但希望更多Java8-y,Streamy :-)

注意

我不想压缩流

"zip"操作将从每个集合中获取一个元素并将它们组合在一起.

拉链操作的结果将是这样的:(不需要的)

 // onetwo
 // threefour
 // fivesix

我正在尝试从员工列表中检索薪水最低的列表。到目前为止，我设法找到了薪水最低的员工，但是如果几个员工的薪水相同，我想检索多个员工。

我认为解决方案应该是一成不变的。因此，我无法创建一个薪水最低的变量，而只能检查每个薪水是否小于或等于Low_Salary。我尝试了一下，它奏效了。

因此，我相信我的问题是“ .min（比较器）”仅检索最低的一个。

Comparator<Employee> comparator = Comparator.comparing( Employee :: getSalary);
List<Employee> lowSalary = employees.stream()
               .min(comparator)
               .stream()
               .collect(Collectors.toList());
lowSalary.forEach(System.out::println);