List에서 요소의 발생 횟수를 계산하는 방법

나는이 ArrayList다음과 같이 자바의 컬렉션 클래스를 :

ArrayList<String> animals = new ArrayList<String>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");

보다시피, animals ArrayList3 개의 bat요소와 하나의 owl요소로 구성됩니다. Collection 프레임 워크에 bat발생 횟수를 반환하는 API가 있는지 또는 발생 횟수를 결정하는 다른 방법 이 있는지 궁금합니다 .

Google의 Collection Multiset에는 요소의 총 발생 횟수를 반환하는 API가 있습니다. 그러나 이는 JDK 1.5 와만 호환됩니다. 당사 제품은 현재 JDK 1.6에 있으므로 사용할 수 없습니다.

Collections의 정적 주파수 방법이 여기에 유용 할 것이라고 확신합니다.

int occurrences = Collections.frequency(animals, "bat");

어쨌든 내가 그렇게하는 방법입니다. 나는 이것이 jdk 1.6이라고 확신합니다.

자바 8 :

Map<String, Long> counts =
    list.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));

이는 효과적인 Java 서적에 설명 된대로 " 인터페이스로 오브젝트 참조 "가 중요한 이유를 보여줍니다 .

구현에 코드를 작성하고 ArrayList를 사용하여 코드의 50 개 장소를 가정 해 봅시다. 항목을 세는 훌륭한 "List"구현을 발견하면 해당 50 개 장소를 모두 변경해야 할 것입니다. 코드를 깰 수 있습니다 (만 사용하면 큰 문제는 없지만 다른 사람이 사용하면 코드도 손상됩니다)

인터페이스에 프로그래밍하면 50 개 위치를 변경하지 않고 ArrayList에서 "CountItemsList"(예 :) 또는 다른 클래스로 구현을 대체 할 수 있습니다.

아래는 이것이 어떻게 작성 될 수 있는지에 대한 매우 기본적인 샘플입니다. 이것은 샘플 일뿐입니다. 프로덕션 준비 목록은 훨씬 더 복잡합니다.

import java.util.*;

public class CountItemsList<E> extends ArrayList<E> { 

    // This is private. It is not visible from outside.
    private Map<E,Integer> count = new HashMap<E,Integer>();

    // There are several entry points to this class
    // this is just to show one of them.
    public boolean add( E element  ) { 
        if( !count.containsKey( element ) ){
            count.put( element, 1 );
        } else { 
            count.put( element, count.get( element ) + 1 );
        }
        return super.add( element );
    }

    // This method belongs to CountItemList interface ( or class ) 
    // to used you have to cast.
    public int getCount( E element ) { 
        if( ! count.containsKey( element ) ) {
            return 0;
        }
        return count.get( element );
    }

    public static void main( String [] args ) { 
        List<String> animals = new CountItemsList<String>();
        animals.add("bat");
        animals.add("owl");
        animals.add("bat");
        animals.add("bat");

        System.out.println( (( CountItemsList<String> )animals).getCount( "bat" ));
    }
}

여기에 적용되는 OO 원칙 : 상속, 다형성, 추상화, 캡슐화.

그것을 할 수있는 간단한 메소드 호출이 없습니다. 그래도지도를 만들고 빈도를 세면됩니다.

HashMap<String,int> frequencymap = new HashMap<String,int>();
foreach(String a in animals) {
  if(frequencymap.containsKey(a)) {
    frequencymap.put(a, frequencymap.get(a)+1);
  }
  else{ frequencymap.put(a, 1); }
}

Java에는이를위한 기본 메소드가 없습니다. 그러나 Apache Commons-Collections의 IterableUtils # countMatches () 를 사용 하여 대신 할 수 있습니다.

실제로 Collections 클래스에는 다음과 같은 정적 메소드가 있습니다 : frequency (Collection c, Object o) 검색하려는 요소의 발생 횟수를 반환합니다. 그런데 이것은 완벽하게 작동합니다.

ArrayList<String> animals = new ArrayList<String>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");
System.out.println("Freq of bat: "+Collections.frequency(animals, "bat"));

스트림 을 사용하는 대체 Java 8 솔루션 :

long count = animals.stream().filter(animal -> "bat".equals(animal)).count();

JDK 1.6에서 Google의 Collection API를 사용할 수없는 이유가 궁금합니다. 그렇게 말합니까? 나는 당신이 할 수 있다고 생각합니다. 낮은 버전을 위해 만들어 졌기 때문에 호환성 문제가 없어야합니다. 1.6으로 빌드되었고 1.5를 실행중인 경우 케이스가 달라졌을 것입니다.

내가 어딘가에 잘못인가?

조금 더 효율적인 접근 방식은

Map<String, AtomicInteger> instances = new HashMap<String, AtomicInteger>();

void add(String name) {
     AtomicInteger value = instances.get(name);
     if (value == null) 
        instances.put(name, new AtomicInteger(1));
     else
        value.incrementAndGet();
}

목록에서 객체의 발생을 직접 얻으려면 :

int noOfOccurs = Collections.frequency(animals, "bat");

Object collection inside list를 얻으려면 Object 클래스의 equals 메소드를 다음과 같이 재정의하십시오.

@Override
public boolean equals(Object o){
    Animals e;
    if(!(o instanceof Animals)){
        return false;
    }else{
        e=(Animals)o;
        if(this.type==e.type()){
            return true;
        }
    }
    return false;
}

Animals(int type){
    this.type = type;
}

Collections.frequency를 다음과 같이 호출하십시오.

int noOfOccurs = Collections.frequency(animals, new Animals(1));

Java 8 기능을 사용하여 배열에서 문자열 값의 발생을 찾는 간단한 방법.

public void checkDuplicateOccurance() {
        List<String> duplicateList = new ArrayList<String>();
        duplicateList.add("Cat");
        duplicateList.add("Dog");
        duplicateList.add("Cat");
        duplicateList.add("cow");
        duplicateList.add("Cow");
        duplicateList.add("Goat");          
        Map<String, Long> couterMap = duplicateList.stream().collect(Collectors.groupingBy(e -> e.toString(),Collectors.counting()));
        System.out.println(couterMap);
    }

출력 : {Cat = 2, Goat = 1, Cow = 1, cow = 1, Dog = 1}

"Cow"와 cow는 같은 문자열로 간주되지 않습니다. 같은 개수로 필요한 경우 .toLowerCase ()를 사용하십시오. 아래의 스 니펫을 찾으십시오.

Map<String, Long> couterMap = duplicateList.stream().collect(Collectors.groupingBy(e -> e.toString().toLowerCase(),Collectors.counting()));

출력 : {cat = 2, cow = 2, goat = 1, dog = 1}

당신이 원하는 것은 가방과 같습니다-이것은 세트와 같지만 발생 횟수를 계산합니다. 불행히도 Java Collections 프레임 워크-Bag impl이 없기 때문에 훌륭합니다. 이를 위해서는 Apache Common Collection 링크 텍스트를 사용해야합니다

List<String> list = Arrays.asList("as", "asda", "asd", "urff", "dfkjds", "hfad", "asd", "qadasd", "as", "asda",
        "asd", "urff", "dfkjds", "hfad", "asd", "qadasd" + "as", "asda", "asd", "urff", "dfkjds", "hfad", "asd",
        "qadasd", "as", "asda", "asd", "urff", "dfkjds", "hfad", "asd", "qadasd");

방법 1 :

Set<String> set = new LinkedHashSet<>();
set.addAll(list);

for (String s : set) {

    System.out.println(s + " : " + Collections.frequency(list, s));
}

방법 2 :

int count = 1;
Map<String, Integer> map = new HashMap<>();
Set<String> set1 = new LinkedHashSet<>();
for (String s : list) {
    if (!set1.add(s)) {
        count = map.get(s) + 1;
    }
    map.put(s, count);
    count = 1;

}
System.out.println(map);

Eclipse Collections 를 사용하는 경우을 사용할 수 있습니다 Bag. 의 MutableBag모든 구현에서 RichIterable를 호출하여 호출 할 수 있습니다 toBag().

MutableList<String> animals = Lists.mutable.with("bat", "owl", "bat", "bat");
MutableBag<String> bag = animals.toBag();
Assert.assertEquals(3, bag.occurrencesOf("bat"));
Assert.assertEquals(1, bag.occurrencesOf("owl"));

HashBagEclipse Collections 의 구현은로 지원됩니다 MutableObjectIntMap.

참고 : 저는 Eclipse Collections의 커미터입니다.

arraylist의 요소를 hashMap에 넣어 빈도를 계산하십시오.

Java 8- 다른 방법

String searched = "bat";
long n = IntStream.range(0, animals.size())
            .filter(i -> searched.equals(animals.get(i)))
            .count();

그래서 구식으로하고 자신을 굴리십시오.

Map<String, Integer> instances = new HashMap<String, Integer>();

void add(String name) {
     Integer value = instances.get(name);
     if (value == null) {
        value = new Integer(0);
        instances.put(name, value);
     }
     instances.put(name, value++);
}

내 ForEach DSL 사용자 인 경우 Count쿼리를 사용하여 수행 할 수 있습니다 .

Count<String> query = Count.from(list);
for (Count<Foo> each: query) each.yield = "bat".equals(each.element);
int number = query.result();

이 사례를 더 어렵게 만들고 싶지 않고 LastName-> FirstName이있는 HashMap이있는 두 개의 반복자로 만들었습니다. 그리고 내 방법은 중복 된 FirstName이있는 항목을 삭제해야합니다.

public static void removeTheFirstNameDuplicates(HashMap<String, String> map)
{

    Iterator<Map.Entry<String, String>> iter = map.entrySet().iterator();
    Iterator<Map.Entry<String, String>> iter2 = map.entrySet().iterator();
    while(iter.hasNext())
    {
        Map.Entry<String, String> pair = iter.next();
        String name = pair.getValue();
        int i = 0;

        while(iter2.hasNext())
        {

            Map.Entry<String, String> nextPair = iter2.next();
            if (nextPair.getValue().equals(name))
                i++;
        }

        if (i > 1)
            iter.remove();

    }

}

List<String> lst = new ArrayList<String>();

lst.add("Ram");
lst.add("Ram");
lst.add("Shiv");
lst.add("Boss");

Map<String, Integer> mp = new HashMap<String, Integer>();

for (String string : lst) {

    if(mp.keySet().contains(string))
    {
        mp.put(string, mp.get(string)+1);

    }else
    {
        mp.put(string, 1);
    }
}

System.out.println("=mp="+mp);

산출:

=mp= {Ram=2, Boss=1, Shiv=1}

Map<String,Integer> hm = new HashMap<String, Integer>();
for(String i : animals) {
    Integer j = hm.get(i);
    hm.put(i,(j==null ? 1 : j+1));
}
for(Map.Entry<String, Integer> val : hm.entrySet()) {
    System.out.println(val.getKey()+" occurs : "+val.getValue()+" times");
}

package traversal;

import java.util.ArrayList;
import java.util.List;

public class Occurrance {
    static int count;

    public static void main(String[] args) {
        List<String> ls = new ArrayList<String>();
        ls.add("aa");
        ls.add("aa");
        ls.add("bb");
        ls.add("cc");
        ls.add("dd");
        ls.add("ee");
        ls.add("ee");
        ls.add("aa");
        ls.add("aa");

        for (int i = 0; i < ls.size(); i++) {
            if (ls.get(i) == "aa") {
                count = count + 1;
            }
        }
        System.out.println(count);
    }
}

출력 : 4