我正在尝试创建一个概率结果模拟器，其中信息来自.csv文件。创建两个ArrayLists，然后将信息和结果放入这些ArrayLists中。 Double ArrayList包含String ArrayList中每个相应两个团队的置信度等级。
Example:
Double ArrayList: 25, 22, 50
String ArrayList: Atlanta, Michigan, NY, Detroit
Atlanta and Michigan would correspond to 25, NY and Detroit would correspond to 22.
我已经制作了程序，双重ArrayList的置信度等级被排序，但团队String ArrayList没有。 这些是两个ArrayLists在排序之前：
[1.0, 7.0, 8.0, 1.0, 10.0, 2.0, 4.0, 3.0, 1.0, 1.0, 9.0, 1.0, 3.0, 6.0, 0.0, 16.0]
[Green Bay, [Detroit, NY Jets, [NY Giants, [St. Louis, Arizona, [Tampa Bay, Atlanta, [Minnesota, Seattle, Houston, [Buffalo, [Miami, Baltimore, Cincinnati, [Cleveland, Jacksonville, [Tennessee, SF, [Chicago, Denver, [San Diego, KC, [Oakland, Carolina, [New Orleans, [New England, Philly, [Pittsburgh, Indy, [Washington, Dallas]
在两个列表被整理出来之后，它就是这样的：
[16.0, 10.0, 9.0, 8.0, 7.0, 6.0, 4.0, 3.0, 3.0, 2.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0]
[[NY Giants, [Cleveland, Jacksonville, Seattle, [Cleveland, [St. Louis, Houston, Arizona, [Buffalo, [NY Giants, [Cleveland, [Cleveland, Baltimore, [Miami, Atlanta, [NY Giants, Atlanta, [Tennessee, SF, [Chicago, Denver, [San Diego, KC, [Oakland, Carolina, [New Orleans, [New England, Philly, [Pittsburgh, Indy, [Washington, Dallas]
信心评级成功地从降序排序，但团队不对应于各自的评级。实际上，同一个团队被多次复制。如何解决此问题并使我的所有团队都符合其适当的评级？ （sortArrays（）方法是进行排序操作的地方）。
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.stage.Stage;
import javafx.scene.layout.*;
import javafx.scene.control.*;
import javafx.stage.FileChooser;
import javafx.geometry.*;
import java.util.*;
import java.io.*;
public class POS extends Application
{
private ArrayList<Double> confidenceList = new ArrayList<>();
private ArrayList<String> cityList = new ArrayList<>();
private BorderPane pane = new BorderPane();
private Button runBtn = new Button("Run");
@Override
public void start(Stage stage)
{
VBox vBox = new VBox(20);
vBox.setPadding(new Insets(15));
Button selectBtn = new Button("Select File");
selectBtn.setStyle("-fx-font: 22 arial; -fx-base: #b6e7c9;");
vBox.getChildren().add(selectBtn);
selectBtn.setOnAction(e->
{
FileChooser fileChooser = new FileChooser();
fileChooser.setTitle("Open Resource File");
FileChooser.ExtensionFilter extFilter =
new FileChooser.ExtensionFilter("TEXT files (*.csv)", "*.CSV", ".xlsv", ".XLSV");
fileChooser.getExtensionFilters().add(extFilter);
File file = fileChooser.showOpenDialog(stage);
run(file);
});
RadioButton weekBtn = new RadioButton("Current Week");
RadioButton seasonBtn = new RadioButton("Entire Season");
runBtn.setStyle("-fx-font: 22 arial; -fx-base: #b6e7c9;");
weekBtn.setSelected(true);
seasonBtn.setDisable(true);
vBox.getChildren().add(weekBtn);
vBox.getChildren().add(seasonBtn);
vBox.getChildren().add(runBtn);
pane.setLeft(vBox);
Scene scene = new Scene(pane, 500, 200);
stage.setScene(scene);
stage.setTitle("POS");
stage.show();
}
public void run(File file)
{
runBtn.setOnAction(e->
{
try
{
Scanner input = new Scanner(file);
input.nextLine();
sortFile(file, input);
input.close();
}
catch (InputMismatchException ex)
{
System.out.println("Error you seem to have typed the wrong type of file");
}
catch(IOException ex)
{
System.out.println("Error, file could not be found");
}
});
}
public void sortFile(File file, Scanner input)
{
if (!input.hasNext())
{
sortArrays(confidenceList, cityList);
}
else
{
String strList = Arrays.toString(input.nextLine().split("\t"));
String[] arrList = strList.split(",");
int homeRank = Integer.parseInt(arrList[1]);
int roadRank = Integer.parseInt(arrList[6]);
Random r = new Random();
int lowestTeamRank = Math.abs(homeRank - roadRank);
double numForHomeTeam = 0;
double numForRoadTeam = 0;
if (homeRank < roadRank)
{
numForHomeTeam = ((r.nextInt(lowestTeamRank) - r.nextInt(2)) + (getLastGameOutcome(arrList[4])* r.nextInt(3))) - getWinPct(arrList[2], arrList[3]);
numForRoadTeam = ((r.nextInt(roadRank) + r.nextInt(2)) + (getLastGameOutcome(arrList[9])* r.nextInt(3))) - getWinPct(arrList[7], arrList[8]);
}
else if (homeRank > roadRank)
{
numForHomeTeam = ((r.nextInt(homeRank) - r.nextInt(2)) + (getLastGameOutcome(arrList[4])* r.nextInt(3))) - getWinPct(arrList[2], arrList[3]);
numForRoadTeam = r.nextInt(lowestTeamRank) - r.nextInt(2) + getLastGameOutcome(arrList[9])* r.nextInt(3) - getWinPct(arrList[7], arrList[8]);
}
double confidenceRate = Math.round(Math.abs(numForHomeTeam - numForRoadTeam));
confidenceList.add(confidenceRate);
if (numForHomeTeam < numForRoadTeam)
{
cityList.add(arrList[0]);
cityList.add(arrList[5]);
}
else if (numForHomeTeam > numForRoadTeam)
{
cityList.add(arrList[5]);
cityList.add(arrList[0]);
}
else
{
cityList.add(arrList[0]);
cityList.add(arrList[5]);
}
sortFile(file, input);
}
}
public int getLastGameOutcome(String lastGame)
{
if (lastGame.charAt(0) == 'W')
{
return (int)(Math.random() * 3);
}
else
{
return (int)(Math.random() * -3);
}
}
public double getWinPct(String wins, String losses)
{
double newWins = Double.parseDouble(wins);
double newLosses = Double.parseDouble(losses);
return newWins / (newWins + newLosses);
}
public void sortArrays(ArrayList<Double> doubleArray, ArrayList<String> stringArray)
{
System.out.println(doubleArray);
System.out.println(stringArray);
for (int i = 0; i < doubleArray.size(); i++)
{
for (int j = 0; j < doubleArray.size(); j++)
{
if (doubleArray.get(j).compareTo(doubleArray.get(i)) < 1)
{
double tempDouble = doubleArray.get(j);
doubleArray.set(j, doubleArray.get(i));
doubleArray.set(i, tempDouble);
String tempString = stringArray.get(j);
String tempString2 = stringArray.get(j + 1);
stringArray.set(j, stringArray.get(i));
stringArray.set(j + 1, stringArray.get(i + 1));
stringArray.set(i, tempString);
stringArray.set(i + 1, tempString2);
}
}
}
System.out.println(doubleArray);
System.out.println(stringArray);
}
}
答案 0 :(得分：3)
我没有两个独立的数据结构，而是将它们组合成一个简单Java对象的List，表示数据的基本含义。
例如，要保持置信度等级和团队：
public class TeamConfidence implements Comparable<TeamConfidence> {
private String team;
private double confidence;
public TeamConfidence(String team, double confidence) {
this.team = team;
this.confidence = confidence;
}
@Override
public int compareTo(TeamConfidence other) {
if(other == this) {
return true;
} else if (other == null ) {
return false;
} else {
return Double.compare(confidence, other.confidence);
}
}
// include getters and setters, maybe a constructor
}
由于它实现了Comparable界面，您可以使用Collections.sort调用来自信排序：
List<TeamConfidence> teams = new ArrayList<>();
// populate list
Collections.sort(teams);
// list is now ordered by confidence, and still retains the relation between
// the team name and the confidence level
以下是我们如何实施此功能的简化示例。
我们假设我们有一个最小的数据集，使用您的原始示例，将丹佛和巴尔的摩作为一些较低的异常值投入：
| Team | Confidence |
| Atlanta | 25 |
| Michigan | 25 |
| Detroit | 22 |
| NY | 22 |
| Denver | 13 |
| Baltimore | 1 |
注意我在上面的TeamConfidence类中添加了一个构造函数用于演示目的。
我们首先创建一组TeamConfidence对象。我们将在这里手动创建它们作为示例，但是您可以调整这些内容以便从文件，数据库或其他数据源进行读取。
我们还会在List的同时将对象添加到// declare a list to hold the TeamConfidence objects
List<TeamConfidence> teams = new ArrayList<>();
// populate the list
teams.add(new TeamConfidence("Detroit", 22.0));
teams.add(new TeamConfidence("Atlanta", 25.0));
teams.add(new TeamConfidence("Baltimore", 1.0));
teams.add(new TeamConfidence("Michigan", 25.0));
teams.add(new TeamConfidence("NY", 22.0));
teams.add(new TeamConfidence("Denver", 13.0));
。
sort此时，我们有一个团队列表。现在我们致电Collections.sort(teams);
：
compareTo现在我们的列表按顺序排列我们的团队。根据您在TeamConfidence中实施-1*Double.compare(confidence, other.confidence);方法的方式，这将导致较小的第一个或更大的第一个。 （要交换订单，多次加-1;例如。[(Baltimore, 1.0), (Denver, 13.0), (NY, 22.0), (Detroit, 22.0), (Atlanta, 25.0), (Michigan, 25.0)]
）
假设这个比较实现为较小的第一个，我认为它是（但我无法回想起我的头脑），我们的列表将按如下方式排序：
compareTo请注意，由于我们的public class TeamConfidence implements Comparable<TeamConfidence> {
private String winner;
private String loser;
private double confidence;
public TeamConfidence(String winner, String loser, double confidence) {
this.winner = winner;
this.loser = loser;
this.confidence = confidence;
}
@Override
public String toString() {
return "(" + confidence + ", " + winner + ", " + loser ")";
}
@Override
public int compareTo(TeamConfidence other) {
if(other == this) {
return true;
} else if (other == null ) {
return false;
} else {
return Double.compare(confidence, other.confidence);
}
}
}
方法仅考虑了置信度，因此在置信度级别内没有排序;所以纽约和底特律将会相邻，但不能保证纽约会一直在底特律之前来到这里。
根据以下评论，最好让模型如下：
| Winner | Loser | Confidence |
| Atlanta | Michigan | 25 |
| NY | Detroit | 22 |
| Denver | Baltimore | 13 |
现在，当您自信地排序时，列表中的每个元素都将指示赢家和输家。
数据：
List<TeamConfidence> teams = new ArrayList<>();
// populate the list
teams.add(new TeamConfidence("Atlanta", "Michigan", 25.0));
teams.add(new TeamConfidence("NY", "Detroit", 22.0));
teams.add(new TeamConfidence("Denver", "Baltimore", 13.0));
Collections.sort(teams);
代码：
// (confidence, winner, loser)
[(13.0, Denver, Baltimore), (22.0, NY, Detroit), (25.0, Atlanta, Michigan)]
结果：
void start();
void process();
void check();
void deposit();