Count-Anzahl der Elemente mit Eigenschaft

Diese kann getan werden einfach mit Java-8-streams — keine zusätzlichen Bibliotheken erforderlich.

List<Custom> list = /*...*/;
long numMatches = list.stream()
                      .filter(c -> "Tom".equals(c.name))
                      .count();

Persönlich nutze ich gerne die Apache-Commons-Sammlung lib, wenn ich kann. (Aber die man auf sourceforge, da es verwendet generics), die Es ermöglicht, Sie haben einige ziemlich elegante Dinge wie mapping-Listen oder filtern von Listen (in einem System-ish Weg). Würden Sie am Ende das schreiben etwas wie dieses:

int count = CollectionUtils.countMatches(myList, new Predicate<Custom>(){
    public boolean evaluate(Custom c){ return "Tom".equals(c.name); }
}

Der einzige Nachteil ist, dass da Java nicht first-order-Funktionen, die Sie haben zu schreiben, kleine Objekte wie das Prädikat Instanz. Es wäre sauberer, wenn Sie schreiben könnten, anonyme Funktionen. also im scala, wäre es dieser:

val myList = List("a", "a", "b", "c", "a")
val c = myList.count{ "a".equals(_) }  //is 3

Entweder Sie verfolgen, wie Sie Elemente hinzufügen oder entfernen aus der Liste. Diese könnte an die Stelle einer hashmap Name->Count . Wo, wenn Sie ein Element hinzufügen, erhöhen Sie die Anzahl der für den Namen, und wenn Sie es entfernen Sie verringern Sie die Anzahl.

Oder Sie Durchlaufen die Kollektion mit einer Schleife prüft, ob der name in Frage.

Je nach dem Verhalten der Anwendung einer dieser Methoden wird schneller sein, aber ohne mehr Informationen ist es schwer zu sagen, welche.

Könnte man die Liste auch Sortieren, bevor Sie Schleifen, dann verwenden Sie Teile und herrsche " -zu finden, die passt, dann zählen. Es hängt wirklich von Ihren Bedürfnissen, wie viele Elemente? Gibt es eine Menge von Einfügungen, die nach einer Suche? etc

Was ist das? :

package test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

public class CustomArrayBuilder extends ArrayList<Custom> {

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

    public CustomArrayBuilder(Collection<? extends Custom> c) {
        super(c);
        this.prepareAddAll(c);
    }

    public int getDifferentNamesAmount() {
        return this.namesMap.size();
    }

    public int getNameAmount(String name) {
        Integer integer = this.namesMap.get(name);
        return (integer != null) ? integer : 0;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Custom set(int index, Custom element) {
        Custom custom = super.set(index, element);
        prepareSet(custom, element);
        return custom;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean add(Custom e) {
        this.prepareAdd(e);
        return super.add(e);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void add(int index, Custom element) {
        this.prepareAdd(element);
        super.add(index, element);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Custom remove(int index) {
        Custom custom = super.remove(index);
        this.prepareRemove(custom);
        return custom;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void clear() {
        super.clear();
        this.namesMap.clear();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean addAll(Collection<? extends Custom> c) {
        this.prepareAddAll(c);
        return super.addAll(c);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean addAll(int index, Collection<? extends Custom> c) {
        this.prepareAddAll(c);
        return super.addAll(index, c);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean remove(Object o) {
        if (super.remove(o)) {
            this.prepareRemove((Custom) o);
            return true;
        } else {
            return false;
        }
    }

    private void prepareSet(Custom oldCustom, Custom newCustom) {
        if (oldCustom != null && !oldCustom.name.equals(newCustom.name)) {
            this.prepareRemove(oldCustom);
            this.prepareAdd(newCustom);
        }
    }

    private void prepareAdd(Custom custom) {
        if (custom != null) {
            Integer integer = this.namesMap.get(custom.name);
            this.namesMap.put(custom.name, (integer != null) ? integer + 1 : 1);
        }
    }

    private void prepareAddAll(Collection<? extends Custom> c) {
        for (Custom custom : c) {
            this.prepareAdd(custom);
        }
    }

    private void prepareRemove(Custom custom) {
        if (custom != null) {
            Integer integer = this.namesMap.get(custom.name);
            this.namesMap.put(custom.name, (integer != null && integer > 0) ? integer - 1 : 0);
        }
    }
}

Verwendung:

package test;

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

public class Test {

    public static void main(String[] args) {

        List<Custom> list = new ArrayList<Custom>() {{
            add(new Custom("A"));
            add(new Custom("B"));
            add(new Custom("C"));
            add(new Custom("A"));
            add(new Custom("A"));
            add(new Custom("B"));
        }};

        CustomArrayBuilder customs = new CustomArrayBuilder(list);
        Custom custom = new Custom("B");
        customs.add(custom);
        customs.add(custom);
        customs.remove(custom);
        customs.remove(custom);
        customs.remove(custom);

        System.out.println("A: " + customs.getNameAmount("A"));
        System.out.println("B: " + customs.getNameAmount("B"));
        System.out.println("C: " + customs.getNameAmount("C"));
        System.out.println("Z: " + customs.getNameAmount("Z"));
        System.out.println("Total different names: " + customs.getDifferentNamesAmount());
    }
}

Ausgabe:

A: 3
B: 2
C: 1
Z: 0
Total different names: 3

Könnte es nützlich sein, wenn Sie Häufig verwenden Sie Ihre count-Operationen.
Hinweis: Sie sollten nicht ändern Sie den Namen des benutzerdefinierten Objekts, sollte es endgültig sein:

package test;

class Custom {
    public int id;
    final public String name;

    public Custom(String name) {
        this.name = name;
    }
}

Oder Sie etwas tun müssen, mit list zu, wenn Sie ändern der Namen von Benutzerdefinierten Objekt aus der Liste.