Recherche de la valeur max / min dans un tableau de primitives utilisant Java

Il est sortingvial d’écrire une fonction pour déterminer la valeur min / max dans un tableau, par exemple:

/** * * @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  max) { max = chars[ktr]; } } return max; } 

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

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

 import java.util.Arrays; import java.util.Collections; import org.apache.commons.lang.ArrayUtils; public class MinMaxValue { public static void main(Ssortingng[] 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() le tableau sous-jacent, il ne doit donc pas être trop gourmand en mémoire et ne doit pas effectuer de copie sur les éléments du tableau.

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 requirejse et probablement mise en œuvre efficacement.

Vous pouvez simplement utiliser les nouveaux Stream Java 8 mais vous devez travailler avec int .

La méthode stream de la classe utilitaire Arrays vous fournit un IntStream sur lequel vous pouvez utiliser la méthode min . Vous pouvez aussi faire max , sum , average , …

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

 import java.util.Arrays; public class Test { public static void main(Ssortingng[] 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 voulez parcourir les données uniquement une fois que vous pouvez utiliser la méthode summaryStatistics() comme ceci

 import java.util.Arrays; import java.util.IntSummaryStatistics; public class SOTest { public static void main(Ssortingng[] 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.

Oui, cela se fait dans la classe Collections . Notez que vous devrez convertir votre tableau de caractères primitif en 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))); } } 
 import java.util.Arrays; public class apples { public static void main(Ssortingng[] 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’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; } 

Vous pouvez facilement le faire avec une 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 stream avec autant d’éléments que ceux présents dans intArray .

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

  3. max() – Récupère l’élément maximum de ce stream en tant que OptionalInt .

  4. getAsInt() – Déroulez le OptionalInt . (Vous pouvez également utiliser ici: orElse(0) , juste au cas où le orElse(0) OptionalInt est vide.)

 import java.util.Random; public class Main { public static void main(Ssortingng[] 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 max) { max = a[j]; } } } System.out.println("Max element: " + max); } } 

Transmettez le tableau à une méthode qui le sortinge avec Arrays.sort() sorte qu’il sortinge uniquement le tableau utilisé par la méthode, puis définit min à array[0] et max à array[array.length-1] .

Voici une classe d’utilitaire fournissant des méthodes min/max pour les types primitifs: Primitives.java

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

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

 public class MinMaxValueOfArray { public static void main(Ssortingng[] 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); } } 
  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; } 

solution générique *:

 public static  T getMax(T[] data) { T[] copy = Arrays.copyOf(data, data.length); Arrays.sort(copy); return copy[data.length - 1]; } public static  T getMin(T[] data) { T[] copy = Arrays.copyOf(data, data.length); Arrays.sort(copy); return copy[0]; } 

** être au courant de possibles arguments passés 🙂 (npx)

* ** pour les primitives, remplacez T par le type désiré ou utilisez Arrays.asList ()

Exemple:

 public static long getMinMax(long[] data, boolean max) { // do checj if length > 0 or not null throw ex illegal state exception long[] copy = Arrays.copyOf(data, data.length); Arrays.sort(copy); return max ? copy[data.length - 1] : copy[0]; }