컬렉션에서 최대값을 얻는 방법(예를 들어 Array List)

컬렉션에서 최대값을 얻는 방법(예를 들어 Array List)

정수값을 저장하는 ArrayList가 있습니다.이 목록에서 최대값을 찾아야 합니다.예를 들어 arrayList에 저장되어 있는 값은 다음과 같습니다.10, 20, 30, 40, 50최대값은50.

최대값을 구하는 효율적인 방법은 무엇입니까?

@Edit : 잘 모르는 솔루션을 하나 찾았습니다.

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

Integer i = Collections.max(arrayList)

그러면 가장 높은 값이 반환됩니다.

각 값을 비교하는 또 다른 방법. selection sort or binary sort algorithm  

를 사용할 수 있습니다.Collections APICollections.max에 충분한 Javadoc를 쉽게 읽을 수 있습니다.

Collections.max(arrayList);

요소의 자연 순서에 따라 지정된 컬렉션의 최대 요소를 반환합니다.컬렉션의 모든 요소는 Comparable 인터페이스를 구현해야 합니다.

이 질문은 거의 1년이 지났습니다만, 오브젝트의 커스텀 컴퍼레이터를 작성하면, 오브젝트의 배열 리스트에 Collections.max 를 사용할 수 있습니다.

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

제가 이해하기로는 기본적으로 Collections.max()가 하는 일은 이것입니다만, 리스트는 범용이기 때문에 컴퍼레이터를 사용합니다.

간단하게 사용할 수 있습니다.Collections.max()그리고.Collections.min()방법.

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

Integer 클래스 구현 비교 가능.따라서 Integer 목록의 최대값 또는 최소값을 쉽게 얻을 수 있습니다.

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

클래스에서 Comparable을 구현하지 않고 최대값과 최소값을 찾아야 하는 경우 자체 Comparator를 작성해야 합니다.

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

Java 8에서는 lamda를 사용하여 컬렉션이 확장되었습니다.따라서 max 및 min을 찾는 방법은 다음과 같습니다.

코드:

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

출력:

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

정렬되지 않은 목록에서 최대값을 찾는 효율적인 방법은 없습니다. 모든 항목을 체크하고 가장 높은 값을 반환하기만 하면 됩니다.

다음은 스트림을 사용하여 목록의 최대값을 찾는 세 가지 방법입니다.

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

이 모든 방법들은 마치Collections.max, 컬렉션 전체에 걸쳐 반복되므로 컬렉션 크기에 비례하는 시간이 필요합니다.

자바 8

정수가 비슷하기 때문에 다음 1개의 라이너를 사용할 수 있습니다.

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

또 한 가지 주의할 점은 이 기능을 사용할 수 없다는 것입니다.Funtion.identity()대신해서i->i~하듯이mapToInt예기하다ToIntFunction이 인터페이스는 완전히 다른 인터페이스이며 이 인터페이스와는 관련이 없습니다.Function게다가 이 인터페이스에는, 1개의 메서드 밖에 없습니다.applyAsInt 된다identity()★★★★★★ 。

Java8의 경우

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

여기 기능이 있습니다.

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

또, 같은 문제에 대한 안전한 해결책을 찾고 있는 사람이 여기 왔을 경우에 대비해, 저는 이렇게 되었습니다.

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

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

최대값을 구하는 방법은 여러 가지가 있습니다.그러나 수집량이 많지 않은 한 성능에는 큰 차이가 없습니다.

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);

System.out.println(
        integers.stream().max(Integer::compare).get()
);
System.out.println(
        integers.stream().mapToInt(Integer::intValue).max().getAsInt()
);
System.out.println(
        integers.stream().max(Comparator.comparing(i -> i)).get()
);
System.out.println(
        integers.stream().reduce((a, b) -> a > b ? a : b).get()
);
System.out.println(
        integers.stream().reduce(Integer.MIN_VALUE, (a, b) -> a > b ? a : b)
);

에서는 " " 가 합니다.Comparator파라미터로 지정합니다.

에서는 reduce를 .BinaryOperator파라미터로 지정합니다.

어레이의 크기에 따라서는 멀티스레드 솔루션의 처리 속도도 향상될 수 있습니다.

언급URL : https://stackoverflow.com/questions/8304767/how-to-get-maximum-value-from-the-collection-for-example-arraylist