Java 将输入存储在两个相关数组中

我正在进行一项小任务，允许用户输入任何国家的地区并将其存储在一个数组中。此外，每次他进入一个区域时，系统都会要求他输入该区域的邻居并存储这些区域

我的想法是，用户每次进入区域时，系统会将其存储在arrya中，每次他进入区域时，系统会要求他在进入第二个区域之前输入该区域的相邻区域，依此类推，并将这些输入存储在第二个数组中，在第一个数组中相关条目的指针下

我所做的只是一个开始，如下所示：

import java.util.Arrays;
import java.util.Scanner;

public class Test {
   public static void main(String[] args) {


      Scanner kb = new Scanner(System.in);


      String [] regionArray = new String[5];

      for (int i = 0; i < regionArray.length; i++) {
         System.out.print("Please enter the region: ");
         regionArray[i] = kb.next();
         //kb.nextLine(); // to get and discard the nextline token
      }

      System.out.print("You have entered: ");

      System.out.println(Arrays.toString(regionArray));
   }
}

导入java.util.array；
导入java.util.Scanner；
公开课考试{
公共静态void main（字符串[]args）{
扫描仪kb=新扫描仪（System.in）；
字符串[]regionArray=新字符串[5]；
for（int i=0；i

例如，假设我们有4个区域：a、b、c、d，a有两个邻居：b和d。在这种情况下，当用户进入第一个区域（a）时，他将被要求输入其邻居（b和d），然后他将能够进入第二个区域（b），依此类推

现在的问题是，如何生成第二个数组并使其链接到第一个数组

请帮帮我

---

谢谢你的帮助。我真的很感激

现在我已经使用了Hashmap，一切都很好，但是在检索特定区域或邻居时，我遇到了另一个问题。除此之外，我需要检索它们中的每一个，以便能够将四色定理应用到它们中的每一个，那么我如何才能做到呢

我的代码如下：

import java.util.*;
import java.util.HashMap;

public class Test5{
public static void main(String[]args){

HashMap<String, String> neighbour = new HashMap<String, String>();
Scanner kb = new Scanner(System.in);

for(;{
System.out.println ("Enter the neighbours first then the region... and when finished press q");

String n = kb.nextLine();
if (n.equalsIgnoreCase("Q"))
break;
System.out.print("region: ");
String region = kb.nextLine();
neighbour.put(region, n);
}

System.out.println(neighbour);


}
} 

import java.util.*；
导入java.util.HashMap；
公共类测试5{
公共静态void main（字符串[]args）{
HashMap邻居=新的HashMap（）；
扫描仪kb=新扫描仪（System.in）；
对于（{
System.out.println（“先输入邻居，然后输入区域…完成后按q”）；
字符串n=kb.nextLine（）；
if（n.等效信号情况（“Q”））
打破
系统输出打印（“区域：”）；
字符串区域=kb.nextLine（）；
邻域put（区域，n）；
}
System.out.println（邻居）；
}
} 

您可以创建一个类或结构，其中包含一个区域及其相邻区域的数组。因此，您可以轻松访问这两个区域

干杯，

---

Dwarak

将地图和集合（如集合）结合使用会更容易：

Map<String, Set<String>> map = new HashMap<String, Set<String>>();
map.put("some region", new HashSet<String>());
map.get("some region").add("some neighbor");
map.get("some region").add("some other neighbor)";
System.out.println("some region's neighbors:");
for(String neighbor : map.get("some region")) {
    System.out.println(neighbor);
}

Map Map=newhashmap（）；
put（“某个区域”，new HashSet（））；
map.get（“某个区域”）.add（“某个邻居”）；
map.get（“某个区域”）.add（“某个其他邻居”）；
System.out.println（“某个地区的邻居：”）；
for（字符串邻居：map.get（“某个区域”））{
System.out.println（邻居）；
}

我建议您使用诸如Map之类的集合，其中键是区域，集合包含相邻区域。我还将维护一组其相邻区域尚未输入的区域。注意：是“a”“Neights”“b”它也应该是另一种方式。

我使用了数组，但不幸的是，只缺少一个区域g是邻域数组的大小，对于每个区域都是固定的，即使在现实生活中也不合适。 举例来说，如果A区有两个邻居，其他地区没有必要有相同数目的邻居，那么在这种情况下，我该怎么办

此外，在输入第一个区域的邻居后，我在编译代码时出错

这是我的代码：

import java.io.*;
import java.util.Scanner;

public class Test4 {

    public static void main(String[] args) {
        System.out.println("Please enter the number of neighbours");
        Scanner kb = new Scanner(System.in);
        BufferedReader reader = new BufferedReader(
            new InputStreamReader(System.in));
        try {
            int size = Integer.parseInt(reader.readLine());
            //SIZE is size of the neighbours array
            String[][] regions = new String[5][size];
            for (int i = 0; i < 5; i++) {
                System.out.println("Please enter the region #"
                    + (i + 1) + ": ");
                String input = reader.readLine();
                regions[i][0] = input; //get input for region;

                for (int j = 1; j <= size; j++) {
                    System.out.println("Please enter the neighbour #"
                        + (j) + ": ");
                    String n = reader.readLine();
                    regions[i][j] = n; //get input for neighbours
                }
            }
        } catch (IOException ioe) {
            System.out.println("An error have occured");
        }
    }
}

import java.io.*；
导入java.util.Scanner；
公共类Test4{
公共静态void main（字符串[]args）{
System.out.println（“请输入邻居的数量”）；
扫描仪kb=新扫描仪（System.in）；
BufferedReader reader=新的BufferedReader(
新的InputStreamReader（System.in））；
试一试{
int size=Integer.parseInt（reader.readLine（））；
//SIZE是数组的大小
字符串[][]区域=新字符串[5][大小]；
对于（int i=0；i<5；i++）{
System.out.println（“请输入区域#”
+（i+1）+“：”；
字符串输入=reader.readLine（）；
regions[i][0]=input；//获取region的输入；
对于（int j=1；j
举例来说，如果A区有两个邻居，其他地区没有必要有相同数目的邻居，那么在这种情况下，我该怎么办

我推荐一种建议的
集合
解决方案，但目标可能是要理解。每个相邻数组的大小可以不同，但必须确定外部循环中每行的大小，如下所示

import java.util.Arrays;
import java.util.Scanner;

public class Test5 {

    private static final int REGION_COUNT = 2;

    public static void main(String[] args) {
        System.out.println("Please enter the number of neighbours; "
            + "enter 'q' to quit.");
        Scanner kb = new Scanner(System.in);
        String[][] regions = new String[REGION_COUNT][];
        for (int r = 0; r < regions.length; r++) {
            System.out.print("How many heighbors for region #"
                + (r + 1) + ": ");
            if (kb.hasNextInt()) {
                int size = kb.nextInt();
                regions[r] = new String[size];
                kb.nextLine();
                for (int n = 0; n < size; n++) {
                    System.out.print("Please enter the neighbour #"
                        + (n) + ": ");
                    regions[r][n] = kb.nextLine();
                }
            } else System.exit(0);
        }
        for (String[] neighbors : regions) {
            System.out.println(Arrays.toString(neighbors));
        }
    }
}

导入java.util.array；
导入java.util.Scanner；
公共类测试5{
私有静态最终整数区域计数=2；
公共静态void main（字符串[]args）{
System.out.println（“请输入邻居的数量
+“输入'q'退出。”）；
扫描仪kb=新扫描仪（System.in）；
字符串[][]区域=新字符串[区域计数][]；
对于（int r=0；r