使用Java在原语数组中查找最大/最小值
编写函数来确定数组中的最小/最大值非常简单,例如:使用Java在原语数组中查找最大/最小值,java,arrays,algorithm,frameworks,Java,Arrays,Algorithm,Frameworks,编写函数来确定数组中的最小/最大值非常简单,例如: /** * * @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] >
/**
*
* @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;
}
但是这不是已经在某个地方完成了吗?是的,已经在课堂上完成了。请注意,您需要手动将基本字符数组转换为字符[]
一个简短的演示:
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)));
}
}
下面是一个为基本类型提供最小/最大方法的实用程序类:
使用Commons Lang将+集合转换为最小值/最大值
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));
}
}
请注意,Arrays.asList包装了基础数组,因此它不应该占用太多内存,也不应该对数组的元素执行复制。在其Chars、int、long等类中有min和max方法
因此,您可以简单地使用:
Chars.min(myarray)
不需要进行转换,而且可能会高效地实现。将数组传递给使用数组进行排序的方法。sort因此它只对该方法使用的数组进行排序,然后将min设置为数组[0],max设置为数组[array.length-1]。通过对数组进行排序,可以获得min/max的第一个和最后一个值
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);
}
}
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);
}
}
尽管排序操作比使用简单循环查找最小/最大值更昂贵。但是,如果性能不是一个问题,例如小型阵列,或者成本与应用程序无关,那么这是一个非常简单的解决方案
注意:数组在此之后也会被修改。您可以简单地使用新的Java 8,但必须使用int 实用程序类的方法为您提供了一个可以在其上使用该方法的方法。你也可以做 该方法用于从 ==更新== 如果执行时间很重要,并且您只想遍历数据一次,那么您可以使用如下方法
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);
}
}
这种方法可以提供比经典循环更好的性能,因为该方法是一种并行化方法。获取数组最小/最大值的基本方法。如果需要未排序的数组,可以创建一个副本或将其传递给返回最小值或最大值的方法。如果不需要,排序数组会更好,因为它在某些情况下执行得更快
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);
}
}
您可以使用IntStream和max方法轻松地实现这一点 实例 解释 range0,intArray.length-获取包含与intArray中相同数量元素的流 mapi->intArray[i]-将流的每个元素映射到intArray的实际元素 max-将此流的最大元素作为optionant获取 getAsInt-展开Optionant。您也可以在此处使用:orElse0,以防optionAgent为空 浮点数示例:
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];
}
我在所有应用程序中都有一个小助手类,其方法如下:
public static double arrayMax(double[] arr) {
double max = Double.NEGATIVE_INFINITY;
for(double cur: arr)
max = Math.max(max, cur);
return max;
}
以下是一个解决方案,可以在99%的运行中获得最大值,更改0.01以获得更好的结果:
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];
}
不完全严重使用reduce的解决方案:
在上面的代码中,reduce以可选格式返回数据,您可以通过getAsInt将其转换为int
如果我们想将最大值与某个数字进行比较,我们可以在reduce中设置一个起始值:
在上面的代码中,当reduce使用标识开始值作为第一个参数时,它将以与标识相同的格式返回数据。利用此属性,我们可以将此解决方案应用于其他阵列:
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
收藏.minmyCollection;如果要将其用于数组,可以像Collections.minarray.asListmyArray一样使用它;将char[]转换为Character[]只是为了确定最大值是非常低效的-最好为每个基本类型创建一个具有静态方法的实用程序类,类似于java.util.Arrays:@Christoph:是的,如果数组的大小很大,我会同意。如果所讨论的应用程序进行了许多数据库调用和/或I/O操作,并且数组的大小相对较小,简单地说它效率低下是没有意义的。出于性能原因,您应该使用Character.valueOfchars[I]而不是新的Characterchars[I]:@Christoph Christoph是正确的,对于min-max搜索,将数组转换为集合既低效又愚蠢。它的实现或多或少与问题中的类似,只是对于长度为0的数组抛出了IllegalArgumentException。这是这里最好的解决方案。避免了所有java.util.ArraySList varargs的混淆。我认为这意味着,如果按升序对数组进行排序,根据定义,最小值将始终位于第一个位置a[0],最大值将始终位于最后一个位置[a.length-1]。这是解决此问题的合法且有用的方法。与其他方法相比,使用它的缺点是什么?@alex time complexity-排序充其量只是一个旁观者,而Michael Rutherfurd方法正在使用。我们不需要排序,因为在列表上进行一次迭代就足以找到最小值和最大值。@akhil_mittal,但这需要比排序更多的代码,因为并没有Java标准方法来完成这个迭代,所以将原语数组转换为容器数组会有帮助:follow
我喜欢Java有多蠢排序的问题在于它有一个On问题的On log n开销。但是这比已经给出的数组答案的其他三种排序方法要好。什么是ArrayUtilsArray.asList应该可以,但是ArrayUtils.toObject会将a的每个元素复制到一个新的Character数组中。Arrays.asLista不起作用。在这种情况下,无法创建基本体列表。首先,您需要将基元值转换为对象,这就是使用ArrayUtils.toObject的原因。可能值得注意的是,a这会修改数组,而b对于大型数组,这是一个更昂贵的解决方案,仅对数n而不是ONY您应该使用double max=double.NEGATIVE_无穷大;而不是double max=double.MIN_值;因为double的最小值为正。。。或者您可以将max设置为数组中的第一项,并从第二项开始迭代,请参见我的答案。这是关于数字int,但问题是询问原始值int、long、char、byte…而您的解决方案可以工作,但它会将时间复杂度增加到Onlogn,而min可以通过使用其他答案轻松找到。在这种情况下使用排序简直太疯狂了。当需要前n>1个最小/最大值时,它会很有用,需要进行一些修复。;-那“不是很严重”好吧。犹豫是否投票…
public static double arrayMax(double[] arr) {
double max = Double.NEGATIVE_INFINITY;
for(double cur: arr)
max = Math.max(max, cur);
return 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;
}
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];
}
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
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
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
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");
}
}