小编Jac*_* G.的帖子

我尝试在堆栈窗格中创建一个包含 2 个窗格的应用程序。一个窗格是主窗格并居中，第二个较小并停靠在舞台的左下角。

问题是我尝试过使用“setAlignment”，但它似乎不起作用（尽管按钮已对齐）。小窗格始终居中。

有什么问题，我如何解决这个问题？我想也许我无法对齐窗格，那么我该如何克服呢？

Pane pane = new Pane();

for (SerialPoint sp : points) {
    Circle circle = new Circle(sp.getX(), sp.getY(), 6, Color.GREEN);
    pane.getChildren().add(circle);
}

Pane smallPane = new Pane();
smallPane.setScaleX(0.25);
smallPane.setScaleY(0.25);
smallPane.setStyle("-fx-border-color: black;");

for (SerialPoint sp : points) {
    Circle circle = new Circle(sp.getX(), sp.getY(), 6, Color.RED);
    smallPane.getChildren().add(circle);
}

Button startBtn = new Button("Start");

StackPane stackPane = new StackPane(pane, smallPane, startBtn);
StackPane.setAlignment(smallPane, Pos.BOTTOM_LEFT);
StackPane.setAlignment(startBtn, Pos.TOP_RIGHT);
StackPane.setMargin(startBtn, new Insets(5));

Scene scene = new Scene(stackPane);

（SerialPoint 是我的内部类）

这就是我得到的：

I am deserializing json that contains instances of many different classes, using gson. The following works as long as I know all the classes up front:

    String receivedPayloadStr = receivedMessage.get("payload");
    Type payloadType = getType(receivedMessage.get("type").toString());
    Object typedPayload = gson.fromJson(payloadJson, payloadType);
    System.out.println(typedPayload);

My getType function is as follows:

static Type getType(String typeName){
    switch (typeName){
        case "mypackage1.MyThing1":
            return new TypeToken<MyThing1>() {}.getType();
        case "mypackage2.MyThing1":
            return new TypeToken<MyThing2>() {}.getType();
        default:
            throw new RuntimeException("Unsupported type: " + typeName);
    }
}

短期有效，但既丑陋又脆弱。显然，我们想要一种更易于维护的方法。有没有办法以通用方式实现 getType ，以便支持所有已知类？

编辑：我们不仅限于 gson。如果另一个库使任务更容易，我们可以切换到它。

我正在尝试根据他们的名称获取产品评论地图，并且需要像这样的地图

Map<String, Set<String>> productReviewMap;

但是当我尝试获取地图时，我得到了

Map<String, Set<Set<String>>> productReviewMap

基于以下代码：

Map<String, Set<Set<String>>> productReviewMap = products.stream().collect(
                    Collectors.groupingBy(Product::getName, Collectors.mapping(Product::getReviews, Collectors.toSet())));

我如何获得预期的地图。我们在流中使用 flatMap 但如何在收集器中实现它？

所以，我有Stream一些对象，我需要从Stream. 例如从第 2 到第 4 个元素。

Stream<String> strs = Stream.of("qwe", "asd", "zxc", "rty", "fgh", "vbn");

并且仅从第 2 到第 4 个元素返回： asd, zxc, rty .

是否可以？

谢谢！

鉴于以下代码,我如何将其简化为单一的功能线？

    // DELETE CSV TEMP FILES
    final Map<Boolean, List<File>> deleteResults = Stream.of(tmpDir.listFiles())
            .filter(tempFile -> tempFile.getName().endsWith(".csv"))
            .collect(Collectors.partitioningBy(File::delete));

    // LOG SUCCESSES AND FAILURES
    deleteResults.entrySet().forEach(entry -> {
        if (entry.getKey() && !entry.getValue().isEmpty()) {
            LOGGER.debug("deleted temporary files, {}",
                    entry.getValue().stream().map(File::getAbsolutePath).collect(Collectors.joining(",")));
        } else if (!entry.getValue().isEmpty()) {
            LOGGER.debug("failed to delete temporary files, {}",
                    entry.getValue().stream().map(File::getAbsolutePath).collect(Collectors.joining(",")));
        }
    });

这是我遇到的一种常见模式,我有一些东西,我想过滤这个流,根据该过滤器创建两个流,然后我可以做一件事流A和另一件事流B.这是一种反模式,还是以某种方式支持？

我最近读了一本书"Java Concurrency in Practice 2nd",作者提到如果我们使用Collections.synchronizedList来创建一个安全的线程List,那么我们必须确保我们使用的是来自SynchronizedCollection的同一个锁.下面的代码来自这本书:

public class ListHelper <E> {
    public List<E> list = Collections.synchronizedList(new ArrayList<E>());

    public synchronized boolean putIfAbsent(E x) {
        boolean absent = !list.contains(x);
        if (absent)
            list.add(x);
        return absent;
    }
}

在这个类中,方法putIfAbsent已被ListHelper中的Object锁定,但是list.contains不使用此Object作为锁,有两个锁,因此在多线程下它不安全.但我的问题是如何证明它不是线程安全的.你有什么想法？

Guava的方法,Lists#partition将a分区List<?>为List<List<?>>每个分区包含N元素的位置(由函数的第二个参数指定,并排除最后一个分区).

是否可以使用此方法但是创建N分区呢？

如果没有,有什么方法可以解决它？

我试图创建31具有以下(分区keys是List<String>大小57),但它只会造成29:

List<String> keys = ...;

var paritions = Lists.partition(keys, (int) Math.ceil(keys.size() / 31D));

我有一个练习要解决.我有一个Fox类,它有名字和颜色字段.我的练习是按颜色找出狐狸的频率.

因此我创建了一个HashMap,其中String属性将是狐狸名称,而Integer将是它本身的出现:

    Map<String, Integer> freq = new HashMap<>();

完成后,我一直在尝试用流编写代码,但我正在努力做到这一点.我写了这样的东西:

    foxes.stream()
    .map(Fox::getColor)
    .forEach()
    //...(continued later on);

,其中狐狸是一个清单.

我的问题基本上是语法.如果颜色没有出现,我想做一些事情

    freq.put(Fox::getName, 1)

其他

    freq.replace(Fox::getName, freq.get(Fox::getName) + 1)

我该怎么把它放在一起？

给定一个int n，使用＃打印一个楼梯。这是从黑客的角度出发，楼梯出现的问题。例如：n = 4。

输出：

   #
  ##
 ###
####

而每行具有相同数量的列，但是随着我们不断浏览行，＃号增加而空间减小。

我已经解决了这个问题，只是想看看是否有更有效的方法

public static void staircase(int n) {
    int spaceCounter = 0;

    for(int i = 1; i <= n; i++) { // Takes care of the rows
        spaceCounter = n - i;

        // Takes care of the column by printing a space until a # sign is required then it would print so.
        for (int j = 1; j <= spaceCounter; j++) {
            System.out.print(" ");

            if (j == spaceCounter) {
                //Prints …

Java 9的出现为Java的Collections API带来了许多新功能,其中一个是集合工厂方法.

它们是什么以及如何正确实施？