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

Il est trivial 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?

Utilisation de Commons Lang (pour 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 cela Arrays.asList()enveloppe le tableau sous-jacent, il ne doit donc pas être trop gourmand en mémoire et il ne doit pas effectuer de copie sur les éléments du tableau.

Vous pouvez simplement utiliser les nouvelles Java 8 Streams , mais vous devez travailler avec int.

La streamméthode de la classe utilitaire Arraysvous donne un IntStreamsur lequel vous pouvez utiliser la minméthode. Vous pouvez aussi le faire max, sum, average, ...

La getAsIntméthode est utilisée pour obtenir la valeur duOptionalInt

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

}

== MISE À JOUR ==

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

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 summaryStatisticsméthode est une opération de réduction et elle permet la parallélisation.

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

Vous pouvez donc simplement utiliser:

Chars.min(myarray)

Aucune conversion n'est requise et probablement mise en œuvre efficacement.

Oui, c'est fait dans la classe Collections . Notez que vous devrez convertir manuellement votre tableau de caractères primitifs en Character [].

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

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

  }

}

J'ai une petite classe d'aide dans toutes mes applications avec des méthodes comme:

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

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

    return max;
}

Vous pouvez facilement le faire avec un IntStreamet la max()méthode.

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 ceux présents dans le intArray.

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

3. max()- Obtenez l'élément maximum de ce flux sous forme de OptionalInt.

4. getAsInt()- Déballez le fichier OptionalInt. (Vous pouvez également utiliser ici:, orElse(0)juste au cas où le OptionalIntserait vide.)

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

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

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 Optionalformat, que vous pouvez convertir inten getAsInt().

Si nous voulons comparer la valeur maximale avec 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, lorsqu'il a reduce()une identité (valeur de départ) comme premier paramètre, il renvoie des données dans le même format avec l'identité. Avec cette propriété, nous pouvons appliquer cette solution à d'autres tableaux:

double[] array = {23.1, 3, 56.6, 97, 42};
double max = Arrays.stream(array).reduce(array[0], (x, y) -> x > y ? x : y);
System.out.println(max);
>>
97.0

Voici une classe utilitaire fournissant des min/maxméthodes pour les types primitifs: Primitives.java

int [] numbers= {10,1,8,7,6,5,2};
    int a=Integer.MAX_VALUE;
    for(int c:numbers) {
        a=c<a?c:a;
        }
        
    System.out.println("Lowest value is"+a);

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

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 complètement sérieux)

Passez le tableau à une méthode qui le trie Arrays.sort()afin qu'elle ne trie que le tableau que la méthode utilise, puis définit min à array[0]et max à array[array.length-1].

La méthode 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 le min ou le max. Sinon, le tableau trié est meilleur 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);
    }
}