在下面的示例中，我正在使用该字段，number即使IntStream.range(0, 10).forEach(number -> new Thread(r).start());它没有被使用。有没有办法重写它，以便我不必使用未使用的数字变量？
import javax.annotation.concurrent.NotThreadSafe;
import java.util.stream.IntStream;
public class LearnThreads {
public static void main(String[] args) {
UnsafeThreadClass counter = new UnsafeThreadClass();
Runnable r = () -> {
try {
System.out.println(counter.getValue() + " : Thread - " +Thread.currentThread());
} catch (InterruptedException e) {
e.printStackTrace();
}
};
IntStream.range(0, 10).forEach(number -> new Thread(r).start());
}
}
@NotThreadSafe
class UnsafeThreadClass {
private int value;
public synchronized int getValue() throws InterruptedException {
Thread.sleep(1000);
return value++;
}
}
我有一个学生列表和一个委托，该委托具有获取给定学生的服务器列表的功能 ( getServersForStudent(student))。我想为每个服务器索引的学生列表创建一个地图。一个学生可以在多个服务器中。
private Map<Server, Student> getStudentsByServer(List<Student> students) {
Map<Server, List<Student>> map = new HashMap<>();
students.forEach(student ->
List<Server> servers = delegate.getServersForStudent(student);
if (!servers.isEmpty()) {
servers.forEach(server -> map.putIfAbsent(server, new ArrayList<>()).add(student));
}
);
return map
}
这工作得很好，但我想重构它以使用流来创建一个不可变的集合。我尝试使用 groupingBy 执行此操作，但无法获得正确的结果：
students
.stream()
.collect(
Collectors.groupingBy(
student -> delegate.getServersForStudent(student);
Collectors.mapping(Function.identity(), Collectors.toList())
)
);
此分组与上面的结果不同，因为它是按列表分组的。有人对如何使用 Java 流最好地做到这一点有任何建议吗？
我试图熟悉 Java 流以及该领域的类似事物，但无法对 type 的数组进行排序int。这是我的代码，它根本不对数组进行排序。
class Scratch {
public static void main(String[] args) {
int [] arr3 = { 9,21,5,8 };
Comparator<Integer> cc = (e1,e2) -> {
return e1.compareTo(e2);
};
Arrays.stream(arr3).boxed().sorted();
System.out.println(Arrays.toString(arr3));
}
}
import java.util.stream.*;
public class MyClass {
public static void main(String args[]) {
Stream.of(1, 2, 3).map(i -> {
System.out.println(i+":inside map");
return i+4;
}).forEach(t->System.out.println(t + ":inside foreach"));
}
}
// 印刷：
1:inside map
5:inside foreach
2:inside map
6:inside foreach
3:inside map
7:inside foreach
输出不应该是：
1:inside map
2:inside map
3:inside map
5:inside foreach
6:inside foreach
7:inside foreach
我的印象是，每个中间操作结束后，它都会返回一个新的流。所以 foreach 应该得到 (5,6,7) 并因此打印
5:inside foreach
6:inside foreach
7:inside foreach
但案例表明，foreach 是对map 的每个条目一一执行的。这是为什么？
这是我在 Java MOOC.fi 课程中学习流的代码。下面的代码可以工作，但我编写它的方式相当业余。我正在考虑以某种方式将流中的 if 语句与先前输入中给出的答案的条件集成，以通过更改一行（过滤器方法）来预测该过程。有任何想法吗？
System.out.println("Print the average of the negative numbers or the positive numbers? (n/p)");
String answer = scanner.nextLine();
double average;
if (answer.equals("n")) {
average = inputs.stream()
.mapToInt(s -> Integer.valueOf(s))
.filter(pos -> pos < 0)
.average()
.getAsDouble();
} else {
average = inputs.stream()
.mapToInt(s -> Integer.valueOf(s))
.filter(pos -> pos > 0)
.average()
.getAsDouble();
}
我尝试过forEach，但我不明白如何使用它。我提供给流的集合是一个ArrayList.
我使用的是 Java 11。
鉴于：
List<String> myStrings = Arrays.asList("broom", "monsoon");
返回：
Map<String, Long> stringToNumberOfVowels = Map.of("broom", 2, "monsoon", 3);
这是我尝试过的：
Map<String, Long> vowelsMap = Stream.of("broom").flatMapToInt(String::chars).filter("aeiou".indexOf(c) >= 0).mapToObj(c -> "aeiou".indexOf(c)>=0 ? "broom" : "").collect(Collectors.groupingBy(Function.indenty(), Collectors.counting()));
for(Map.Entry<String, Long> a : vowelsMap.entrySet()) { System.out.println(a.getKey() + "==>"); System.out.println(a.getValue()); }
我的输出（仅适用于流中传递的 1 个字符串）：
扫帚==> 2
期望的输出：
扫帚==> 2
季风==> 3
public static void main(String[] args) throws IOException {
List<String> lst = new ArrayList<>();
lst.add("Alpha");
lst.add("Beta");
lst.add("Gamma");
String joinResult = lst.stream().peek(x->System.out.println(x)).map(x -> {
System.out.println("In the middle");return x+"3";}).peek(System.out::println).collect(Collectors.joining());
System.out.println(joinResult);
}
最后我没有使用collect(Collectors.joining())，而是使用了count()。但是没有打印任何内容。count()没有终端操作吗？count返回的是long，所以应该是这样。真的很奇怪。
上面的代码从头到尾打印每个元素。Alpha -> 中间 ->Alpha3 Beta -> 中间 -> Beta3 依此类推
这就是流的工作原理吗？每个元素都从头到尾进行处理？
我是 Java 新手，开始学习java streams. 我已经理解了filter如何使用流，但是理解map正在成为一个挑战。
我有一个Person.java代码
public class Person {
// Fields
private String name;
private int age;
private String gender;
// Constructor
public Person( String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
// Getters
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
public String getGender() {
return this.gender;
}
// Setters
public void setName(String name) { …如果我有一个java.util.Stream需要关闭的（一旦完成），我如何才能既关闭它（通过调用close）又调用一个终端操作，如countor collect？
例如：
java.nio.file.Files.lines(FileSystems.getDefault().getPath("myfile.txt"))
.collect(Collectors.toSet());
//.close(); ???
（在此示例中，调用close并不重要，但可以说我有一个Stream对象，该对象通过onClose在流中注册了关键的close操作）。
我猜您可以将流存储在temp var中并关闭它，如下所示：
Stream<String> ss = java.nio.file.Files.lines(FileSystems.getDefault().getPath("myfile.txt"));
Set<String> lines = ss.collect(Collectors.toSet());
ss.close();
return lines;
但似乎有点笨拙。以这种方式关闭流是否总是安全的？
我需要检查类的Id变量是否为null。如果为null，则必须将其插入一个列表中；如果不为null，则必须将其插入另一列表中。我这样做是这样的：
我不希望有两个流，我只想做一个，然后使用Strem和过滤器，您能帮我吗？
具有空ID的电子邮件将保留在数据库中。
List<Email> emails = payment.getUser().getEmails();
if (!emails.isEmpty()){
List<Email> create = emails.stream().filter(email -> email.getId() == null).collect(Collectors.toList());
List<Email> existingEmails = emails.stream().filter(email -> email.getId() != null).collect(Collectors.toList());
}