It's trivial to write a function to determine the min/max value in an array, such as:
/** * * @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; } but isn't this already done somewhere?
316 Answers
Using Commons Lang (to convert) + Collections (to 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)); } } Note that Arrays.asList() wraps the underlying array, so it should not be too memory intensive and it should not perform a copy on the elements of the array.
You can simply use the new Java 8 Streams but you have to work with int.
The stream method of the utility class Arrays gives you an IntStream on which you can use the min method. You can also do max, sum, average,...
The getAsInt method is used to get the value from the 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==
If execution time is important and you want to go through the data only once you can use the summaryStatistics() method like this
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); } } This approach can give better performance than classical loop because the summaryStatistics method is a reduction operation and it allows parallelization.
The Google Guava library has min and max methods in its Chars, Ints, Longs, etc. classes.
So you can simply use:
Chars.min(myarray) No conversions are required and presumably it's efficiently implemented.
2By sorting the array, you get the first and last values for 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); } } Although the sorting operation is more expensive than simply finding min/max values with a simple loop. But when performance is not a concern (e.g. small arrays, or your the cost is irrelevant for your application), it is a quite simple solution.
Note: the array also gets modified after this.
5Yes, it's done in the Collections class. Note that you will need to convert your primitive char array to a Character[] manually.
A short 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))); } } I have a little helper class in all of my applications with methods like:
public static double arrayMax(double[] arr) { double max = Double.NEGATIVE_INFINITY; for(double cur: arr) max = Math.max(max, cur); return max; } You could easily do it with an IntStream and the max() method.
Example
public static int maxValue(final int[] intArray) { return IntStream.range(0, intArray.length).map(i -> intArray[i]).max().getAsInt(); } Explanation
range(0, intArray.length)- To get a stream with as many elements as present in theintArray.map(i -> intArray[i])- Map every element of the stream to an actual element of theintArray.max()- Get the maximum element of this stream asOptionalInt.getAsInt()- Unwrap theOptionalInt. (You could also use here:orElse(0), just in case theOptionalIntis empty.)
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; } 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); } } A solution with 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 the code above, reduce() returns data in Optional format, which you can convert to int by getAsInt().
If we want to compare the max value with a certain number, we can set a start value 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 the code above, when reduce() with an identity (start value) as the first parameter, it returns data in the same format with the identity. With this property, we can apply this solution to other 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 Here's a utility class providing min/max methods for primitive types: 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); Example with 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]; } Pass the array to a method that sorts it with Arrays.sort() so it only sorts the array the method is using then sets min to array[0] and max to array[array.length-1].
The basic way to get the min/max value of an Array. If you need the unsorted array, you may create a copy or pass it to a method that returns the min or max. If not, sorted array is better since it performs faster in some cases.
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); } } Here is a solution to get the max value in about 99% of runs (change the 0.01 to get a better result):
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]; } (Not completely serious)
1 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"); } } 
