小编shm*_*sel的帖子

假设我有一个名为Student的对象列表.对象学生的定义是这样的

public Class Student {
    private String studentName;
    private String courseTaking;
}

在学生列表中,可以有多个学生对象具有相同的studentName但不同的courseTaking.现在我想将学生列表转换为studentName和courseTaking的地图

Map<String, Set<String>>

关键是studentName,并且该值是同一个学生作为一组放在一起的所有课程.我怎么能用stream()和collect()做到这一点？

我有一个接口和几个实现。我想创建一个方法，它可以接受接口集合及其任何实现的集合。

import com.google.common.collect.ImmutableList;
import java.util.Collections;
import java.util.List;

public class Main {

    public interface ITest {
    }

    public static class Test1 implements ITest {
    }

    public static void main(String[] args) {
        ITest t1 = new Test1();
        List<ITest> lt1  = ImmutableList.of(t1);
        Test1 t2 = new Test1();
        List<Test1> lt2  = ImmutableList.of(t2);
        buildIntRange(lt1);
        buildIntRange(lt2);
    }

    private static List<ITest> method(List<ITest> test) {
        return Collections.unmodifiableList(test);
    }
}

该方法是否可以接受List<ITest>和List<Test1>作为其参数？

如果有人能解释为什么我不能使用Java中的Stream API来比较数组中的String,我将很高兴.

我试图在第一个单词按字典顺序排在第二个单词之前仅过滤对.

String[] input = { "Apple", "Banana" };

    Arrays.stream(input)
            .filter( (a,b)-> a.compareTo(b)< 0 )

看来Java不明白,"b"是一个字符串,但为什么呢？

对于特定类型的ArrayList,我们可以在ArrayList中找到对象(特定类型的)的大小,并直接在O(1)中的任何索引处访问该对象.这是因为对象引用存储在ArrayList中的连续内存块中,因此通过跳过object_size * index内存位置,我们访问所需对象的引用所在的内存位置.
然而,在LinkedList中,我们必须遍历每个对象,直到我们到达所需的对象.

对于包含不同类型对象(具有不同大小)的通用ArrayList,是get(index i)在O(1)中完成的吗？如果是这样,怎么样？

我即将从字符串创建二维数组:

char[][] chars;
String alphabet = "abcdefghijklmnopqrstuvwxyz";

所以数组将说明这个矩阵:

但是我怎么能用Java 8 Streams做到这一点,因为我不想通过休闲循环来做到这一点？

我有一个ArrayList,其中包含以下内容 - CHENNAI,MUMBAI,DELHI,CHENNAI,DELHI,CHENNAI.此外,假设这3个城市名称被定义为具有针对每个城市的值的ENUM.(CHENNAI = 1,MUMBAI = 2和DELHI = 3)

我的Java 8 Streams,我能够计算城市值的总和,在这种情况下,它将是1 + 2 + 3 + 1 + 3 + 1 = 11.

问题是,如果有一个额外的标准,我怎么能计算相同ArrayList的城市值之和,

如果城市名称出现两次,则必须仅添加一次.即在这种情况下,CHENNAI存在3次.因此,当添加其值时,我们应该只考虑1(对于前2次出现)+ 1 = 2而不是3.同样,DELHI出现2次.因此,德里的价值应该只采取一次.因此,如前所述,最终结果将是2 + 2 + 3 = 7而不是11.

请帮助如何在Java 8中实现这一点

我正在尝试自学如何在Java中使用lambda表达式而不是常规的外部迭代类型解决方案.我做了一个简短的程序,我使用整数流并为它们分配等级字母.我没有使用典型的"switch"语句,而是使用了这些lambda表达式.有什么办法可以简化吗？似乎有更好的方法来做到这一点.它有效,但看起来并不整洁.

    grades.stream()
          .mapToInt(Integer::intValue)
          .filter(x -> x >= 90)
          .forEach(x -> System.out.println(x + " -> A"));

    grades.stream()
          .mapToInt(Integer::intValue)
          .filter(x -> x >= 80 && x <= 89)
          .forEach(x -> System.out.println(x + " -> B"));

    grades.stream()
          .mapToInt(Integer::intValue)
          .filter(x -> x >= 70 && x <= 79)
          .forEach(x -> System.out.println(x + " -> C"));

    grades.stream()
          .mapToInt(Integer::intValue)
          .filter(x -> x >= 60 && x <= 69)
          .forEach(x -> System.out.println(x + " -> D"));

    grades.stream()
          .mapToInt(Integer::intValue)
          .filter(x -> x >= 50 && x <= 59) …

我希望以前没有问过这个问题.在java 8中,我myArray在输入中有一个String数组和一个整数maxLength.我想计算我的数组中的字符串数小于maxLength.我想使用流来解决此问题.

为此,我想这样做:

int solution = Arrays.stream(myArray).filter(s -> s.length() <= maxLength).count();

但是我不确定这是否是正确的方法.它需要经过第一个数组,然后通过过滤后的数组进行计数.

但是如果我不使用流,我可以轻松地制作一个算法,我在myArray上循环一次.

我的问题很简单:有没有办法用相同的时间性能来解决这个问题而不是循环？它总是一个使用流的"好"解决方案吗？

我正在使用 Java 8 以及包中的 Map、Reduce、Collect API java.util.stream。我有一个用例，我需要对列表的列表进行垂直求和。我的列表的结构是List<List<Integer>> 我想不出一种方法可以使用映射压缩内部列表，并减少或收集流上可用的操作。考虑以下代码。假设我的列表名为transactions. 此交易存储的是内部列表中每个商品的每笔交易中售出的商品数量。内部清单的长度对于所有交易都是相同的，因为它包含库存中每一项的一个条目。如果该项目未参与交易，则仅存储 0。

我在想一些关于

transaction.stream().map(
      /*Try and put sum into an accumulator List*/
).collect(
      /*Collect entries into a list*/
)

我只是不知道如何在代码中实现这一点。网络上的所有资源都是简单的示例，不适用于集合对象。任何指示/提示将不胜感激。

请考虑以下代码段:

           String msg = null;
            do {
                msg = login();
            } while (!msg.equals("OK"));

我想,当在控制台中显示消息msg是从不同的"OK",例如:ERROR, Try again...!.我这样做了:

        String msg;
        do {
            msg = login();
            if(!msg.equals("OK")){
                System.out.println("ERROR, Try again...!");
            }
        } while (!msg.equals("OK"));

有用.我想知道是否还有其他优雅的方法可以做到这一点.