标签: java-8

我正在研究Java 8接口中的新虚拟扩展方法:

public interface MyInterface {
   default String myMethod() { 
      return "myImplementation"; 
   }
}

我的目的是允许接口随着时间的推移而发展,以及多重继承位,但它们看起来非常像我的抽象类.

如果你正在做新的工作,抽象类优先于扩展方法来提供"接口"的实现,还是这两种方法在概念上是等价的？

我正在为新的JDK8 java.time类寻找一个模块.我查看了FasterXML GitHub项目列表,目前没有找到.

据我所知,Jackson仍然是针对JDK6编译的,所以不能直接使用这些类,并且必须将它构建为一个单独的模块,正如Joda所要求的那样.

我不介意启动这个项目,但是看看是否还有其他工作正在进行中.

鉴于一个Map<String, Person>地方的人有一个String getName()就可以了(等)的方法,我怎么能转Map<String, Person>成Map<String, String>,其中String从调用获得Person::getName()？

我会使用Pre-Java 8

Map<String, String> byNameMap = new HashMap<>();

for (Map.Entry<String, Person> person : people.entrySet()) {
    byNameMap.put(person.getKey(), person.getValue().getName());
}

但是我想用流和lambdas来做.

我无法看到如何以功能样式执行此操作:Map/HashMap不实现Stream.

people.entrySet()返回Set<Entry<String, Person>>我可以流过的内容,但是如何Entry<String, String>向目标地图添加新内容？

如何使用Java 8的lambda表达式实现以下数组打印？

int[] values = new int[16];
// Populate values

for (int value : values) {
    System.out.println(Integer.toUnsignedString(value, 16));
}

我想将两个Java-8-Streams一起迭代,以便我在每次迭代中都有两个参数.像这样的东西,somefunction产生类似的东西Stream<Pair<A,B>>.

Stream<A> as;
Stream<B> bs;
somefunction (as, bs)
  .forEach ((a, b) -> foo (a, b));
// or something like
somefunction (as, bs)
  .forEach ((Pair<A, B> abs) -> foo (abs.left (), abs.right ()));

我想知道,如果Java提供类似的东西,虽然Pair在Java中没有:-(如果没有像这样的API函数,是否有另一种方式同时迭代两个流？

为什么这段代码有时会产生ArrayOutOfBoundsException？怎么可能String.valueOf(int)呢？

public static String ipToString(ByteString bs) {
  if (bs == null || bs.isEmpty()) {
    return null;
  } else {
    StringBuilder sb = new StringBuilder();
    boolean started = false;
    for (Byte byt : bs) {
      if (started) {
        sb.append(".");
      }
      sb.append(String.valueOf(byt & 0xFF));
      started = true;
    }

    return sb.toString();
  }
}


java.lang.ArrayIndexOutOfBoundsException: -81914
  at java.lang.Integer.getChars(Integer.java:458)
  at java.lang.Integer.toString(Integer.java:402)
  at java.lang.String.valueOf(String.java:3086)
  at com.mystuff.mypackage.ipToString(MyCode.java:1325)
  ...
  at java.util.concurrent.FutureTask.run(FutureTask.java:266)
  at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
  at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
  at java.lang.Thread.run(Thread.java:745)

更新

当发生这种情况时,我不知道字节的值,但似乎不应该有任何可能的字节值.

一旦发生一次,每次调用都会以相同的异常出错.

环境:

java version "1.8.0_20"
Java(TM) SE …

Run Code Online (Sandbox Code Playgroud)

随着Java 7的发布MethodHandle,它允许用户像使用其底层字节码一样调用方法.特别是,MethodHandles.Lookup该类提供工厂方法来创建访问类成员的方法句柄:

Lookup对象上的工厂方法对应于方法,构造函数和字段的所有主要用例.工厂方法创建的每个方法句柄都是特定字节码行为的功能等价物.

从功能上讲,这或多或少等同于使用反射来访问这些相同的类成员,但方法句柄比反射更快.

那么,有什么理由仍然使用反射功能一样Field#get(..)/ Method.invoke(..)或这些方法是引进了更快的方法手柄的有效过时了吗？

_{请注意,尽管在Java 7中引入了方法句柄,但我的问题主要与Java 8有关,在Java 8中,它们被优化为可以达到与直接字段/方法调用大致相等的性能,超过了反射的能力.}

在Java 8 中引入了lambda表达式以帮助减少样板代码.如果界面只有一个方法,它可以正常工作.如果它由多个方法组成,那么这些方法都不起作用.我该如何处理多种方法？

我们可以选择以下示例

public interface I1()
{
    void show1();
    void show2();
}

那么主要功能的结构是什么来定义main本身的方法呢？

我正在寻找一个计算两个日期之间的月份的解决方案.我认为joda或java8时间可以做到.但是当我比较它们时,我发现了一些非常奇怪的东西.

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import org.joda.time.Months;

public class DateMain {
    public static void main(String[] args) throws ParseException {

    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    Date d1 = simpleDateFormat.parse("2017-01-28 00:00:00.000");
    Date d2 = simpleDateFormat.parse("2017-02-28 00:00:00.000");

    System.out.println("Test Cast 1");
    System.out.println("joda time api result: " + monthsBetweenJoda(d1, d2) + " month");
    System.out.println("java8 time api result: " + monthsBetweenJava8(d1, d2) + " month");

    Date dd1 = simpleDateFormat.parse("2017-01-29 00:00:00.000");
    Date dd2 = simpleDateFormat.parse("2017-02-28 00:00:00.000");

    System.out.println("Test Cast …

使用Java 8,我有这样的代码:

if(element.exist()){
    // Do something
}

我想转换为lambda风格,

element.ifExist(el -> {
    // Do something
});

使用这样的ifExist方法:

public void ifExist(Consumer<Element> consumer) {
    if (exist()) {
        consumer.accept(this);
    }
}

但现在我还有其他情况要打电话:

element.ifExist(el -> {
    // Do something
}).ifNotExist(el -> {
    // Do something
});

我可以写一个类似的ifNotExist,我希望它们是互斥的(如果exist条件为真,则无需检查ifNotExist,因为有时,exists()方法需要花费很多工作量来检查),但我总是要检查两个倍.我怎么能避免这种情况？

也许"存在"这个词会让别人误解我的想法.你可以想象我还需要一些方法:

 ifVisible()
 ifEmpty()
 ifHasAttribute()

很多人说这是个坏主意,但是:

在Java 8中,我们可以使用lambda forEach而不是传统的for循环.在编程中for,if是两个基本的流程控制.如果我们可以使用lambda作为for循环,为什么使用lambda是个if坏主意？

for (Element element : list) {
    element.doSomething();
}

list.forEach(Element::doSomething);

在Java 8中,有Optional …