早期jdk8-ea的javadoc 这样表示有一个java.util.stream.Streamable接口,它似乎有一个同样的关系Stream作为Iterable必须的Iterator.
现在好像我们被困住了Supplier<Stream>,这肯定是不一样的.
发生什么事了Streamable？
我的目标:采取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())
);
它工作,但我觉得我在作弊,因为我流式传输地图的入口集,而不是在初始流上进行操作...必须是一个更正确的方式这样做,但我无法想象出来...
谢谢
请考虑以下代码:
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并根据条件收集项目.
我已经在JDK 1.8上工作了几天,在那里我遇到了一些与此类似的代码:
List<Integer> list = Arrays.asList(1,2,3,4,5);
list.stream();
现在,对于使用streams(java.util.stream)的人来说,它看起来既简单又干净,我找不到实现该java.util.Collection.stream()方法的实际类.
当我说list.stream():我有以下问题:
java.util.stream.Stream从哪里得到的？我也尝试过的单证看java.util.AbstractCollection和java.util.AbstractList,但未能找到它.
假设我已经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并没有真正启发我.