Question

很抱歉，如果标题不清楚，我不知道如何说出来。我有一个对象的arraylist，在每个对象中，我存储一个引用类别的整数值和一个引用ID的值。

我想找到有类别和ID的唯一组合的数量。

所以目前我已经

了

for(Object object: listofObjects){
     //For each unique type of object.getID
     //For each unique type of object.getCategory
     //Add 1 to counter
}

我无法弄清楚如何做到这一点。像（int cat：object.getCategory（））这样的操作会出错。

我可以将值添加到每个循环的初始值中的新列表，如此，

ArrayList<Integer> aList= new ArrayList<Integer>();
for (Object object : spriteExplore) {
    aList.add(object.getCategory());
}
for (int cat : aList) {
    testCounter++;
}

但是这显然没有考虑到唯一性，也使得在ID的另一个变量中进行因子分解变得尴尬。

我觉得可能有一些更容易解决的问题，我错过了。有什么建议？提前谢谢。

Answer 1

因此，您在ArrayList中列出了UserDefine对象，并且您希望从列表中找到唯一的Object.Just create set。

例如假设你有

List<Customer> list=new ArrayList<Custeomer>();
list.add(new Customer("A",12));
list.add(new Customer("B",13));
list.add(new Customer("A",12));

现在创建集从此列表

Set<Customer> set = new HashSet<Customer>(list);

这将拥有独特的客户 IMP：别忘了为Customer

重写equals和hashcode方法

Answer 2

您最好的方法是正确存储数据。

您可能仍然需要存储非唯一项目，如果这样 - 继续使用ArrayList，但另外，请使用以下内容：

覆盖哈希码＆amp; equels功能如此链接所示： What issues should be considered when overriding equals and hashCode in Java?

然后，使用Set（HashSet可能就足够了）来存储所有对象。此数据结构将忽略对于集合中已有元素不唯一的元素。

然后，您需要做的就是查询集合的大小，并为您提供列表中唯一元素的数量。

Answer 3

我不知道任何自动执行此操作的库，但您可以使用集合手动执行此操作。集合将仅保留唯一对象，因此如果您尝试将相同的值添加两次，则只保留一个引用。

Set<Integer> categories = new HashSet<Integer>();
Set<Integer> ids= new HashSet<Integer>();

for (Object object : listofObjects) {
    categories.add(object.getCategory());
    ids.add(object.getID());
}

然后通过

获取唯一类别/ ID的数量

categories.size()
ids.size()

如果您想使用它们，所有您的唯一值都会存储在集合中。

Answer 4

我会考虑使用(Hash)Map<Integer, Integer>。然后只有一个foreach循环，通过检查Map<object.getId(), object.getCategory()>是否为空来检查map.get(object.getId())的值是否为空 - 如果是，则该对尚不存在，所以将此对添加到使用map.put(object.getId(), object.getCategory())进行地图制作。如果没有，什么也不做。然后，最后，要查找唯一对的数量，您可以使用map.size()

希望这有帮助

Answer 5

Map<Integer,List<Integer>> uniqueCombinations = new HashMap<Integer,List<Integer>>();

for (Object object : listofObjects) {
  if(uniqueCombinations.get(object.getCategoryId())==null) {
    uniqueCombinations.put(object.getCategoryId(), new LinkedList<Integer>);
  }
  uniqueCombinations.get(object.getCategoryId()).add(object.getId());
}

return uniqueCombinations.size()

Answer 6

使用Hashmap保存事件。别忘了实现hashcode和equals方法。如果使用Eclipse IDE，则可以生成它们。

public static void main(String[] args) {

    List<MyObject> myObjects = Arrays.asList(new MyObject(1, 2), new MyObject(2, 3), new MyObject(3, 4), new MyObject(3, 4));

    Map<MyObject, Integer> map = new HashMap<>();

    for (MyObject myObject : myObjects) {

        Integer counter = map.get(myObject);

        if(counter == null){
            counter = 1;
        } else {
            counter = counter + 1;
        }

        map.put(myObject, counter);
    }

    long uniqueness = 0;
    for(Integer i : map.values()){
        if(i == 1){
            ++uniqueness;
        }
    }

    System.out.println(uniqueness);

}

如果您正在使用Java 8，那么最后一部分可以替换为这一行表达式：

long uniqueness = map.values().stream().filter(i -> i == 1).count();

Answer 7

我相信你想要类别和身份的独特组合，对吗？

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;


public class SO {

    class MyObject{
        private int id;
        private int category;
        private String name;
        private MyObject(int id, int category,String name) {
            super();
            this.id = id;
            this.category = category;
            this.name = name;
        }
        protected int getId() {
            return id;
        }
        protected int getCategory() {
            return category;
        }
        @Override
        public String toString() {
            return "MyObject [id=" + id + ", category=" + category + ", name=" + name + "]";
        }

    }

    public static void main(String[] args) {

        SO so = new SO();

        List<Object> listofObjects = new ArrayList<Object>();
        listofObjects.add(so.new MyObject(1,1,"One"));
        listofObjects.add(so.new MyObject(1,1,"Two"));
        listofObjects.add(so.new MyObject(1,2,"Three"));

        Map<String,List<MyObject>> combinations = new HashMap<String,List<MyObject>>();

        for(Object object: listofObjects ){
             //For each unique type of object.getID
             //For each unique type of object.getCategory
             //Add 1 to counter
            if (object instanceof MyObject){
                MyObject obj = (MyObject)object;
                String unique = obj.id+"-"+obj.category;
                if (combinations.get(unique) == null){
                    combinations.put(unique, new ArrayList<MyObject>());
                }
                combinations.get(unique).add(obj);
            }
        }

        System.out.println(combinations);

        //counts

        for(Entry<String,List<MyObject>> entry:combinations.entrySet()){
            System.out.println(entry.getKey()+"="+entry.getValue().size());
        }
    }

}

Java - 如何使用a for each循环来检查对象列表中值的不同出现次数

7 个答案: