Beste Weise, die 4 Listen zu einer

Question

kombiniert Ich muss 4 Listen der medizinischen Daten vorbearbeiten, bevor wir es in die Software importieren können. Ich habe 4 Listen gegeben, die jeweils bereits bestellt, die wie folgt aussehen:

File 1) chapter 
A00-B99; 
C00-D48; 
D50-D89; 
C00-C99; 
E00-E90; 
... 
Z00-Z99; 

File 2) subchapter 
A00-A09; 
A15-A19; 
A92-A99; 
B95-B98; 
B99-B99; 
C00-C48; 
... 
Z80-Z99; 

File 3) Groups 
A00.- 
A01.- 
A02.- 
... 
C01.- 
.... 
Z99.- 

File 4) diagnoses 

A00.0; 
A00.1; 
A00.7; 
A00.8; 
A01.7; 
A02.8; 
.. 
Z00.3; 
Z00.4; 

;

Am Ende sollte es wie die folgende Liste bestellt werden. Jede Zeile wird eine Zeile innerhalb einer CSV-Datei sein.

A00-B99; (Chapter) 
A00-A09; (Subchapter) 
A00.- (corresponding group) 
A00.0 (corresponding diagnoses) 
A00.1 
A00.7 
A00.8 
A01.- (corresponding group) 
A01.7 (corresponding diagnoses) 
A02.- (corresponding group) 
A02.8 (corresponding diagnoses) 
... 
B15-B99(Subchapter) 
... 
C00-C99 (Chapter) 
C00-D48 (Subchapter) 
C01.- (corresponding group) 
C01.2 (corresponding diagnoses) 

Ich habe es bisher versucht, indem Sie einige verknüpfte hasmaps verwenden, aber nicht das richtige Ergebnis erhalten.

while (entries_kapitel.hasNext()) { 

    Entry thisEntry_kapitel = (Entry) entries_kapitel.next(); 
    String key_kapitel = (String) thisEntry_kapitel.getKey(); 
    String text_kapitel = (String) thisEntry_kapitel.getValue(); 

    // A00-B99 -> A und B 
    String kapitel_char1 = key_kapitel.split("-")[0].substring(0, 1); 
    String kapitel_char2 = key_kapitel.split("-")[1].substring(0, 1); 

    // A00-B99 -> 99 
    int kapitel_int2 = Integer.parseInt(key_kapitel.split("-")[1].substring(1, 3)); 
    // subchapters 
    while (entries_gruppen.hasNext()) { 

      Entry thisEntry_gruppen = (Entry) entries_gruppen.next(); 
      String key_gruppen = (String) thisEntry_gruppen.getKey(); 
      String text_gruppen = (String) thisEntry_gruppen.getValue(); 

      // Gruppe splitten T90-T89 
      String gruppe_char1 = key_gruppen.split("-")[0].substring(0, 1); 
      String gruppe_char2 = key_gruppen.split("-")[1].substring(0, 1); 
      int gruppe_int2 = Integer.parseInt(key_gruppen.split("-")[1].substring(1, 3)); 


      if (gruppe_char1.equals(gruppe_char2) == false){ 
       System.err.println("Subchapters start with the same capital!"); 
       System.exit(1); 
      } 
      while (entries_gruppierung.hasNext()) { 
      Entry thisEntry_gruppierung = (Entry) entries_gruppierung.next(); 
       String key_gruppierung = (String) thisEntry_gruppierung.getKey(); 
       String text_gruppierung = (String) thisEntry_gruppierung.getValue(); 

       String gruppierung_char1 = key_gruppierung.substring(0, 1); 
       int gruppierung_int1 =  Integer.parseInt(key_gruppierung.substring(1, 3)); 
(gruppierung_char1.equals(gruppe_char1) && gruppierung_int1 <= gruppe_int2) { 
        System.out.println("Chapter: " + key_kapitel + "  subchapter: " + key_gruppen + " group" + key_gruppierung); 


       while (diagnoses.hasNext()) { 
       .... 

Das Ergebnis nicht wie es nicht aussehen sollte (es fehlen Einträge und sie sind nicht alle richtig bestellt) Was ist der beste Weg, um diese Aufgabe zu lösen? Ich konnte keinen funktionierenden Baum bekommen, was wahrscheinlich der beste Weg ist, oder?

Answer 1

Wenn ich gut verstehe, sind Sie Bedürfnisse. Ich würde einen SORT/MERGE-Join-Ansatz verwenden. Betrachten Sie 4 Listen, die die Einträge richtig sortiert enthalten. Dann können Sie die Listen zusammenführen, indem Sie sie abwechselnd scannen. Ich habe den Code nicht getestet, aber Sie werden die allgemeine Idee:

public class EntryComparator implements Comparator<Entry> 
{ 
    public boolean isSubsection(Entry e1, Entry e2) 
    { 
     // should return true if e2 subsection of e1 
    } 

    public int compare(Entry e1, Entry e2) 
    { 
     // see the Comparator interface documentation 
    } 
} 

List<Entry> chapters = new ArrayList<>(); 
List<Entry> subchapters = new ArrayList<>(); 
List<Entry> groups = new ArrayList<>(); 
List<Entry> diagnoses = new ArrayList<>(); 

List<Entry> result = new ArrayList<>(); // will hold the final result 

// populate the lists, maybe sort them using Collections.sort and the Comparator above 

int i1 = 0; 
int i2 = 0; 
int i3 = 0; 
int i4 = 0; 

EntryComparator c = new EntryComparator(); 

while(i1 < chapters.size()) 
{ 
    result.add(chapters.get(i1)); 
    while(i2 < subchapters.size() && 
      c.isSubsection(chapters.get(i1), subchapters.get(i2))) 
    { 
     result.add(subchapters.get(i2)); 
     while(i3 < groups.size() && 
       c.isSubsection(subchapters.get(i2), groups.get(i3))) 
     { 
      result.add(groups.get(i3)); 
      while(i4 < subchapters.size() && 
        c.isSubsection(groups.get(i3), diagnoses.get(i4))) 
      { 
       result.add(diagnoses.get(i4)); 
       i4++; 
      } 
      i3++; 
     } 
     i2++; 
    } 
    i1++; 
} 

EDIT: der von 911DidBush gegebene Rat ist gut, man kann das gleiche Muster mit Spezialklassen.

Answer 2

danke für Ihre Antworten. Wie empfohlen, werde ich jede Liste als Klasse implementieren. Das scheint eine wirklich gute Idee zu sein. Das Klassenkapitel wird so aussehen. Die anderen Klassen haben ebenfalls die gleiche Struktur.

public class Chapter { 

private String key_chapter; 
private String text; 

private ArrayList<Subchapter> subchapters = new ArrayList<>(); 

public Chapter(String chapter, String text) { 
    this.key_chapter = chapter; 
    this.text = text; 
    subchapters = new ArrayList<Subchapter>(); 
} 

public String getChapter() { 
    return key_chapter; 
} 

public String getText() { 
    return text; 
} 

public void addSubchapter(String subchapter, String text) { 
    subchapters.add(new Subchapter(subchapter, text)); 
} 

public Subchapter getKeyAtIndex(int index) { 
    return subchapters.get(index); 
} 

// get the entire ArrayList: 
public ArrayList getListOfSubchapters() { 
    return subchapters; 

} 
}