Es gibt eine ArrayList, in der ganzzahlige Werte gespeichert sind. Ich muss den Maximalwert in dieser Liste finden. Angenommen, die gespeicherten Werte in arrayList sind: 10, 20, 30, 40, 50und der Maximalwert wäre 50.

Was ist der effiziente Weg, um den Maximalwert zu finden?

@ Edit: Ich habe gerade eine Lösung gefunden, für die ich nicht sehr sicher bin

ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(100); /* add(200), add(250) add(350) add(150) add(450)*/

Integer i = Collections.max(arrayList)

und dies gibt den höchsten Wert zurück.

Eine andere Möglichkeit, jeden Wert zu vergleichen, z selection sort or binary sort algorithm  

Sie können das verwenden Collections API, um einfach das zu erreichen, was Sie wollen - effizient lesen - genug Javadoc für Collections.max

Collections.max(arrayList);

Gibt das maximale Element der angegebenen Sammlung gemäß der natürlichen Reihenfolge ihrer Elemente zurück. Alle Elemente in der Sammlung müssen die Schnittstelle Comparable implementieren.

Diese Frage ist fast ein Jahr alt, aber ich habe festgestellt, dass Sie Collections.max für eine Array-Liste von Objekten verwenden können, wenn Sie einen benutzerdefinierten Komparator für Objekte erstellen.

import java.util.Comparator;

public class compPopulation implements Comparator<Country> {
    public int compare(Country a, Country b) {
        if (a.getPopulation() > b.getPopulation())
            return -1; // highest value first
        if (a.getPopulation() == b.Population())
            return 0;
        return 1;
    }
}
ArrayList<Country> X = new ArrayList<Country>();
// create some country objects and put in the list
Country ZZ = Collections.max(X, new compPopulation());

public int getMax(ArrayList list){
    int max = Integer.MIN_VALUE;
    for(int i=0; i<list.size(); i++){
        if(list.get(i) > max){
            max = list.get(i);
        }
    }
    return max;
}

Nach meinem Verständnis ist dies im Grunde das, was Collections.max () tut, obwohl sie einen Komparator verwenden, da Listen generisch sind.

Wir können einfach Collections.max()und Collections.min()Methode verwenden.

public class MaxList {
    public static void main(String[] args) {
        List l = new ArrayList();
        l.add(1);
        l.add(2);
        l.add(3);
        l.add(4);
        l.add(5);
        System.out.println(Collections.max(l)); // 5
        System.out.println(Collections.min(l)); // 1
    }
}

Die Integer-Klasse implementiert Comparable. So können wir leicht den Max- oder Min-Wert der Integer-Liste erhalten.

public int maxOfNumList() {
    List<Integer> numList = new ArrayList<>();
    numList.add(1);
    numList.add(10);
    return Collections.max(numList);
}

Wenn eine Klasse Comparable nicht implementiert und wir den Max- und Min-Wert finden müssen, müssen wir unseren eigenen Comparator schreiben.

List<MyObject> objList = new ArrayList<MyObject>();
objList.add(object1);
objList.add(object2);
objList.add(object3);
MyObject maxObject = Collections.max(objList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        if (o1.getValue() == o2.getValue()) {
            return 0;
        } else if (o1.getValue() > o2.getValue()) {
            return -1;
        } else if (o1.getValue() < o2.getValue()) {
            return 1;
        }
        return 0;
    }
});

Comparator.comparing

In Java 8 wurden Sammlungen mithilfe von Lambda erweitert. Das Finden von Max und Min kann also wie folgt erreicht werden Comparator.comparing:

Code:

List<Integer> ints = Stream.of(12, 72, 54, 83, 51).collect(Collectors.toList());
System.out.println("the list: ");
ints.forEach((i) -> {
    System.out.print(i + " ");
});
System.out.println("");
Integer minNumber = ints.stream()
        .min(Comparator.comparing(i -> i)).get();
Integer maxNumber = ints.stream()
        .max(Comparator.comparing(i -> i)).get();

System.out.println("Min number is " + minNumber);
System.out.println("Max number is " + maxNumber);

Ausgabe:

 the list: 12 72 54 83 51  
 Min number is 12 
 Max number is 83

Es gibt keine besonders effiziente Möglichkeit, den Maximalwert in einer unsortierten Liste zu finden. Sie müssen nur alle überprüfen und den höchsten Wert zurückgeben.

Hier sind drei weitere Möglichkeiten, um mithilfe von Streams den Maximalwert in einer Liste zu ermitteln:

List<Integer> nums = Arrays.asList(-1, 2, 1, 7, 3);
Optional<Integer> max1 = nums.stream().reduce(Integer::max);
Optional<Integer> max2 = nums.stream().max(Comparator.naturalOrder());
OptionalInt max3 = nums.stream().mapToInt(p->p).max();
System.out.println("max1: " + max1.get() + ", max2: " 
   + max2.get() + ", max3: " + max3.getAsInt());

Alle diese Methoden Collections.maxdurchlaufen genau wie die gesamte Sammlung, daher benötigen sie Zeit, die proportional zur Größe der Sammlung ist.

Java 8

Da ganze Zahlen vergleichbar sind, können wir den folgenden Liner verwenden:

List<Integer> ints = Stream.of(22,44,11,66,33,55).collect(Collectors.toList());
Integer max = ints.stream().mapToInt(i->i).max().orElseThrow(NoSuchElementException::new); //66
Integer min = ints.stream().mapToInt(i->i).min().orElseThrow(NoSuchElementException::new); //11

Ein weiterer Punkt ist , wir nicht verwenden können , Funtion.identity()anstatt i->iwie mapToInterwartet , ToIntFunctiondie eine ganz andere Schnittstelle ist und nicht im Zusammenhang mit Function. Darüber hinaus hat diese Schnittstelle nur eine Methode applyAsIntund keine identity()Methode.

Hier ist die Funktion

public int getIndexOfMax(ArrayList<Integer> arr){
    int MaxVal = arr.get(0); // take first as MaxVal
    int indexOfMax = -1; //returns -1 if all elements are equal
    for (int i = 0; i < arr.size(); i++) {
        //if current is less then MaxVal
        if(arr.get(i) < MaxVal ){
            MaxVal = arr.get(i); // put it in MaxVal
            indexOfMax = i; // put index of current Max
        }
    }
    return indexOfMax;  
}

package in.co.largestinarraylist;

import java.util.ArrayList;
import java.util.Scanner;

public class LargestInArrayList {

    public static void main(String[] args) {

        int n;
        ArrayList<Integer> L = new ArrayList<Integer>();
        int max;
        Scanner in = new Scanner(System.in);
        System.out.println("Enter Size of Array List");
        n = in.nextInt();
        System.out.println("Enter elements in Array List");

        for (int i = 0; i < n; i++) {
            L.add(in.nextInt());
        }

        max = L.get(0);

        for (int i = 0; i < L.size(); i++) {
            if (L.get(i) > max) {
                max = L.get(i);
            }
        }

        System.out.println("Max Element: " + max);
        in.close();
    }
}

Zusätzlich zur Antwort von gotomanners für den Fall, dass jemand anderes hierher kam, um nach einer null-sicheren Lösung für dasselbe Problem zu suchen, kam ich zu diesem Ergebnis

Collections.max(arrayList, Comparator.nullsFirst(Comparator.naturalOrder()))

In Java8

arrayList.stream()
         .reduce(Integer::max)
         .get()

model =list.stream().max(Comparator.comparing(Model::yourSortList)).get();

Abhängig von der Größe Ihres Arrays kann eine Multithread-Lösung auch die Arbeit beschleunigen