标签: java-8

据我所知，流比传统的旧编程更快。

但是，当我运行以下代码时，结果出乎我的意料。

public class Application {
    public static void main(String[] args) {
        long startTime = System.nanoTime();
        int[] a = { 1, 2, 3, 4 };
        int m = Arrays.stream(a).reduce(Integer.MIN_VALUE, Math::max);
        long endTime = System.nanoTime();
        long totalTime = endTime - startTime;
        System.out.println(totalTime);

    }
}

输出为：22857304

public class Application {
        public static void main(String[] args) {
        long startTime = System.nanoTime();
        int[] a = { 1, 2, 3, 4 };
        int e = a.length;
        int m = Integer.MIN_VALUE;
        for (int i = 0; …

当为可空的可选抛出异常时，我收到编译错误，要求我捕获或声明异常为抛出，但 NPE 是不需要捕获的运行时异常。所以基本上 orElseThrow 行为与在 java 8 之前抛出异常不同。这是一个特性还是一个错误？有什么想法吗？

这不编译：

protected String sendTemplate() {
    String template = getTemplate();
    return Optional.ofNullable(template).orElseThrow(() -> {
        throw new NullPointerException("message");
    });

}

这样做：

protected String sendTemplate() {
    String template = getTemplate();
    if (template == null){
        throw new NullPointerException("message");
    }
    else return template;
}

我正在尝试将Listavailable转换Currency为 a Map，要根据货币数字代码进行查找，我想获取字符串代码。这是代码。

但是上面的代码抛出以下错误，我对 Java 8 很陌生，因此我很头疼：

Exception in thread "main" java.lang.ExceptionInInitializerError
Caused by: java.lang.IllegalStateException: Duplicate key YUM
    at java.util.stream.Collectors.lambda$throwingMerger$0(Collectors.java:133)
    at java.util.HashMap.merge(HashMap.java:1254)
    at java.util.stream.Collectors.lambda$toMap$58(Collectors.java:1320)
    at java.util.stream.ReduceOps$3ReducingSink.accept(ReduceOps.java:169)
    at java.util.HashMap$KeySpliterator.forEachRemaining(HashMap.java:1556)
    at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
    at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
    at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)
    at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
    at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)

但是上面的这段代码抛出了错误，我对 Java 8 很陌生，因此我很头疼

public class IsoCurrencyCode {

  private static final Set<Currency> ISO_CURRENCY = Currency.getAvailableCurrencies();

  private static final Map<Integer, Currency> NUMERIC_MAP = ISO_CURRENCY.stream().collect(Collectors.toMap(Currency::getNumericCode, Function.identity()));

  public static void main(String[] args) {
    //
    Currency currency = NUMERIC_MAP.get(971);
    System.out.println(currency.getCurrencyCode());
  } …

我正在使用 SimpleDateFormat 来格式化或验证日期，但我想通过使用 java 8 DateTimeFormatter 使其成为线程安全的。我无法实现某些要求。

我的应用程序将只接受三种类型的格式。"yyyy-MM-dd", "yyyy-MM", "yyyy"

Existing Code gives me desired output:
/*simple date format to process yyyy-MM-dd format
SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd")
/*simple date format to process yyyy-MM format
SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM")

/*simple date format to process yyyy format
SimpleDateFormat simpleDateFormat3 = new SimpleDateFormat("yyyy")

/* to parse input
simpleDateFormat.parse(input)
/* to format
simpleDateFormat.format(simpleDateFormat1)

这是输入和预期输出：

  input             expected
'2018-03-19'       '2018-03-19'
'2018-03'          '2018-03'
'2018'             '2018'
'2017-02-54'       '2017-02'
'2016-13-19'       '2016'

1. 如何在 java 8 DateTimeFormat enter code …

I am new in Java8, and I want to create a Predicate that checks if a value is contained inside a List of values, so I created:

public class Predicates {

    public static Predicate<String> isStringValueAllowed(List<String> allowedValues) {
        return allowedValues::contains;
    }
}

and

String valueToCheck = "test";

        Predicate<String> predicate1 = (valueToCheck) -> Predicates.isStringValueAllowed(list);

我想检查一个实例化类的所有字段是否都是 NULL EXCEPT FROM id。

例如：

class Doggy {
   String id;
   String name;
   String breed;
   String eyeColour;
   String hairColour;
   Integer age;
   Long height;
   Long weight;
   //getters & setters
}

我想知道它是否可以使用 java 8 发生。在此先感谢您。

我有一个这样的实例化对象：

Doggy doggy = new Doggy;
doggy.setId("123");

我想要一种更优雅的方式来执行以下操作：

if (doggy.getId()!=null && doggy.getName()==null && doggy.getBreed()==null && 
        doggy.getEyeColour()==null && doggy.getHairColour()==null && 
        doggy.getAge()==null && doggy.getHeight()==null && doggy.getWeight()==null) {
   doSomething();
}

需要转换List<Object>到Map<String,Long>使用与长期价值为零Collectors.toMap()。

这里的 Object 指的是我自己定义的 java 类。

List<Test> list = new ArrayList<Test>(); list.add(X); list.add(Y);
Map<String,Long> map = list.stream().collect(Collectors.toMap(Test:getName,XXXX)));

我的预期输出：

{"x",0},{"Y",0}

我想从微秒创建一个 java.util.Date 对象。但我不想失去它的精度微秒到毫秒。目前我正在通过以下方式将微秒转换为 Date 对象。如果我将微秒传递给 Date 构造函数，那么它会给出一个错误的日期，例如56521-12-01.

long microSeconds = value.getTimestampValue();// This function returns a microseconds.
DateFormat FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSSSSS);
long millis = TimeUnit.MILLISECONDS.convert(microSeconds, TimeUnit.MICROSECONDS);
String startDate = FORMAT.format(new Date(millis));

我不想将微秒转换为毫秒。是否有 API 或 java-8 实用程序的方法可以将微秒直接转换为 Date 对象？

这种方法的问题是它删除微秒的最后三位数字使其成为毫秒，然后从毫秒创建一个日期对象，解析器只需将其毫秒部分乘以将其1000转换为微秒。通过这种方式，我丢失了一个实际的微发送。

我正在尝试计算从 Item 对象列表中复制了多少项。如果项目具有相同的 id，则项目是重复的。

例如

[5, 5, 2, 4, 2]

id 5 和 2 都出现不止一次，所以答案是 2。

public class Item {

    int id;

    public Item(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }
}

public class DuplicateItems {

    public static int count(List<Item> items) {
        int count = 0;
        if (items.size() == 0) {
            return 0;
        }

        items.sort(Comparator.comparingInt(Item::getId));
        Map<Object, Long> resultMap = new HashMap<>();
        items.forEach(e -> resultMap.put(e, resultMap.getOrDefault(e, 0L) + 1L));
        System.out.println(resultMap.size());
        return count;
    }

    private static …

Java 8 添加了函数式编程结构，包括Function类及其关联identity()方法。

这是此方法的当前结构：

// Current implementation of this function in the [JDK source][1]
static <T> Function<T, T> identity() {
    return t -> t;
}

// Can be used like this
List<T> sameList = list.stream().map(Function.identity()).collect(Collectors.toList());

但是，还有第二种构造它的方法：

// Alternative implementation of the method
static <T> T identity(T in) {
    return in;
}

// Can be used like this
List<T> sameList = list.stream().map(Function::identity).collect(Collectors.toList());

甚至还有第三种方式来构建它：

// Third implementation
static final Function<T, T> IDENTITY_FUNCTION = t -> t;

// Can …