Java kullanarak bir ilkel dizisindeki maks / min değerini bulma

Bir dizideki min / maks değerini belirlemek için bir işlev yazmak önemsizdir, örneğin:

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

ama bu zaten bir yerde yapılmadı mı?

Commons Lang (dönüştürmek için) + Koleksiyonlar'ı (min / maks.) Kullanma

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

Not Arrays.asList()çok bellek yoğun olmamalı ve dizinin elemanları üzerinde bir kopyasını yapmak gerekir, böylece altta yatan diziyi sarar.

Sadece yeni Java 8 kullanabilir Streams ancak çalışmak zorunda int.

streamYardımcı sınıf yöntemi Arrayssize verir IntStreamkullanabilirsiniz ON minyöntemi. Ayrıca yapabilirsiniz max, sum, average, ...

getAsIntYöntem, bir değer elde etmek için kullanılırOptionalInt

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

}

== GÜNCELLEME ==

Yürütme süresi önemliyse ve verileri yalnızca bir kez böyle bir summaryStatistics()yöntemle kullanabilmek istiyorsanız

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

Bu yaklaşım klasik döngüden daha iyi performans verebilir, çünkü summaryStatisticsyöntem bir indirgeme işlemidir ve paralelleştirmeye izin verir.

Google Guava kütüphane onun vs. Chars, Ints, Longs, sınıflarında minimum ve maksimum yöntemleri vardır.

Böylece şunları kullanabilirsiniz:

Chars.min(myarray)

Dönüşüm gerekmez ve muhtemelen verimli bir şekilde uygulanır.

Evet, Koleksiyonlar sınıfında yapılır . İlkel karakter dizinizi manuel olarak bir Karakter [] biçimine dönüştürmeniz gerekeceğini unutmayın.

Kısa bir 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);

  }

}

Ben gibi yöntemler ile tüm uygulamalarımda küçük bir yardımcı sınıf var:

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

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

    return max;
}

Bunu bir IntStreamve max()yöntemiyle kolayca yapabilirsiniz .

Misal

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

açıklama

1. range(0, intArray.length)- 'de mevcut olduğu kadar çok öğeye sahip bir akış elde etmek intArray.

2. map(i -> intArray[i])- Akışın tüm öğelerini gerçek bir öğesiyle eşleştirin intArray.

3. max()- Bu akışın maksimum öğesini olarak alın OptionalInt.

4. getAsInt()- Aç OptionalInt. (Burada da kullanabilirsiniz: boş orElse(0)olması durumunda OptionalInt.)

İşte min/maxilkel türler için yöntemler sağlayan bir yardımcı sınıf : 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;
    }

Aşağıdakileri içeren bir çözüm 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

Yukarıdaki kodda, biçimini dönüştürebileceğiniz reduce()verileri döndürür .OptionalintgetAsInt() .

Maksimum değeri belirli bir sayıyla karşılaştırmak istiyorsak, bir başlangıç ​​değeri ayarlayabiliriz 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

Yukarıdaki kodda reduce(), ilk parametre olarak bir kimlikle (başlangıç ​​değeri) olduğunda, verileri kimlikle aynı biçimde döndürür. Bu özellik ile bu çözümü diğer dizilere uygulayabiliriz:

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

Şamandıralı örnek:

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

İşte çalışmaların yaklaşık% 99'unda maksimum değeri elde etmek için bir çözüm (daha iyi bir sonuç elde etmek için 0.01'i değiştirin):

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

(Tamamen ciddi değil)

İle türlü bunu bir yönteme dizi geçmek Arrays.sort()sadece bir yöntem kullanan bir dizi sıralar, böylece daha sonra ayarlar dk için array[0]ve maksimum için array[array.length-1].

Bir Dizinin min / maks değerini almanın temel yolu. Sıralanmamış diziye ihtiyacınız varsa, bir kopya oluşturabilir veya bunu min veya max değerini döndüren bir yönteme iletebilirsiniz. Değilse, sıralı dizi bazı durumlarda daha hızlı performans gösterdiğinden daha iyidir.

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