没有特别有效的方法来查找未排序列表中的最大值——您只需要检查它们并返回最大值。

你可以使用 Collections API来实现你想轻松-有效地阅读-足够 Javadoc for Collections.max

Collections.max(arrayList);

根据给定集合元素的自然顺序，返回该集合的最大元素。集合中的所有元素都必须实现 Compable 接口。

根据数组的大小，多线程解决方案也可能加快速度

public int getMax(ArrayList list){
int max = Integer.MIN_VALUE;
for(int i=0; i<list.size(); i++){
if(list.get(i) > max){
max = list.get(i);
}
}
return max;
}

根据我的理解，这基本上就是 Collections.max ()所做的，尽管它们使用了一个比较器，因为列表是通用的。

这个问题几乎有一年了，但是我发现如果你为对象制作一个自定义比较器，你可以使用 Collections.max 作为对象的数组列表。

import java.util.Comparator;


public class compPopulation implements Comparator<Country> {
public int compare(Country a, Country b) {
if (a.getPopulation() > b.getPopulation())
return -1; // highest value first
if (a.getPopulation() == b.Population())
return 0;
return 1;
}
}
ArrayList<Country> X = new ArrayList<Country>();
// create some country objects and put in the list
Country ZZ = Collections.max(X, new compPopulation());

我们可以简单地使用 Collections.max()和 Collections.min()方法。

public class MaxList {
public static void main(String[] args) {
List l = new ArrayList();
l.add(1);
l.add(2);
l.add(3);
l.add(4);
l.add(5);
System.out.println(Collections.max(l)); // 5
System.out.println(Collections.min(l)); // 1
}
}

Comparator.comparing

在 Java8中，集合通过使用 lambda 得到了增强。因此，使用 Comparator.comparing，可以按照以下方式查找 max 和 min:

密码:

List<Integer> ints = Stream.of(12, 72, 54, 83, 51).collect(Collectors.toList());
System.out.println("the list: ");
ints.forEach((i) -> {
System.out.print(i + " ");
});
System.out.println("");
Integer minNumber = ints.stream()
.min(Comparator.comparing(i -> i)).get();
Integer maxNumber = ints.stream()
.max(Comparator.comparing(i -> i)).get();


System.out.println("Min number is " + minNumber);
System.out.println("Max number is " + maxNumber);

产出:

 the list: 12 72 54 83 51
Min number is 12
Max number is 83

这就是功能

public int getIndexOfMax(ArrayList<Integer> arr){
int MaxVal = arr.get(0); // take first as MaxVal
int indexOfMax = -1; //returns -1 if all elements are equal
for (int i = 0; i < arr.size(); i++) {
//if current is less then MaxVal
if(arr.get(i) < MaxVal ){
MaxVal = arr.get(i); // put it in MaxVal
indexOfMax = i; // put index of current Max
}
}
return indexOfMax;
}

以下是另外三种使用流查找列表中最大值的方法:

List<Integer> nums = Arrays.asList(-1, 2, 1, 7, 3);
Optional<Integer> max1 = nums.stream().reduce(Integer::max);
Optional<Integer> max2 = nums.stream().max(Comparator.naturalOrder());
OptionalInt max3 = nums.stream().mapToInt(p->p).max();
System.out.println("max1: " + max1.get() + ", max2: "
+ max2.get() + ", max3: " + max3.getAsInt());

与 Collections.max一样，所有这些方法都会遍历整个集合，因此它们需要与集合大小成比例的时间。

Integer 类实现了 Compaable.So 我们可以很容易地得到 Integer 列表的 max 或 min 值。

public int maxOfNumList() {
List<Integer> numList = new ArrayList<>();
numList.add(1);
numList.add(10);
return Collections.max(numList);
}

如果一个类没有实现 Compaable，我们必须找到 max 和 min 值，那么我们必须编写我们自己的 Compaator。

List<MyObject> objList = new ArrayList<MyObject>();
objList.add(object1);
objList.add(object2);
objList.add(object3);
MyObject maxObject = Collections.max(objList, new Comparator<MyObject>() {
@Override
public int compare(MyObject o1, MyObject o2) {
if (o1.getValue() == o2.getValue()) {
return 0;
} else if (o1.getValue() > o2.getValue()) {
return -1;
} else if (o1.getValue() < o2.getValue()) {
return 1;
}
return 0;
}
});

package in.co.largestinarraylist;


import java.util.ArrayList;
import java.util.Scanner;


public class LargestInArrayList {


public static void main(String[] args) {


int n;
ArrayList<Integer> L = new ArrayList<Integer>();
int max;
Scanner in = new Scanner(System.in);
System.out.println("Enter Size of Array List");
n = in.nextInt();
System.out.println("Enter elements in Array List");


for (int i = 0; i < n; i++) {
L.add(in.nextInt());
}


max = L.get(0);


for (int i = 0; i < L.size(); i++) {
if (L.get(i) > max) {
max = L.get(i);
}
}


System.out.println("Max Element: " + max);
in.close();
}
}

除了 请回答，如果有人来这里寻找解决同样问题的 零安全解决方案，这就是我最终得到的结果

Collections.max(arrayList, Comparator.nullsFirst(Comparator.naturalOrder()))

爪哇8

由于整数具有可比性，我们可以在以下内容中使用一行代码:

List<Integer> ints = Stream.of(22,44,11,66,33,55).collect(Collectors.toList());
Integer max = ints.stream().mapToInt(i->i).max().orElseThrow(NoSuchElementException::new); //66
Integer min = ints.stream().mapToInt(i->i).min().orElseThrow(NoSuchElementException::new); //11

另一点要注意的是，我们不能用 Funtion.identity()代替 i->i，因为 mapToInt期望 ToIntFunction是一个完全不同的接口，与 Function无关。而且该接口只有一个 applyAsInt方法，没有 identity()方法。

在 Java8中

arrayList.stream()
.reduce(Integer::max)
.get()

model =list.stream().max(Comparator.comparing(Model::yourSortList)).get();

有很多方法可以找到最大值。但是，除非集合非常庞大，否则在性能上不会有明显的差异。

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);


System.out.println(
integers.stream().max(Integer::compare).get()
);
System.out.println(
integers.stream().mapToInt(Integer::intValue).max().getAsInt()
);
System.out.println(
integers.stream().max(Comparator.comparing(i -> i)).get()
);
System.out.println(
integers.stream().reduce((a, b) -> a > b ? a : b).get()
);
System.out.println(
integers.stream().reduce(Integer.MIN_VALUE, (a, b) -> a > b ? a : b)
);

Max 方法需要一个 Comparator作为参数。

Reduce 方法需要一个 BinaryOperator作为参数。