Listedeki bir öğenin yineleme sayısı nasıl hesaplanır

ArrayListAşağıdaki gibi bir Java Koleksiyonu sınıfına sahibim :

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

Gördüğünüz gibi animals ArrayList3 bateleman ve bir owlelemandan oluşmaktadır. Koleksiyon çerçevesinde herhangi bir API batolup olmadığını veya olay sayısını belirleyen başka bir yol olup olmadığını merak ediyordum .

Google'ın Koleksiyonunda Multisetbir öğenin toplam tekrarlama sayısını döndüren bir API olduğunu buldum . Ancak bu yalnızca JDK 1.5 ile uyumludur. Ürünümüz şu anda JDK 1.6'da, bu yüzden kullanamıyorum.

Koleksiyonlardaki statik frekans yönteminin burada kullanışlı olacağından eminim:

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

Zaten böyle yaparım. Bunun jdk 1.6 dümdüz olduğuna eminim.

Java 8'de:

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

Bu, Etkili Java'da açıklandığı gibi " Nesnelerin arayüzlerine göre başvurulmasının " neden önemli olduğunu gösterir. kitabında .

Uygulamayı kodlar ve ArrayList'i kodunuzda 50 yer kullanırsanız, öğeleri sayan iyi bir "Liste" uygulaması bulduğunuzda, bu 50 yeri de değiştirmeniz gerekir ve muhtemelen kodunuzu kırın (yalnızca sizin tarafınızdan kullanılıyorsa, büyük bir anlaşma yoktur, ancak başka biri tarafından kullanılıyorsa, kodlarını da kırarsınız)

Arabirime programlayarak, bu 50 yeri değiştirmeden bırakabilir ve uygulamayı ArrayList'ten "CountItemsList" (örneğin) veya başka bir sınıfa değiştirebilirsiniz.

Aşağıda bunun nasıl yazılabileceğine dair çok temel bir örnek verilmiştir. Bu sadece bir örnek, üretime hazır bir liste çok daha karmaşık olurdu .

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

Burada uygulanan OO ilkeleri: kalıtım, polimorfizm, soyutlama, kapsülleme.

Üzgünüm, bunu yapabileceğiniz basit bir yöntem çağrısı yok. Yine de yapmanız gereken tek şey bir harita oluşturmak ve onunla frekans saymaktır.

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'da bunu sizin için yapmanın yerel bir yöntemi yoktur. Ancak, Apache Commons Koleksiyonlarından IterableUtils # countMatches () yöntemini kullanarak bunu sizin için yapabilirsiniz.

: Aslında Koleksiyonları sınıf denilen bir statik yöntem vardır frekans (Koleksiyon c Nesne o), bu sizin için mükemmel çalışacak arada, aradığınız elemanın yineleme sayısını döndürür:

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

Akışları kullanan alternatif Java 8 çözümü :

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

Acaba, neden Google'ın Koleksiyon API'sını JDK 1.6 ile kullanamıyorsunuz? Öyle mi diyor? Bence, daha düşük bir sürüm için oluşturulduğu için herhangi bir uyumluluk sorunu olmamalıdır. 1.6 için yapılmış olsaydı ve 1.5 çalıştırıyorsanız durum farklı olurdu.

Bir yerde yanlış mıyım?

Biraz daha verimli bir yaklaşım

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

Nesnenin oluşumlarını doğrudan listeden almak için:

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

İçeride Nesne koleksiyonunun oluşmasını sağlamak için, Object sınıfındaki equals yöntemini şu şekilde geçersiz kılın:

@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 öğesini şu şekilde arayın:

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

Java 8 özelliklerini kullanarak bir dizede dize değerinin oluşumunu bulmanın basit yolu.

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

Çıktı: {Kedi = 2, Keçi = 1, İnek = 1, inek = 1, Köpek = 1}

"İnek" ve inek aynı dize olarak değerlendirilmez, aynı sayı altında gerekli olması durumunda .toLowerCase () kullanın. Bunun için lütfen aşağıdaki pasajı bulun.

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

Çıktı: {cat = 2, inek = 2, keçi = 1, köpek = 1}

İstediğiniz bir Çanta - bir set gibi ama aynı zamanda meydana gelen olayların sayısını da sayar. Ne yazık ki java Koleksiyonlar çerçevesi - harika bir Çanta impl yok gibi. Bunun için Apache Common Collection bağlantı metnini kullanmalısınız

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

Yöntem 1:

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

for (String s : set) {

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

Yöntem 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);

Eğer kullanırsanız Eclipse Koleksiyonlar , bir kullanabilirsiniz Bag. A MutableBagherhangi uygulanmasından iade edilebilir RichIterablearayarak 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 koleksiyonlarında uygulama a tarafından desteklenmektedirMutableObjectIntMap .

Not: Eclipse Collections için bir komisyoncuyum.

Frekansı saymak için arraylist öğelerini hashMap'e koyun.

Java 8 - başka bir yöntem

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

Öyleyse eski moda bir şekilde yapın ve kendiniz yapın:

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'imin bir kullanıcısıysanız , bunu bir Countsorgu ile yapabilirsiniz .

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

Bu davayı daha zor hale getirmek istemedim ve iki yineleyici ile yaptım LastName -> FirstName ile bir HashMap var. Ve yöntemim dulicate FirstName içeren öğeleri silmeli.

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

Çıktı:

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

Çıktı: 4