Question

我有一个对象列表的列表，每个单个内列表都有3个Object元素，理论上是一个String和两个双精度，例如 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 值？即。我想找到一个索引最大值。

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）填充FooBar的列表

    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（与Comparator一起使用）

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

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

3 个答案: