Fatal编程技术网
  • java/
  • 数组中每个项的Java计数出现次数

数组中每个项的Java计数出现次数

java arrays java-8

数组中每个项的Java计数出现次数,java,arrays,count,java-8,Java,Arrays,Count,Java 8,是否有任何方法可以计算数组中每个项目的出现次数 假设我有： String[] array = {"name1","name2","name3","name4", "name5"}; 这里的输出将是： name1 1 name2 1 name3 1 name4 1 name5 1 如果我有： String[] array = {"name1","name1","name2","name2", "name2"}; 产出将是： name1 2 name2 3 这里的输出只是为了演示预期结果。您

是否有任何方法可以计算数组中每个项目的出现次数

假设我有：

String[] array = {"name1","name2","name3","name4", "name5"};
这里的输出将是：

name1 1
name2 1
name3 1
name4 1
name5 1
如果我有：

String[] array = {"name1","name1","name2","name2", "name2"};
产出将是：

name1 2
name2 3
这里的输出只是为了演示预期结果。

您可以使用来自Google Collections/Guava的或来自Apache Commons的

如果使用集合而不是数组，则可以使用
addAll（）
将整个内容添加到上述数据结构中，然后对每个值应用
count（）
方法。
SortedMultiSet
或
SortedBag
将按照定义的顺序为您提供项目

Google Collections实际上有非常方便的方法，可以从数组转换为SortedMultiset，我会使用一个哈希表，其中in键取数组的元素（这里是字符串），in值为整数

然后浏览列表，做如下操作：

for(String s:array){
if(hash.containsKey(s)){
  Integer i = hash.get(s);
  i++;
}else{
  hash.put(s, new Interger(1));
}
您可以使用HashMap，其中键是字符串和值计数。

我为此编写了一个解决方案以供自己练习。这看起来不像其他的答案贴出来的那么棒，但我还是要贴出来，然后再学习如何使用其他方法来做这件事。享受：

public static Integer[] countItems(String[] arr)
{
    List<Integer> itemCount = new ArrayList<Integer>();
    Integer counter = 0;
    String lastItem = arr[0];

    for(int i = 0; i < arr.length; i++)
    {
        if(arr[i].equals(lastItem))
        {
            counter++;
        }
        else
        {
            itemCount.add(counter);
            counter = 1;
        }
        lastItem = arr[i];
    }
    itemCount.add(counter);

    return itemCount.toArray(new Integer[itemCount.size()]);
}

public static void main(String[] args)
{
    String[] array = {"name1","name1","name2","name2", "name2", "name3",
            "name1","name1","name2","name2", "name2", "name3"};
    Arrays.sort(array);
    Integer[] cArr = countItems(array);
    int num = 0;
    for(int i = 0; i < cArr.length; i++)
    {
        num += cArr[i]-1;
        System.out.println(array[num] + ": " + cArr[i].toString());
    }
}

公共静态整数[]countItems（字符串[]arr）
{
List itemCount=new ArrayList（）；
整数计数器=0；
字符串lastItem=arr[0]；
对于（int i=0；i
您可以使用以下示例中给出的哈希映射：

import java.util.HashMap;
import java.util.Set;

/**
 * 
 * @author Abdul Rab Khan
 * 
 */
public class CounterExample {
    public static void main(String[] args) {
        String[] array = { "name1", "name1", "name2", "name2", "name2" };
        countStringOccurences(array);
    }

    /**
     * This method process the string array to find the number of occurrences of
     * each string element
     * 
     * @param strArray
     *            array containing string elements
     */
    private static void countStringOccurences(String[] strArray) {
        HashMap<String, Integer> countMap = new HashMap<String, Integer>();
        for (String string : strArray) {
            if (!countMap.containsKey(string)) {
                countMap.put(string, 1);
            } else {
                Integer count = countMap.get(string);
                count = count + 1;
                countMap.put(string, count);
            }
        }
        printCount(countMap);
    }

    /**
     * This method will print the occurrence of each element
     * 
     * @param countMap
     *            map containg string as a key, and its count as the value
     */
    private static void printCount(HashMap<String, Integer> countMap) {
        Set<String> keySet = countMap.keySet();
        for (String string : keySet) {
            System.out.println(string + " : " + countMap.get(string));
        }
    }
}

import java.util.HashMap；
导入java.util.Set；
/**
* 
*@作者阿卜杜勒·拉布·汗
* 
*/
公共类反例{
公共静态void main（字符串[]args）{
字符串[]数组={“name1”、“name1”、“name2”、“name2”、“name2”}；
countstringaccurrences（数组）；
}
/**
*此方法处理字符串数组以查找
*每个字符串元素
* 
*@param strArray
*包含字符串元素的数组
*/
私有静态void countStringOccurrences（字符串[]strArray）{
HashMap countMap=新HashMap（）；
用于（字符串：strArray）{
如果（！countMap.containsKey（字符串））{
countMap.put（字符串，1）；
}否则{
整数计数=countMap.get（字符串）；
计数=计数+1；
countMap.put（字符串，计数）；
}
}
打印计数（countMap）；
}
/**
*此方法将打印每个元素的引用
* 
*@param countMap
*映射包含字符串作为键，其计数作为值
*/
私有静态void打印计数（HashMap countMap）{
Set keySet=countMap.keySet（）；
for（字符串：键集）{
System.out.println（字符串+”：“+countMap.get（字符串））；
}
}
}
这是我的解决方案- 该方法将整数数组（假设范围在0到100之间）作为输入，并返回每个元素的出现次数

假设输入是
[21,34,43,21,21,21,45,65,65,76,76,76]
。 因此，输出将在映射中，它是：
{34=1，21=4，65=2，76=3，43=1，45=1}



public Map<Integer, Integer> countOccurrence(int[] numbersToProcess) {
    int[] possibleNumbers = new int[100];
    Map<Integer, Integer> result = new HashMap<Integer, Integer>();

    for (int i = 0; i < numbersToProcess.length; ++i) {
      possibleNumbers[numbersToProcess[i]] = possibleNumbers[numbersToProcess[i]] + 1;
      result.put(numbersToProcess[i], possibleNumbers[numbersToProcess[i]]);
    }

    return result;
}



public Map countOccurrence（int[]numbersToProcess）{
int[]可能枚举数=新int[100]；
映射结果=新的HashMap（）；
for（int i=0；i



列表asList=array.asList（array）；

List asList = Arrays.asList(array);
Set<String> mySet = new HashSet<String>(asList);

for(String s: mySet){
 System.out.println(s + " " + Collections.frequency(asList,s));
}


Set mySet=newhashset（asList）；
for（字符串s:mySet）{
System.out.println（s+“”+Collections.frequency（asList，s））；
}
有几种方法可以提供帮助，但这是for循环使用的方法之一

import java.util.Arrays;

public class one_dimensional_for {

private static void count(int[] arr) {

    Arrays.sort(arr);

    int sum = 0, counter = 0;

    for (int i = 0; i < arr.length; i++) {
        if (arr[0] == arr[arr.length - 1]) {
            System.out.println(arr[0] + ": " + counter + " times");
            break;
        } else {
            if (i == (arr.length - 1)) {
                sum += arr[arr.length - 1];
                counter++;
                System.out.println((sum / counter) + " : " + counter
                        + " times");
                break;
            } else {
                if (arr[i] == arr[i + 1]) {
                    sum += arr[i];
                    counter++;
                } else if (arr[i] != arr[i + 1]) {
                    sum += arr[i];
                    counter++;
                    System.out.println((sum / counter) + " : " + counter
                            + " times");
                    sum = 0;
                    counter = 0;
                }
            }
        }
    }
}

public static void main(String[] args) {
    int nums[] = { 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 5, 5, 5, 6 };
    count(nums);
}

}

导入java.util.array；
公共类一维{
专用静态无效计数（int[]arr）{
数组。排序（arr）；
整数和=0，计数器=0；
对于（int i=0；i
使用，您可以这样做：

String[] array = {"name1","name2","name3","name4", "name5", "name2"};
Arrays.stream(array)
      .collect(Collectors.groupingBy(s -> s))
      .forEach((k, v) -> System.out.println(k+" "+v.size()));
输出：

name5 1
name4 1
name3 1
name2 2
name1 1
它所做的是：

  • 从原始数组创建
    流
  • 按标识、结果和 
    Map<String, Long> map = Arrays.stream(array)
    .collect(Collectors.groupingBy(s -> s, Collectors.counting()));

    import java.util.Arrays;

public class ArrayTest {
public static int mainCount=0;

public static void main(String[] args) {
    String prevItem = "";
    String[] array = {"name1","name1","name2","name2", "name2"};
    Arrays.sort(array);

    for(String item:array){
        if(! prevItem.equals(item)){
            mainCount = 0;
            countArray(array, 0, item);
            prevItem = item;
        }
    }
}

private static void countArray(String[] arr, int currentPos, String item) {
    if(currentPos == arr.length){
        System.out.println(item + " " +  mainCount);
        return;
    }
    else{
        if(arr[currentPos].toString().equals(item)){
            mainCount += 1;
        }
        countArray(arr, currentPos+1, item);
    }
  }
}

    import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

public class MultiString {

    public HashMap<String, Integer> countIntem( String[] array ) {

        Arrays.sort(array);
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        Integer count = 0;
        String first = array[0];
        for( int counter = 0; counter < array.length; counter++ ) {
            if(first.hashCode() == array[counter].hashCode()) {
                count = count + 1;
            } else {
                map.put(first, count);
                count = 1;
            }
            first = array[counter];
            map.put(first, count);
        }

        return map;
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] array = { "name1", "name1", "name2", "name2", "name2",
                "name3", "name1", "name1", "name2", "name2", "name2", "name3" };

        HashMap<String, Integer> countMap = new MultiString().countIntem(array);
        System.out.println(countMap);
    }
}



Gives you O(n) complexity.

    def occurance(arr):
  results = []
  for n in arr:
      data = {}
      data["point"] = n
      data["count"] = 0
      for i in range(0, len(arr)):
          if n == arr[i]:
              data["count"] += 1
      results.append(data)
  return results

    public class HashMapExample {
    public static void main(String[] args) {
        stringArray();          
    }
public static void stringArray()
{
    String[] a = {"name1","name2","name3","name4", "name5"};

    Map<String, String> hm = new HashMap<String, String>();
    for(int i=0;i<a.length;i++)
    {
    String bl=(String)hm.get(a[i]);
    if(bl==null)
    {
        hm.put(a[i],String.valueOf(1));
    }else
    {
        String k=hm.get(a[i]);
        int j=Integer.valueOf(k);
        hm.put(a[i],String.valueOf(j+1));
    }

    }
    //hm.entrySet();
    System.out.println("map elements are "+hm.toString());
}

}

    public class Count {
    static String names[] = {"name1","name1","name2","name2", "name2"};
    public static void main(String args[]) {

        printCount(names);

    }

    public static void printCount(String[] names){

        java.util.Arrays.sort(names);
        int n = names.length, c;
        for(int i=0;i<n;i++){
            System.out.print(names[i]+" ");
        }
        System.out.println();
        int result[] = new int[n];
        for(int i=0;i<n;i++){
            result[i] = 0;
        }

        for(int i =0;i<n;i++){
            if (i != n-1){
                for(int j=0;j<n;j++){
                    if(names[i] == names[j] )
                        result[i]++;
                }
            }
            else if (names[n-2] == names[n-1]){
            result[i] = result[i-1];
         }

         else result[i] = 1;
        }
        int max = 0,index = 0;
        for(int i=0;i<n;i++){
         System.out.print(result[i]+"     ");
            if (result[i] >= max){
                max = result[i];
                index = i;
            }

        }
    }
}

    main(){
    String[] array ={"a","ab","a","abc","abc","a","ab","ab","a"};
    Map<String,Integer> hm = new HashMap();

    for(String x:array){

        if(!hm.containsKey(x)){
            hm.put(x,1);
        }else{
            hm.put(x, hm.get(x)+1);
        }
    }
    System.out.println(hm);
}

    String[] array = {"name1","name1","name2","name2", "name2"};
List<String> sampleList=(List<String>) Arrays.asList(array);
for(String inpt:array){
int frequency=Collections.frequency(sampleList,inpt);
System.out.println(inpt+" "+frequency);
}

    import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class StringOccurence {

public static void main(String args[]) {

    String[] stringArray = { "name1", "name1", "name2", "name2", "name2" };
    countStringOccurence(stringArray);
    countStringOccurenceUsingStream(stringArray);
    countStringOccurenceUsingCollections(stringArray);
}

private static void countStringOccurenceUsingCollections(String[] stringArray) {
    // TODO Auto-generated method stub
    List<String> asList = Arrays.asList(stringArray);
    Set<String> set = new HashSet<String>(asList);
    for (String string : set) {
        System.out.println(string + "   -->   " + Collections.frequency(asList, string));
    }

}

private static void countStringOccurenceUsingStream(String[] stringArray) {
    // TODO Auto-generated method stub
    Arrays.stream(stringArray).collect(Collectors.groupingBy(s -> s))
            .forEach((k, v) -> System.out.println(k + "   -->   " + v.size()));
}

private static void countStringOccurence(String[] stringArray) {
    // TODO Auto-generated method stub
    Map<String, Integer> map = new HashMap<String, Integer>();
    for (String s : stringArray) {
        if (map.containsKey(s)) {
            map.put(s, map.get(s) + 1);
        } else {
            map.put(s, 1);
        }
    }

    for (Map.Entry<String, Integer> entry : map.entrySet()) {
        System.out.println(entry.getKey() + "   -->   " + entry.getValue());
    }

}

    public class Main
{
    public static void main(String[] args) {
        
        String[] a ={"name1","name1","name2","name2", "name2"};
        for (int i=0;i<a.length ;i++ )
        {
            int count =0;
            int count1=0;
            for(int j=0;j<a.length;j++)
            {
                if(a[i]==a[j])
                {
                    count++;
                    
                }
            }
            for(int j=i-1;j>=0 ;j--)
            {
                if(a[i]==a[j])
                {
                    count1++;
                }
            }
            if(count1 ==0)
            {
                System.out.println(a[i]+" occurs :"+count);
            }
        }
    }
}