标签: java-stream

我有一个元素列表,我需要找到满足条件的第一个元素然后使用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),是否有一种优雅的方式来实现流？

 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);

我有这个方法：

filteredListIn.addAll(Stream.of(listRef)
    .filter(results ->
            results.getTitle().contains(query.toString().toLowerCase())
     ));

有了这两个变量：

private List<Results> listRef = new ArrayList<>();
List<Results> filteredListIn = new ArrayList<>();

但我得到

为 addAll(Stream) 找到了已过滤的ListIn.addAll(Stream.of(listRef) ^ 方法 Collection.addAll(Collection) 不适用（参数不匹配；Stream 无法转换为 Collection）方法 List.addAll(Collection) 不适用

有什么问题，我该如何解决？

这可能是因为我使用外部库来支持 api 24 下的流吗？

我在尝试平均 java 中地图的值时遇到了很多麻烦。我的方法接受一个文本文件，并查看以某个字母开头的每个单词的平均长度（不区分大小写并遍历文本文件中的所有单词。

例如，假设我有一个包含以下内容的文本文件：

"Apple arrow are very common Because bees behave Cant you come home"

我的方法目前返回：

{A=5, a=8, B=7, b=10, c=10, C=5, v=4, h=4, y=3}

因为它是看字母，求单词的平均长度，但是还是区分大小写的。

它应该返回：

{A=5, a=8, B=7, b=10, c=10, C=5, v=4, h=4, y=3}

{a=4.3, b=5.5, c=5.0, v=4.0, h=4.0, y=3}

这是我到目前为止。

public static Map<String, Integer> findAverageLength(String filename) {
    
     Map<String, Integer> wordcount = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
       
        try 
        {
            Scanner in = new Scanner(new File(filename));
            List<String> wordList = new ArrayList<>();
            while (in.hasNext()) 
            {
                wordList.add(in.next());
            }

            wordcount = wordList.stream().collect(Collectors.toConcurrentMap(w->w.substring(0,1), w -> …