标签: java-8

这段代码可以变成lambda表达式吗？我尝试了很多,但我没有得到它.

DirectoryStream.Filter<Path> dirFilter = new DirectoryStream.Filter<Path>() {
    @Override
    public boolean accept(Path dir) throws IOException {
        return Files.isDirectory(dir);
    }
};
Path baseDirectory = getProjectDir();
try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(baseDirectory, dirFilter)) {
    for(Path path : dirStream) {
        System.out.println(path.getFileName());
    }
} catch(IOException ioe) {
    ioe.printStackTrace();
}

我发现的所有示例都使用其他类型信息来推断其类型Stream.empty().似乎应该有语法允许我直接投射它.这个例子有效:

import java.util.*;
import java.util.stream.*;

class OptionalBasics {
    static void test(Optional<String> optString) {
        if(optString.isPresent())
            System.out.println(optString.get());
        else
            System.out.println("Nothing inside!");
      }
    public static void main(String[] args) {
        Stream<String> s = Stream.empty();
        test(s.findFirst());
        test(Stream.of("Epithets").findFirst());
    }
}
/* Output:
Nothing inside!
Epithets
*/

但请注意,我必须s单独创建才能提供类型信息Stream.empty().我想在调用中创建它 test(),就像这样(这不起作用):

test(Stream<String>.empty().findFirst());

是否有用于设置调用类型的语法Stream.empty()？

我正在尝试根据值对地图进行排序.

但我看到以下程序有一些奇怪的行为

public class CompareByValueMain {

    public static void main(String[] args) {
        Map<String,Integer> itemIDToTimeMap = new HashMap<String,Integer>();

        itemIDToTimeMap.put("Baggage", 3);
        itemIDToTimeMap.put("Handbag", 16);
        itemIDToTimeMap.put("Closed Footwear", 4);
        itemIDToTimeMap.put("Shirt", 25);

        Set<String> itemIDs = itemIDToTimeMap.entrySet().stream()
                .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
                .map(Map.Entry::getKey)
                .collect(Collectors.toSet());

        System.out.println(itemIDs);
    }
}

输出结果是正确的

[衬衫,手提包,封闭式鞋类,行李 ]

但是当我从Baggage改为Bag时的输入 它给出了以下输出

[衬衫,包,手提包,封闭式鞋]

理想情况下,应根据地图中的值进行排序,而不管键值如何.但是如果在这里更改密钥,不确定为什么会改变.

我使用java8的最新项目,发现处理Collection类型非常方便,它给了我很大的惊喜.但突然觉得一些传统的语法是如此繁琐,例如我有一个名为BuyerOrderCountStats的Object,每次买家提交订单,都会增加他的订单数,

BuyerOrderCountStats bocs = ...;
bocs.setOrderCount(bocs.getOrderCount()+1);

在java 8中有哪些方便的方式我不知道？

Java 8允许在注释的帮助下在同一元素上进行相同类型的多个@Repeatable注释.

不幸的是,他们显然忘记了一个注释案例的相应功能支持:

import java.lang.annotation.Inherited;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Objects;

public class MultipleAnnotationsCompatibility {

   @Inherited
   @Retention(RetentionPolicy.RUNTIME)
   public @interface FileTypes {
      FileType[] value();
   }

   @Inherited
   @Repeatable(FileTypes.class)
   @Retention(RetentionPolicy.RUNTIME)
   public @interface FileType {
      String value();
   }

   @FileType("png")
   @FileType("jpg")
   public static class Image {
   }

   @FileType("xls")
   public static class Worksheet {
   }

   public static void main(String[] args) {

      FileTypes fileTypes;

      fileTypes = Image.class.getAnnotation(FileTypes.class);

      System.out.println("fileTypes for Image = " + Objects.toString(fileTypes));

      fileTypes = Worksheet.class.getAnnotation(FileTypes.class);

      System.out.println("fileTypes for Worksheet = " + …

我有一个方法,它返回一个属性的平均值超过许多模型对象:

List<Activity> activities = ...;
double effortSum = 0;
double effortCount = 0;
activities.stream().forEach(a -> {
    double effort = a.getEffort();
    if (effort != Activity.NULL) {
        effortCount++;            < Compilation error, local variable
        effortSum += effort;      < Compilation error, local variable
    }
});

但是,如上所述,上述尝试无法编译.我遇到的唯一解决方案是使用AtomicReference一个Double对象,但这看起来很苛刻,并且会给应该是一个简单的操作带来大量的混淆.(或者加入番石榴并获得AtomicDouble,但是得出了同样的结论.)

是否有使用新Java 8循环修改局部变量的"最佳实践"策略？

活动的相关代码:

public class Activity {
    public static final double NULL = Double.MIN_VALUE;

    private double effort = NULL;

    public void setEffort(double effort) { this.effort = effort; }
    public double …

我希望根据某些条件从列表中获取最小或最大项目.下面的摘录总结了我在做什么:

Optional<Person> target;
if(condition){
    target = detailedList.stream().min((d1, d2) -> d1.age() + d2.age());
} else {
    target = detailedList.stream().max((d1, d2) -> d1.age() + d2.age());
}

它有效,但相当冗长.本质上,我想在流中选择方法min或max.有一个更好的方法吗？

我将很快尝试我的OCA,并且我已经获得有关如何正确声明Longs和Floats的混合信息.

从JavaSE8开始,如何正确地声明一个Long和一个Float,就像在演员值的末尾有额外的L或F一样,或者这不再是必要的吗？

我是java的新手.我正在尝试从包含showNames的流创建一个HashMap.我的问题是,名称可能是重复的,它们可能会出现多次,这意味着它们必须映射到相同的键上,我在映射后尝试使用过滤器,但我不确定要放置什么条件.X-> x.equals(x)的？流showNames的外观如下:

LOTR,Lucifer,Breaking Bad,LOTR,Exorcist,The Godfather,The Godfather,Lucifer,等等

哈希映射应该具有显示名称的键,以及字符串在流中显示的时间值

我有一个像这样的对象

public class Keyword
{
  private int id;
  private DateTime creationDate
  private int subjectId
  ...
}

所以现在我有像下面这样的数据列表

KeywordList = [{1,'2018-10-20',10},{1,'2018-10-21',10},{1,'2018-10-22',10},{1,'2018 -10-23' ,20},{1, '2018年10月24日',20} {1, '2018年10月25日',20},{1, '2018年10月26日',30}, {1, '2018年10月27日',30},{1, '2018年10月28日',40}]

我想限制主题ID的这个列表

例如:如果我提供限制为2,它应该只包括每个主题id的最新2条记录,通过creationDate排序并将结果也作为列表返回.

resultList = KeywordList = [{1,'2018-10-21',10},{1,'2018-10-22',10},{1,'2018-10-24',20},{1, '2018年10月25日',20},{1, '2018年10月26日',30},{1, '2018年10月27日',30},{1, '2018年10月28日', 40}]

我们如何在Java 8中实现这种功能我已经以这种方式实现了它.但我对这段代码的性能有所怀疑.

dataList.stream()
        .collect(Collectors.groupingBy(Keyword::getSubjectId,
            Collectors.collectingAndThen(Collectors.toList(),
                myList-> myList.stream().sorted(Comparator.comparing(Keyword::getCreationDate).reversed()).limit(limit)
                    .collect(Collectors.toList()))))
        .values().stream().flatMap(List::stream).collect(Collectors.toList())