Het is triviaal om een functie te schrijven om de MIN / MAX-waarde in een array te bepalen, zoals:
/**
*
* @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;
}
Maar is dit niet ergens ergens gedaan?
Antwoord 1, Autoriteit 100%
Gebruik Commons Lang (om te converteren) + collecties (naar 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));
}
}
Merk op dat Arrays.asList()
de onderliggende array wikkelt, dus het mag niet te geheugen intensief zijn en het mag geen kopie uitvoeren op de elementen van de array.
Antwoord 2, Autoriteit 71%
U kunt eenvoudig de nieuwe Java 8 gebruiken stream
S MAAR JE MOET WERKEN MET int
.
De stream
methode van de utility class Arrays
geeft u een IntStream
waarop u de min
methode. U kunt ook max
, sum
, average
,…
De getAsInt
methode wordt gebruikt om de waarde te halen uit de 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==
Als de uitvoeringstijd belangrijk is en u de gegevens slechts één keer wilt bekijken, kunt u de summaryStatistics()
methode zoals deze
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);
}
}
Deze aanpak kan betere prestaties opleveren dan de klassieke lus omdat de summaryStatistics
-methode is een reductiebewerkingen het maakt parallellisatie mogelijk.
Antwoord 3, autoriteit 34%
De Google Guava-bibliotheekheeft min en max methoden in zijn Chars, Ints, Longs, etc. lessen.
Je kunt dus gewoon het volgende gebruiken:
Chars.min(myarray)
Er zijn geen conversies vereist en vermoedelijk wordt het efficiënt geïmplementeerd.
Antwoord 4, autoriteit 11%
Ja, het is gedaan in de Collecties klasse. Merk op dat u uw primitieve CHAR-array naar een personage [] handmatig wilt converteren.
een korte 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)));
}
}
Antwoord 5, Autoriteit 10%
Door de array te sorteren, krijgt u de eerste en laatste waarden voor MIN / MAX.
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);
}
}
Hoewel de sorteerbewerking duurder is dan simpelweg het vinden van min / max-waarden met een eenvoudige lus. Maar wanneer de prestaties geen zorg (b.v. kleine arrays of uw de kosten is irrelevant voor uw aanvraag), is het een vrij eenvoudige oplossing.
Opmerking: de array wordt hierna ook gewijzigd.
Antwoord 6, Autoriteit 6%
Ik heb een kleine helperklasse in al mijn toepassingen met methoden zoals:
public static double arrayMax(double[] arr) {
double max = Double.NEGATIVE_INFINITY;
for(double cur: arr)
max = Math.max(max, cur);
return max;
}
Antwoord 7, Autoriteit 2%
U kunt het eenvoudig doen met een IntStream
en de max()
-methode.
Voorbeeld
public static int maxValue(final int[] intArray) {
return IntStream.range(0, intArray.length).map(i -> intArray[i]).max().getAsInt();
}
Uitleg
-
range(0, intArray.length)
– Om een stroom te krijgen met zoveel elementen zoals aanwezig in deintArray
. -
map(i -> intArray[i])
– Kaart elk element van de stroom naar een feitelijk element van deintArray
. -
max()
– Krijg het maximale element van deze stroom alsOptionalInt
. -
getAsInt()
– PUNTEN DEOptionalInt
. (U kunt hier ook gebruiken:orElse(0)
, voor het geval dat deOptionalInt
leeg is.)
Antwoord 8, Autoriteit 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;
}
Antwoord 9
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);
}
}
Antwoord 10
Een oplossing met 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
In de bovenstaande code retourneert reduce()
gegevens in de indeling Optional
, die u kunt converteren naar int
door getAsInt()
.
Als we de maximale waarde willen vergelijken met een bepaald getal, kunnen we een startwaarde instellen in 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
In de bovenstaande code, wanneer reduce()
met een identiteit (startwaarde) als de eerste parameter, worden gegevens geretourneerd in hetzelfde formaat als de identiteit. Met deze eigenschap kunnen we deze oplossing toepassen op andere arrays:
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
Antwoord 11
Hier is een hulpprogrammaklasse die min/max
-methoden biedt voor primitieve typen: Primitives.java
int [] numbers= {10,1,8,7,6,5,2};
int a=Integer.MAX_VALUE;
for(int c:numbers) {
a=c<a?c:a;
}
System.out.println("Lowest value is"+a);
Antwoord 12
Voorbeeld met 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];
}
Antwoord 13
Hier is een oplossing om de maximale waarde in ongeveer 99% van de runs te krijgen (verander de 0.01 om een beter resultaat te krijgen):
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];
}
(Niet helemaal serieus)
Antwoord 14
Geef de array door aan een methode die het sorteert met Arrays.sort()
zodat het alleen de array sorteert die de methode gebruikt en zet dan minin op array[0]
en maxnaar array[array.length-1]
.
Antwoord 15
De basismanier om de min/max-waarde van een array te krijgen. Als u de ongesorteerde array nodig hebt, kunt u een kopie maken of deze doorgeven aan een methode die de min of max retourneert. Zo niet, dan is een gesorteerde array beter omdat deze in sommige gevallen sneller presteert.
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);
}
}
Antwoord 16
int[] arr = {1, 2, 3};
List<Integer> list = Arrays.stream(arr).boxed().collect(Collectors.toList());
int max_ = Collections.max(list);
int i;
if (max_ > 0) {
for (i = 1; i < Collections.max(list); i++) {
if (!list.contains(i)) {
System.out.println(i);
break;
}
}
if(i==max_){
System.out.println(i+1);
}
} else {
System.out.println("1");
}
}