我目前正在学习如何使用Java,我的朋友告诉我,使用Java 8时可以简化这段代码.他指出parseIntArray可以简化.你会如何在Java 8中做到这一点？
public class Solution {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String[] tokens = input.nextLine().split(" ");
int[] ints = parseIntArray(tokens);
}
static int[] parseIntArray(String[] arr) {
int[] ints = new int[arr.length];
for (int i = 0; i < ints.length; i++) {
ints[i] = Integer.parseInt(arr[i]);
}
return ints;
}
}
我正在查看一些代码并遇到这个方法,它采用HTML Header值(即Content-Disposition = inline; filename = foo.bar)并将其解析为由分号分隔成key = value对的映射.起初它看起来像是使用流进行优化的一个很好的候选者,但是在我实现之后,我无法重用计算的String.indexOf('=')值意味着字符串必须被扫描3次,这是实际上不如原来的最佳.我完全清楚有很多实例,Streams不适合这项工作,但我想知道我是否错过了一些技术,可以让Stream比初始代码更高效/更高效.
/**
* Convert a Header Value String into a Map
*
* @param value The Header Value
* @return The data Map
*/
private static Map<String,String> headerMap (String value) {
int eq;
Map<String,String> map = new HashMap<>();
for(String entry : value.split(";")) {
if((eq = entry.indexOf('=')) != -1) {
map.put(entry.substring(0,eq),entry.substring(eq + 1));
}
}
return map;
return Stream.of(value.split(";")).filter(entry -> entry.indexOf('=') != -1).collect(Collectors.));
} //headerMap
我尝试Streaming it:
/**
* Convert a Header Value …假设我有一个清单
ArrayList<String> arr = new ArrayList(Arrays.asList("N1", "N2", "N3", "N5"));
我怎么找到"N4",我的意思是,我怎么发现丢失的整数是4？
到目前为止我尝试过的
Integer missingID = arr.stream().map(p -> Integer.parseInt(p.substring(1))).sorted()
.reduce((p1, p2) -> (p2 - p1) > 1 ? p1 + 1 : 0).get();
这不起作用,因为reduce在这种情况下不打算以我需要的方式工作,实际上,我不知道怎么做.如果没有丢失的数字,则必须是下一个"N6" - or just 6 -(在此示例中)
它必须使用java标准流的库,不使用第三方.
我对 Java 8 lambdas 和其他东西很陌生……我想编写一个 lambda 函数，它接受 a JSONArray，遍历它的JSONObjects 并创建某个字段的值列表。
例如，一个函数接受JSONArray:[{name: "John"}, {name: "David"}]并返回一个列表["John", "David"]。
我写了以下代码：
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
public class Main {
public static void main(String[] args) {
JSONArray jsonArray = new JSONArray();
jsonArray.add(new JSONObject().put("name", "John"));
jsonArray.add(new JSONObject().put("name", "David"));
List list = (List) jsonArray.stream().map(json -> json.toString()).collect(Collectors.toList());
System.out.println(list);
}
}
但是，我收到一个错误：
线程“main”中的异常 java.lang.NullPointerException
你知道如何解决吗？
是java.util.stream.Collectors::joining实现线程安全的？我能做点什么吗
public final class SomeClass {
private static final Collector<CharSequence, ?, String> jc = Collectors.joining(",");
public String someMethod(List<String> someList) {
return someList.parallelStream().collect(jc);
}
}
不用担心遇到并发问题？
让我们假设我想迭代一组对象.
List<String> strmap = ...
//Without lambdas
strmap.stream().filter(new Predicate<String>() {
public boolean test(String string) {
return string.length == 10;
}
}.forEach(new Consumer<String>() {
public void accept (String string) {
System.out.println("string " + string + " contains exactly 10 characters");
}
}
//With lambdas
strmap.stream()
.filter(s -> s.length == 10)
.forEach(s -> System.out.println("string " + s + " contains exactly 10 characters");
第二个例子(没有lambdas)如何工作？每次调用代码时都会创建一个新对象(Predicate和Consumer),java jit编译器可以优化lambda表达式多少？为了获得更好的性能,我应该将所有lambdas声明为变量并且始终只传递引用吗？
private Predicate<String> length10 = s -> s.length == 10;
private Consumer<String> printer = s -> { "string …我在使用Java 8时有些新手,并且正在重构一些旧的代码(对于流操作来说似乎是一个很好的用例).较旧的代码"有效",但在我看来它看起来效率很低.
我的问题的简短版本是我试图找到List的单个元素并用相同元素的更新版本替换它(键是相同的,但每次调用代码时属性都有不同的值) .
try
{
List<Object> items = lookup(itemCache.getKey());
for (int i = 0; i < items.size(); i++)
{
Object originalObject = items.get(i);
if (originalObject.getPropValue() == newObject.getPropValue())
{
List<Object> newItems = new ArrayList<>(items);
newItems.set(i, newObject);
putIntoCache(newObject.getKey(), newItems);
break;
}
}
}
catch (Exception ex) { /*exception handling*/ }
基于我到目前为止所读到的关于流的内容,似乎我需要使用.map()或者 .filter()隔离我想要识别的元素,但这似乎也就像在流语句中的任何一个filter或之后发生的操作一样map完整列表或列表中每个项目都受到影响.map().
这似乎很简单,但我正在努力绕过它.因为初始查找List本身,我认为流可以取代所有这些.该ArrayList<>()原代码出现,但项目的顺序并不重要,只要我能够通过它的键替换项目.
如果您选择帮助,谢谢.
说我有这个流:
list.stream()
.map(fn1) // part1
.map(fn2) //
.filter(fn3) //
.flatMap(fn4) // part 2
.map(fn5) //
.filter(fn6) //
.map(fn7) //
.collect(Collectors.toList())
我怎样才能看起来像:
list.stream()
.map(fnPart1)
.map(fnPart2)
.collect(Collectors.toList())
无需手动展开fnX部件并将它们放在一起(出于维护原因,我希望保持它们不受影响,并用它们表达fnPartX).
takeWhile()与Java 9中的filter()有何不同.它有什么额外的实用程序？
Stream.of(1,2,3,4,5,6,7,8,9,10).filter(i -> i < 4 )
.forEach(System.out::println);
这可能是以下会做的
Stream.of(1,2,3,4,5,6,7,8,9,10).takeWhile(i -> i < 4 )
.forEach(System.out::println);
那么这个新功能需要什么呢？
我知道Stream.concat存在(doc)来连接两个流.但是,我遇到了需要在现有流中添加"更多"项目,然后继续处理它的情况.在这种情况下,我本来希望能够将以下方法联系在一起:
getStream(someArg)
.map(Arg::getFoo)
.concat(someOtherStreamOfFoos) // Or append, or...
.map(...)
但是,不存在这种实例级可链接append/concat方法.
这不是一个问题,要求解决这个问题,或更优雅的方法(虽然我当然会感激任何其他观点!).相反,我问的是导致这一决定的设计因素.我相信,Stream界面是由一些非常聪明的人设计的,他们都知道最小惊讶原则 - 所以,我必须假设他们决定省略这个(对我来说)直观明显的方法,这意味着该方法是一个反模式,或由于某些技术限制而无法实现.我很想知道原因.