我需要转换java.util.Date到String的yyyy-MM-dd格式在一个大的数额.
我刚刚转到java 8并想知道如何正确地做到这一点.我使用Java 7的解决方案如下:
DateTimeFormatter DATE_FORMATTER = DateTimeFormat.forPattern(DATE_FORMAT_PATTERN)
DATE_FORMATTER.print(value.getTime())
它帮助我不创建大量冗余对象.
所以现在当我转到java 8时,我想要正确地重写它,但是:
LocalDate.fromDateFields(value).toString())
每次都创建新LocalDate对象,这为GC提供了大量的工作.
有什么方法可以解决我的问题吗？性能和线程安全非常重要.
经过一些测试后,我发现即使创建新的对象构造:
new SimpleDateFormat("yyyy-MM-dd")).format(value))
这个话题最快.
在Java(目前使用Java 8)中,我可以编写这个并且所有编译都很好:
Supplier<Long> asd = () -> {
throw new RuntimeException();
};
但是,我不能这样写:
Supplier<Long> asd = () -> throw new RuntimeException(); // This won't compile :(
有谁知道为什么Java的实现不允许这样的样式(表达式lambda)和只有语句/代码块样式lambda？
我的意思是,由于lambda 只抛出RuntimeException,为什么JDK不能将lambda表达式推断为:
new Supplier<Long>() {
@Override
public Long get() {
throw new RuntimeException();
}
};
这是在specs/docs中的某处记录的吗？这是仅在JDK> 8中添加的吗？
根据下面的代码,hashmap初始dafault容量是16,LF是0.75,所以当我输入第13个元素然后重新发送应该发生并且因为我提供了一个常量哈希码,它在内部维护一个链表以维持一个插入顺序.因此,直到第10个元素它按预期工作,但是当我输入第11个元素时,它会改变顺序.任何人都可以帮助我理解为什么它只在第11个元素插入时发生.
class A{
int a;
A(int a){
this.a = a;
}
@Override
public int hashCode() {
return 7;
}
@Override
public String toString() {
return "" + a + "";
}
}
class Base {
public static void main(String[] args) {
Map<Object, Integer> m = new HashMap<Object, Integer>();
m.put(new A(1), 1);
m.put(new A(2), 1);
m.put(new A(3), 1);
m.put(new A(4), 1);
m.put(new A(5), 1);
m.put(new A(6), 1);
m.put(new A(7), 1);
m.put(new A(8), 1);
m.put(new A(9), 1);
m.put(new A(10), 1);
//m.put(new A(11), …我写了一些简单的代码，如下所示。此类正常运行，没有任何错误。
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参数一起使用。
我知道我误会了一些东西，但是现在我知道了。有人可以解释一下吗？
I have a List of String like:
List<String> locations = Arrays.asList("US:5423","US:6321","CA:1326","AU:5631");
And I want to convert in Map<String, List<String>> as like:
AU = [5631]
CA = [1326]
US = [5423, 6321]
I have tried this code and it works but in this case, I have to create a new class GeoLocation.java.
List<String> locations=Arrays.asList("US:5423", "US:6321", "CA:1326", "AU:5631");
Map<String, List<String>> locationMap = locations
.stream()
.map(s -> new GeoLocation(s.split(":")[0], s.split(":")[1]))
.collect(
Collectors.groupingBy(GeoLocation::getCountry,
Collectors.mapping(GeoLocation::getLocation, Collectors.toList()))
);
locationMap.forEach((key, value) -> System.out.println(key + " = …JLS：
的最低优先级操作者是lambda表达式的箭头（ - >） ，随后由赋值运算符。
遵循哪个方向（增加优先级，减少优先级）？-“跟随”是指分配的优先级较高还是较低（相对于箭头运算符）？我猜想，这是因为“最低”（箭头）表示绝对最低。
据我了解，箭头（->）应该位于此Princeton运算符优先级表的最底部（在所有赋值运算符的下方），因此箭头（->）的优先级为0（零）（根据该表）。
我的理解正确吗？
ExamTray似乎说箭头优先级至少与分配相同。此外，还阐明了箭头的关联性是Left-> To-> Right（与分配不同）。我没有找到JLS的箭头关联性报价。
我一直认为分配优先级原则上最低。
java specifications operator-precedence language-lawyer java-8
我要做的是过滤列表,然后映射它并使用orElseif null然后将其收集回列表.现在我可以通过这种方式实现它:
return users.stream()
.filter(user -> id.equals(user.getId()))
.map(
user -> {
if(user.getData() != null) {
return user.getData();
}
return Collections.emptyMap();
}
)
.collect(Collectors.toList());
但问题是:我怎样才能使这个结构更好,为什么我不能orElse在这种情况下使用？
我正在阅读有关无国籍状态的文章并在文档中遇到过这个问题:
如果流操作的行为参数是有状态的,则流管道结果可能是不确定的或不正确的.有状态lambda(或实现适当功能接口的其他对象)的结果取决于在流管道执行期间可能发生变化的任何状态.
现在,如果我有一个字符串列表(strList比如说),然后尝试使用并行流从中删除重复的字符串,方法如下:
List<String> resultOne = strList.parallelStream().distinct().collect(Collectors.toList());
或者如果我们想要不区分大小写:
List<String> result2 = strList.parallelStream().map(String::toLowerCase)
.distinct().collect(Collectors.toList());
此代码是否有任何问题,因为并行流将分割输入并且在一个块中不同并不一定意味着在整个输入中是不同的？
这distinct是有状态操作,并且在有状态中间操作的情况下,并行流可能需要多次通过或大量缓冲开销.distinct如果元素的排序不相关,也可以更有效地实现.另外根据文件:
对于有序流,不同元素的选择是稳定的(对于重复元素,保留在遇到顺序中首先出现的元素.)对于无序流,不进行稳定性保证.
但是在有序流并行运行的情况下,不同可能是不稳定的 - 意味着它将在重复的情况下保留任意元素,而不一定是distinct其他情况下预期的第一个元素.
从链接:
在内部,distinct()操作保持一个包含先前已经看到的元素的Set,但它隐藏在操作中,我们无法从应用程序代码中获取它.
因此,在并行流的情况下,它可能会消耗整个流,或者可能使用CHM(类似于ConcurrentHashMap.newKeySet()).对于有序的,很可能是使用LinkedHashSet或类似的结构.
我有一个关于Java 8的Optional的问题,其目的是解决NullPointerException异常问题.
问题是,让两种类型让我们选择的原因是什么:
Optional.of(T value) <-----non-null value, null value will throw NPE
Optional.ofNullable(T value) <----- nullable value
因为我的期望是,当我使用时:
Optional.of(nullValue);
它不会抛出一个NullPointerException.
一些回复后扩大了我的问题:
为什么人们会选择Optional而不是普通if-else的null检查？
我有一个像这样的方法,我正在使用Streams的递归:
private static List<Member> convertToFlatList(List<Member> memberList)
{
return memberList.stream().flatMap(i -> Stream.concat(Stream.of(i), convertToFlatList(i.getChildren()).stream())).collect(Collectors.toList());
}
假设一个Member类有一个子成员列表,总是初始化为一个空列表.这里我正在做的是将成员的分层列表转换为平面列表.我明白那一部分.我不明白的是递归是如何工作的.
在递归中,当满足某些条件时它会终止.但在这里,我没有给出故意终止的任何条件.那么终止部分如何在这里工作？