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

Vous pouvez simplement utiliser le nouveau Java 8 Streams mais vous avez à travailler avec int.

La stream méthode de la classe utilitaire Tableaux vous donne un IntStream sur lequel vous pouvez utiliser la min méthode. Vous pouvez également faire max, somme, moyenne,...

La getAsInt méthode 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)
    }

}

==Mise à JOUR==

Si le temps d'exécution est important et vous voulez aller à travers les données qu'une seule fois, vous pouvez utiliser le summaryStatistics() méthode 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 les classiques de la boucle parce que le summaryStatistics méthode est un réduction de fonctionnement et il permet la parallélisation.

Oui, c'est fait dans le Collections classe. Notez que vous aurez besoin de convertir votre primitif char tableau d'un Caractère[] manuellement.

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

J'ai un peu de 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;
}

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

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 des données dans Optional format, qui vous permet de convertir int par getAsInt().

Si l'on veut comparer la valeur de max avec un certain nombre, on peut 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) comme premier paramètre, il renvoie les 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

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

Passer de la matrice à une méthode qui trie avec Arrays.sort() donc il ne trie le tableau de la méthode est d'utiliser définit ensuite min à array[0] et max à array[array.length-1].