我的目标:采取LinkedList的UserS和提取LinkedList在一个优雅的,Java的8路的用户名.
public static void main(String[] args) {
LinkedList<User> users = new LinkedList<>();
users.add(new User(1, "User1"));
users.add(new User(2, "User2"));
users.add(new User(3, "User3"));
// Vanilla Java approach
LinkedList<String> usernames = new LinkedList<>();
for(User user : users) {
System.out.println(user.getUsername());
usernames.add(user.getUsername());
}
System.out.println("Usernames = " + usernames.toString());
// Java 8 approach
users.forEach((user) -> System.out.println(user.getUsername()));
LinkedList<String> usernames2 = users.stream().map(User::getUsername). // Is there a way to turn this map into a LinkedList?
System.out.println("Usernames = " + usernames2.toString());
}
static class …我想换一个java.util.streams.Stream围绕InputStream处理一个字节或一次一个字符.我没有找到任何简单的方法来做到这一点.
请考虑以下练习:我们希望计算每个字母在文本文件中出现的次数.我们可以将它存储在一个数组中,以便tally[0]存储在文件中出现的次数,tally[1]存储出现的时间b等等.由于我找不到直接传输文件的方法,我这样做了:
int[] tally = new int[26];
Stream<String> lines = Files.lines(Path.get(aFile)).map(s -> s.toLowerCase());
Consumer<String> charCount = new Consumer<String>() {
public void accept(String t) {
for(int i=0; i<t.length(); i++)
if(Character.isLetter(t.charAt(i) )
tall[t.charAt(i) - 'a' ]++;
}
};
lines.forEach(charCount);
有没有办法在不使用该lines方法的情况下完成此操作？我可以直接将每个字符作为Stream或Stream处理,而不是为文本文件中的每一行创建字符串.
我可以更直接地转换java.io.InputStream成java.util.Stream.stream？
我正在尝试使用`stream将以下代码重构为lambda表达式,尤其是嵌套的foreach循环:
public static Result match (Response rsp) {
Exception lastex = null;
for (FirstNode firstNode : rsp.getFirstNodes()) {
for (SndNode sndNode : firstNode.getSndNodes()) {
try {
if (sndNode.isValid())
return parse(sndNode); //return the first match, retry if fails with ParseException
} catch (ParseException e) {
lastex = e;
}
}
}
//throw the exception if all elements failed
if (lastex != null) {
throw lastex;
}
return null;
}
我开始时:
rsp.getFirstNodes().forEach().?? // how to iterate the nested 2ndNodes?
我第一次尝试使用java 8流...
我有一个对象Bid,它代表用户对拍卖中项目的出价.我有一个出价列表,我想制作一张地图,其中包含用户出价的拍卖数量(不同).
这是我的看法:
bids.stream()
.collect(
Collectors.groupingBy(
bid -> Bid::getBidderUserId,
mapping(Bid::getAuctionId, Collectors.toSet())
)
).entrySet().stream().collect(Collectors.toMap(
e-> e.getKey(),e -> e.getValue().size())
);
它工作,但我觉得我在作弊,因为我流式传输地图的入口集,而不是在初始流上进行操作...必须是一个更正确的方式这样做,但我无法想象出来...
谢谢
对于Collectors.groupingBy()那个返回Map<K,List<T>>,它暗示List<T>是为了评估流？
我没有看到列表排序的明确描述,而并发版本明确表示没有排序.如果它没有以某种方式订购,我会期望它是一个收藏品,我不会看到除了收到订单之外的其他订单.
我希望保证每个列表中的最后一个值是该组收到的最后一个值.
请考虑以下代码:
List<Integer> odd = new ArrayList<Integer>();
List<Integer> even = null;
List<Integer> myList = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
even = myList.stream()
.filter(item -> {
if(item%2 == 0) { return true;}
else {
odd.add(item);
return false;
}
})
.collect(Collectors.toList());
我在这里要做的是将列表中的偶数和奇数值分别放入单独的列表中.
stream filter()方法返回true偶数项,流收集器将收集它们.
对于奇数情况,过滤器将返回false,项目将永远不会到达收集器.
所以我在else块之前创建的另一个列表中添加了这些奇数.
我知道这不是一种优雅的流式处理方式.例如,如果我使用并行流,那么奇数列表将出现线程安全问题.由于性能原因,我不能使用不同的过滤器多次运行它(应该是O(n)).
这只是一个用例的示例,列表可以包含任何对象,并且过滤器内的lambda需要根据某些逻辑将它们分离到单独的列表中.
简单来说:从列表中创建多个列表,其中包含基于某些条件分隔的项目.
如果没有流,只需运行for循环并执行简单的if-else并根据条件收集项目.
假设我已经List<Car>并且我想搜索该列表以验证我同时拥有思域和焦点.如果它是一个OR,它很容易,因为我可以在它上面应用OR .filter().请记住,我不能filter().filter()为这种类型的AND做.
一个有效的解决方案是:
boolean hasCivic = reportElements.stream()
.filter(car -> "Civic".equals(car.getModel()))
.findFirst()
.isPresent();
boolean hasFocus = reportElements.stream()
.filter(car -> "Focus".equals(car.getModel()))
.findFirst()
.isPresent();
return hasCivic && hasFocus;
但后来我基本上处理了两次列表.我不能&&在过滤器中应用,也不能filter().filter().
有没有办法处理流一次,以查找列表是否包含思域和焦点汽车？
重要更新:提供的解决方案的关键问题是它们都保证O(n),而我的解决方案可以在两次比较后完成.如果我的汽车列表是1000万辆汽车,那么将会有非常显着的性能成本.然而,我的解决方案感觉不对,但也许这是性能最佳的解决方案......
假设我们在集合中有一些项目,我们想要使用某个比较器对它们进行排序,期望列表中的结果:
Collection<Item> items = ...;
Comparator<Item> itemComparator = ...;
其中一种方法是对列表中的项进行排序,例如:
List<Item> sortedItems = new ArrayList<>(items);
Collections.sort(sortedItems, itemComparator);
另一种方法是使用排序流:
List<Item> sortedItems = items
.stream()
.sorted(itemComparator)
.collect(Collectors.toList());
我想知道,哪种方法更有效率？排序流是否有任何优点(如多核上的紧固排序)？
从运行时复杂性/速度的角度来看,效率很高.
我不相信自己能够实现一个完美的基准,学习SortedOps并没有真正启发我.
我写了一些简单的代码，如下所示。此类正常运行，没有任何错误。
public class Test {
public static void main(String[] args) {
List<Integer> intList = IntStream.of(1,2,3,4,5,6,7,8,9,10).boxed().collect(Collectors.toList());
int value = intList.stream().max(Integer::compareTo).get();
//int value = intList.stream().max(<Comparator<? super T> comparator type should pass here>).get();
System.out.println("value :"+value);
}
}
如代码注释所示，该max()方法应传递type参数Comparator<? super Integer>。
但是Integer::compareTo实现Comparable接口- 不是 Comparator。
public final class Integer extends Number implements Comparable<Integer> {
public int compareTo(Integer anotherInteger) {
return compare(this.value, anotherInteger.value);
}
}
这怎么工作？该max()方法说它需要一个Comparator参数，但是可以与Comparable参数一起使用。
我知道我误会了一些东西，但是现在我知道了。有人可以解释一下吗？