리스트에서 요소의 발생 횟수를 카운트하는 방법
는 i i나 an an an i i i i i i i 。ArrayList. Collection은 다음과
ArrayList<String> animals = new ArrayList<String>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");
바와 같이 '하다'는animals ArrayList 3개의 3개의 3개의 3개의 3개의 3개의 3개의 3개의 3개의 3개의 3개의 3개의 3개의bat 및 1개의 '''로 구성됩니다.owl에 Collection API 번호를 가 있는지 .bat발생 횟수 또는 발생 횟수를 결정하는 다른 방법이 있는지 확인합니다.
은 ★★★★★★★★★★★★★★★★★★★★★★★★★★.Multiset에는 요소의 총 발생 횟수를 반환하는 API가 있습니다., 1.호환성이 은 JDK 1.5뿐입니다.저희 제품은 현재 JDK 1.6으로 되어 있어서 사용할 수 없습니다.
Collections의 정적 주파수 방식은 여기서 유용하게 쓰일 것입니다.
int occurrences = Collections.frequency(animals, "bat");
어쨌든 난 그렇게 할 거야.이건 jdk 1.6 스트레이트일 거예요
Java 8의 경우:
Map<String, Long> counts =
list.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));
스트림을 사용하는 대체 Java 8 솔루션:
long count = animals.stream().filter(animal -> "bat".equals(animal)).count();
이는 효과적인 Java 책자에 설명된 대로 "인터페이스별 객체 참조"가 중요한 이유를 보여줍니다.
예를 들어, 구현에 따라 코드를 작성하고 ArrayList를 사용하는 경우, 예를 들어 코드의 50개소에서 아이템을 카운트하는 적절한 "목록" 구현이 발견되면 그 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의 ItableUtils#countMatches()를 사용하여 이를 수행할 수 있습니다.
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, Got=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, got=1, dog=1}
왜 구글의 컬렉션 API를 JDK 1.6과 함께 사용할 수 없는지 궁금하네요.저 버전용으로 제작되었기 때문에 호환성 문제는 없다고 생각합니다.1.6용으로 구축되어 있고 1.5를 실행하고 있는 경우, 케이스는 다릅니다.
어디선가 내가 틀린 건가요?
실제로 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"));
조금 더 효율적인 접근법은
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");
오브젝트 컬렉션 inside 목록을 가져오려면 오브젝트 클래스의 동등한 메서드를 다음과 같이 덮어씁니다.
@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 Collections 프레임워크는 Bag incont가 없기 때문에 훌륭합니다.그러기 위해서는 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);
이를 달성하기 위해 다음과 같은 여러 가지 방법으로 수행할 수 있습니다.
단일 요소의 발생 횟수를 반환하는 메서드:
Collections.frequency(animals, "bat");
자바 스트림:
필터
animals.stream().filter("bat"::equals).count();
그냥 반복해서 리스트가
public static long manually(Collection<?> c, Object o){
int count = 0;
for(Object e : c)
if(e.equals(o))
count++;
return count;
}
주파수 맵을 작성하는 방법:
Map<String, Long> counts =
animals.stream()
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
Map<String, Long> map = new HashMap<>();
c.forEach(e -> map.merge(e, 1L, Long::sum));
수동
Map<String, Integer> mp = new HashMap<>();
animals.forEach(animal -> mp.compute(animal, (k, v) -> (v == null) ? 1 : v + 1));
모든 메서드를 사용한 실행 예시:
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
public class Frequency {
public static int frequency(Collection<?> c, Object o){
return Collections.frequency(c, o);
}
public static long filter(Collection<?> c, Object o){
return c.stream().filter(o::equals).count();
}
public static long manually(Collection<?> c, Object o){
int count = 0;
for(Object e : c)
if(e.equals(o))
count++;
return count;
}
public static Map<?, Long> mapGroupBy(Collection<?> c){
return c.stream()
.collect(Collectors.groupingBy(Function.identity() , Collectors.counting()));
}
public static Map<Object, Long> mapMerge(Collection<?> c){
Map<Object, Long> map = new HashMap<>();
c.forEach(e -> map.merge(e, 1L, Long::sum));
return map;
}
public static Map<Object, Long> manualMap(Collection<?> c){
Map<Object, Long> map = new HashMap<>();
c.forEach(e -> map.compute(e, (k, v) -> (v == null) ? 1 : v + 1));
return map;
}
public static void main(String[] args){
List<String> animals = new ArrayList<>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");
System.out.println(frequency(animals, "bat"));
System.out.println(filter(animals,"bat"));
System.out.println(manually(animals,"bat"));
mapGroupBy(animals).forEach((k, v) -> System.out.println(k + " -> "+v));
mapMerge(animals).forEach((k, v) -> System.out.println(k + " -> "+v));
manualMap(animals).forEach((k, v) -> System.out.println(k + " -> "+v));
}
}
메서드명에 이러한 메서드가 무엇을 하고 있는지 반영해야 하는데, 저는 그 이름을 대신 사용하고 있는 접근방식을 반영하기 위해 사용했습니다(현재의 컨텍스트에서는 문제가 없습니다.
이클립스 컬렉션을 사용하는 경우Bag.A.AMutableBag를 호출함으로써 임의의 실장으로부터 반환할 수 있다.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"));
HashBag은 Eclipse 컬렉션의 을 받습니다.MutableObjectIntMap.
주의: 저는 Eclipse Collections의 커밋입니다.
hashMap에 배열 목록 요소를 넣고 빈도를 카운트합니다.
구식 방식으로 직접 만들어 보십시오.
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++);
}
Java 8 - 다른 방법
String searched = "bat";
long n = IntStream.range(0, animals.size())
.filter(i -> searched.equals(animals.get(i)))
.count();
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
ForEach DSL을 사용하고 있는 경우는, 다음과 같이 할 수 있습니다.Count문의합니다.
Count<String> query = Count.from(list);
for (Count<Foo> each: query) each.yield = "bat".equals(each.element);
int number = query.result();
이 문제를 더 어렵게 만들고 싶지 않아 2개의 반복기를 사용하여 HashMap에 LastName-> FirstName을 붙였습니다.그리고 내 메서드는 dulicate 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");
}
Java 8의 groupingBy 기능을 사용 사례에 사용할 수 있습니다.
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
public class Test {
public static void main(String[] args) {
List<String> animals = new ArrayList<>();
animals.add("bat");
animals.add("owl");
animals.add("bat");
animals.add("bat");
Map<String,Long> occurrenceMap =
animals.stream().collect(Collectors.groupingBy(Function.identity(),Collectors.counting()));
System.out.println("occurrenceMap:: " + occurrenceMap);
}
}
산출량
occurrenceMap:: {bat=3, owl=1}
Integer[] spam = new Integer[] {1,2,2,3,4};
List<Integer> list=Arrays.asList(spam);
System.out.println(list.stream().collect(Collectors.groupingBy(Function.identity(),Collectors.counting())));
System.out.println(list.stream().collect(Collectors.groupingBy(Function.identity(),HashMap::new,Collectors.counting())));
산출량
{1=1, 2=2, 3=1, 4=1}
언급URL : https://stackoverflow.com/questions/505928/how-to-count-the-number-of-occurrences-of-an-element-in-a-list
'programing' 카테고리의 다른 글
| v-for의 요소에 액세스하는 방법 (0) | 2022.07.29 |
|---|---|
| vuex에서 중첩된/복잡한 개체 처리 (0) | 2022.07.29 |
| Vuex Getters는 참조(어레이, 객체 등)를 상태로 반환합니까? (0) | 2022.07.29 |
| Java에서 정수로 이중 캐스트 (0) | 2022.07.29 |
| Viewify 메인 드로어/내비게이션에서 하위 메뉴를 만드는 방법 (0) | 2022.07.29 |