小编Hol*_*ger的帖子

有人可以解释复杂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 …

我正在尝试获取整数的最高有效十进制数字，我的方法如下：

1. 我正在尝试获取整数（N）中的数字总数（计数）；

2. 我将 Integer(N) 除以 1(....count 乘以 0)。

我已经完成了以下代码，它工作得很好，我只是想使用 java-8 来实现它，如果可能的话。

int N = 456778889;
double expo = Math.log10(N);
int expNum = (int)Math.floor(expo)+1;  //gets the total digits in the Integer N

现在，由于我有了数字 N 中的总位数，因此我可以将 N 除以 1 后跟零的总数，以实现此 1 后跟 X 数量的零，我的逻辑如下：

    StringBuilder sb = new StringBuilder("1");
    sb.setLength(expNum);
    String f = sb.toString().replaceAll("[^0-9]","0"); // It makes the 1 followed by X amount of zero that i require to get my MSB
    int mostSigNum = N/(Integer.valueOf(f));
    System.out.println(mostSigNum);

我知道我的方法有点不同，因为我主要使用日志和其他数学函数，但我真的想以不同的方式做。

java 8和流 …

我有一些代码删除文件第一行的 BOM 标头，如下所示：

public static String removeBOMIndicator(String line) {\n    if (line.length() > 1) {\n        byte[] bytes = line.getBytes();\n        if (bytes.length >= 3 && bytes[0] == (byte) 0xEF && bytes[1] == (byte) 0xBB && bytes[2] == (byte) 0xBF) {\n            line = line.substring(1);\n        }\n    }\n    return line;\n}\n

这个函数运行良好，我创建了一个测试用例以确保它保持这种状态。当我使用 IntelliJ 启动它或我们的 SonarQube 实例运行它时，测试顺利通过。

但是，当我使用 Git Bash ( ) 启动测试时mvn surefire:test -Dtest=RemoveBomHeadertTest，函数的输出\xe2\x95\x97\xe2\x94\x90在开头包含两个字符。

如果我更改代码以删除前 3 个字符而不是仅删除第一个字符，那么它在 Git Bash 中运行良好，但在 IntelliJ 中，我丢失了字符串的前两个字符。

知道为什么这两种情况下的行为substring可能不同吗？

我有一个函数，用于检查映射是否具有键 ( map.get(key) != null) 的某个值，然后返回该值，否则创建新值。
\n我想知道当给定键的值存在时，是否有任何 JVM 或 JIT 魔法不必执行 2 次映射查找？

Value someValue = map.get(key) != null ? map.get(key) : new Value();\n

根据我的基准测试，似乎无法进行优化，因为它明显比我们有一个局部变量来保存该值要慢：

@Benchmark\npublic String duplicateCall() {\n    return map.get(1) != null ? map.get(1) : DEFAULT;\n}\n\n@Benchmark\npublic String nonDuplicateCall() {\n    final String s = map.get(1);\n    return s != null ? s : DEFAULT;\n}\n

结果：

Benchmark                                  Mode  Cnt       Score       Error   Units\nduplicateCall     thrpt    5  634001.515 \xc2\xb1 69181.631  ops/ms\nnonDuplicateCall  thrpt    5  869980.580 \xc2\xb1 66572.021  ops/ms\n

我是一名大学讲师，我正在修改关于 Java 反射的讲座。其他几年，当我讲授抑制访问检查的可怕之处时，我向您展示了您可以设置一个 SecurityManager 并执行类似的操作

    if ("suppressAccessChecks".equals(p.getName())){
      StackTraceElement[] st = Thread.currentThread().getStackTrace();
      if(.. st ..) { throw new SecurityException(); }
    }

通过这种方式，您可以允许列入白名单的反序列化器仅调用suppressAccessChecks。然而，现在他们正在弃用 SecurityManager。我认为新的模块系统应该在这里有所帮助，但我找不到解释如何支持上面白名单反序列化器的想法的资源。

有什么提示吗？

我有两个解决方案,想要一个构成比较器库的枚举:

public enum SongComparator {

    BY_TITLE(Comparator.comparing(Song::getTitle)),
    BY_ARTIST(Comparator.comparing(Song::getArtist)),
    BY_DURATION(Comparator.comparing(Song::getDuration));

    private Comparator<Song> comp;

    private SongComparator(Comparator<Song> comp) {
        this.comp = comp;
    }

    public Comparator<Song> get() {
        return comp;
    }
}

和...

public enum SongComparator2 implements Comparator<Song> {

    BY_TITLE {
        public int compare(Song s1, Song s2) {
            return s1.getTitle().compareTo(s2.getTitle());
        };
    },
    BY_ARTIST {
        public int compare(Song s1, Song s2) {
            return s1.getArtist().compareTo(s2.getArtist());
        };
    },
    BY_DURATION {
        public int compare(Song s1, Song s2) {
            return Integer.compare(s1.getDuration(), s2.getDuration());
        };
    };

}

如果我想替换期望Comparator的枚举值,在第一个解决方案中我必须说SongComparator.BY_TITLE.get(); 而在第二个解决方案中我可以说SongComparator2.BY_TITLE.

第二个在这个意义上更好,但是,我不喜欢为每个枚举值编写public int compare …

我试图在Java 8中了解泛型和通配符.但我无法理解为什么不能模拟这个存储库方法.代码非常简单,因此应该很容易重现.

我在"thenReturn"部分的"when"中得到了这个编译错误

The method thenReturn(Stream<capture#1-of ? extends Something>) in the type
OngoingStubbing<Stream<capture#1-of ? extends Something>> is not applicable
for the arguments (Stream<capture#3-of ? extends Something>)

考试:

@Test
public void ItShourReturnStreamFromRepository() {
    List<Something> list = new ArrayList<Something>();
    list.add(new Something());
    Stream<? extends Something> stream = list.stream();
    when(someRepository.getStream()).thenReturn(stream);     
}

班级:

public class Something {}

存储库:

public interface SomeRepository{
    Stream<? extends Something> getStream();
}

有人可以帮忙吗？谢谢!

我有一个返回对象列表的函数.获取该列表后,我想将每个对象中的字段设置为相同的值.有没有办法可以将下面的三个(模拟)代码行减少到一个？

List<someObjects> aList = functionReturningList();
aList.stream().forEach(m -> m.setField(fieldValue));
anotherList.addAll(aList);

我最近熟悉了volatile关键字,我发现直接从主内存中读取不会导致不一致和所谓的可见性问题.

我相信CPU缓存并不特定于任何线程.所以我想知道这个volatile关键字是否会在单一处理器中有用？