Java类型，用于保存任何基元类型的两个基元

我想在一个字段内存储两个基元值（我在这里包括String作为基元）。例如，我可能要存储String和int如下：Java类型，用于保存任何基元类型的两个基元

("hello", 42)

所以，如果我要找的是X类型，我希望能够宣布现场

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

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

我想弄清楚该字段必须是什么类型。它必须接受任何Java原始类型和String，因此它可能是String + int或String + float ...实际上是原始（+ String）类型的任意组合。基本上，从功能语言中借用一个概念，我只想要一个限于基元的tuple。但Java没有。

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

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

来源

2016-01-22 Steeven_b

你是什么意思“所有类型”？所有基元类型+字符串（int，布尔值，短小，浮点等等）还是所有对象？ – ParkerHalo

Nop只是原始类型 –

全部是对象 – Typo

如果您确实想将这些值存储为一种基本类型，则必须对它们进行“编码”。

例如：

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

来源

2016-01-22 11:43:41 NaN

不要以为有一种方法做它内置的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)

来源

2016-01-22 11:45:31

Java没有内置的Tuple类型。

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

来源

2016-01-22 14:48:25

由于您只处理原语（和String），因此您似乎希望尽可能避免自动装箱和取消装箱。这意味着你不能使用泛型。（原始类型不能用作类型参数。）它也好像你想避免不必要的促销（例如，如果你将floats作为doubles存储，你会保留原始值，但失去了它实际上是一个事实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); 
    } 
}

您当然可以添加更多班级和工厂m其他组合的方法。

我想作一个抽象类PrimitivePair，将有对getFirstValue()和getSecondValue()方法创建方法和方法声明，但会要求返回类型的协方差适用于原语，我不相信确实。

来源

2016-01-22 15:28:54

Java类型，用于保存任何基元类型的两个基元

回答

相关问题