问题[java]

当发送问题解决方案进行验证时，验证系统会通知您答案不正确。 任务正文：

给定一个无向图，可能存在环路和多条边。需要找到一个包含数字为 1 的顶点的连通分量。

输入格式

第一行包含两个整数N（1≤N≤10^3）和M（0≤M≤5×10^5）——表示图中顶点和边的数量。接下来的 M 行列出了边 - 定义连接边的顶点的数量的数字对。顶点从一开始编号。

输出格式

在第一行中，打印数字 K——连接组件中的顶点数。在第二行中，打印 K 个整数 - 连通分量的顶点，按数字升序排列。

内存限制：256 MB

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class GraphTraversal {

    public static void main(String[] args) {
        try(BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
            int[] graphMetaData = Arrays.stream(reader.readLine().split("\\s")).mapToInt(Integer::valueOf).toArray();
            int n = graphMetaData[0];
            int m = graphMetaData[1];
            int start = 1;
            if(m > 0) {
                Set<Integer> visited = new HashSet<>();
                Map<Integer, Set<Integer>> graph = new HashMap<>(n);
                for(int i = 0; i < m; i++) {
                    int[] nodeData = Arrays.stream(reader.readLine().split("\\s")).mapToInt(Integer::valueOf).toArray();
                    int node1 = nodeData[0];
                    int node2 = nodeData[1];
                    addNodesInGraph(graph, node1, node2);
                }
                travel(graph, start, visited);
                print(visited);
            } else {
                System.out.println(1);
                System.out.println(1);
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
    
    private static void addNodesInGraph(Map<Integer, Set<Integer>> graph, int node1, int node2) {
        graph.computeIfAbsent(node1, k -> new HashSet<Integer>()).add(node2);
        graph.computeIfAbsent(node2, k -> new HashSet<Integer>()).add(node1);
    }
    
//  Alternative way by recursion
    private static void travel(Map<Integer, Set<Integer>> graph, int node, Set<Integer> visited) {
        visited.add(node);
        for(int neighbour : graph.getOrDefault(node, Collections.emptySet())) {
            if(!visited.contains(neighbour)) {
                travel(graph, neighbour, visited);
            }
        }
    }
    
//  Alternative way by queue
//  private static void travel(Map<Integer, Set<Integer>> graph, int start, Set<Integer> visited) {
//      Queue<Integer> noVisited = new LinkedList<>();
//      noVisited.add(start);
//      while(noVisited.size() > 0) {
//          int node = noVisited.remove();
//          if(!visited.contains(node)) {               
//              Set<Integer> neighbours = graph.getOrDefault(node, Collections.emptySet());
//              noVisited.addAll(neighbours);
//              visited.add(node);
//          }
//      }
//  }
    
    private static void print(Set<Integer> visited) {
        List<Integer> result = new ArrayList<>(visited);
        result.sort(Comparator.naturalOrder());
        System.out.println(visited.size());
        System.out.println(result.stream().map(String::valueOf).collect(Collectors.joining(" ")));
    }
}

我有一个市场形式的项目，我用 Java 编写，使用 Hibernate 和 Spring。

我有卖家、买家、产品、订单（order）、购物车的实体。买家、卖家和订单都有形式为 的字段HashMap。它将产品（ID）存储为键，将产品数量存储为值。我怎样才能最好地将它们存储在数据库中？

Neuronka 提供了一个选项将它们存储为 JSONB 对象，即将 JSON 嵌套在另一个 JSON 中。但据我了解，Hibernate 无法自行将地图解析为 JSON。我不太想自己编写解析器，所以问题出现了：还有什么其他方法可以有效地将地图存储在数据库中？

有一个 Java 应用程序，您需要在按下某些键时处理事件。应用程序本身启动了，但没有响应按这些键。问题是为什么？我甚至添加了一个记录器来处理事件，但它根本没有帮助

public class Controller {

private static final Logger logger = Logger.getLogger(Controller.class.getName());

@FXML
void keyPressed(KeyEvent event) throws IOException {
    event.consume();

    logger.info("Клавиша нажата: " + event.getCode());
    if (event.getCode().equals(KeyCode.T)) {
        Habitat.getInstance().timeFlag = !Habitat.getInstance().timeFlag;
        Habitat.getInstance().showTimeLabel();
    } else if (event.getCode().equals(KeyCode.B)) {
        if (!Habitat.startFlag) {
            Habitat.getInstance().startAction();
        }
    } else if (event.getCode().equals(KeyCode.E)) {
        if (Habitat.startFlag) {
            Habitat.getInstance().stopAction();
        }
    }
}

如果需要的话，附上一段带有主窗口代码的fxml：

<AnchorPane focusTraversable="true" maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" onKeyReleased="#keyPressed"
        prefHeight="750.0" prefWidth="900.0" xmlns="http://javafx.com/javafx/17" xmlns:fx="http://javafx.com/fxml/1"
        fx:controller="com.example.teststststs.Controller">
<Pane fx:id="modelPane" onKeyReleased="#keyPressed" prefHeight="750.0" prefWidth="900.0"/>
<Pane onKeyReleased="#keyPressed" prefHeight="717.0" prefWidth="900.0">

请告诉我此刻的情况。我不太明白flush()使用输出流时该方法究竟如何工作。从我读到的内容来看，我明白独立缓冲区刷新和数据写入需要它。有专门BufferedOutputStream用于BufferedWriter字节和字符的缓冲流，其中有一个内部缓冲区，以免每次都访问外部源（文件、网络套接字等）。那么，在即时写入数据的常规“非缓冲”类中，这种方法有什么意义呢？

import java.io.*;

public class Program {
 
    public static void main(String[] args) {
        
        try(FileWriter writer = new FileWriter("note.txt")
        {
            String text = "Some text";
            writer.write(text);
            
            writer.flush();
        }
        catch(IOException ex){
             
            System.out.println(ex.getMessage());
        } 
    } 
}

对我来说没有什么用，我检查了所有内容，实际上是从书中复制了所有内容，我添加了值 1,9,9，因为我需要指示玩家呼叫的号码，如果我理解正确的话，我添加了 Player 和 GameLauncher 类，如书中所述，但它仍然不起作用，IDE 说我应该将 Player 和 Gamelauncher 类设为非公开，我这样做了，但消息仍然挂起，在另一个关于这个问题的旧讨论中，他们写道代码是正常的，没有过时，但我现在怀疑了。

public class GuessGame {
    player p1;
    player p2;
    player p3;

    public void startGame() {
        p1 = new player();
        p2 = new player();
        p3 = new player();
        int guessp1 = 1;
        int guessp2 = 9;
        int guessp3 = 9;
        boolean p1isRight = false;
        boolean p2isRight = false;
        boolean p3isRight = false;
        int targetNumber = (int) (Math.random() * 10);
        System.out.println("Я загадываю число от 0 до 9 ...");
        while (true) {
            System.out.println("Число, которое нужно угадать,- " + targetNumber);
            p1.guess();
            p2.guess();
            p3.guess();
            guessp1 = p1.number;
            System.out.println("Первый игрок думает, что это" + guessp1);
            guessp2 = p2.number;
            System.out.println("Второй игрок думает, что это" + guessp2);
            guessp3 = p3.number;
            System.out.println("Третий игрок думает, что это" + guessp3);
            if (guessp1 == targetNumber) {
                p1isRight = true;
            }
            if (guessp2 == targetNumber) {
                p2isRight = true;
            }
            if (guessp3 == targetNumber) {
                p3isRight = true;
            }
            if (p1isRight || p2isRight || p3isRight) {
                System.out.println("У нас есть победитель!");
                System.out.println("Первый игрок угадал? " + p1isRight);
                System.out.println("Второй игрок угадал? " + p2isRight);
                System.out.println("Третий игрок угадал? " + p3isRight);
                System.out.println("Конец игры.");
                break;
            } else {
                System.out.println("Никто не угадал. Попробуйте еще раз.");
            }
        }
    }
}

    public class Player {
        int number = 0;
        public void guess() {
            number = (int) (Math.random() * 10);
            System.out.println("Думаю это число: " + number);
        }
    }
    public class Gamelauncher {
        public static void main(String[] args) {
            GuessGame game = new GuessGame();
            game.startGame();
        }
    }