Question

我目前有一张地图（如下所示）<Object, ArrayList<Object>>。这包含对象Observatory，它连接了Earthquake对象的arrayList。我的目标是找到地震属性的平均值＆＃34;幅度＆＃34;在每个ArrayList中，返回每个键（Observatory）的平均幅度。

  public static ArrayList<Observatory> obsList = new ArrayList<>();
  public static ArrayList<Earthquake> quakeList = new ArrayList<>();

  public static Map<Observatory, ArrayList<Earthquake>> eqMap = new HashMap<>();

然后我希望返回具有最高平均值的天文台的名称。

我使用以下代码填充我的ArrayList：

    public static void mapQuakeToObs(String o, Earthquake e) {

          //Earthquake object contains String "o" to define its assigned observatory

        for (Observatory obs : obsList) {

            if(obs.getObsname().equals(o)) {

                Observatory x = obs;

                if (!eqMap.containsKey(o)) { 
                    eqMap.put(x, new ArrayList<Earthquake>()); 
                }
                eqMap.get(x).add(e);

            }                                               
        }           
    }

所以我正在寻找的是一种计算分配给每个天文台钥匙的地震平均震级的方法，以最大的平均值返回天文台钥匙。

Answer 1

我不确定你的地震和天文台课程是什么样的，但我认为它们看起来像这样：

Earthquake:

    public class Earthquake {

    private final String obsname;
    private final float magnitude;

    public Earthquake(String obsname, float magnitude) {
        this.obsname = obsname;
        this.magnitude = magnitude;
    }

    public float getMagnitude() {
        return magnitude;
    }

    public String getObsname() {
        return obsname;
    }
}

天文台：

public class Observatory {

    private final String obsname;

    public Observatory(String obsname) {
        this.obsname = obsname;
    }

    public String getObsname() {
        return obsname;
    }

    @Override
    public String toString() {
        return obsname;
    }
}

创建一个方法来返回地震列表的平均幅度：

public static float findAverageMagnitude(List<Earthquake> earthquakes) {
    float total = 0.0f;
    for(Earthquake earthquake : earthquakes) {
        total += earthquake.getMagnitude();
    }
    return total / earthquakes.size();
}

修改您在问题中显示的方法，以返回包含字符串键的地图，其中每个值都是地震列表：

    public static Map<String, List<Earthquake>> mapQuakeToObs(
            List<Observatory> obsList, List<Earthquake> quakes) {

        Map<String, List<Earthquake>> obsAndQuakes =
                new HashMap<String, List<Earthquake>>();
        //Earthquake object contains String "o" to define its assigned observatory
        for(Earthquake quake : quakes) {
            for (Observatory obs : obsList) {

                if (obs.getObsname().equals(quake.getObsname())) {
                    List<Earthquake> quakesMappedToObs = null;
                    // If the map doesn't already contain the key, then put it there
                    if(!obsAndQuakes.containsKey(obs.getObsname())) {
                        quakesMappedToObs = new ArrayList<Earthquake>();
                        obsAndQuakes.put(obs.getObsname(), quakesMappedToObs);
                    } else {
                        quakesMappedToObs = obsAndQuakes.get(obs.getObsname());
                    }
                    quakesMappedToObs.add(quake);
                }
            }
        }
        return obsAndQuakes;
    }

最后，用另一种方法调用这些方法，看看哪个天文台的地震震级平均值最高：

public static Observatory findObservatoryWithHighestAverageMagnitude(
            List<Observatory> observatories, List<Earthquake> earthquakes) {

        float highestRecordedAverage = 0.0f;
        String obsnameWithHighestRecordedAverage = null;
        Map<String, List<Earthquake>> obsAndQuakes
                = mapQuakeToObs(observatories, earthquakes);
        for(String obsName: obsAndQuakes.keySet()) {
            List<Earthquake> quakesMappedToObs = obsAndQuakes.get(obsName);
            float averageMagnitude = findAverageMagnitude(quakesMappedToObs);
            if(averageMagnitude > highestRecordedAverage) {
                highestRecordedAverage = averageMagnitude;
                obsnameWithHighestRecordedAverage = obsName;
            }

        }
        for(Observatory observatory : observatories) {
            if(observatory.getObsname().equals(obsnameWithHighestRecordedAverage)) {
                return observatory;
            }
        }
        //This code won't be reached
        return null;
    }

现在，观看它的实际效果：

public static void main(String[] args) {
        Observatory observatory1 = new Observatory("Observatory One");
        Observatory observatory2 = new Observatory("Observatory Two");
        Earthquake quake1a = new Earthquake("Observatory One", 0.1f);
        Earthquake quake1b = new Earthquake("Observatory One", 7.9f);
        Earthquake quake1c = new Earthquake("Observatory One", 8.3f);
        Earthquake quake2a = new Earthquake("Observatory Two", 3.2f);
        Earthquake quake2b = new Earthquake("Observatory Two", 2.9f);
        Earthquake quake2c = new Earthquake("Observatory Two", 4.7f);
        List<Observatory> observatories = new ArrayList<Observatory>();
        observatories.add(observatory1);
        observatories.add(observatory2);
        List<Earthquake> earthquakes = new ArrayList<Earthquake>();
        earthquakes.add(quake1a);
        earthquakes.add(quake1b);
        earthquakes.add(quake1c);
        earthquakes.add(quake2a);
        earthquakes.add(quake2b);
        earthquakes.add(quake2c);
        // Prints "Observatory One"
        System.out.println(findObservatoryWithHighestAverageMagnitude(
                observatories, earthquakes));
    }

查找地图中每个键的平均对象字段

1 个答案: