Java，字符串的格式數組

Question

我有一個包含以下值的java String數組：

  arr[0] = "ClassA -> ClassSuper";
  arr[1] = "ClassSuperSuper -> ClassSuperSuperSuper";
  arr[2] = "ClassC -> Java/lang/object";
  arr[3] = "ClassSuper -> ClassSuperSuper";

如果數組類似於上面，我想將此數組格式化為一種形式，以反映上述數組的值之間的關系。 在每個班級的意義上的關系； 該類的超類應附加在右邊。

作為一個例子，我想格式化上面的數組，如下所示：

  arr[0] = "ClassA -> ClassSuper-> ClassSuperSuper -> ClassSuperSuperSuper";
  arr[1] = "ClassSuperSuper -> ClassSuperSuperSuper";
  arr[2] = "ClassC -> Java/lang/object";
  arr[3] = "ClassSuper -> ClassSuperSuper -> ClassSuperSuper";

請幫我。 我是Java的新手，花了幾個小時來解決這個問題，但仍然無法成功。 這是我到目前為止所做的。

for(int t=0; t<superOrInterfaceList.length;t++) {
   if(superOrInterfaceList[t] != null) {
      String co = superOrInterfaceList[t].substring((superOrInterfaceList[t].lastIndexOf('>')+1),superOrInterfaceList[t].length());

      for(int s=0; s<superOrInterfaceList.length;s++) {
          if(superOrInterfaceList[s] != null) {
              String cof = superOrInterfaceList[s].substring(0,(superOrInterfaceList[s].indexOf('-')));
              if(cof.equals(co)) {
                  superOrInterfaceList[t] = superOrInterfaceList[t]+"->"+cof;

              }
          }
       }

   }
}

但是執行此循環后，我在數組中得到了一些奇怪的值。 它確實只為1個級別找到一個超類，然后一次又一次地重復添加它。 運行上面的代碼后，當我打印數組時，我得到了類似波紋管的答案。

"ClassA-> ClassSuper -> ClassSuper -> ClassSuper ..."

請幫助我更正我的代碼。 或者，如果您還有其他好的方法，請告訴我。 如果您需要更多說明來回答此問題，請詢問。

Answer 1

正如scottb所說，更好的數據模型可以為您節省很多工作：

static class AClass {
    private String name;
    private AClass superClass;

    public AClass(String name) {
        this.name = name;
    }

    public void setSuperClass(AClass superClass) {
        this.superClass = superClass;
    }

    @Override
    public String toString() {
        return name + (superClass != null ? " -> " + superClass : "");
    }
}

// return an object from the map if present; otherwise create, insert and return a new one
private static AClass getOrCreate(String name, Map<String, AClass> map) {
    AClass result = map.get(name);
    if (result == null) {
        result = new AClass(name);
        map.put(name, result);
    }
    return result;
}

public static void main(String[] args) {
    String[] arr = {"A -> B", "C -> D", "D -> E", "B -> C"};
    Map<String, AClass> map = new HashMap<>();

    for (String s : arr) {
        String[] split = s.split("\\s+->\\s+"); // split into [subclass, superclass]
        AClass superClass = getOrCreate(split[1], map);
        getOrCreate(split[0], map).setSuperClass(superClass);
    }
    for (AClass c : map.values()) {
        System.out.println(c);
    }
}

有關split()使用的正則表達式的詳細信息，請參見模式 ；有關所需的任何類和方法，請參見javadoc。

本示例將打印所有提及的類，即使它們沒有超類，本例中也包括E 它還以未定義的順序打印它們。 如果需要，這些東西應該不難更改。

Answer 2

請原諒我無視OP的行為。
我解決了問題。 我在代碼中添加了盡可能多的文檔。
希望OP學到一些東西...

public static void main(String[] args)
{
    String[] arr = new String[4];
    arr[0] = "ClassA -> ClassSuper";
    arr[1] = "ClassSuperSuper -> ClassSuperSuperSuper";
    arr[2] = "ClassC -> Java/lang/object";
    arr[3] = "ClassSuper -> ClassSuperSuper";

    int linkLeafIndex, linkRootIndex;
    do {
        // find a "link": leaf (class name at the end) and root (class name at the start) that are equal
        linkLeafIndex = -1;
        linkRootIndex = -1;
        for (int i = 0 ; i < arr.length ; i++) {
            String leaf = getOneClassName(arr[i], Integer.MAX_VALUE);
            for (int j = 0 ; j < arr.length ; j++) {
                if (j != i) {
                    String root = getOneClassName(arr[j], 0);
                    if (leaf.equals(root)) {
                        linkLeafIndex = i;
                        linkRootIndex = j;
                    }
                }
            }
        }

        // if found, merge the two chains 
        if (linkLeafIndex > -1) {
            // since we link two entries, linked array will have length-1;
            String[] tempArr = new String[arr.length-1];
            // put the merged chain first
            tempArr[0] = linkChains(arr[linkLeafIndex], arr[linkRootIndex]);
            // copy all the rest
            int tempArrIndex = 1 ;
            for (int i = 0 ; i < arr.length ; i++) {
                if (i != linkLeafIndex && i != linkRootIndex) tempArr[tempArrIndex++] = arr[i]; 
            }
            // prepare for next iteration
            arr = tempArr;
        }
    // exit the loop when no more links are found
    } while (linkLeafIndex > -1);

    for (int i = 0 ; i < arr.length ; i++) {
        System.out.println(arr[i]); 
    }
}

// extract either a root or leaf class name 
private static String getOneClassName(String chain, int requiredIndex)
{
    String[] classNames = chain.split("->");
    return requiredIndex < classNames.length ? classNames[requiredIndex].trim() : classNames[classNames.length-1].trim() ;
}

// as the name suggests: create a chain out of merging two given Strings 
private static String linkChains(String startChain, String endChain)
{
    String[] startClassNames = startChain.split("->");
    String[] endClassNames = endChain.split("->");
    String[] linkedClassNames = new String[startClassNames.length + endClassNames.length - 1];

    // copy entire starting chain 
    int linkedClassNamesIndex = 0 ;
    for (int i = 0 ; i < startClassNames.length ; i++) {
        linkedClassNames[linkedClassNamesIndex++] = startClassNames[i].trim();
    }
    // copy ending chain without its root 
    for (int i = 1 ; i < endClassNames.length ; i++) {
        linkedClassNames[linkedClassNamesIndex++] = endClassNames[i].trim();
    }
    // create the required String representation  
    String linkedChain = "";
    for (int i = 0 ; i < linkedClassNames.length ; i++) {
        linkedChain += linkedClassNames[i];
        if (i < linkedClassNames.length-1) {
            linkedChain += " -> ";
        }
    }
    return linkedChain;
}