在java中对相关文本文件进行排序创建公共索引

大家好 我想对2个相关文件进行排序，创建一个唯一的索引，可以对它们进行排序

我有一个.txt文件，格式如下：

File1

Houston
Chicago
Seattle
Cleveland

另一个文件的格式如下：

File2

44
33
55
22

我想要以下输出：

Seattle 55
Houston 44
Chicago 33
Cleveland 22

我已经从.txt文件创建了2个对象数组，因此由于“<或>”运算符，我无法使用bubblesort。我使用了.sort函数对分数进行排序，但这样我就不会创建一个索引来对团队进行排序。我怎样才能解决这个问题

这是我的密码

 private void visualizzaClassificaButtonActionPerformed(java.awt.event.ActionEvent evt) {                                                           
    // TODO add your handling code here:
    List<String> teams = new ArrayList<String>();
    List<Float> scores = new ArrayList<Float>();

    try {
        FileInputStream fstream = new FileInputStream("C:/Users/Fra....../file1");
        FileInputStream fstream2 = new FileInputStream("C:/Users/Fra...../file2");
        DataInputStream in = new DataInputStream(fstream);
        DataInputStream in2 = new DataInputStream(fstream2);
        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        BufferedReader br2 = new BufferedReader(new InputStreamReader(in2));
        String team = null;
        String score = null;

        while ((score = br.readLine()) != null && (team = br2.readLine()) !=null)   {
            teams.add(team);
            scores.add(Float.parseFloat(score));
        }

        Object[] squadreTutte = teams.toArray();
        Object[] punteggiTutti = scores.toArray();
        Arrays.sort(punteggiTutti, Collections.reverseOrder());
        //????????????????????????????????
        for(int index=0; index<punteggiTutti.length; index++){
            System.out.println(punteggiTutti[index]);
            System.out.println(squadreTutte[index]);
        }
        in.close();
    } catch (Exception e) {
    }

}

private void VisualizaClassificAbutonactionPerformed（java.awt.event.ActionEvent evt）{
//TODO在此处添加您的处理代码：
列表团队=新建ArrayList（）；
列表分数=新的ArrayList（）；
试一试{
FileInputStream fstream=newfileinputstream（“C:/Users/Fra……/file1”）；
FileInputStream fstream2=新的FileInputStream（“C:/Users/Fra…./file2”）；
DataInputStream in=新的DataInputStream（fstream）；
DataInputStream in2=新的DataInputStream（fstream2）；
BufferedReader br=新的BufferedReader（新的InputStreamReader（in））；
BufferedReader br2=新的BufferedReader（新的InputStreamReader（in2））；
字符串team=null；
字符串分数=空；
而（（score=br.readLine（））！=null&&（team=br2.readLine（））！=null）{
团队。添加（团队）；
scores.add（Float.parseFloat（score））；
}
Object[]squadretute=teams.toArray（）；
Object[]punteggiTutti=scores.toArray（）；
sort（punteggiTutti，Collections.reverseOrder（））；
//????????????????????????????????
对于（int index=0；index来说，对团队进行排序并在Natural worder中进行评分和读取集合的顺序是相反的要简单得多。顺便说一句，除非有很好的理由，否则不要使用float或float。改为使用Long或Double

基于@Joachim的团队课程

List<Team> teams = new ArrayList<Team>();

BufferedReader br=new BufferedReader(new FileReader("C:/Users/Fra..../file1"));
BufferedReader br2=new BufferedReader(new FileReader("C:/Users/Fra..../file2"));

String name = null;
String score = null;
while ((score = br.readLine()) != null && (name = br2.readLine()) != null) 
    teams.add(new Team(name, Double.parseDouble(score)));
br.close();
br2.close();

// reverse sort.
Collections.sort(teams, new Comparator<Team>() {
    public int compare(Team t1, Team t2) {
        return Double.compare(t2.score, t1.score);
    }
});


for(Team t: teams)
   System.out.println(t.name + ' ' + t.score);


public class Team {
  final String name;
  final double score;

  public Team(String name, double score) {
    this.name=name;
    this.score=score;
  }
}

List teams=new ArrayList（）；
BufferedReader br=新的BufferedReader（新文件读取器（“C:/Users/Fra..../file1”）；
BufferedReader br2=新的BufferedReader（新文件读取器（“C:/Users/Fra..../file2”）；
字符串名称=null；
字符串分数=空；
而（（score=br.readLine（））！=null&&（name=br2.readLine（））！=null）
添加（新团队（名称，Double.parseDouble（分数））；
br.close（）；
br2.close（）；
//反向排序。
Collections.sort（团队，新的Comparator（）{
公共整数比较（t1组、t2组）{
返回双倍比较（t2.score，t1.score）；
}
});
对于（t组：团队）
系统输出打印项次（t.name+“”+t.score）；
公开课小组{
最后的字符串名；
最终双倍得分；
公共团队（字符串名称，双倍分数）{
this.name=name；
这个。分数=分数；
}
}
在Natural worder中对团队进行排序和评分，并按照相反的顺序读取集合要简单得多。顺便说一句，除非有充分的理由，否则不要使用float或float。使用Long或Double代替

基于@Joachim的团队课程

List<Team> teams = new ArrayList<Team>();

BufferedReader br=new BufferedReader(new FileReader("C:/Users/Fra..../file1"));
BufferedReader br2=new BufferedReader(new FileReader("C:/Users/Fra..../file2"));

String name = null;
String score = null;
while ((score = br.readLine()) != null && (name = br2.readLine()) != null) 
    teams.add(new Team(name, Double.parseDouble(score)));
br.close();
br2.close();

// reverse sort.
Collections.sort(teams, new Comparator<Team>() {
    public int compare(Team t1, Team t2) {
        return Double.compare(t2.score, t1.score);
    }
});


for(Team t: teams)
   System.out.println(t.name + ' ' + t.score);


public class Team {
  final String name;
  final double score;

  public Team(String name, double score) {
    this.name=name;
    this.score=score;
  }
}

List teams=new ArrayList（）；
BufferedReader br=新的BufferedReader（新文件读取器（“C:/Users/Fra..../file1”）；
BufferedReader br2=新的BufferedReader（新文件读取器（“C:/Users/Fra..../file2”）；
字符串名称=null；
字符串分数=空；
而（（score=br.readLine（））！=null&&（name=br2.readLine（））！=null）
添加（新团队（名称，Double.parseDouble（分数））；
br.close（）；
br2.close（）；
//反向排序。
Collections.sort（团队，新的Comparator（）{
公共整数比较（t1组、t2组）{
返回双倍比较（t2.score，t1.score）；
}
});
对于（t组：团队）
系统输出打印项次（t.name+“”+t.score）；
公开课小组{
最后的字符串名；
最终双倍得分；
公共团队（字符串名称，双倍分数）{
this.name=name；
这个。分数=分数；
}
}
目标是第一个列表中的团队按照第二个列表中的分数排序

您的问题是两个列表的排序是不相关的。您应该尝试对夫妇“团队+分数”进行排序。也许使用类似于
列表的东西可以通过定义自定义比较器来做您想做的…
目标是第一个列表中的团队按照第二个列表中的分数进行排序

您的问题是，两个列表的排序是不相关的。您应该尝试对夫妇“团队+分数”进行排序。也许使用类似于
列表的东西可以通过定义自定义比较器来实现您想要的功能…
几乎总是当有人想要对并行数组进行排序时，这是一个简单的例子

您应该做的是创建一个对象来保存名称、分数对：

public class Team implements Comparable<Team> {
  private final String name;
  private final int score;

  public Team(final String name, final int score) {
    this.name=name;
    this.score=score;
  }

  // add getters

  public int compareTo(Team other) {
    if (this.score != other.score) {
      return Integer.valueOf(this.score).compareTo(other.score);
    } else {
      return this.name.compareTo(other.name);
    }
  }
}

公共类团队实现了可比较的{
私有最终字符串名；
个人最终积分；
公共团队（最终字符串名称、最终整数分数）{
this.name=name；
这个。分数=分数；
}
//添加吸气剂
公共int比较（团队其他）{
if（this.score！=其他.score）{
返回Integer.valueOf（this.score）.compareTo（other.score）；
}否则{
返回此.name.compareTo（其他.name）；
}
}
}

然后，在读取文件时，为文件中的每一行创建一个
团队
对象，将它们放入
集合
并对其进行排序。您要么需要在类中实现（如上所述），要么提供一个用于对它们进行排序的方法。
几乎总是当有人想要对并行数组进行排序时，这就是一种情况

您应该做的是创建一个对象来保存名称、分数对：

public class Team implements Comparable<Team> {
  private final String name;
  private final int score;

  public Team(final String name, final int score) {
    this.name=name;
    this.score=score;
  }

  // add getters

  public int compareTo(Team other) {
    if (this.score != other.score) {
      return Integer.valueOf(this.score).compareTo(other.score);
    } else {
      return this.name.compareTo(other.name);
    }
  }
}

公共类团队实现了可比较的{
私有最终字符串名；
个人最终积分；
公共团队（最终字符串名称、最终整数分数）{
this.name=name；
这个。分数=分数；
}
//添加吸气剂
公共int比较（团队其他）{
if（this.score！=其他.score）{
返回Integer.valueOf（this.score）.compareTo（other.score）；
}否则{
返回此.name.compareTo（其他.name）；
}
}
}

然后，在读取文件时，创建一个
团队