Es trivial para escribir una función para determinar el min/max valor en una matriz, tales como:

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

pero no es este hecho ya en alguna parte?

InformationsquelleAutor Nick Heiner | 2009-09-27

15 Comentarios

  1. 159

    Utilizando Commons Lang (convertir) + Colecciones (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));
       }
    }

    Nota que Arrays.asList() envuelve el subyacente de la matriz, por lo que no debería ser demasiado intensivo de memoria y no se debe de realizar una copia de los elementos de la matriz.

    • ¿qué es ArrayUtils
    • Arrays.asList() debe estar bien, pero ArrayUtils.toObject() copia de cada elemento de a a una nueva matriz de Character.
    • Arrays.asList(a) no funciona. Usted no puede hacer una lista de primitivas (List<char> en este caso). En primer lugar usted necesita para convertir los valores primitivos a los objetos y por eso ArrayUtils.toObject se utiliza.
  2. 65

    Usted puede simplemente utilizar el nuevo Java 8 Streams pero usted tiene que trabajar con int.

    La stream método de la utilidad de la clase Matrices le da una IntStream en el que puede utilizar el min método. Usted también puede hacer max, suma, media,…

    La getAsInt método se utiliza para obtener el valor 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 el tiempo de ejecución es importante y quieres ir a través de los datos sólo una vez, puede utilizar el summaryStatistics() método como este

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

    Este enfoque puede dar mejor rendimiento que el clásico bucle porque el summaryStatistics es un método de operación de reducción de y permite la paralelización.

  3. 56

    La Google Guayaba biblioteca ha min y max métodos en sus Caracteres, Enteros, enteros Largos, etc. clases.

    Así que usted puede simplemente utilizar:

    Chars.min(myarray)

    No hay conversiones son necesarios y, presumiblemente, se aplican de manera eficiente.

  4. 20

    Sí, se hace en el Colecciones clase. Tenga en cuenta que usted necesita para convertir su primitivo char array de Caracteres[] manualmente.

    Una breve demostración:

    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)));
        }
    }
    • Las colecciones.min(myCollection); Si usted quiere usar para matrices, usted puede hacerlo como Colecciones.min(Matrices.asList(myArray));
    • la conversión de un char [] a un Character [] sólo para determinar el máximo es bastante ineficiente – mejor crear una clase de utilidad con métodos estáticos para cada tipo primitivo similar a java.util.Arrays: java.sun.com/javase/6/docs/api/java/util/Arrays.html
    • sí, si el tamaño de la matriz es grande, yo estaría de acuerdo. Simplemente indica que es «ineficiente» no tiene sentido si la aplicación en cuestión hace que muchas de las llamadas de base de datos y/o operaciones de e/S y el tamaño de la matriz es (relativo) de los pequeños.
    • usted debe utilizar Character.valueOf(chars[i]) en lugar de new Character(chars[i]) por razones de rendimiento: java.sun.com/javase/6/docs/api/java/lang/…
    • editado.
    • Christoph es derecho, es ineficiente y estúpido para transformar una matriz a una Colección, para min max de búsqueda.

  5. 15
    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);
    
      }
    
    }
    • Sírvanse proporcionar alguna explicación.
    • Creo que lo que esto quiere decir es que si usted ordenar la matriz (en orden ascendente), por definición, el valor mínimo será siempre en la primera posición, a[0], y el valor máximo será siempre en la última posición, [una.length-1].
    • Esta es una actividad legítima y útil manera de resolver el problema. ¿Cuál es la desventaja de utilizar en comparación con los demás?
    • el tiempo en la complejidad de la clasificación es, en el mejor de O(nlogn) asunto, mientras que Michael Rutherfurd enfoque es O(n).
    • No necesitamos ordenar como una sola iteración a través de la lista es suficiente para encontrar min y max.
    • Creo que el uso de ordenación es una exageración

  6. 10

    Tengo un pequeño ayudante de la clase en todas mis aplicaciones con métodos como:

    public static double arrayMax(double[] arr) {
        double max = Double.NEGATIVE_INFINITY;
    
        for(double cur: arr)
            max = Math.max(max, cur);
    
        return max;
    }
    • Usted debe utilizar doble max = Doble.NEGATIVE_INFINITY; en lugar de doble max = Doble.MIN_VALUE; Como MIN_VALUE para doble es positiva
    • … o puede establecer max para el primer elemento de la matriz, y recorrer desde el 2º punto, véase mi respuesta.
  7. 3

    Que se puede hacer fácilmente con un IntStream y la max() método.

    Ejemplo

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

    Explicación

    1. range(0, intArray.length) – Para obtener una corriente con todos los elementos presentes en la intArray.

    2. map(i -> intArray[i]) – Mapa de cada elemento de la secuencia de un elemento real de la intArray.

    3. max() – Obtener el máximo elemento de esta corriente como OptionalInt.

    4. getAsInt() – Desenvuelva el OptionalInt. (También se puede utilizar aquí: orElse(0), sólo en caso de que el OptionalInt está vacía.)

  8. 2
    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);
    }
    }
  9. 2
        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;
        }
    • Esto es para los números int pero la pregunta está pidiendo a los valores primitivos int, long, char, byte....
  10. 1

    Ejemplo con 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];
    }
    • Mientras que la solución va a trabajar, sino que también aumentará el tiempo de complejidad O(nlogn), mientras que min se puede encontrar fácilmente en O(n) mediante el uso de otras respuestas.
    • simplemente una locura el uso de una especie en esta situación.
    • Esto puede ser útil cuando el primer n>1 menor/mayor valor es necesario, con algunas reparaciones.
  11. 1

    Una solución con 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

    En el código anterior, reduce() devuelve los datos en Optional formato, que puede convertir a int por getAsInt().

    Si queremos comparar el valor máximo con un número determinado, se puede establecer un valor de inicio en 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

    En el código anterior, cuando reduce() con una identidad (valor inicial) como el primer parámetro, devuelve los datos en el mismo formato, con la identidad. Con esta propiedad, podemos aplicar esta solución a otras matrices:

    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
    • Excelente! legible y simple solución!
  12. 0

    Pasar la matriz a un método que ordena con Arrays.sort() de modo que sólo se ordena la matriz el método que se está utilizando, a continuación, establece min a array[0] y max a array[array.length-1].

    • Es probablemente vale la pena señalar que a) modifica la matriz, y b) para las grandes matrices es una solución más costosa O(nlog n) en lugar de O(n)
  13. 0

    La forma básica de obtener la min/max valor de una Matriz. Si usted necesita sin clasificar de la matriz, puede crear una copia o pasar a un método que devuelve el min o max. Si no, matriz ordenada es mejor, ya que se realiza más rápido en algunos casos.

    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);
        }
    }
    • El problema con la clasificación de los es que tiene un O(n log n) sobrecarga de un O(n) problema. Pero esto es mejor que los otros tres «ordenar la matriz» respuestas ya dadas.
  14. 0

    Aquí es una solución para obtener el máximo valor en el 99% de carreras (cambio de 0.01 para obtener un mejor resultado):

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

    (No completamente en serio)

    • 😉 Que «No está completamente en serio» bien. Dudando de upvote…

Dejar respuesta

Please enter your comment!
Please enter your name here