कैसे एक सूची में एक तत्व की घटनाओं की संख्या की गिनती करने के

Question

इस प्रकार मैं एक ArrayList, जावा के एक संग्रह वर्ग है:

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

आप देख सकते हैं, animals तत्वों से युक्त है और एक owl तत्व। मैं सोच रहा था कि संग्रह ढांचे में कोई एपीआई है जो bat घटनाओं की संख्या देता है या यदि घटनाओं की संख्या निर्धारित करने का कोई और तरीका है।

मुझे पता चला कि Google का संग्रह Multiset में एक एपीआई है जो किसी तत्व की घटनाओं की कुल संख्या देता है। लेकिन यह केवल जेडीके 1.5 के साथ संगत है। हमारा उत्पाद वर्तमान में जेडीके 1.6 में है, इसलिए मैं इसका उपयोग नहीं कर सकता।

Answer 1

जावा में ऐसा करने के लिए जावा में कोई मूल विधि नहीं है। हालांकि, आप अपाचे कॉमन्स-कलेक्शन से IterableUtils#countMatches() का उपयोग अपने लिए कर सकते हैं।

Answer 2

क्षमा करें कोई आसान तरीका कॉल नहीं है जो इसे कर सकता है। आपको बस इतना करना होगा कि नक्शा बनाएं और इसके साथ आवृत्ति गिनती करें।

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); } 
} 

Answer 3

आप जो चाहते हैं वह एक बैग है - जो एक सेट की तरह है लेकिन घटनाओं की संख्या भी गिना जाता है। दुर्भाग्यवश जावा संग्रह ढांचे - बढ़िया है क्योंकि उनके पास एक थैला प्रत्यारोपण नहीं है। के लिए है कि एक अपाचे आम संग्रह link text

Answer 4

का उपयोग करना चाहिए तो यह पुराने जमाने तरह से करते हैं और अपने खुद के रोल:

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++); 
} 

Answer 5

मुझे आश्चर्य है, तुम क्यों उपयोग नहीं कर सकते कि JDK 1.6 के साथ गूगल के संग्रह API। क्या ऐसा कहता है? मुझे लगता है कि आप कर सकते हैं, कोई संगतता समस्या नहीं होनी चाहिए, क्योंकि यह निम्न संस्करण के लिए बनाया गया है। यदि मामला 1.6 के लिए बनाया गया था और आप 1.5 चल रहे हैं तो मामला अलग होगा।

क्या मैं कहीं गलत हूं?

Answer 6

आवृत्ति की गणना करने के लिए हैश मैप में सरणीसूची के तत्वों को रखें।

Answer 7

एक से थोड़ा अधिक कुशल दृष्टिकोण हो सकता है

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(); 
} 

Answer 8

इससे पता चलता है, यह महत्वपूर्ण क्यों है "Refer to objects by their interfaces" करने के लिए Effective Java पुस्तक में वर्णित है।

यदि आप कार्यान्वयन के लिए कोड करते हैं और आपके कोड में 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")); 
    } 
} 

ओओ सिद्धांत यहां लागू: विरासत, बहुरूपता, अमूर्तता, encapsulation।

Answer 9

यदि आप मेरे ForEach DSL के उपयोगकर्ता हैं, तो इसे Count क्वेरी के साथ किया जा सकता है।

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

Answer 10

मैं यकीन है कि संग्रह में स्थिर आवृत्ति विधि यहाँ काम में आएगा हूँ:

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

कि कैसे मैं इसे वैसे भी करना चाहते हैं है। मुझे यकीन है कि यह सीधे जेडीके 1.6 है।

Answer 11

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} 

Answer 12

जावा 8 में:

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

Answer 13

आप Eclipse Collections का उपयोग करते हैं, तो आप एक Bag उपयोग कर सकते हैं। MutableBag को के किसी भी कार्यान्वयन से 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 कार्यान्वयन एक MutableObjectIntMap द्वारा समर्थित है।

नोट: मैं ग्रहण संग्रह के लिए एक committer हूँ।

Answer 14

वास्तव में, संग्रह वर्ग एक स्थिर विधि कहा जाता है: आवृत्ति (संग्रह ग, वस्तु ओ) जो तत्व आप खोज रहे हैं की पुनरावृत्ति की संख्या देता है, वैसे, यह आपके लिए पूरी तरह से काम करेगा:

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")); 

Answer 15

जावा 8 - एक और तरीका

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

Answer 16

वैकल्पिक जावा 8 समाधान स्ट्रीम का उपयोग कर:

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

Answer 17

सीधे सूची से वस्तु की घटनाओं को प्राप्त करने के लिए:

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

सूची के अंदर वस्तु संग्रह की घटना प्राप्त करने के लिए, वस्तु वर्ग में बराबरी विधि ओवरराइड के रूप में:

: के रूप में

@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)); 

Answer 18

मैं इस मामले को और अधिक कठिन नहीं बनाना चाहता था और इसे दो iterators के साथ बनाया था मेरे पास LastName -> 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(); 

    } 

} 

Answer 19

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); 

Answer 20

सरल जावा 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); 
    } 

आउटपुट: {बिल्ली = 2, बकरी = 1, गाय = 1, गाय = 1, कुत्ता = 1}

आप "गाय" और गाय नोटिस नहीं कर सकते माना जाता है एक ही स्ट्रिंग के रूप में, यदि आपको इसे समान गणना के तहत आवश्यक है, तो .toLowerCase() का उपयोग करें। कृपया इसके लिए नीचे स्निपेट पाएं।

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

आउटपुट: {बिल्ली = 2, गाय = 2, बकरी = 1, कुत्ते = 1}