4

我有一个像下面这样的数组

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

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

从上面的数组中，“巴塞罗那”具有一个经常存在于数组中的值。
如何编码以查找数组中出现频率最高的值？

4

6 回答 6

7

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

例如：

put("Barcelona", 1);

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

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

由于“巴塞罗那”的键是 1，所以现在你放它的时候，键就是 2。

于 2013-10-23T07:30:31.690 回答
3 
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
    }
}

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

于 2013-10-23T07:39:29.487 回答
2

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

于 2013-10-23T08:04:16.820 回答
1

如果性能无关紧要：

        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.");
        }
于 2013-10-23T09:30:13.587 回答
1

这非常有效，max 是用于存储找到的最大计数的新变量，如果两个元素具有相同的频率 String[] football_club = {"Chelsea","Chelsea", "Real Madrid", "Real Madrid", "Real Madrid", "巴塞罗那" ,"切尔西"};

这回归：切尔西

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;
}
于 2015-02-05T20:00:09.350 回答
0

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

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

于 2013-10-23T07:53:37.153 回答