如何在列表列表中找到索引的最大值

Question

我有一个对象列表列表，每个内部列表有 3 个对象元素，理论上是一个字符串和两个双精度对象，比如 a 和 b，按顺序.

ArrayList<ArrayList<Object>> timings = new ArrayList<ArrayList<String>>()
        for (int runnerno = 0; runnerno < runners; runnerno++) {
            ArrayList<Object> thisrunner = new ArrayList<Object>();
            thisrunner.add(sc.next()); //string
            thisrunner.add(sc.nextDouble()); //double a 
            thisrunner.add(sc.nextDouble()); //double b
            timings.add(thisrunner);
            sc.nextLine();
        }

如何找出列表列表中的最大 a 值？ IE。我想找到一个索引最大值。

Answer 1

1) 让我们更好地封装您的数据对象，称之为 FooBar

public class FooBar {
    private String text;
    private Double x;
    private Double y;

    public FooBar() {

    }

    public FooBar(String text,Double x,Double y) {
        this.text = text;
        this.x = x;
        this.y = y;
    }

    public String getText() {
        return text;
    }
    public void setText(String text) {
        this.text = text;
    }
    public Double getX() {
        return x;
    }
    public void setX(Double x) {
        this.x = x;
    }
    public Double getY() {
        return y;
    }
    public void setY(Double y) {
        this.y = y;
    }
}

2) 填充 FooBars 列表

    List<FooBar> points = new ArrayList<FooBar>();

    for( int i = 0; i < 1000; i++ ) {
        FooBar f = new FooBar("Text" + i,
        ThreadLocalRandom.current().nextDouble(0, 100),
        ThreadLocalRandom.current().nextDouble(0, 100));
        points.add(f);
    }

3) 使用streams.max（带比较器）

    Optional<FooBar> maxFooBar = points.stream().max(new Comparator<FooBar>() {

        @Override
        public int compare(FooBar o1, FooBar o2) {
            return o1.getX().compareTo(o2.getX());
        }
    });

    System.out.println("Max Point: " + maxFooBar.get().getX());

4) 或者使用 Collections.max

    FooBar maxFooBar = Collections.max(points, new Comparator<FooBar>() {

        @Override
        public int compare(FooBar o1, FooBar o2) {
            return o1.getX().compareTo(o2.getX());
        }
    });
    System.out.println("Max Point: " + maxFooBar.getX());

5) 或者只是自己对列表进行排序并获取第一项（如果降序排序；如果升序排序，则获取最后一个）

    points.sort(new Comparator<FooBar>() {

        @Override
        public int compare(FooBar o1, FooBar o2) {
            return -1 * o1.getX().compareTo(o2.getX());
        }
    });
    System.out.println("Max Point: " + points.get(0).getX());

Answer 2

列表列表中Double类型的所有值的最大double值，像这样

public static double findMax(List<List> lists) {
    double max = Double.MIN_VALUE;
    for (List list : lists)
        for (Object o : list)
            if (o instanceof Double)
                if ((Double) o).doubleValue() > max)
                   max = ((Double) o).doubleValue();
    return max;
}

Answer 3

如果您使用 Comparator 接口按升序对每个单独的 Runner 对象进行排序，并且时序 treeSet 中的最后一个 Runner 对象将始终是最大值的索引

我们不能使用 ArrayList，因为它没有任何支持 Comparator 作为参数的构造函数

public class Runner {
     private String s;
     public double a;
     public double b;

     public Runner() {}
     public Runner(String s, double a, double b) {
         this.s = s;
         this.a = a;
         this.b = b;
     }

     @Override
     public String toString() {
         return s + " " + a + " " + b;
     }
}

调用类

 import java.util.Comparator;
 import java.util.Scanner;
 import java.util.TreeSet;

 public class Calling {

      public static void main(String[] args) {
           Scanner sc = new Scanner(System.in);
           int runners = 3;
           TreeSet<Runner> timings = new TreeSet<>(new MyComparator());

           for (int runnerno = 0; runnerno < runners; runnerno++) {
                timings.add(new Runner(sc.nextLine(), Double.parseDouble(sc.nextLine()), Double.parseDouble(sc.nextLine())));               
           }
      System.out.println(timings);
      System.out.println("max value " + timings.last());
      }

 }

class MyComparator implements Comparator<Runner> {
    @Override
    public int compare(Runner o1, Runner o2) {
        return Double.valueOf(o1.a).compareTo(Double.valueOf(o2.a));
   }
}