list中如何判断相同值的个数？

Question

比如说一个list，里面是1,1,2,2,3,3,3,4,4
如何得到1有2个，2有2个，3有3个，4有2个？

Answer 1

我有个笨办法。
比如你已经知道list里的数就0-9之间，就建个数组，假设叫count[10]
然后,count[list里的数]++;
如果list里的数个数未知，也是这么个意思，就是麻烦点。

Answer 2

我有个笨办法。
比如你已经知道list里的数就0-9之间，就建个数组，假设叫count[10]
然后,count[list里的数]++;
如果list里的数个数未知，也是这么个意思，就是麻烦点。

Answer 3

把list遍历一下，元素保存到一个map<元素,数量>里

Answer 4

List<Integer> list = new ArrayList<Integer>();
Map<Integer,Integer> map = new HashMap<Integer,Integer>();
for(Integer i :list){
map.put(i, map.get(i)+1);
}

Answer 5

不一定用Integer,可以改为任意object
List list = new ArrayList(); // 里面是1,1,2,2,3,3,3,4,4 
Map <Integer,Object> map = new HashMap<Integer,Object>();
for(Object i : list){
  map.put(i, map.get(i)+1);
} 

Answer 6

顶？LZ要找出其中每个重复值的个数，放在Map中，然后呢？

Answer 7

不一定用Integer,可以改为任意object
List list = new ArrayList(); // 里面是1,1,2,2,3,3,3,4,4 
Map <Integer,Object> map = new HashMap<Integer,Object>();
for(Object i : list){
  map.put(i, map.get(i)+1);
} 

Answer 8

package com.java.others;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;/**
 * 计算字符串的字符出现的次数
 * @author lichaoever
 *
 */
public class getCount { List<String> list = new ArrayList<String>();
Scanner s = new Scanner(System.in);
public getCount() {
System.out.println("请输入字符:");
this.count(s.nextLine());
}
private void count(String str)
{
char[] c = str.toCharArray();
for(char s : c)
{
list.add(String.valueOf(s));
}
Collections.sort(list);

for(String s : list)
{
int begin = list.indexOf(s);
int end = list.lastIndexOf(s);

System.out.println("字母'"+ s + "'有:"+(end - begin + 1)+"个");
}
}
public static void main(String[] args) {
new getCount();
}
}

Answer 9

循环，遍历，用Map统计结果。

Answer 10

List<Object> list = new ArrayList<Object>(); 
Map <Object,Integer> map = new HashMap <Object,Integer>(); 
for(Object o :list){ 
  map.put(o, map.get(o)==null?1:map.get(o)+1); 
}

Answer 11

   import java.util.ArrayList;
import java.util.List;public class B { public static void main(String[] args) {
List<Integer> list = initData();
int x = list.size();
while(list.size()!=0){
List<Integer> arr =  list;
Integer obj = list.get(0);
List<Integer> l1 = new ArrayList<Integer>();
l1.add(obj);
arr.removeAll(l1);

System.out.println(obj+"出现"+(x-arr.size())+"次");
x = arr.size();
}
}

public static List<Integer> initData(){
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(1);
list.add(2);
list.add(2);
list.add(3);
list.add(3);
list.add(3);
list.add(4);
list.add(4);
return list;
}}
我这是把结果简单的输出，你也可以把结果存起来

Answer 12

用HashSet吧,这个里面存放的数不会有重复的或者LinkedHashSet都行

Answer 13

给 list  加个属性  个数循环的时候  判断下 是否有相同的   有的话   个数 +  1

Answer 14

这样是不行的...其实, 当这个list比较松散的时候, 比如1000000长度的list中存放的元素只有一个元素出现了两次, 你的map中比较拿到数量最多的那组又变成了一个很繁琐的问题.

Answer 15

这个方法不错, 然而indexOf的效率是多少呢???其实String中的一些操作效率都是比较低的, 可以考虑用正则.

Answer 16

list中的object出现是没规律的，不能用.lastIndexOf() - .indexOf() + 1也可能是2344223

Answer 17

可以放到Map里面
前一个对应键，后一个对应出现次数举个例子：    Map<Integer,Integer> map=new HashMap<Integer,Integer>();
    
    for(int num:arr){
      if(map.containsKey(num)){
        int count=map.get(num)+1;
        map.put(num, count);
      }
      else{
        map.put(num, 1);
      }
    }

Answer 18

遍历这个list，每拿一个出来就try catch往一个HashSet里面塞，一旦catch到异常就统计一下。

Answer 19

你也没看到   Collections.sort(list); 这个吗， 已经排序了。 怎么可能会是没有规律

Answer 20

把list中的元素放到set中去,如果某个数连续放不进去多少次,就有n+1个

Answer 21

22楼的解法完全正确，你需要判断value为null的情况。前面的都有问题。至于大数据量的话，我想还是先写进数据库，然后用sql语句的聚合函数来处理比较好。

Answer 22

循环判断List list=new ArrayList();
for(int i=0;i<list.size()-1;i++){
List list2=new ArrayList();
for(int j=list.size()-1;j>i;j--){
if(list.get(j).equals(list.get(i))){
list2.add(list.get(j));
list.remove(j);
}
}
System.out.println(list2.get(0)+"元素重复个数为：   "+(list2.size()+1)+"个");
}

Answer 23

用linq最快最简单。。想知道那个元素直接写方法。datasource.where(j=>j=1).count()

Answer 24

list不是有个直接的方法吗？循环判断啊list.contains(Object o);

Answer 25

用Map肯定方便，用Linq肯定简单，11楼的方法对，51楼思路好。

Answer 26

   import java.util.ArrayList;
import java.util.List;public class B {    public static void main(String[] args) {
        List<Integer> list = initData();
        int x = list.size();
        while(list.size()!=0){
            List<Integer> arr =  list;
            Integer obj = list.get(0);
            List<Integer> l1 = new ArrayList<Integer>();
            l1.add(obj);
            arr.removeAll(l1);
            
            System.out.println(obj+"出现"+(x-arr.size())+"次");
            x = arr.size();
        }
    }
    
    public static List<Integer> initData(){
        List<Integer> list = new ArrayList<Integer>();
        list.add(1);
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        list.add(3);
        list.add(3);
        list.add(4);
        list.add(4);
        return list;
    }}
O(∩_∩)O哈哈~

Answer 27

List <Integer> list = new ArrayList <Integer>(); 
Map <Integer,Integer> map = new HashMap <Integer,Integer>(); 
for(Integer i :list){ 
map.put(i, map.get(i)+1); 
}

Answer 28

package com.java.others;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;/**
 * 计算字符串的字符出现的次数
 * @author lichaoever
 *
 */
public class getCount {    List<String> list = new ArrayList<String>();
    Scanner s = new Scanner(System.in);
    public getCount() {
        System.out.println("请输入字符:");
        this.count(s.nextLine());
    }
    private void count(String str)
    {
        char[] c = str.toCharArray();
        for(char s : c)
        {
            list.add(String.valueOf(s));
        }
        Collections.sort(list);
        
        for(String s : list)
        {
            int begin = list.indexOf(s);
            int end = list.lastIndexOf(s);
            
            System.out.println("字母'"+ s + "'有:"+(end - begin + 1)+"个");
        }
    }
    public static void main(String[] args) {
        new getCount();
    }
}

Answer 29

顶 22楼 map.get(i)要判断是否为空！

Answer 30

22楼的好。
测试了下。import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class CountValue {
public static void main(String[] args) {
List<Object> list = new ArrayList<Object>(); 
list.add(2);
list.add(3);
list.add(4);
list.add(2);
list.add(3);
list.add(3);
Map <Object,Integer> map = new HashMap <Object,Integer>(); 
for(Object o :list){ 
  map.put(o, map.get(o)==null?1:map.get(o)+1); 
}
for(Object i:map.keySet()){
System.out.println(i+"----->"+map.get(i));
}
}
}

Answer 31

用字符串替换然后加到字典中 然后遍历字典输出  static Dictionary <string, int> dic = new Dictionary <string,int >(); 
  string s ="dsadadsadsadfkashjfsafkakflaskjfl";   int len = s.Length; 
    while(len  > 0) 
    { 
         string temp = s[0].ToString(); 
                
          s = s.Replace(s[0].ToString(),"");           dic.Add( temp,len - s.Length); 
          len = s.Length; 
     } 
foreach (KeyValuePair <string , int> pair in dic) 
   { 
        Console.WriteLine(pair.key+"  "+pari.value);        
     }                
           

Answer 32

 Collections.sort(list);排序是速度最慢的，所以这个方法看上去很好，其实是最烂的方法！
用Map实现计数是最快，也是最有效的方式。

Answer 33

可以试一下：
1、当list.size>0时，每次都取obj = list.get(0)；
2、list.removeAll(Collection<obj>);
3、把remove之前的size与之后的size相减，得到obj出现的次数。没有测试过这样效率如何，感兴趣的可以试一下！

Answer 34

好像之前在哪看过，只不过以前是字符串。我把原来的程序修改了下。能够打出全部字符的次数。import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;public class FindMaxTimes {    public static void main( String[] args ) {
        System.out.println( search( list().toArray() ).toString() );
    }    public static Map<Object, Integer> search( Object[] strs ) {
        Map<Object, Integer> results = new HashMap<Object, Integer>();
        for ( Object str : strs ) {
            if ( !results.containsKey( str ) ) {
                results.put( str, 1 );
            } else {
                results.put( str, results.get( str ) + 1 );
            }
        }
        int maxTimes = 0;
        for ( Map.Entry<Object, Integer> entry : results.entrySet() ) {
            if ( entry.getValue() >= maxTimes ) {
                maxTimes = entry.getValue();
            } else {
                results.put( entry.getKey(), 0 );
            }
        }
        return results;
    }    public static List<Integer> list() {
        List<Integer> list = new ArrayList<Integer>();
        list.add( 5 );
        list.add( 5 );
        list.add( 8 );
        list.add( 5 );
        return list;
    }
}输入结果：{8=1, 5=3}

Answer 35

List list = new ArrayList();
int[] arr = list.toArray
public static int[] countsArr(int[] arr){
int[] counts = new int[10];
for(int i=0;i<arr.length;i++){
counts[arr[i] - 0]++;
}
return counts;
}我大致写了一个方法不知道可行不~~~~~~

Answer 36

路过, 
这个最少遍历一遍
最差比较次数为o(n^2)
空间使用量最大为list中元素个数. 
支持的顶下, 不同见解, 请分析, 谢谢

Answer 37

            List<int> list = new List<int>() { 1, 3, 3, 2, 1, 1, 3, 2, 1, 3, 2 };
            string listToString = "", result = "";
            foreach (var item in list)
            {
                listToString += item;
            }            while (listToString.Length > 0)
            {
                string target = listToString[0].ToString();
                int i = listToString.Length;
                listToString = listToString.Replace(target,"");
                result += target + ":有" + (i - listToString.Length) + "个。\r\n";
            }
            MessageBox.Show(result);

Answer 38

我来给LZ一个简单的办法，下面是示例代码import java.util.ArrayList;
import java.util.List;import org.apache.commons.collections.Bag;
import org.apache.commons.collections.bag.TreeBag;/**
 * @author houyinming
 * 
 */
public class ApplicationRunner
{ /**
 * @param args
 */
public static void main( String[] args )
{
List < Integer > list = new ArrayList < Integer >();
Bag bag = new TreeBag( list );
Object[] values = bag.uniqueSet().toArray();
for( int i = 0 , count = values.length ; i < count ; i++ )
{
System.out.println( values[i] + "在List中存在" + bag.getCount( values[i] ) + "个" );
}
}
}

Answer 39

不用循环真想不出来怎么弄 看看api去

Answer 40

最简单的办法就是用org.apache.commons.collections.Bag，示例代码在92楼。

Answer 41

import java.util.*; 
public class Test2{
public static void main(String [] args) {
List<Integer> myList=Arrays.asList(1,1,2,2,3,3,3,4,4);
HashSet<Integer> hs=new HashSet<Integer>(myList);
for(Integer i:hs){
System.out.println(i+" 在List中存在" + Collections.frequency(myList,i) + "个");
} 
} 
}
和92楼的比比.