我试图让这段代码确定哪个元素与常量具有最接近的值。
在此代码中，变量boxes = 5，任何具有boxCapacity >= boxes的元素都将添加到ArrayList中。从该列表中，应使用距离boxCapacity到boxes最近的列表。我可以选择大于boxes但不能选择距离最近boxCapacity的那些。
public void deliver(double miles, int boxes) {
for (int i = 0; i < cars.size(); i++){
if (cars.get(i).getBoxCapacity() >= boxes){
deliveryCars = new ArrayList<Car>();
deliveryCars.add(cars.get(i));
smallest = deliveryCars.get(0).getBoxCapacity();
for(j = 0; j < deliveryCars.size(); j++){
if (deliveryCars.get(j).getBoxCapacity() < smallest) {
smallest = deliveryCars.get(j).getBoxCapacity();
k++;
}
}
}
}
System.out.println("Delivering with " + deliveryCars.get(k).getPlate());
}
我试图制作一个新列表，但它还没有成功。
答案 0 :(得分：1)
您可以将代码简化为类似
的代码public void deliver(double miles, int boxes){
// check if there are cars availible
if (!cars.isEmpty()) {
// assume that first car in a list is best for delivery
int smallest = cars.get(0).getBoxCapacity();
Car deliveryCar = cars.get(0);
// iterating over all cars in a list
// but still compares to the first car in a list
for (Car car : cars) {
if (car.getBoxCapacity() >= boxes
&& car.getBoxCapacity() < smallest) {
deliveryCar = car;
}
}
System.out.println("Delivering with " + deliveryCar.getPlate());
}
}
答案 1 :(得分：1)
使用Java 8流......
Car deliveryVehicle = cars
.stream()
.filter(c -> c.getBoxCapacity() > boxes)
.min(Comparator.comparingInt(Car::getBoxCapacity))
.orElse(null);
假设您的cars是一个可迭代/可流式集合，这会创建一个流，对其进行过滤以提取容量大于boxes的所有实例，找到容量最小的元素，然后返回它，或null如果没有超过boxes容量的汽车。
然后，您可以使用返回的Car对象执行任何操作，例如调用getPlate()。在没有找到可接受的汽车的情况下，请记得检查是否为空。
答案 2 :(得分：0)
所以我认为你所说的是你有[0, 1, 2, 3, 4, 5, 6]的值列表然后给你另一个数字说4，你想要做的就是选择列表中的数字是所有大于4的数字中最小的数字，因此在这种情况下，您想要选择5，对吧？
嗯，有很多方法可以做到这一点。但最快的方法是通过列表一次，并跟踪比你的目标号码更大的最小数字＆＃39;：
...
public Integer getNextBiggest(List<Integer> numbers, int targetNumber)
{
// Set the default 'nextInt' to the largest possible value.
int nextInt = Integer.MAX_VALUE;
for (int i = 0; i < numbers.length; i++) {
// If the current number is greater than our targetNumber.
if (sortedList.get(i) > targetNumber) {
// Set the nextInt variable to the MINIMUM of current number
// and the current nextInt value.
nextInt = Math.min(nextInt, sortedList.get(i));
}
}
return nextInt;
}
...
这样可行，但是你的列表有点复杂，因为你使用的是对象而不是整数，这就是说，这是一个简单的转换：
首先是一些假设：
cars是一个列表。Car对象有getBoxCapacity()方法，返回int。Car对象有getPlate()方法，返回String。好的，所以看起来像这样：
...
public Car getBestFitCar(List<Car> cars, int targetBoxCapacity)
{
// Default best fit is null. No best first yet.
Car bestFit = null;
for (int i = 0; i < cars.length; i++) {
Car current = cars.get(i);
// If the current Car box capacity is greater than our target box capacity.
if (current.getBoxCapacity() > targetBoxCapacity) {
// Set the bestFit variable to the Car that has the MINIMUM
// 'box capacity' between the current Car and the bestFit Car.
if (bestFit == null || bestFit.getBoxCapacity() > current.getBoxCapacity()) {
bestFit = current;
}
}
}
return bestFit;
}
public static void main(String[] args) {
List<Car> cars = new ArrayList<>();
// add some cars here...
int targetBoxCapacity = 5;
Car bestFit = getBestFitCar(cars, targetBoxCapacity);
if (bestFit != null) {
System.out.println("Best fit car is: " + bestFit.getPlate());
} else {
System.out.println("No car can fit " + targetBoxCapacity + " boxes.");
}
}
<强>更新 我已经看到了使用流的一些不错的回复，但我要添加一些警告。 Streams使得编写代码更快/更易读，但最终在时间/空间上的效率低于具有简单循环的解决方案。该解决方案仅使用O（1）额外空间，在最坏情况下使用O（n）时间。
我认为流答案将使用O（n）额外空间，并且在最坏的情况下使用O（n * n log n）时间。
所以，如果你有一个小清单我会说简单的非常酷的流解决方案，但你有一个很多元素的列表，你会用更传统的方法更好
答案 3 :(得分：0)
您不需要新列表。您已经概述的任务是通过无序列表进行顺序搜索，除非我误解了您的目标，否则您只需要一个for循环 - 也就是说，您只需要遍历列表一次。由于您正在寻找单个项目，并且您不需要一次查看多个项目以查看它是否是目前为止最好的项目，您只需要一个变量来跟踪它列表中的位置。
这是一个工作样本。请注意，变量名称描述了目的（例如＆＃34; mimimumBoxCapacity＆＃34;而不是模糊的＆＃34;框＆＃34;）。这有助于我更好地理解我的代码正在做什么。
// print the plate number of the car with the smallest boxCapacity
// greater than a specified minimum
public void deliver(List<Car> cars, double miles, int minimumBoxCapacity)
{
if ((cars != null) && (cars.size() > 0))
{
int indexOfBestMatch = -1; // negative index means no match yet
for (int i = 0; i < cars.size(); i++)
{
if (cars.get(i).getBoxCapacity() > minimumBoxCapacity)
{
if (indexOfBestMatch < 0)
{
// this is the only match seen so far; remember it
indexOfBestMatch = i;
}
else
{
// found a better match; replace the old best match
if (cars.get(i).getBoxCapacity() < cars.get(indexOfBestMatch).getBoxCapacity())
{
indexOfBestMatch = i;
}
}
}
}
if (indexOfBestMatch >= 0)
{
System.out.println("Delivering with " + cars.get(indexOfBestMatch).getPlate());
}
}
}
此代码说明了您的算法如何更改以执行您想要的操作。 DataDino使用Car变量来跟踪最佳拟合的答案更加清晰，尤其是在方法返回Car结果并让调用逻辑决定如何处理该结果的情况下。
（你的原始代码没有编译，因为像＆＃34;最小＆＃34;和＃34; deliveryCars＆＃34;之类的变量在使用之前没有被定义。这将有助于未来如果您发布编译的代码，即使它还没有完成您想要它做的事情。）
答案 4 :(得分：0)
这个答案来自@DataDino提供的澄清，即目标是找到最大boxCapacity大于targetCapacity的汽车。
根据汽车列表，您可以过滤掉任何小于目标的boxCapacity的汽车，然后从剩下的内容中选择最小的boxCapacity。
List<Car> cars = List.of(new Car(8), new Car(3), new Car(5), new Car(6));
int suggestedCapacity = 4;
Optional<Car> bestFit = cars.stream()
.filter(car -> car.getBoxCapacity() >= suggestedCapacity)
.min(Comparator.comparing(Car::getBoxCapacity));
if (bestFit.isPresent()) {
System.out.println("found car with capacity " + bestFit.get().getBoxCapacity());
} else {
System.out.println("No suitable car found");
}
Streams api负责列表操作并跟踪最小内部状态。