Question

我想在一个字段中存储两个原始值（我在这里包含String作为基元）。例如，我可能希望存储String和int，如下所示：

("hello", 42)

因此，如果我正在寻找的类型是X，我希望能够声明一个字段

private X myX = new X("hello", 42);

或其他一些咒语给我相同的结果。

我正在试图找出该字段必须是什么类型。它必须接受任何Java原始类型和String所以它可以是String + int或String + float ...实际上是原始的任何组合（+ String）类型。从本质上讲，要从函数式语言中借用一个概念，我只想要一个仅限于原语的tuple。但Java没有那个。

由于它们是原始的，因此泛型不能很好地工作。而且我不确定我对拳击/拆箱的感受。

我可以在Java中使用的最佳数据类型/结构是什么？

Answer 1

如果您真的想将值存储为一种基本类型，则必须编码＆＃39;它们。

例如：

String field = "hello;42";
String[] values = field.split(";");
int intValue = Integer.parseInt(values[1]);

Answer 2

不要认为有一种方法可以使用内置的Java库来实现它。但是，可以在Scala语言中编写与Tuple2类相同的Tuple类，如下所示：

public class Tuple<K, V> {
        private K first;
        private V second;

        // create tuple only with static method "of"
        private Tuple(K first, V second) {
            this.first = first;
            this.second = second;

        }

        public static <K, V> Tuple<K, V> of(K a, V b) {
            return new Tuple<K, V>(a, b);
        }

        public Tuple<V, K> swap() {
            return new Tuple<V, K>(second, first);
        }

        public K getFirst() {
            return this.first;
        }

        public V getSecond() {
            return this.second;
        }

        @Override
        public String toString() {
            return "(" + first.toString() + "," + second.toString() + ")";
        }

        public static void main(String[] args) {
            Tuple myTuple = Tuple.of("hello", 2);

            System.out.println("toString: "+myTuple);
            System.out.println("First: "+myTuple.getFirst());
            System.out.println("Swap: "+ myTuple.swap());
        }

    }

    Output:

    toString: (hello,2)
    First: hello
    Swap: (2,hello)

Answer 3

由于您只使用原语（和String），因此您似乎希望尽可能避免自动装箱和拆箱。这意味着您无法使用泛型。（原始类型不能用作类型参数。）似乎您也希望避免不必要的推广（例如，如果您将floats存储为doubles，那么d保留原始值，但却失去了它实际上是float）的事实。

一个相当精细的解决方案是创建一组PrimitivePair类，一个用于您要存储的基本类型的每种组合，以及一个用于轻松构建它们的工厂类。例如，您可能有以下三个类来存储各种基元：

package primitivepair;

public class PrimitivePairStringInt
{
   final String s;
   final int i;

   PrimitivePairStringInt(final String s, final int i)
   {
      this.s = s;
      this.i = i;
   }

   public String getFirstValue()
   {
      return s;
   }

   public int getSecondValue()
   {
      return i;
   }
}

package primitivepair;

public class PrimitivePairFloatDouble
{
   final float f;
   final double d;

   PrimitivePairFloatDouble(final float f, final double d)
   {
      this.f = f;
      this.d = d;
   }

   public float getFirstValue()
   {
      return f;
   }

   public double getSecondValue()
   {
      return d;
   }
}

package primitivepair;

public class PrimitivePairCharByte
{
   final char c;
   final byte b;

   PrimitivePairCharByte(final char c, final byte b)
   {
      this.c = c;
      this.b = b;
   }

   public char getFirstValue()
   {
      return c;
   }

   public byte getSecondValue()
   {
      return b;
   }
}

它们将由以下工厂类创建：

package primitivepair;

public class PrimitivePairFactory
{
   public static PrimitivePairCharByte createPrimitivePair(final char c, final byte b)
   {
      return new PrimitivePairCharByte(c, b);
   }

   public static PrimitivePairFloatDouble createPrimitivePair(final float f, final double d)
   {
      return new PrimitivePairFloatDouble(f, d);
   }

   public static PrimitivePairStringInt createPrimitivePair(final String s, final int i)
   {
      return new PrimitivePairStringInt(s, i);
   }
}

您当然可以为其他组合添加更多类和工厂方法。

我想创建一个抽象的PrimitivePair类，它具有getFirstValue()和getSecondValue()方法的创建方法和方法声明，但是这样做会有要求返回类型协方差适用于原语，我不相信它。

Answer 4

Java没有内置的Tuple类型。

您可以使用标准Map.Entry<K,V>，但如果可能，我个人会建议使用Apache Commons Lang3的元组类型。

包含任何基本类型的两个基元的Java类型

4 个答案: