java - 读取 txt 文件并操作 readLine 字符串

Question

我想采用这种格式:

//Game, Team, Player, Position, Order, Sub----Not part of file

331027,24,7912,CF,1,1
331028,22,7913,P,1,1
331028,22,5909,1B,2,1
331028,22,8394,P,2,2

并根据给定顺序中子的较高数字显示此数据(顺序)，输出将变为:

331027,24,7912,CF,1 //player 7912 goes first for team 24
331028,22,7913,P,1 //player 7913 goes first for team 22
331028,22,8394,P,2 // player 8394 goes second for team 22 because he/she has higher 'Sub' order

更新:

    import java.io.BufferedReader;
    import java.io.DataInputStream;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;

    public class BattingOrder {

    String game_ID;
    String team_ID;
    String player_ID;
    String position;
    String battingOrder;
    String subOrder;

    public BattingOrder(String game, String team, String player, String place,
        String batter, String sub) {
        game_ID = game;
        team_ID = team;
        player_ID = player;
        position = place;
        battingOrder = batter;
        subOrder = sub;
    }

    @Override
    public String toString() {
    return game_ID + "," + team_ID + "," + player_ID + "," + position + ","
            + battingOrder;
    }

    public static void main(String[] args) throws IOException {
    FileInputStream fstream = new FileInputStream(
            "BatterInfo.txt");
    DataInputStream in = new DataInputStream(fstream);
    BufferedReader br = new BufferedReader(new InputStreamReader(in));

    List<BattingOrder> sortList = new ArrayList<BattingOrder>();
    for (String line; (line = br.readLine()) != null;) {
        String delims = "[,]";
        String[] parsedData = line.split(delims);
        sortList.add(new BattingOrder(parsedData[0], parsedData[1],
                parsedData[2], parsedData[3], parsedData[4], parsedData[5]));
    }
    for (BattingOrder order : sortList) {
        System.out.println(order);
    }

    br.close();

}

}

当前输出:

 331027,24,7912,CF,1
 331028,22,7913,P,1
 331028,22,5909,1B,2 //This should be replaced by bottom 'string' because the subOrder is higher.
 331028,22,8394,P,2

我想要:

331027,24,7912,CF,1
331028,22,7913,P,1
331028,22,8394,P,2

伪代码中的逻辑是什么样的？

Answer 1

来自http://www.mkyong.com/java/how-to-sort-an-arraylist-in-java/和 http://www.mkyong.com/java/java-object-sorting-example-comparable-and-comparator/以及上面来自 Java Devil 的回答

我认为最好的方法是将每个 BattingOrder 对象放入一个集合中，即 ArrayList 并使用 Collections.sort

List<BattingOrder> unsortList = new ArrayList<BattingOrder>();

向 BattingOrder 添加构造函数，或者仅手动设置 main 中的 for 循环内的值，以从文件中分割输入字符串或接受预解析的值 然后在 for 循环完成后调用 Collections.sort 并传入自定义比较器，您将大部分必需的代码注释掉应该没有问题。

for (String line; (line = br.readLine()) != null;) {
    // String delims = "[,]";
    // String[] parsedData = line.split(delims);

    //Split and assign the values to a new BattingOrder object here either in a 
    //constructor for BattingObject or here and pass in the values from the file
    unsortList.add(new BattingOrder(line));
}

循环完成后调用我们的自定义排序函数

Collections.sort(unsortList ,new Comparator<BattingOrder>(){
 @Override
 public int compare(BattingOrder one, BattingOrder two) {

      Integer orderOne = Integer.parseInt(one.battingOrder);
      Integer orderTwo = Integer.parseInt(two.battingOrder);

      //ascending order
      return orderOne.compareTo(orderTwo);

      //descending order
      //return orderTwo.compareTo(orderOne);
    }

});

并且 bam 应该被排序

我无法在没有 Java 编译器的情况下在工作中测试此代码，但如果不正确，它应该很接近

祝你好运;)

编辑 3(澄清)

我希望您可以在一夜之间添加更多详细信息，(带索引的原始输入)

 Index Pos Order Sub
 1     CF    1   1
 2     P     1   1
 3     1B    2   1
 4     P     2   2

Atm you don't have sufficient sort logic, disappearing index 3 is possible with the lower subOrder but 1 & 2 are interchangeable as they both have subOrder of 1 and order of 1 so whichever was read in first will be at the top of the list i think.

This code should sort them in some random order (Determined by the order they are read in by basically) then will delete any that have a matching battingOrder and a lower subOrder

I hope thats close to what you want anyway the sort is pretty good just not great logic the delete isn't very efficient but its all I have to go on atm

All the casts could be removed by storing the integers as ints rather than strings

    import java.io.BufferedReader;
    import java.io.DataInputStream;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.List;

public class BattingOrder
{
    String game_ID;
    String team_ID;
    String player_ID;
    String position;
    String battingOrder;
    String subOrder;

    public BattingOrder(String game, String team, String player, String place, String batter, String sub) {
        game_ID = game;
        team_ID = team;
        player_ID = player;
        position = place;
        battingOrder = batter;
        subOrder = sub;
    }

    @Override
    public String toString() 
    {
        return game_ID + "," + team_ID + "," + player_ID + "," + position + "," + battingOrder;
    }

    public static void main(String[] args) throws IOException 
    {
        FileInputStream fstream = new FileInputStream("BatterInfo.txt");
        DataInputStream in = new DataInputStream(fstream);
        BufferedReader br = new BufferedReader(new InputStreamReader(in));

        String delims = "[,]";
        List<BattingOrder> battingOrders = new ArrayList<BattingOrder>();
        for (String line; (line = br.readLine()) != null;) 
        {
            String[] parsedData = line.split(delims);
            battingOrders.add(new BattingOrder(parsedData[0], parsedData[1], parsedData[2], parsedData[3], parsedData[4], parsedData[5]));
        }
        br.close();

        System.out.println("Unordered");
        for (BattingOrder order : battingOrders) 
        {
            System.out.println(order);
        }

        Collections.sort(battingOrders ,new Comparator<BattingOrder>(){
        @Override
        public int compare(BattingOrder one, BattingOrder two) 
        {
            if(one.battingOrder.equals(two.battingOrder))
            {
                Integer subOrderOne = Integer.parseInt(one.subOrder);
                Integer subOrderTwo = Integer.parseInt(two.subOrder);

                return subOrderOne.compareTo(subOrderTwo);
            }
            Integer orderOne = Integer.parseInt(one.battingOrder);
            Integer orderTwo = Integer.parseInt(two.battingOrder);

            return orderOne.compareTo(orderTwo);
           }
       });

        System.out.println("Ordered");
        for (BattingOrder order : battingOrders) 
        {
            System.out.println(order);
        }

        List<BattingOrder> toDelete = new ArrayList<BattingOrder>();
        for (BattingOrder one : battingOrders) 
        {
            for (BattingOrder two : battingOrders) 
            {
                if(one.battingOrder.equals(two.battingOrder))
                {
                    Integer subOrderOne = Integer.parseInt(one.subOrder);
                    Integer subOrderTwo = Integer.parseInt(two.subOrder);
                    if(subOrderOne < subOrderTwo)
                    {
                        toDelete.add(one);
                    }
                    else if(subOrderOne > subOrderTwo)
                    {
                        toDelete.add(two);
                    }
                }
            }
        }
        battingOrders.removeAll(toDelete);
        System.out.println("Final");
        for (BattingOrder order : battingOrders) 
        {
            System.out.println(order);
        }
    }
}