为对象和值对的组合创建数组列表的设计模式[重复]答案

【问题标题】：Design pattern to create an arraylist for a combination of object and value pair [duplicate]为对象和值对的组合创建数组列表的设计模式[重复]
【发布时间】：2016-11-23 07:25:59
【问题描述】：

想知道java中可能的设计模式方法的输入：

场景：尝试为对象和值对的组合创建一个数组列表。如果对象有 A、B、C...等如果值有 X1, X2, X3...等

对于 A 和 X1 的组合，可能有一个 Y1 的数组列表对于 A 和 X2 的组合，可能有一个 Y2 的数组列表 .....等等，等等等等。

我尝试使用 Factory Creational Design Pattern，但匹配得不太好。有人可以为这个问题提出一种可能的设计方法吗？

我无法在我的实现中使用 Apache Pair。好的，我已经添加了我的问题 Java 类代码：

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

public class FieldsProvider2 {
private MyObject object;
private MyAction action;

public FieldsProvider2(MyObject object, MyAction action) {
    this.object = object;
    this.action = action;
}

public List<Object> getList() {
    if ((action != null && object != null)) {
        if (Action.A == action) {
            List<Object> fields = new ArrayList<>();
            if (object.getTypeKey().equals(MYObject.X1)) {
                // fields.add(Y1);
                // fields.add(Y2);

                // fields.add(Y3);
                // fields.add(Y4);

                // fields.add(Y5);

                // fields.add(Y5);

                // fields.add(Y6);
                // fields.add(Y7);

                return fields;
            }

            if (object.getTypeKey().equals(MYObject.X2)) {
                // nothing
            }

            if (object.getTypeKey().equals(MYObject.X3)) {
                // fields.add(Y1);
            }

            if (object.getTypeKey().equals(MYObject.X4)) {
                // fields.add(Y1);
                // fields.add(Y8);
                // fields.add(Y9);
            }

            if (object.getTypeKey().equals(MYObject.X5)) {
                // fields.add(Y1);
            }

            if (object.getTypeKey().equals(MYObject.X6)) {
                // fields.add(Y1);
            }

            if (object.getTypeKey().equals(MYObject.X7)) {
                // fields.add(Y1);
            }

            if (object.getTypeKey().equals(MYObject.X8)) {
                // fields.add(Y1);
            }

            if (object.getTypeKey().equals(MYObject.X9)) {
                // fields.add(Y9);
            }

            if (object.getTypeKey().equals(MYObject.X10)) {
                // fields.add(Y10);
            }

            // Common items

            // fields.add(Y11);
            // fields.add(Y12);

            // fields.add(Y13);
            // fields.add(Y14);
            // or
            // fields.add(Y15);

            return fields;
        }

        if (Action.B == action) {
            List<Object> fields = new ArrayList<>();
            if (object.getTypeKey().equals(MYObject.X1)) {
                // fields.add(Y1);
                // fields.add(Y2);

                // fields.add(Y3);
                // fields.add(Y4);

                // fields.add(Y5);

                // fields.add(Y5);

                // fields.add(Y6);
                // fields.add(Y7);

                return fields;
            }

            if (object.getTypeKey().equals(MYObject.X2)) {
                // fields.add(Y7);
            }
        }
        //Action.C will start
        //Action.D will start and so on...
    return null;
}
}

【问题讨论】：

请解释更多或写下您在尝试实现此目的期间编写的代码。我无法理解您的问题。
设计模式是针对某些工作流程的解决方案，而不是针对数据结构的解决方案（尽管该解决方案可能会使用某些数据结构）。所以我认为你在这里走错了路。
只需创建一个包含所有所需功能的 API。就像一个需要全套操作的代数。然后最好的数据结构会自动适应。
您的问题是有道理的，它是一个完全有效的寻求帮助的请求，但它似乎更多的是关于设计而不是编码。它可能更适合：Programmers.
设计模式只是“良好实践”。这不是你必须在你的类设计中包含的东西，地狱或高水位。如果您有想用设计模式解决的问题，请描述它。（例如“我希望我的班级不依赖于特定的数据存储方式...”）

标签： java design-patterns

【解决方案1】：

在我的项目中，我实现了自己的 Pair 类，与 Scala 类似。

这里是代码库

      import java.util.Objects;

public class Pair<A, B> {
   public final A _1;
   public final B _2;

  private Pair(A _1, B b) {
    this._1 = _1;
    this._2 = b;
  }

  public A _1() {
    return _1;
  }

  public B _2() {
    return _2;
  }


 @Override
 public String toString() {
    return "(" + _1 + "," + _2 + ")";
}

public static <X, Y> Pair<X, Y> of(X a, Y b) {
    return new Pair<>(a, b);
}


public static <X, Y> Pair<X, Y> pair(X a, Y b) {
    return of(a, b);
}


public boolean equals(Object var1) {
    return var1 instanceof Pair && Objects.equals(this._1, ((Pair) var1)._1) && Objects.equals(this._2, ((Pair) var1)._2);
}

public int hashCode() {
    return this._1 == null ? (this._2 == null ? 0 : this._2.hashCode() + 1) : (this._2 == null ? this._1.hashCode() + 2 : this._1.hashCode() * 17 + this
            ._2.hashCode());
}
}

【讨论】：

为什么需要这两种方法：of 和 pair?
都是工厂方法
两者的功能完全相同，甚至具有相同的签名。有点不必要的 write 2 方法做完全相同的事情。
同意，我们仍在公开讨论哪个更具可读性，最后我们将只选择一个:)

【解决方案2】：

如果我猜对了，你就有这样的结构：

Map<Pair<A,X>, List<Y>>

没有用于填充此 Map 的设计模式，但有一些重要的事情需要考虑。如果使用 Pair 作为键，则必须覆盖 Pair 中的 hashcode() 和 equals() 方法以使 Map 正常工作。另外，您应该在 Pair 中提供一个构造函数，以便一步轻松地创建用于搜索等的键。

如果您使用的是 Java8，则可以使用流/lambdas 进行过滤/搜索。

【讨论】：