7

假设我像这样创建了一些对象类

public class thing {
        private String name; 
        private Integer num;

        public oDetails (String a, Integer b) {
            name = a;
            num = b;
        }
...gets/ sets/ etc

现在我想创建一个数组列表来保存一些这样的对象类。

ArrayList<thing> myList = new ArrayList<thing>;
thing first = new thing("Star Wars", 3);
thing second = new thing("Star Wars", 1);
myList.add(first);
myList.add(second);

我想包含某种逻辑，以便在这种情况下......当我们尝试添加对象“second”而不是向 arrayList 添加新对象时，我们将 second.getNum() 添加到 first.getNum()。因此，如果您要遍历 ArrayList 它将是

"Star Wars", 4

我很难想出一种优雅的方式来处理这个问题。并且随着数组列表的增长，搜索它以确定是否有重复的名称项变得很麻烦。任何人都可以提供一些指导吗？

4

5 回答 5

4

如果您想拥有一组独特的对象，请使用Set而不是List.

此外，如果您想自己定义对象何时被视为相等，请考虑覆盖类的equals和hashCode方法。

于 2012-04-01T05:18:12.090 回答
4

您必须创建自己的方法来检查name类 Thing 的字段是否设置为“星球大战”，然后添加到numClass Thing 的相应字段，这是一种可能的解决方案。

另一种解决方案是使用 a Map，其中 name 字段作为键，num 字段作为值。

前任：

public class Thing
{
   private String name;
   private int    num;

   public Thing(String name, int num)
   {
       this.name = name;
       this.num  = num;
   } 
}

public class ThingMap
{
    Map<String, Integer> thingMap; 

    public ThingMap()
    {
       this.thingMap = new HashMap<>();
    }

    public void put(Thing t)
    {
       String  k = t.getName();
       Integer v = t.getNum();

       if(thingMap.get(k) == null) //no entry exists
       {
          thingMap.put(k, v);
       }
       else //entry exists
       {
          //add to the current value
          thingMap.put(k, thingMap.get(k) + v);
       }
    }

    public Integer get(String k)
    {
       return this.thingMap.get(k);
    }
}

public class TestThing
{
   public static void main(String[] args)
   {
      ThingMap tMap = new ThingMap();
      Thing a = new Thing("Star Wars", 3);
      Thing b = new Thing("Star Wars", 1);

      tMap.put(a);
      tMap.put(b);

      System.out.println("Current value: " + tMap.get(a.getName());
   }

}

希望这可以帮助。

于 2012-04-01T05:30:48.980 回答
1

恕我直言，如果您不想更改课程，则使用 aMap<String, Integer>而不是ArrayList或 a更有意义。Map<String, Thing>

于 2012-04-01T05:23:49.887 回答
1

您需要以这种方式覆盖类 Thing 中的equals方法和hashCode方法：

public class Thing {
        private String name;
        private Integer num;

        public Thing(String a, Integer b) {
            name = a;
            num = b;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void setNum(Integer num) {
            this.num = num;
        }

        @Override
        public boolean equals(Object obj) {
            if(this == obj){
                return true;
            }

            if((obj == null) || (obj.getClass() != this.getClass())){
                return false;
            }

            Thing that = (Thing)obj;

            // Use the equality == operator to check if the argument is the reference to this object,
            // if yes. return true. This saves time when actual comparison is costly.
            return  num == that.num &&
                    (name == that.name || (name != null && name.equals(that.name)));

        }

        /**
         * This method returns the hash code value for the object on which this method is invoked.
         * This method returns the hash code value as an integer and is supported for the benefit of
         * hashing based collection classes such as Hashtable, HashMap, HashSet etc. This method must
         * be overridden in every class that overrides the equals method.
         *
         * @return
         */
        @Override
        public int hashCode() {
            int hash = 7;
            hash = 31 * hash + num;
            hash = 31 * hash + (null == name ? 0 : name.hashCode());
            return hash;
        }
    }

然后你可以这样使用它：

ArrayList<Thing> myList = new ArrayList<>();

Thing first = new Thing("Star Wars", 3);

if(!myList.contains(first)){
   myList.add(first);
}

Thing second = new Thing("Star Wars", 1);

if(!myList.contains(second)){
   myList.add(second);
}

就我而言，我使用 LinkedHashSet 来维护插入顺序，因为我认为这会更有效率。我没有用 ArrayList 尝试这个例子。

有关更多信息，您可以从此处阅读：为什么我以这种方式覆盖 equals 和 hashCode

于 2015-10-20T13:37:06.183 回答
0

如果你想最终使用 List 而不是写你的Comparator,

通过编写 Comparator，您可以创建类似 set 的行为。

于 2012-04-01T05:20:35.073 回答