web-dev-qa-db-fra.com

Recherche de la valeur max/min dans un tableau de primitives à l'aide de Java

Il est facile d'écrire une fonction pour déterminer la valeur min/max dans un tableau, telle que:

/**
 * 
 * @param chars
 * @return the max value in the array of chars
 */
private static int maxValue(char[] chars) {
    int max = chars[0];
    for (int ktr = 0; ktr < chars.length; ktr++) {
        if (chars[ktr] > max) {
            max = chars[ktr];
        }
    }
    return max;
}

mais n'est-ce pas déjà fait quelque part?

javaarraysalgorithmframeworks
151
Nick Heiner

Utiliser Commons Lang (convertir) + Collections (en min/max)

import Java.util.Arrays;
import Java.util.Collections;

import org.Apache.commons.lang.ArrayUtils;

public class MinMaxValue {

    public static void main(String[] args) {
        char[] a = {'3', '5', '1', '4', '2'};

        List b = Arrays.asList(ArrayUtils.toObject(a));

        System.out.println(Collections.min(b));
        System.out.println(Collections.max(b));
   }
}

Notez que Arrays.asList() encapsule le tableau sous-jacent afin qu’il ne nécessite pas trop de mémoire et n’exécute pas de copie des éléments du tableau.

151
Michael Rutherfurd

Vous pouvez simplement utiliser le nouveau code Java 8 Streams mais vous devez utiliser int.

La méthode stream de la classe d'utilitaires Arrays vous donne un IntStream sur lequel vous pouvez utiliser la méthode min . Vous pouvez également faire max , sum , average , ...

La méthode getAsInt est utilisée pour obtenir la valeur de la OptionalInt

import Java.util.Arrays;

public class Test {
    public static void main(String[] args){
        int[] tab = {12, 1, 21, 8};
        int min = Arrays.stream(tab).min().getAsInt();
        int max = Arrays.stream(tab).max().getAsInt();
        System.out.println("Min = " + min);
        System.out.println("Max = " + max)
    }

}

== UPDATE ==

Si le temps d'exécution est important et que vous souhaitez parcourir les données une seule fois, vous pouvez utiliser la méthode summaryStatistics() comme ceci

import Java.util.Arrays;
import Java.util.IntSummaryStatistics;

public class SOTest {
    public static void main(String[] args){
        int[] tab = {12, 1, 21, 8};
        IntSummaryStatistics stat = Arrays.stream(tab).summaryStatistics();
        int min = stat.getMin();
        int max = stat.getMax();
        System.out.println("Min = " + min);
        System.out.println("Max = " + max);
    }
}

Cette approche peut donner de meilleures performances que la boucle classique car la méthode summaryStatistics est une opération de réduction et permet la parallélisation.

55
Ortomala Lokni

La bibliothèque Google Guava a des méthodes min et max dans ses classes Chars, Ints, Longs, etc.

Donc vous pouvez simplement utiliser:

Chars.min(myarray)

Aucune conversion n'est requise et sa mise en œuvre est supposée efficace.

54
Andrew McKinlay

Oui, cela se fait dans la classe Collections . Notez que vous devrez convertir manuellement votre tableau de caractères primitif en un caractère [].

Une courte démo:

import Java.util.*;

public class Main {

    public static Character[] convert(char[] chars) {
        Character[] copy = new Character[chars.length];
        for(int i = 0; i < copy.length; i++) {
            copy[i] = Character.valueOf(chars[i]);
        }
        return copy;
    }

    public static void main(String[] args) {
        char[] a = {'3', '5', '1', '4', '2'};
        Character[] b = convert(a);
        System.out.println(Collections.max(Arrays.asList(b)));
    }
}
20
Bart Kiers
import Java.util.Arrays;

public class apples {

  public static void main(String[] args) {
    int a[] = {2,5,3,7,8};
    Arrays.sort(a);

     int min =a[0];
    System.out.println(min);
    int max= a[a.length-1];
    System.out.println(max);

  }

}
16
Lubna_Nsour

J'ai une petite classe d'assistance dans toutes mes applications avec des méthodes telles que:

public static double arrayMax(double[] arr) {
    double max = Double.NEGATIVE_INFINITY;

    for(double cur: arr)
        max = Math.max(max, cur);

    return max;
}
9
Sauer

Vous pouvez facilement le faire avec une méthode IntStream et la méthode max().

Exemple

public static int maxValue(final int[] intArray) {
  return IntStream.range(0, intArray.length).map(i -> intArray[i]).max().getAsInt();
}

Explication

  1. range(0, intArray.length) - Pour obtenir un flux avec autant d'éléments que présents dans la variable intArray.

  2. map(i -> intArray[i]) - Mappe chaque élément du flux sur un élément réel de intArray.

  3. max() - Récupère l'élément maximum de ce flux sous la forme OptionalInt.

  4. getAsInt() - Déballez la OptionalInt. (Vous pouvez aussi utiliser ici: orElse(0), juste au cas où la OptionalInt serait vide.)

3
winklerrr
import Java.util.Random;

public class Main {

public static void main(String[] args) {
   int a[] = new int [100];
   Random rnd = new Random ();

    for (int i = 0; i< a.length; i++) {
        a[i] = rnd.nextInt(99-0)+0;
        System.out.println(a[i]);
    }

    int max = 0;          

    for (int i = 0; i < a.length; i++) {
        a[i] = max;


        for (int j = i+1; j<a.length; j++) {
            if (a[j] > max) {
               max = a[j];
            }

        }
    }

    System.out.println("Max element: " + max);
}
}
2
mark2

Exemple avec float:

public static float getMaxFloat(float[] data) {

    float[] copy = Arrays.copyOf(data, data.length);
    Arrays.sort(copy);
    return copy[data.length - 1];
}

public static float getMinFloat(float[] data) {

    float[] copy = Arrays.copyOf(data, data.length);
    Arrays.sort(copy);
    return copy[0];
}
1
Andrey

Transmettez le tableau à une méthode qui le trie avec Arrays.sort() afin qu'il ne trie que le tableau utilisé par la méthode, puis définitmin sur array[0] et max sur array[array.length-1].

1
whoduexpect

Voici une classe d’utilitaires fournissant les méthodes min/max pour les types primitifs: Primitives.Java

1
Christoph
    public int getMin(int[] values){
        int ret = values[0];
        for(int i = 1; i < values.length; i++)
            ret = Math.min(ret,values[i]);
        return ret;
    }
0
Nicholas Hamilton

Une solution avec reduce():

int[] array = {23, 3, 56, 97, 42};
// directly print out
Arrays.stream(array).reduce((x, y) -> x > y ? x : y).ifPresent(System.out::println);

// get the result as an int
int res = Arrays.stream(array).reduce((x, y) -> x > y ? x : y).getAsInt();
System.out.println(res);
>>
97
97

Dans le code ci-dessus, reduce() renvoie les données au format Optional, que vous pouvez convertir en int par getAsInt(). 

Si nous voulons comparer la valeur maximale à un certain nombre, nous pouvons définir une valeur de départ dans reduce():

int[] array = {23, 3, 56, 97, 42};
// e.g., compare with 100
int max = Arrays.stream(array).reduce(100, (x, y) -> x > y ? x : y);
System.out.println(max);
>>
100

Dans le code ci-dessus, lorsque reduce() avec une identité (valeur de départ) en tant que premier paramètre, il renvoie des données au même format que l'identité. 

0
Simon Zhang

Voici une solution pour obtenir la valeur maximale dans environ 99% des exécutions (modifiez la valeur 0.01 pour obtenir un meilleur résultat):

public static double getMax(double[] vals){
    final double[] max = {Double.NEGATIVE_INFINITY};

    IntStream.of(new Random().ints((int) Math.ceil(Math.log(0.01) / Math.log(1.0 - (1.0/vals.length))),0,vals.length).toArray())
            .forEach(r -> max[0] = (max[0] < vals[r])? vals[r]: max[0]);

    return max[0];
}

(Pas tout à fait sérieux)

0
mnzl

Le moyen de base pour obtenir la valeur min/max d'un tableau. Si vous avez besoin du tableau non trié, vous pouvez créer une copie ou la transmettre à une méthode qui renvoie les valeurs min ou max. Sinon, un tableau trié est préférable car il fonctionne plus rapidement dans certains cas.

public class MinMaxValueOfArray {
    public static void main(String[] args) {
        int[] A = {2, 4, 3, 5, 5};
        Arrays.sort(A);
        int min = A[0];
        int max = A[A.length -1];
        System.out.println("Min Value = " + min);        
        System.out.println("Max Value = " + max);
    }
}
0
Kim G.