Question

我必须预先处理4个医疗数据列表，然后才能将其导入软件。我已经给出了4个列表，每个列表已经订购，如下所示：

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;

最后，请按以下清单订购。每行都是csv文件中的一行。

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)

到目前为止，我已尝试使用一些链接的包含但未获得正确的结果。

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()) {
                 ....

结果看起来不应该（缺少条目，并且它们都没有正确排序）解决此任务的最佳方法是什么？我无法找到一棵工作树，这可能是最好的方法，对吗？

Answer 1

如果我理解你的需求。我会使用SORT / MERGE连接方法。考虑包含条目的4个列表，正确排序。然后，您可以通过交替扫描列表来合并列表。我没有测试过代码，但你会得到一般的想法：

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++;
}

编辑：911DidBush给出的建议很好，你可以用专门的类来应用相同的模式。

Answer 2

感谢您的回复。按照建议，我将每个列表实现为一个类。这似乎是个好主意。类章节将如下所示。其他类也具有相同的结构。

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;

}
}

将4个列表合并为一个的最佳方法

2 个答案: