Java中的街道名称/编号排序

我需要用街道名称和号码填充数据库。 我必须为一个城市做这件事，我有一个以这种格式列出街道名称的列表：
街道名称1
街道名称2
街道名称3
街道名称4
街道名称5a
街名20
街道名称22
街道名称24
街道名称27
街道名称29b
街道名称33
等等

现在我需要以这种格式获取数据：
街道名称1-5 A
街道名称20-24 E
街名27-29 O
街名33 O
代表奇数，e代表偶数，a代表全体

正如您所看到的，它需要按升序进行格式化，但是如果街道号码出现中断，它也需要被修复。 有些数字的末尾还包含从a到c的字母

现在我只有一些基本的代码可以在.txt文件中读取 使用缓冲读取器，将文本输入保存在数组列表中，并使用一些正则表达式在控制台中给出输出

        import java.io.BufferedReader;
        import java.io.DataInputStream;
        import java.io.FileInputStream;
        import java.io.InputStreamReader;
        import java.util.ArrayList;
        import java.util.Arrays;
        import java.util.List;
        import java.util.regex.Matcher;
        import java.util.regex.Pattern;

        public class test {

        public static void main(String[] args) {
                String[] arr= null;
                String[] hn=null;

                List<String> strassen = new ArrayList<String>();
                List<String> hausnummern = new ArrayList<String>();
                String endstr1 = "a";
                String endstr2 = "b";
                String endstr3 = "c";
                String strhn[] = null;
                int hn2;
                try 
                { 
                    FileInputStream fstream_strassen = new FileInputStream("Straßen.txt"); 
                    DataInputStream data_input = new DataInputStream(fstream_strassen); 
                    BufferedReader buffer = new BufferedReader(new InputStreamReader(data_input)); 
                    FileInputStream fstream_strassen2 = new FileInputStream("Straßen.txt"); 
                    DataInputStream data_input2 = new DataInputStream(fstream_strassen2); 
                    BufferedReader buffer2 = new BufferedReader(new InputStreamReader(data_input2)); 

                    String str_line; 
                    String str_line2;

                        while (((str_line = buffer.readLine()) != null) && ((str_line2 = buffer2.readLine()) != null) ) 
                        {                       
                            str_line = str_line.trim(); 
                            str_line2 = str_line2.trim();                       

                            if ((str_line.length()!=0) && (str_line2.length()!=0))  
                            { 
                                strhn = str_line2.split("\\D+");
                                strassen.add(str_line);
                                hausnummern.add(str_line2);                         
                            } 
                        }                   

                    hausnummern.toString();
                    hn = (String[])hausnummern.toArray(new String[hausnummern.size()]);
                    arr = (String[])strassen.toArray(new String[strassen.size()]);              
                }
                catch (Exception e)  
                {
                 // Catch exception if any
                    System.err.println("Error: " + e.getMessage());
                }           

       for(String s : arr) {
                        Matcher m = Pattern.compile("^(.*?) (\\d*?[a-zA-Z]{0,}?)$").matcher(s);
                        if(m.matches()) {       
                            if(m.group(2).endsWith(endstr1)||m.group(2).endsWith(endstr2)||m.group(2).endsWith(endstr3)==true){
                                hn2 = Integer.parseInt(m.group(2).substring(0, m.group(2).length()-1));

                                    if(m.group(2).endsWith(endstr1) == true){

                                        System.out.printf("%s %s %s\n", m.group(1), hn2, endstr1);
                                        /*if(hn2 % 2 != 0){
                                            System.out.printf("%s %s %s\n", str, hn2, endstr1);
                                        }*/
                                    }
                                    if(m.group(2).endsWith(endstr2) == true){

                                        System.out.printf("%s %s %s\n", m.group(1), hn2, endstr2);
                                        /*if(hn2 % 2 != 0){
                                            System.out.printf("%s %s %s\n", str, hn2, endstr2);
                                        }*/
                                    }
                                    if(m.group(2).endsWith(endstr3) == true){

                                        System.out.printf("%s %s %s\n", m.group(1), hn2, endstr3);
                                        /*if(hn2 % 2 != 0){
                                            System.out.printf("%s %s %s\n", str, hn2, endstr3);
                                        }*/
                                    }                           
                            }
                            else{
                                 hn2 = Integer.parseInt(m.group(2));
                                 System.out.printf("%s %s\n", m.group(1), hn2);
                            }
                        }   
                  }
        }
    }

导入java.io.BufferedReader；
导入java.io.DataInputStream；
导入java.io.FileInputStream；
导入java.io.InputStreamReader；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
公开课考试{
公共静态void main（字符串[]args）{
字符串[]arr=null；
字符串[]hn=null；
List strassen=new ArrayList（）；
List hausnumern=new ArrayList（）；
字符串endstr1=“a”；
字符串endstr2=“b”；
字符串endstr3=“c”；
字符串strhn[]=null；
int-hn2；
尝试
{ 
FileInputStream fstream_strassen=新的FileInputStream（“Straßen.txt”）；
DataInputStream data\u input=新的DataInputStream（fstream\u strassen）；
BufferedReader buffer=新的BufferedReader（新的InputStreamReader（数据输入））；
FileInputStream fstream_strassen2=新的FileInputStream（“Straßen.txt”）；
DataInputStream data_input2=新的DataInputStream（fstream_Strasse2）；
BufferedReader buffer2=新的BufferedReader（新的InputStreamReader（数据_input2））；
弦线；
字符串stru_line2；
而（（（str_line=buffer.readLine（））！=null）和（（str_line 2=buffer2.readLine（））！=null））
{                       
str_line=str_line.trim（）；
str_line2=str_line2.trim（）；
如果（（str_line.length（）！=0）和&（str_line 2.length（）！=0））
{ 
strhn=str_line2.拆分（\\D+）；
strassen.add（str_线）；
hausnumern.add（str_line2）；
} 
}                   
hausnumern.toString（）；
hn=（字符串[]）hausnumern.toArray（新字符串[hausnumern.size（）]）；
arr=（字符串[]）strassen.toArray（新字符串[strassen.size（）]）；
}
捕获（例外e）
{
//捕获异常（如果有）
System.err.println（“错误：+e.getMessage（））；
}           
用于（字符串s:arr）{
Matcher m=Pattern.compile（“^（.*？”\\d*？[a-zA-Z]{0，}？$”）.Matcher（s）；
如果（m.matches（））{
if（m.group（2）.endsWith（endstr1）| | m.group（2）.endsWith（endstr2）| | m.group（2）.endsWith（endstr3）=真{
hn2=Integer.parseInt（m.group（2）.substring（0，m.group（2）.length（）-1））；
if（m.group（2）.endsWith（endstr1）==true）{
System.out.printf（“%s%s%s\n”，m.group（1），hn2，endstr1）；
/*如果（hn2%2！=0）{
System.out.printf（“%s%s%s\n”，str，hn2，endstr1）；
}*/
}
if（m.group（2）.endsWith（endstr2）==true）{
System.out.printf（“%s%s%s\n”，m.group（1），hn2，endstr2）；
/*如果（hn2%2！=0）{
System.out.printf（“%s%s%s\n”，str，hn2，endstr2）；
}*/
}
if（m.group（2）.endsWith（endstr3）==true）{
System.out.printf（“%s%s%s\n”，m.group（1），hn2，endstr3）；
/*如果（hn2%2！=0）{
System.out.printf（“%s%s%s\n”，str，hn2，endstr3）；
}*/
}                           
}
否则{
hn2=整数.parseInt（m.group（2））；
System.out.printf（“%s%s\n”，m.group（1），hn2）；
}
}   
}
}
}

我的输出如下所示：
Ihmenkampsweg 1
Ihmenkampsweg 2 a
Ihmenkampsweg 2 b
Ihmenkampsweg 4
Ihmenkampsweg 5
Ihmenkampsweg 9
Ihmenkampsweg 10 a
Ihmenkampsweg 10 b
Ihmenkampsweg 11
Ihmenkampsweg 12 a
Ihmenkampsweg 12 b
Ihmenkampsweg 14 a
Ihmenkampsweg 14 b
Ihmenkampsweg 16 a
Ihmenkampsweg 16 b
Ihmenkampsweg 18
Ihmenkampsweg 20

现在我需要帮助对整个列表进行排序。就像在考试中一样