Ermitteln des Max / Min-Werts in einem Array von Grundelementen mithilfe von Java

Es ist trivial, eine Funktion zu schreiben, um den Min / Max-Wert in einem Array zu bestimmen, wie zum Beispiel:

/**
 * 
 * @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;
}

aber ist das nicht schon irgendwo gemacht?

Verwenden von Commons Lang (zum Konvertieren) + Sammlungen (zu 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));
   }
}

Beachten Sie, dass Arrays.asList()das zugrunde liegende Array umbrochen wird, damit es nicht zu speicherintensiv ist und keine Kopie der Elemente des Arrays erstellt wird.

Sie können einfach die neue Java 8 verwenden Streams , aber Sie müssen die Arbeit mit int.

Die streamMethode der Utility-Klasse Arraysgibt Ihnen eine, IntStreamfür die Sie die minMethode verwenden können. Sie können auch tun max, sum, average, ...

Die getAsIntMethode wird verwendet, um den Wert von der zu erhaltenOptionalInt

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

Wenn die Ausführungszeit wichtig ist und Sie die Daten nur einmal durchgehen möchten, können Sie die summaryStatistics()Methode wie folgt verwenden

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

Dieser Ansatz kann eine bessere Leistung als die klassische Schleife liefern, da die summaryStatisticsMethode eine Reduktionsoperation ist und eine Parallelisierung ermöglicht.

Die Google Guava-Bibliothek verfügt über Min- und Max-Methoden in den Klassen Chars, Ints, Longs usw.

Sie können also einfach Folgendes verwenden:

Chars.min(myarray)

Es sind keine Konvertierungen erforderlich und vermutlich wird es effizient implementiert.

Ja, es wird in den Sammlungen gemacht Klasse durchgeführt. Beachten Sie, dass Sie Ihr primitives Zeichenarray manuell in ein Zeichen [] konvertieren müssen.

Eine kurze Demo:

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

  }

}

Ich habe in all meinen Anwendungen eine kleine Hilfsklasse mit Methoden wie:

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

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

    return max;
}

Sie könnten es leicht mit einem IntStreamund der max()Methode tun .

Beispiel

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

Erläuterung

1. range(0, intArray.length)- Um einen Stream mit so vielen Elementen wie möglich in der zu erhalten intArray.

2. map(i -> intArray[i])- Ordnen Sie jedes Element des Streams einem tatsächlichen Element des Streams zu intArray.

3. max()- Holen Sie sich das maximale Element dieses Streams als OptionalInt.

4. getAsInt()- Packen Sie die aus OptionalInt. (Sie können auch hier verwenden : orElse(0), nur für den Fall, dass das OptionalIntleer ist.)

Hier ist eine Dienstprogrammklasse, die min/maxMethoden für primitive Typen bereitstellt : Primitives.java

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

Eine Lösung mit 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

In dem obigen Code, reduce()liefert Daten in OptionalFormat, das Sie konvertieren können intdurchgetAsInt() .

Wenn wir den Maximalwert mit einer bestimmten Zahl vergleichen möchten, können wir einen Startwert festlegen in 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

Wenn im obigen Code reduce()eine Identität (Startwert) als erster Parameter verwendet wird, werden Daten im gleichen Format wie die Identität zurückgegeben. Mit dieser Eigenschaft können wir diese Lösung auf andere Arrays anwenden:

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

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

Hier ist eine Lösung, um den Maximalwert in etwa 99% der Läufe zu erhalten (ändern Sie die 0,01, um ein besseres Ergebnis zu erzielen):

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

(Nicht ganz ernst)

Übergeben Sie das Array an eine Methode, mit der Arrays.sort()es sortiert wird, sodass nur das von der Methode verwendete Array sortiert wird, und setzen Sie dann min auf array[0]und max auf array[array.length-1].

Der grundlegende Weg, um den Min / Max-Wert eines Arrays zu erhalten. Wenn Sie das unsortierte Array benötigen, können Sie eine Kopie erstellen oder an eine Methode übergeben, die min oder max zurückgibt. Wenn nicht, ist das sortierte Array besser, da es in einigen Fällen schneller arbeitet.

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