Question

我有一个类似下面的数组

String[] football_club = {"Barcelona", "Real Madrid", "Chelsea", "Real Madrid", "Barcelona", "Barcelona"};

//result
Sting result_club = "a value most in the array"

从上面的数组中，“Barcelona”，其值通常存在于数组中。
如何编码以找到数组中最常出现的值？

Answer 1

您可以制作HashMap<String,Integer>。如果字符串已经出现在地图中，请将其键增加1，否则，将其添加到地图中。

例如：

put("Barcelona", 1);

然后，再次假设它是“巴塞罗那”，你可以这样做：

put("Barcelona", get("Barcelona") + 1);

由于“Barcelona”的键为1，现在当你把它放入时，键将为2。

Answer 2

import java.util.HashMap;

/**
 * Created with IntelliJ IDEA.
 * User: Alexander.Iljushkin
 * Date: 23.10.13
 * Time: 11:32
 */
public class TestClass1 {


    public static void main(String[] args) {
        String[] football_club = {"Barcelona", "Real Madrid", "Chelsea", "Real Madrid", "Barcelona", "Barcelona"};
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        String tempStr;
        for (int i = 0; i < football_club.length; i++)
        {
            tempStr = football_club[i];
            if(map.containsKey(tempStr))
            {
                map.put(tempStr, map.get(tempStr) + 1);
            }
            else
            {
                map.put(tempStr,1);
            }
        }

        System.out.print(map.toString());
    }
}

稍后您可以使用Comparator按amount对地图中的项目进行排序，如下所示（这只是一个示例，以自我教育的方式进行更改：

public class Testing {

    public static void main(String[] args) {

        HashMap<String,Double> map = new HashMap<String,Double>();
        ValueComparator bvc =  new ValueComparator(map);
        TreeMap<String,Double> sorted_map = new TreeMap<String,Double>(bvc);

        map.put("A",99.5);
        map.put("B",67.4);
        map.put("C",67.4);
        map.put("D",67.3);

        System.out.println("unsorted map: "+map);

        sorted_map.putAll(map);

        System.out.println("results: "+sorted_map);
    }
}

class ValueComparator implements Comparator<String> {

    Map<String, Double> base;
    public ValueComparator(Map<String, Double> base) {
        this.base = base;
    }

    // Note: this comparator imposes orderings that are inconsistent with equals.    
    public int compare(String a, String b) {
        if (base.get(a) >= base.get(b)) {
            return -1;
        } else {
            return 1;
        } // returning 0 would merge keys
    }
}

然后当您对hashmap进行排序时，只需获取第一个键，这将是最常用的键

Answer 3

另一种方法：对数组进行排序，然后对其进行迭代以计算连续的公共元素，并跟踪最大计数/相应元素。
排序可能很重（相对），但我认为hashmap访问具有相同的复杂程度（O（n.log（n））。

Answer 4

如果表现无关紧要：

        String[] football_club = {"Barcelona", "Real Madrid", "Chelsea", "Real Madrid", "Barcelona", "Barcelona"};              
        List<String> l = Arrays.asList(football_club);
        Set<String> s = new HashSet<String>(l);
        for (String key : s) {
            int count = Collections.frequency(l, key);
            System.out.println("Found '" + key + "' " + count + " times.");
        }

Answer 5

这很有效，max是用于存储最大计数的新变量，如果两个元素具有相同的频率String [] football_club = {＆＃34; Chelsea＆＃34;，＆＃34; Chelsea＆＃34;，＆＃ 34;皇家马德里＆＃34;，＆＃34;皇家马德里＆＃34;，＆＃34;皇家马德里＆＃34;，＆＃34;巴塞罗那＆＃34; ＆＃34;切尔西＆＃34;};

此回归：切尔西

private String getRepeatedString(String[] football_club) {
    List<String> List1 = Arrays.asList(football_club);
    HashMap<String, Integer> data = new HashMap<String, Integer>();
    int max = 0;
    for (String string : List1) {
        int count = 1;
        if (data.containsKey(string)) {
            count = data.get(string) + 1;
            data.put(string, count);
        } else {
            data.put(string, 1);
        }
        if (max < count)
            max =count;
    }
    System.out.println(data);
    for (Entry<String, Integer> entry : data.entrySet()) {
        if (max == entry.getValue()) {
            return entry.getKey();
        }
    }
    return null;
}

Answer 6

您可以定义一个封装HashMap对象的新类。

然后你可以定义你自己的put和get方法。

从数组中获取最常见的值

6 个答案: