Menemukan nilai maks / min dalam array primitif menggunakan Java

Itu sepele untuk menulis fungsi untuk menentukan nilai min / maks dalam array, seperti:

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

tetapi bukankah ini sudah dilakukan di suatu tempat?

Menggunakan Commons Lang (untuk mengkonversi) + Koleksi (untuk minimum / maks)

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

Catatan yang Arrays.asList()membungkus array yang mendasarinya, jadi seharusnya tidak terlalu banyak memori dan tidak boleh melakukan salinan pada elemen-elemen array.

Anda hanya dapat menggunakan baru Java 8 Streams tetapi Anda harus bekerja dengan int.

The streammetode kelas utilitas Arraysmemberi Anda IntStreamyang dapat Anda menggunakan minmetode. Anda juga dapat melakukan max, sum, average, ...

The getAsIntmetode yang digunakan untuk mendapatkan nilai dariOptionalInt

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

Jika waktu eksekusi itu penting dan Anda ingin melalui data hanya sekali Anda dapat menggunakan summaryStatistics()metode seperti ini

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

Pendekatan ini dapat memberikan kinerja yang lebih baik daripada loop klasik karena summaryStatisticsmetode ini merupakan operasi reduksi dan memungkinkan paralelisasi.

The Google Jambu perpustakaan memiliki min dan metode max di Chars nya, Ints, Longs, dll kelas.

Jadi Anda cukup menggunakan:

Chars.min(myarray)

Tidak diperlukan konversi dan mungkin ini diterapkan secara efisien.

Ya, itu dilakukan di kelas Koleksi . Perhatikan bahwa Anda perlu mengonversi array char primitif Anda ke Karakter [] secara manual.

Demo singkat:

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

  }

}

Saya memiliki kelas pembantu kecil di semua aplikasi saya dengan metode seperti:

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

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

    return max;
}

Anda dapat dengan mudah melakukannya dengan IntStreamdan max()metode.

Contoh

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

Penjelasan

1. range(0, intArray.length)- Untuk mendapatkan aliran dengan elemen sebanyak yang ada di intArray.

2. map(i -> intArray[i])- Peta setiap elemen aliran ke elemen aktual intArray.

3. max()- Dapatkan elemen maksimum dari aliran ini sebagai OptionalInt.

4. getAsInt()- Buka bungkusnya OptionalInt. (Anda juga bisa menggunakan di sini orElse(0):, kalau-kalau OptionalIntkosong.)

Inilah kelas utilitas yang menyediakan min/maxmetode untuk tipe primitif: 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;
    }

Solusi dengan 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

Dalam kode di atas, reduce()mengembalikan data dalam Optionalformat, yang dapat Anda konversi intolehgetAsInt() .

Jika kami ingin membandingkan nilai maks dengan angka tertentu, kami dapat menetapkan nilai awal di 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

Dalam kode di atas, ketika reduce()dengan identitas (nilai awal) sebagai parameter pertama, itu mengembalikan data dalam format yang sama dengan identitas. Dengan properti ini, kami dapat menerapkan solusi ini ke array lain:

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

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

Berikut ini adalah solusi untuk mendapatkan nilai maksimal di sekitar 99% proses (ubah 0,01 untuk mendapatkan hasil yang lebih baik):

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

(Tidak sepenuhnya serius)

Pass array ke metode yang mengurutkannya Arrays.sort()sehingga hanya mengurutkan array metode yang digunakan kemudian set min ke array[0]dan maks ke array[array.length-1].

Cara dasar untuk mendapatkan nilai min / max Array. Jika Anda membutuhkan array yang tidak disortir, Anda dapat membuat salinan atau meneruskannya ke metode yang mengembalikan min atau maks. Jika tidak, array yang diurutkan lebih baik karena kinerjanya lebih cepat dalam beberapa kasus.

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