标签: java-stream

需要对文件中的单词按照出现次数和确定符号进行排序（先按出现次数排序，再按字母排序）。例如，对于符号“e”，结果应为：avrgspeed=2；变成=2；因为=2 ...自动=1；自动连线=1。

有没有更好的方法来以流式编写所有内容。

             public class Sorter {

public Map<String, Integer> getDistinctWordsMap(String path, char symbol) throws IOException {
    Pattern delimeter = Pattern.compile("([^a-zA-Z])");
    List<WordParameter> parameterList = new ArrayList<>();
    Files.lines(Paths.get(path))
            .flatMap(delimeter::splitAsStream).map(String::toLowerCase).distinct()
            .forEachOrdered(word -> parameterList.add(new WordParameter(word, symbol)));
    Collections.sort(parameterList);
    return parameterList.stream().filter(w->w.count>0).collect(toMap(n->n.word, n->n.count, (e1, e2) -> e1, LinkedHashMap::new));
}

class WordParameter implements Comparable<WordParameter>{
    String word;
    int count;

    public WordParameter(String word, char symbol) {
        this.word = word;
        this.count = countEntrance(symbol);
    }

    private int countEntrance(char symbol){
        int quantity = 0;
        char[] charArr = word.toCharArray();
        for(int i = 0; …

我正在阅读Cracking the Coding Interview，它有一个在 JShell 上运行的查找素数的示例

boolean isPrime(int n) {
  for (int i = 2; i * i <= n; i++) {
    if (n % i == 0) {
      return false;
    }
  }
  return true;
}

然后我试图将其转换为java中的流，但发现这很困难，如上所述

boolean isPrimeStream(int n) {
  return IntStream.range(0, n) // how to do similar to for loop above
    .anyMatch(i -> n % i == 0);  // i think this is the reason for failure
}

我想测试一种返回流的方法。

class Foo {
    public void getClicks(boolean somecondition) {
        Stream s1 = computeAndGetAllClicks(new Date());
        if (somecondition) {
            Stream s2 = computeAndGetAllClicks(new Date());
        }
        return Stream.concat(s1, s2);
    }

    Stream computeAndGetAllClicks(Date d) {
        // return stream
    }
}

现在我已经为 somecondition = true 的情况编写了以下测试

    final ArgumentCaptor<Date> argumentCaptorTodayDate = ArgumentCaptor.forClass(Date.class);

    doReturn(Arrays.asList(new Click.Builder().build()).stream())
    .when(fooInstance)
    .addAtlasLineItem(computeAndGetAllClicks(argumentCaptorTodayDate.capture))

   final ArgumentCaptor<Date> argumentCaptorEndDate = ArgumentCaptor.forClass(Date.class);


    doReturn(Arrays.asList(new Click.Builder().build()).stream())
    .when(fooInstance)
    .addAtlasLineItem(computeAndGetAllClicks(argumentCaptorEndDate.capture))

    fooInstance.getClicks(true);

但是我得到异常： java.lang.IllegalStateException：流已被操作或关闭。

我该如何解决它？

我有以下数据结构

public class Zones {

   private List<Zone> zones;
}

public class Zone {

  private int id;
  private String name;
  private List<Part> parts;
}

public class Part {
  private int id;
  private String name;
}

这是我的问题。我有一个区域实例，比如 z。

我想流式传输 z 并执行以下操作：使用以下条件构造 z 的映射：如果密钥（基于区域的“Id”）是新的，则使用该密钥和该密钥在映射中创建一个条目区。如果该键是重复的，则将该重复区域的所有“部分”附加到现有区域的部分列表中。最后，我应该有一个以区域的“Id”为键、以区域为值的地图。

在 Java8 中如何使用流来做到这一点？

在java 8中，当我这样做时，

类型1

list.stream().parallel().map(/**/).unordered().filter(/**/).collect(/**/);

2型

list.stream().parallel().unordered().map(/**/).filter(/**/).collect(/**/);

由于两个流都是并行的，我可以理解每个操作（如过滤器、映射等）的所有对象将并行执行，但操作本身将按照定义的顺序顺序执行。

问题

1.在Type1中，我确实在map()操作之后说unordered()。那么，map() 操作是否尝试处理“排序”，因为它位于 unOrdered() 之前？

2.在Type2中，排序不是跨地图维护的，过滤器操作对吗？我的理解正确吗？

给出以下示例类：

class Foo{
    String name;
    int value;
    public Foo(String name, int value) {
        this.name = name;
        this.value = value;
    }
    // getters, setters, toString & equals
}

和 foo 列表：

List<Foo> fooList = List.of(new Foo("A",1), new Foo("A",2),
                                new Foo("B",1),
                                new Foo("C",1),
                                new Foo("D",1), new Foo("D",2), new Foo("D",3)
                            );

我想获得一份按名称区分的 foo 列表，如果有多个，Foos我想保留具有最高值的那个。

我发现这个java-8-distinct-by-property问题可以按名称获取不同列表的元素，它使用此方法来获取不同的元素：

public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
}

我这样使用它：

fooList.stream().filter(distinctByKey(Foo::getName)).collect(Collectors.toList());

它可以获取不同的元素，但如果有两个或多个同名元素，则保留列表中的第一个元素，并且我无法添加条件来保留具有最高值的元素。

另一种选择是使用分组依据：

Map<String,List<Foo>> …

当我的交易对手可以是时，我如何null使用 Java 8 处理以下代码中的检查null。counterParty我只想在它有值时设置，如果它为空则不设置。

 public static Iterable<? extends Trade> buildTrade (final List<Trade> trade) {
    return () -> trade.stream()
                .map(trade -> Trade.newBuilder()
                    .setType(trade.type())              
                    .setUnit(trade.unit())
                    .setCounterParty(trade.counterParty())                  
                    .build())
                .iterator();
    }

假设我有一些课程来说明歌曲和投票的问题。

用户.java

@EqualsAndHashCode
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Document(collection = "users")
public class User {

  @Id private String id;

  private String username;

  private String email;

  private Integer age;

  private String password;

  @DBRef(db = "interview", lazy = true)
  @EqualsAndHashCode.Exclude
  @ToString.Exclude
  private Set<Song> songs;
}

歌曲.java

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Song {

  @Id private String id;

  private String title;

  private String author;

  private SongGenre songGenre;

  Set<Vote> votesOfSong;
}

投票.java

@Builder
@AllArgsConstructor
@NoArgsConstructor
@Document(collection = "votes")
@Getter
public class Vote {

  @Id …

我正在尝试使用stream()并放入地图来迭代列表，其中键是 steam 元素本身，值是 AtomicBoolean，true。

List<String> streamDetails = Arrays.asList("One","Two");
toReplay = streamDetails.stream().collect(Collectors.toMap(x -> x.toString(), new AtomicBoolean(true)));

我在编译时收到以下错误。

Type mismatch: cannot convert from String to K
The method toMap(Function<? super T,? extends K>, Function<? super T,? extends U>) in the type Collectors is not applicable for the arguments ((<no type> x) -> {}, 
     AtomicBoolean)

我可能做错了什么，我应该用什么x -> x.toString()来代替？

我正在尝试创建一个类似于 的自定义浮动添加Collectors.summingDouble()。

但我面临两个问题，我不知道如何解决它。

1. BiConsumer- 第 #27 行 - void 方法不能返回值
2. Collectors.ofBiConsumer<R,T>- 第 32 行 - Collector 类型中的 (Supplier, , , Collector.Characteristics...)方法BinaryOperator<R>不适用于参数 ( Supplier<Float[]>, BiConsumer<Float,Employee>, BinaryOperator<Float>) 这里需要做什么来解决这个问题？

public class CustomCollector {


    public static void main(String[] args) {
        Employee e1=new Employee(1,"Tom",10.2f);
        Employee e2=new Employee(1,"Jack",10.4f);
        Employee e3=new Employee(1,"Harry",10.4f);
        ArrayList<Employee> lstEmployee=new ArrayList<Employee>();
        lstEmployee.add(e1);lstEmployee.add(e2);lstEmployee.add(e3);

/*  Implementation 1
 *  double totalSal=lstEmployee.stream().collect(Collectors.summingDouble(e->e.getSal()));
        System.out.println(totalSal);
*/  
        //Implementation 2
        Function<Employee,Float> fun=(e)->e.getSal();
        BiConsumer<Float,Employee> consumer=(val,e)->val+e.getSal();
        BinaryOperator<Float> operator=(val1,val2)->val1+val2;
        Supplier<Float[]> supplier=() -> new Float[2]; …