Поиск значения max/min в массиве примитивов с использованием Java

тривиально писать функцию для определения значения min / max в массиве, например:

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

но разве это уже сделано где-то?

14 ответов


использование Commons Lang ( для преобразования) + коллекции (до 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));
   }
}

отметим, что Arrays.asList() обертывает базовый массив, поэтому он не должен быть слишком интенсивным для памяти и не должен выполнять копирование элементов массива.


на библиотека Google Guava имеет методы min и max в своих Chars, Ints, Longs, etc. занятия.

Так что вы можете просто использовать:

Chars.min(myarray)

преобразования не требуются и, предположительно, эффективно реализованы.


вы можете просто использовать новый Java 8 Streams но вы должны работать с int.

на stream метод служебного класса Arrays дает IntStream на котором вы можете использовать min метод. Вы также можете сделать max, sum, average,...

на getAsInt метод используется для получения значение 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==

если время выполнения важно, и вы хотите пройти через данные только один раз, когда вы можете использовать summaryStatistics() способ такой

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

этот подход может дать лучшую производительность, чем классический цикл, потому что summaryStatistics метод операция по уменьшению и это позволяет распараллеливания.


Да, это сделано в коллекции класса. Обратите внимание, что вам нужно будет вручную преобразовать примитивный массив символов в символ [].

короткое демо:

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

  }

}

У меня есть небольшой вспомогательный класс во всех моих приложениях с такими методами, как:

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

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

    return max;
}

вы могли бы легко сделать это с помощью IntStream и max() метод.

пример

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

объяснение

  1. range(0, intArray.length) - чтобы получить поток с таким количеством элементов, как присутствует в intArray.

  2. map(i -> intArray[i]) - сопоставьте каждый элемент потока с фактическим элементом intArray.

  3. max() - получить максимальный элемент этого потока, как OptionalInt.

  4. getAsInt() - разверну OptionalInt. (Вы также можете использовать здесь: orElse(0) на всякий случай OptionalInt пусто.)


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

передайте массив методу, который сортирует его с помощью Arrays.sort() поэтому он сортирует только массив, который использует метод, а затем устанавливает мин to array[0] и Макс to array[array.length-1].


вот служебный класс, предоставляющий min/max методы для примитивных типов: примитивы.java


пример с 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];
}

основной способ получить минимальное / максимальное значение массива. Если вам нужен несортированный массив, вы можете создать копию или передать ее методу, который возвращает min или max. Если нет, сортированный массив лучше, так как в некоторых случаях он работает быстрее.

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

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

универсального решения*:

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

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

* * знайте о возможных null переданных args :) (npx)

* * * для примитива замените T на нужный тип или использовать массивы.asList()

пример:

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