小编Hol*_*ger的帖子

jdk.internal.misc.SharedSecrets 将自己描述为：

“共享秘密”的存储库，这是一种在不使用反射的情况下调用另一个包中的实现私有方法的机制。包私有类实现了一个公共接口，并提供了在该包内调用包私有方法的能力；实现该接口的对象是通过限制访问的第三个包提供的。该框架避免了为此目的使用反射的主要缺点，即编译时检查的丢失。

有人可以提供一个示例来演示这种机制如何使一个包中的类能够访问不同包中的包私有方法吗？

我有一张像波纹管的地图,

 [key = "car", value = ["bmw", "toyota"]]
 [key = "bike", value = ["honda", "kawasaki"]]

我想使用java 8功能apis将其转换为另一个地图,如bellow,

 [key = "bmw", value = "car"]
 [key = "toyota", value = "car"]
 [key = "honda", value = "bike"]
 [key = "kawasaki", value = "bike"]

我在许多Java 8参考资料和示例中看到了以下代码:

List <Integer> l = Arrays.asList(7, 3, 9, 8, 6, 5, -1, -100);  

l.stream().filter(y -> y <l.get(0)).collect(Collectors.toList()).
      forEach(System.out::println);

但是,我可以使用以下方法获得相同的结果:

l.stream().filter(y -> y <l.get(0)).forEach(System.out::println);

那么,使用几乎普遍使用的collect(Collectors.toList())的神圣性是什么？

我最近开始使用collectAndThen,发现与其他编码程序相比,它需要花费相当长的时间,我用它来执行类似的任务.

这是我的代码:

        System.out.println("CollectingAndThen");
        Long t = System.currentTimeMillis();
        String personWithMaxAge = persons.stream()
                                        .collect(Collectors.collectingAndThen(
                                                                Collectors.maxBy(Comparator.comparing(Person::getAge)),
                                                                (Optional<Person> p) -> p.isPresent() ? p.get().getName() : "none"
                                                ));


        System.out.println("personWithMaxAge - "+personWithMaxAge + " time taken = "+(System.currentTimeMillis() - t));
        Long t2 = System.currentTimeMillis();
        String personWithMaxAge2 = persons.stream().sorted(Comparator.comparing(Person::getAge).reversed())
                                                    .findFirst().get().name;
        System.out.println("personWithMaxAge2 : "+personWithMaxAge2+ " time taken = "+(System.currentTimeMillis() - t2));

在这里输出:

CollectingAndThen
personWithMaxAge - Peter time taken = 17
personWithMaxAge2 : Peter time taken = 1

这表明收集和收集时间相对较长.

所以我的问题是 - 我应该继续收集和其他建议吗？

我有这段代码,从具有某些条件的DeviceEvents列表中提取

List<DeviceEvent> deviceEvents = new ArrayList<>();

        deviceEventService
            .findAll(loggedInUser())
            .filter(this::isAlarmMessage)   
            .iterator() 
            .forEachRemaining(deviceEvents::add);


private boolean isAlarmMessage (DeviceEvent deviceEvent) {

        return AlarmLevelEnum.HIGH == deviceEvent.getDeviceMessage().getLevel();
    }

但我得到了这个编译错误:

The method filter(this::isAlarmMessage) is undefined for the type 
 Iterable<DeviceEvent>

• findAll 返回一个 Iterable<DeviceEvent>

我想用优雅的java 8流或lambda解决方案替换以下for循环.有什么简洁有效的吗？

    public static void main(String[] args) {
        ArrayList<Integer> myList = new ArrayList<>( Arrays.asList( 10,-3,5));

        // add 1/2 of previous element to each element
        for(int i =1 ;i < myList.size();  ++i )
            myList.set(i, myList.get(i)+myList.get(i-1)/2);

        // myList.skip(1).forEach( e -> e + prevE/2 );  // looking for something in this spirit
    }

我有两个清单。

List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 2));
List<Integer> list2 = new ArrayList<>(Arrays.asList(2, 3, 4));

我想删除的元素包含在list2从list1，正是多次，因为它们包含在list2。在上面的示例中：当我们删除列表1中存在于列表2中的元素时，我们应该得到结果[1, 2]（由于仅包含的一个实例，因此2应该从中删除一次出现）。list1list22

我尝试过，list1.removeAll(list2);但得到的结果列表仅包含[1]。

实现此目标的最佳方法是什么？同时浏览两个列表对我来说似乎有点麻烦。

有人可以解释复杂Comparators的以下变体之间的区别吗？

List<String> listOfStrings = Arrays.asList("algo", "test", "is", "a", "common");

listOfStrings.stream()
             .sorted(Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()))
             .sorted(Comparator.naturalOrder().thenComparing(Comparator.comparingInt(String::length))
             .forEach(System.out::println);

为什么第一次调用sorted是可以的,而第二次调用甚至无法编译？

我在其他语言中发现了这个问题,但还没有在java应用程序中找到解决这个问题的方法.

我有一个.txt包含数百万条记录的大文件.每条记录都是/n分隔的.基本上它是来自表的单列数据.目标是从输入文件中读取数据并对其进行分区.然后将分区数据写入新文件.例如,一个包含200万条记录的文件将成为200个文件,每个文件有10,000条记录(最后一个文件包含<10,000个.)

我成功地读取和分区数据.我成功创建了第一个文件,并且正确命名.

问题是只创建了一个文件,它是空的.代码编译和运行没有错误或异常.

我的代码如下:

    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.StringWriter;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicInteger;
    import java.util.stream.Collectors;

    public class ChunkTextFile {

    private static final String inputFilename = "inputFile.txt";

    public static void main(String[] args) {

        BufferedReader reader = null;

        BufferedWriter fileWriter = null;

        BufferedWriter lineWriter = null;

        StringWriter stringWriter = null;

        // Create an ArrayList object to hold the lines of input file

        List<String> lines = new …

class A<T>
{
    class InnerA<U>
    {}
}

public class Main
{
    public static void main(String[] args)
    {
        A<Integer>.InnerA<String> var = new A<>().new InnerA<>();
    }
}

当上面的代码片段被编译，它会导致编译时错误说“不兼容的类型：不能推断类型参数A.InnerA<>。在我看来，编译器应该能够推断出类型为InnerA<String>。

为什么它不能这样做？如果有人可以解释它在幕后是如何工作的，那将会很有帮助。