标签: java-8

下面是定义枚举类型的代码.

enum Company{
    EBAY(30), PAYPAL(10), GOOGLE(15), YAHOO(20), ATT(25);
    private int value;

    private Company(int value){
        super(this.name()); 
        this.value = value;
    }

    public int getValue(){
        return value;
    }
}

内部编译到,

final class Company extends Enum<Company>{
    public final static Company EBAY = new Company(30);
    public final static Company PAYPAL = new Company(10);
    public final static Company GOOGLE = new Company(15);
    public final static Company YAHOO = new Company(20);
    public final static Company ATT = new Company(25);

    private int value;

    private Company(int value){
        super(this.name(),Enum.valueOf(Company.class, this.name())); …

我有以下简单的代码,我试图转换为功能样式

for(String str: list){
    if(someCondition(str)){
       list2.add(doSomeThing(str));
    }
    else{
        list2.add(doSomethingElse(str));
    }
}

是否可以用流替换这个循环？我看到的唯一选择是使用两个不同的过滤条件迭代流两次.

考虑以下方法,如果字段存在,则返回字段,或者在找到字段之前递归调用自身:

private Field getField(Class<?> clazz, String p) {
    Optional<Field> field = Arrays.stream(clazz.getDeclaredFields())
            .filter(f -> p.equals(f.getName()))
            .findFirst();

    return field.isPresent() ? field.get() : getField(clazz.getSuperclass(), p);
}

虽然这有效,但我认为我可以缩短它:

private Field getField(Class<?> clazz, String p) {
    return Arrays.stream(clazz.getDeclaredFields())
            .filter(f -> p.equals(f.getName()))
            .findFirst()
            .orElse(getField(clazz.getSuperclass(), p));
}

但奇怪的是,这.orElse部分似乎总是被称为.

我在这里错过了什么？

Java 8中有一个新的n-cool Date API,即java.time包.我知道它比旧类更好的设计,更少的模糊和更多的线程安全.不过,我不知道如何使用它:

• 我应该专门使用它而不是旧类吗？
• 我应该更换旧课程的现有用法,因为新的东西要好得多吗？
• 我应该避免使用java.util.Calendar, java.util.Date,java.sql.Date并java.text.DateFormat支持新的API一起还是有使用的情况下,其中的老班还是最好？
• 由于新的Date API类似于使用Java 8流API 替换Guava FluentIterable,Joda Time API是否已经过时了？

我知道这些都是很多问题,但他们感觉彼此有些相关.如果有人可以回答整个问题,那将是非常棒的,但也可以赞赏好的部分答案.

我一直在尝试使用lambda表达式在Java8中创建Map.Entry Comparator,并且发现了一种非常奇怪的行为.

Map<Integer, String> map = new TreeMap<>();

map.put(1, "Hello");
map.put(3, "zzzz");
map.put(2, "aaaa");
map.put(5, "AAAAA");
map.put(4, "aaaa");

Comparator<Map.Entry<Integer, String>> com = Comparator.comparing(Map.Entry::getValue);
com = com.reversed();

Comparator<Map.Entry<Integer, String>> com2 = Comparator.comparing(Map.Entry::getValue).reversed();

com工作正常,但com2包含一个错误的" 无法解析方法getValue ".我真的不知道为什么？有什么建议？

PS有没有办法避免用Integer,String键入Map.Entry？任何更短的方式？

在阅读了Java 8的java.util.stream.Intstream之后,我一直在用流替换一些传统的循环.不幸的是,在处理嵌套循环时遇到了一些性能问题.

正如预期的那样,以下代码在我的机器中运行大约47毫秒:

IntStream.range(0, 1000000000).forEach(i -> {});

但是,嵌套另一个IntStream hyper会将执行时间膨胀到大约10,458 ms - 即:

IntStream.range(0, 1000000000).forEach(i -> {
    IntStream.range(0, 1).forEach(j -> {});
});

这是我的滥用案例,还是这个问题将来可以解决？

编辑:为了进行比较,以下代码使用传统的内部循环运行得更快(在1,801毫秒内).因此,即使考虑到优化,使用内部IntStream似乎也会有更多的开销？

final long[] random = {1};
IntStream.range(0, 1000000000).forEach(i -> {
    for (int j = 0; j < 1; j++) {
        random[0] += i;
    }
});

我目前正在将我的应用程序从Java 7迁移到Java 8,目前我正在运行Spring 3.1.6 jar.这是否与Java 8兼容或者我需要升级Spring jar？

我知道Spring 4x版本对Java 8有自然的支持,但这对时间至关重要,我正在寻求尽可能少的改变.

我正在深入探讨 Java 8 Lambda和方法参考等功能.玩了一下让我看到以下示例:

public class ConsumerTest {

  private static final String[] NAMES = {"Tony", "Bruce", "Steve", "Thor"};

   public static void main(String[] args) {
      Arrays.asList(NAMES).forEach(Objects::requireNonNull);
   }
}

我的问题是:

为什么main方法中的行会编译？

如果我理解正确的话,引用的方法的签名必须对应于功能接口的SAM签名.在这种情况下,消费者需要以下签名:

void accept(T t);

但是,该requireNonNull方法返回T而不是void:

public static <T> T requireNonNull(T obj)

我创建了一个带有类型参数的方法,使用这些类型参数返回泛型类型,并获取Function也取决于类型参数的参数.当我使用lambdas作为参数时,编译器强制我指定方法的类型参数,这感觉不对.

我正在设计一个实用程序类,其中包含使用的方法Stream.flatMap.它将每种集合条目映射到包含键和值元素的FlatEntry,并且可以使用构建器在多个级别上执行此操作.受影响的方法是flatEntryMapperBuilder.这是代码:

import java.util.function.Function;
import java.util.stream.Stream;

public class GdkStreams
{
    public static <T, K, V> Function<T, Stream<FlatEntry<K, V>>> flatEntryMapper(Function<T, K> keyMapper,
                                                                                 Function<T, Stream<V>> valueMapper)
    {
        return input -> {
            K key = keyMapper.apply(input);
            return valueMapper.apply(input).map(value -> new FlatEntry<>(key, value));
        };
    }

    public static <T, K, V> FlatEntryMapperBuilder<T, K, V> flatEntryMapperBuilder(Function<T, K> keyMapper,
                                                                                   Function<T, Stream<V>> valueMapper)
    {
        return new FlatEntryMapperBuilder<>(keyMapper, valueMapper);
    }

    public static class FlatEntryMapperBuilder<T, K, V>
    {
        private Function<T, K>         keyMapper;

        private Function<T, …

CompletableFuture::supplyAsync(() -> IO bound queries)

如何为CompletableFuture :: supplyAsync选择Executor以避免污染ForkJoinPool.commonPool().

有许多选项Executors(newCachedThreadPool,newWorkStealingPool,newFixedThreadPool等)

我在这里阅读了关于新ForkJoinPool的内容

如何为我的用例选择合适的？