标签: java-8

我想知道有没有办法摆脱警告findFirst().get()而不使用.orElse()如果我100%知道每次都有结果,所以我永远不会到达那里NoSuchElementException.例如,让我们看看以下代码:

    List<String> myList = new ArrayList<>();
    myList.add("Test");
    myList.add("Example");
    myList.add("Sth");

    String fisrstString = myList.stream().findFirst().get(); // here I surely get "Test" 

我不知道其他IDE如何对待它,但是我的IDE(IntelliJ)将其视为警告('Optional.get()' without 'isPresent()').我想可能它不知道你何时可以到达NoSuchElementException那里,何时不到,或者我不知道为什么.我知道有办法解决这个警告(isPresent()检查.orElse(something)),但有无用的代码,所以我不想使用这些解决方案,因为它们是如此不必要.你知道我该怎么做,或解释这是怎么回事？

编辑:对不起NPE,它有NoSuchElementException我的错误,但我认为这个问题仍然存在.

我正在尝试使用以下签名实现一个方法:

public static <A,B> Pair<Stream<A>, Stream<B>> flatten(Iterator<Pair<Stream<A>, Stream<B>>> iterator);

方法的目标是将每个流类型展平为单个流并将输出包装成一对.我只有一个迭代器(不是Iterable),我不能改变方法签名,所以我必须在一次迭代中执行展平.

我目前最好的实施是

public static <A,B> Pair<Stream<A>, Stream<B>> flatten(Iterator<Pair<Stream<A>, Stream<B>> iterator) {
    Stream<A> aStream = Stream.empty();
    Stream<B> bStream = Stream.empty();
    while(iterator.hasNext()) {
        Pair<Stream<A>, Stream<B>> elm = iterator.next();
        aStream = Stream.concat(aStream, elm.first);
        bStream = Stream.concat(bStream, elm.second);
    }
    return Pair.of(aStream, bStream);
}

虽然这在技术上是正确的,但我对此并不十分满意,原因有两个:

1. Stream.concat警告不要这样做,因为它可能导致StackOverflowError.
2. 在风格上,我宁愿它是纯粹的功能,如果可能的话,而不是必须遍历迭代器并重新分配流.

感觉Stream#flatMap应该适合这里(在使用Guava的Streams.stream(Iterator)将输入Iterator转换为Stream之后,但由于中间的Pair类型,它似乎不起作用.

另外一个要求是任何迭代器/流可能非常大(例如,输入可能包含从一对极大的流到一个项目流中的许多流的任何地方),因此理想情况下,解决方案不应包含收集结果. - 记忆收藏.

我对中间阶段的顺序的状态的问题-从施加到一个阶段的操作的所有输入流(项目)或是所有级/操作施加到各流项目？

我知道这个问题可能不容易理解,所以我举一个例子.在以下流处理中:

List<String> strings = Arrays.asList("Are Java streams intermediate stages sequential?".split(" "));
strings.stream()
           .filter(word -> word.length() > 4)
           .peek(word -> System.out.println("f: " + word))
           .map(word -> word.length())
           .peek(length -> System.out.println("m: " + length))
           .forEach(length -> System.out.println("-> " + length + "\n"));

我对这段代码的期望是它会输出:

f: streams
f: intermediate
f: stages
f: sequential?

m: 7
m: 12
m: 6
m: 11

-> 7
-> 12
-> 6
-> 11

相反,输出是:

f: streams
m: 7
-> 7

f: intermediate
m: …

为什么Java 8支持静态方法？下面代码中main方法中两行的区别是什么？

package sample;
public class A {
    public static void doSomething()
    {
        System.out.println("Make A do something!");
    }
}

public interface I {
    public static void doSomething()
    {
        System.out.println("Make I do something!");
    }
}

public class B {
    public static void main(String[] args) {
        A.doSomething(); //difference between this
        I.doSomething(); //and this
    }
}

正如我们在上面看到的那样,我甚至没有在B中实现.当我们可以在另一个类中编写相同的静态方法并调用它时,在接口中使用静态方法的目的是什么？是否为模块化以外的任何其他目的而引入.通过模块化,我的意思是:

public interface Singable {
    public void sing();
    public static String getDefaultScale()
    {
        return "A minor";
    }
}

只是把类似的方法放在一起.

我正在将现有的应用程序从Joda-Time移植到Java 8 java.time.

我遇到了一个问题,解析包含"星期几"值的日期/时间字符串在我的单元测试中触发了异常.

解析时:

2016-12-21 20:50:25 12月周三+0000 3

使用格式:

yyyy'-'MM'-'dd' 'HH':'mm':'ss' 'EEEE' 'MMMM' 'ZZ' 'e

我明白了:

java.time.format.DateTimeParseException: 
Text '2016-12-21 20:50:25 Wednesday December +0000 3' 
could not be parsed: Conflict found: 
Field DayOfWeek 3 differs from DayOfWeek 2 derived from 2016-12-21

当让它DateTimeFormatter表明它所期望的时候:

String logline     = "2016-12-21 20:50:25 Wednesday December +0000";
String format      = "yyyy'-'MM'-'dd' 'HH':'mm':'ss' 'EEEE' 'MMMM' 'ZZ";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format).withLocale(Locale.ENGLISH);;
ZonedDateTime dateTime = formatter.parse(logline, ZonedDateTime::from);

format      = "yyyy'-'MM'-'dd' 'HH':'mm':'ss' 'EEEE' 'MMMM' 'ZZ' 'e";
formatter = …

在将我们的一个项目迁移到Java 9(build 9 + 181)时,我遇到了一个特殊的问题,在类型推断和java模块相关的某些库中看起来像是一个不正确的实现.我使用的是dropwizard-core(1.1.0)和guice(4.1.0)配置如下:

public class CustomService extends io.dropwizard.Application<CustomServiceConfig> {

    public static void main(String[] args) throws Exception {
        new CustomService().run(args);
    }

    // other initializations

    @Override
    public void run(CustomServiceConfig config, io.dropwizard.setup.Environment environment) throws Exception {
        com.google.inject.Injector injector = createInjector(config, environment);
        environment.jersey().register(injector.getInstance(SomeResource.class)); //line 45
        environment.healthChecks().register("DBHealth", injector.getInstance(HealthCheck.class)); 
        environment.servlets().addFilter("Filter-Name", SomeFilter.class)
                .addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, "/*");
    }


    private com.google.inject.Injector createInjector(CustomServiceConfig config, Environment environment) {
        return com.google.inject.Guice.createInjector(new CustomServiceModule(config, environment));
    }

}

public class CustomServiceModule extends com.google.inject.AbstractModule { …

我可能会使用错误的术语,随意纠正.

我有一个测试方法,它采取Runnable:

void expectRollback(Runnable r) { .. }

我可以像这样调用这个方法:

expectRollback(() -> aList.add(x))

很酷,我理解lambdas!这太棒了.让我们超级聪明......

expectRollback(() -> aList.add(x) && bList.add(y))

但是什么？那不会编译:'void' methods cannot return a value.第一次调用是否也返回一个值？第一次和第二次通话有什么区别？

考虑以下WorkExperience课程:

public class WorkExperience {
    private int year;
    private List<Skills> skill;

    public WorkExperience(int year, List<Skills> skill) {
        this.year = year;
        this.skill = skill;
    }   
    //getter setter         
}

public class Skills {
    private String skills;

    public Skills(String skills) {
        this.skills = skills;
    }

    @Override
    public String toString() {
        return "Skills [skills=" + skills + "]";
    }
}     

假设我希望按年份按照我的技能进行分组,这就是我们groupBy今年的表现:

public static void main(String[] args) {

    List<Skills> skillSet1 = new  ArrayList<>();
    skillSet1.add(new Skills("Skill-1"));
    skillSet1.add(new Skills("Skill-2"));
    skillSet1.add(new Skills("Skill-3"));

    List<Skills> skillSet2 …

注意这不是以下任何一个重复

• 计算两个Java日期实例之间的差异
• 计算java中两个日期之间的月份[复制]

我有两个约会:

• 开始日期: "2016-08-31"
• 结束日期: "2016-11-30"

它在上述两个日期之间的91天持续时间,我预计我的代码将返回3个月的持续时间,但以下方法仅返回2个月.有人有更好的建议吗？或者你们认为这是Java 8中的一个错误吗？91天的持续时间仅返回2个月.

非常感谢你的帮助.

方法1:

Period diff = Period.between(LocalDate.parse("2016-08-31"),
    LocalDate.parse("2016-11-30"));

方法2:

long daysBetween = ChronoUnit.MONTHS.between(LocalDate.parse("2016-08-31"),
    LocalDate.parse("2016-11-30"));

方法3:

我尝试使用Joda库而不是Java 8 API,它的工作原理.它将loos返回3,看起来像Java持续时间的月计算也使用了天数值.但就我而言,我不能在我的项目中使用Joda.所以还在寻找其他解决方案.

    LocalDate dateBefore= LocalDate.parse("2016-08-31");
    LocalDate dateAfter = LocalDate.parse("2016-11-30");
    int months = Months.monthsBetween(dateBefore, dateAfter).getMonths();
    System.out.println(months);

我在pom.xml中有以下依赖项:

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.16.8</version>
</dependency>

当我跑步时mvn clean install,我有以下错误:

Caused by: java.lang.ClassNotFoundException: com.sun.tools.javac.code.TypeTags
    at java.lang.ClassLoader.findClass (ClassLoader.java:711)
    at java.lang.ClassLoader.loadClass (ClassLoader.java:566)
    at lombok.launch.ShadowClassLoader.loadClass (ShadowClassLoader.java:418)

我试着用java 1.8, 1.9, 1.10.我试过了隆巴克1.6.10, 1.6.12, 1.6.20.他们都有同样的问题.