Java 与字符串数组关联的数组中的最小数

我尽我所能寻找数组中的最小数；但是，我找不到任何具有与单独字符串数组关联的数组的示例。我有两个数组，一个是名称数组，第二个是时间数组（int）。我想要一个结果，显示最短的时间，以及那个时间是谁完成的

这是我必须处理的骨架：

class Marathon {
    public static void main (String[] arguments){
        String[] names ={"Elena", "Thomas", "Hamilton", "Suzie", "Phil", "Matt", "Alex", "Emma", "John", "James", "Jane", "Emily", "Daniel", "Neda", "Aaron", "Kate"
        };

        int[] times ={341, 273, 278, 329, 445, 402, 388, 275, 243, 334, 412, 393, 299,343, 317, 265
        };

        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i] + ": " + times[i]);
        }
    }
}

职业马拉松{
公共静态void main（字符串[]参数）{
String[]name={“Elena”、“Thomas”、“Hamilton”、“Suzie”、“Phil”、“Matt”、“Alex”、“Emma”、“John”、“James”、“Jane”、“Emily”、“Daniel”、“Neda”、“Aaron”、“Kate”
};
int[]次={341，273，278，329，445，402，388，275，243，334，412，393，299343，317，265
};
for（int i=0；i

我能够编写一些代码以获得最短的时间：

public class Test {

    public static void main (String[] args) {

        String[] names = new String[] {"Elena", "Thomas", "Hamilton", "Suzie", "Phil", "Matt", "Alex", "Emma", "John", "James", "Jane", "Emily", "Daniel", "Neda", "Aaron", "Kate"
        };

        int[] times = new int[]{ 341, 273, 278, 329, 445, 402, 388, 275, 243, 334, 412, 393, 299, 343, 317, 265
        };

        int win = times[0];

        for(int i=0; i< names.length; i++) {
            if (times[i] < win) 
                win = times[i];                                     
        }    
        System.out.println("names[i]" + ": " + win);                
    }        
}
// result "names[i]: 243

公共类测试{
公共静态void main（字符串[]args）{
字符串[]名称=新字符串[]{“Elena”、“Thomas”、“Hamilton”、“Suzie”、“Phil”、“Matt”、“Alex”、“Emma”、“John”、“James”、“Jane”、“Emily”、“Daniel”、“Neda”、“Aaron”、“Kate”
};
int[]次=新int[]{34127329445402382752433343441239317465
};
int win=次[0]；
for（int i=0；i

但似乎找不到显示关联名称的方法（因此我甚至不知道这段代码是让我走得更近还是更远）。我最近的一次尝试是通过继续循环……但它只与时间[0]直接比较，我收到的结果都小于341

public class Marathon { 

    public static void main (String[] args) {

        String[] names = new String[] {"Elena", "Thomas", "Hamilton", "Suzie", "Phil", "Matt", "Alex", "Emma", "John", "James", "Jane", "Emily", "Daniel", "Neda", "Aaron", "Kate"
        };

        int[] times = new int[] {341, 273, 278, 329, 445, 402, 388, 275, 243, 334, 412, 393, 299, 343, 317, 265
        };

        for (int i = 1; i < names.length; i++) {
            if (times[i] >= times[0]) continue;
                System.out.println(names[i]+ ": " + times[i]);
        }
    }
}
//Result: 
//"Thomas: 273
//Hamilton: 278
//Suzie: 329
//Emma: 275
//John: 243
//James: 334
//Daniel: 299
//Aaron: 317
//Kate: 265"

公共课马拉松{
公共静态void main（字符串[]args）{
字符串[]名称=新字符串[]{“Elena”、“Thomas”、“Hamilton”、“Suzie”、“Phil”、“Matt”、“Alex”、“Emma”、“John”、“James”、“Jane”、“Emily”、“Daniel”、“Neda”、“Aaron”、“Kate”
};
int[]次=新int[]{34127329445402382752433343441239317465
};
for（int i=1；i=次[0]）继续；
System.out.println（名称[i]+“：“+次[i]）；
}
}
}
//结果:
//“托马斯：273
//汉密尔顿：278
//苏西：329
//艾玛：275
//约翰：243
//詹姆斯：334
//丹尼尔：299
//亚伦：317
//凯特：265“

---

我还尝试与times[I++]进行比较，结果出现了一个错误，我不确定是否有其他方法可以与整个数组进行比较，并将名称与正确的时间关联起来（我找到了很多方法来取消正确的名称和时间的关联）。我如何才能将正确的名称与最短的时间相关联。下一阶段还将显示亚军；然而，我希望我能弄清楚，一旦我获得第一名的人和时间…我在任何地方找到的唯一示例都只涉及一个数组，多个数组的事情似乎让我陷入了困境！

Find mini数组中的最大值：

int[] array ...
int min = Integer.MAX_VALUE;
int index = -1;
for (int i=0 i<array.length; i++){

    if (array[i] > min){
         index = i;
         min = array[i];
    }
}
System.out.println(names[index]);

int[]数组。。。
int min=整数最大值；
int指数=-1；
对于（整数i=0 i min）{
指数=i；
min=数组[i]；
}
}
System.out.println（名称[索引]）；

在数组中查找最小值：

int[] array ...
int min = Integer.MAX_VALUE;
int index = -1;
for (int i=0 i<array.length; i++){

    if (array[i] > min){
         index = i;
         min = array[i];
    }
}
System.out.println(names[index]);

int[]数组。。。
int min=整数最大值；
int指数=-1；
对于（整数i=0 i min）{
指数=i；
min=数组[i]；
}
}
System.out.println（名称[索引]）；

使用变量

min

将索引存储在

时间[]

具有最低值的。在数组上迭代

次

一次，因为这是决定判断的因素。在迭代过程中，检查

次

中的当前元素是否小于索引

min

中的元素。如果是，则将当前索引指定给

min

int min = 0;
for(int i=0; i<times.length; i++){
    if(times[i] < times[min])
        min = i;
}
System.out.println("Lowest time is of "+names[min]+
                   ", the time being "+times[min]);

---

使用变量

min

将索引存储在

时间[]

具有最低值的。在数组上迭代

次

一次，因为这是决定判断的因素。在迭代过程中，检查

次

中的当前元素是否小于索引

min

中的元素。如果是，则将当前索引指定给

min

int min = 0;
for(int i=0; i<times.length; i++){
    if(times[i] < times[min])
        min = i;
}
System.out.println("Lowest time is of "+names[min]+
                   ", the time being "+times[min]);

真正的答案
停止使用小丑解决方案，开始使用对象。 创建一个包含名称和时间的对象。 停止使用数组。 将新对象类型存储在列表中（LinkedList可能很好，如果需要随机访问列表，请使用ArrayList）

您想要的答案
使用两个数组存储关于一个项目的相关数据是一个极好的解决方案。 查找最低时间和关联名称的简单解决方案：

查找最低时间的索引

由于数组的顺序相同，请使用该索引值从完全独立的名称数组中检索名称

真正的答案
停止使用小丑解决方案，开始使用对象。 创建一个包含名称和时间的对象。 停止使用数组。 将新对象类型存储在列表中（LinkedList可能很好，如果需要随机访问列表，请使用ArrayList）

您想要的答案
使用两个数组存储关于一个项目的相关数据是一个极好的解决方案。 查找最低时间和关联名称的简单解决方案：

查找最低时间的索引

由于数组的顺序相同，请使用该索引值从完全独立的名称数组中检索名称

---

假设名称数组的索引与时间数组的索引相关联

public static void main (String[] args) {

    String[] names = new String[] {"Elena", "Thomas", "Hamilton", "Suzie", "Phil", "Matt", "Alex", "Emma", "John", "James", "Jane", "Emily", "Daniel", "Neda", "Aaron", "Kate"
    };

    int[] times = new int[]{ 341, 273, 278, 329, 445, 402, 388, 275, 243, 334, 412, 393, 299, 343, 317, 265
    };

    int win = times[0];
    int winningIndex = 0;


    for(int i=0; i< names.length; i++) {

        if (times[i] < win){ 
            win = times[i];
            winningIndex = i;
        }
    }    
        System.out.println(names[winningIndex] + ": " + times[winningIndex]);                
 // result "John: 243
}   

publicstaticvoidmain（字符串[]args）{
字符串[]名称=新字符串[]{“Elena”、“Thomas”、“Hamilton”、“Suzie”、“Phil”、“Matt”、“Alex”，
list.stream()
            .sorted()
            .forEach(i -> System.out.println(i.name + " " + i.time));

    String[] names = new String[] { "Elena", "Thomas", "Hamilton", "Suzie", "Phil", "Matt", "Alex", "Emma", "John", "James", "Jane", "Emily",
            "Daniel", "Neda", "Aaron", "Kate" };
    int[] times = new int[] { 341, 273, 278, 329, 445, 402, 388, 275, 243, 334, 412, 393, 299, 343, 317, 265 };

    int minIndex = IntStream.range(0, times.length).boxed().min((a, b) -> times[a] - times[b]).get();
    System.out.println(minIndex + " " + times[minIndex] + " " + names[minIndex]);

    TreeMap<Integer, String> sortedMap = IntStream.range(0, times.length).collect(TreeMap<Integer, String>::new,
            (map, i) -> map.put(times[i], names[i]), Map::putAll);
    System.out.println(sortedMap.firstEntry());

8 243 John
243=John