It's sepele untuk menulis fungsi untuk menentukan min/max nilai 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;
}
tapi isn't ini sudah dilakukan di suatu tempat?
Menggunakan Commons Lang (mengkonversi) + Koleksi (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));
}
}
Perhatikan bahwa Array.sebagai daftar()
membungkus mendasari array, sehingga tidak boleh terlalu intensif memori dan tidak harus melakukan copy pada elemen array.
Anda hanya dapat menggunakan Java baru 8 `Stream tapi anda harus bekerja dengan int
.
The aliran
metode utilitas kelas Array
memberikan anda sebuah IntStream
di mana anda dapat menggunakan pendidikan
metode. Anda juga dapat melakukan max
, jumlah
, rata-rata
,...
The getAsInt
metode ini digunakan untuk mendapatkan nilai dari 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==
Jika waktu eksekusi lebih penting dan anda ingin pergi 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 dari yang klasik loop karena summaryStatistics
metode adalah pengurangan operasi dan memungkinkan paralelisasi.
Google Jambu perpustakaan memiliki min dan max metode dalam Karakter, Int, Long, dll. kelas-kelas.
Jadi anda hanya dapat menggunakan:
Chars.min(myarray)
Tidak ada konversi yang diperlukan dan mungkin itu's efisien dilaksanakan.
Ya, itu's dilakukan di Koleksi kelas. Perhatikan bahwa anda akan perlu untuk mengkonversi primitif char array 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 sedikit penolong kelas 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 bisa dengan mudah melakukannya dengan IntStream
dan max()
metode.
public static int maxValue(final int[] intArray) {
return IntStream.range(0, intArray.length).map(i -> intArray[i]).max().getAsInt();
}
range(0, intArray.panjang)
- Untuk mendapatkan aliran dengan sebanyak elemen yang hadir dalam intArray
.
peta(i -> intArray[i])
- Peta setiap elemen dari aliran yang sebenarnya elemen intArray
.
max()
- Mendapatkan maksimum elemen dari aliran ini sebagai OptionalInt
.
getAsInt()
- Membuka OptionalInt
. (Anda juga bisa menggunakan di sini: orElse(0)
, hanya dalam kasus OptionalInt
ini kosong.)
Solusi dengan mengurangi()
:
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, mengurangi()
mengembalikan data di Optional
format, yang dapat mengkonversi ke int
oleh getAsInt()
.
Jika kita ingin membandingkan nilai max dengan nomor tertentu, kita dapat mengatur nilai awal di mengurangi()
:
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 mengurangi()
dengan identitas (nilai awal) sebagai parameter pertama, ia mengembalikan data dalam format yang sama dengan identitas. Dengan properti ini, kita 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
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);
}
}
Misalnya 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 max di sekitar 99% dari berjalan (mengubah 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 benar-benar serius)
Cara dasar untuk mendapatkan min/max nilai dari Array. Jika anda perlu disortir array, anda dapat membuat salinan atau lulus untuk sebuah metode yang mengembalikan min atau max. Jika tidak, array diurutkan lebih baik karena melakukan 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);
}
}