12 回答

• 6

  Native Java 8（一行）

  使用Java 8， int[] 可以轻松转换为 Integer[] ：

  int[] data = {1,2,3,4,5,6,7,8,9,10};
  
  // To boxed array
  Integer[] what = Arrays.stream( data ).boxed().toArray( Integer[]::new );
  Integer[] ever = IntStream.of( data ).boxed().toArray( Integer[]::new );
  
  // To boxed list
  List<Integer> you  = Arrays.stream( data ).boxed().collect( Collectors.toList() );
  List<Integer> like = IntStream.of( data ).boxed().collect( Collectors.toList() );
  

  正如其他人所说， Integer[] 通常不是一个好的 Map 键 . 但就转换而言，我们现在拥有一个相对干净的本机代码 .

  回复于 2024-04-26T08:10:44+08:00
• -1

  如果要将 int[] 转换为 Integer[] ，则无法在JDK中自动执行此操作 . 但是，你可以这样做：

  int[] oldArray;
  
  ... // Here you would assign and fill oldArray
  
  Integer[] newArray = new Integer[oldArray.length];
  int i = 0;
  for (int value : oldArray) {
      newArray[i++] = Integer.valueOf(value);
  }
  

  如果您有权访问Apache lang库，那么您可以使用ArrayUtils.toObject(int[])方法，如下所示：

  Integer[] newArray = ArrayUtils.toObject(oldArray);
  

  回复于 2024-04-26T08:10:44+08:00
• 3

  据推测，您希望映射的键匹配元素的值而不是数组的标识 . 在这种情况下，您需要某种对象，如您所期望的那样定义 equals 和 hashCode . 最简单的是转换为 List<Integer> ，或 ArrayList 或更好地使用 Arrays.asList . 更好的是你可以引入一个代表数据的类（类似于 java.awt.Rectangle ，但我建议将变量设为私有，最后也是类最终） .

  回复于 2024-04-26T08:10:44+08:00
• 2

  使用没有外部库的常规for循环：

  Convert int[] to Integer[]:

  int[] primitiveArray = {1, 2, 3, 4, 5};
  Integer[] objectArray = new Integer[primitiveArray.length];
  
  for(int ctr = 0; ctr < primitiveArray.length; ctr++) {
      objectArray[ctr] = Integer.valueOf(primitiveArray[ctr]); // returns Integer value
  }
  

  Convert Integer[] to int[]:

  Integer[] objectArray = {1, 2, 3, 4, 5};
  int[] primitiveArray = new int[objectArray.length];
  
  for(int ctr = 0; ctr < objectArray.length; ctr++) {
      primitiveArray[ctr] = objectArray[ctr].intValue(); // returns int value
  }
  

  回复于 2024-04-26T08:10:44+08:00
• 5

  我在之前的回答中错了 . 正确的解决方案是使用此类作为包装实际int []的映射中的键 .

  public class IntArrayWrapper {
          int[] data;
  
          public IntArrayWrapper(int[] data) {
              this.data = data;
          }
  
          @Override
          public boolean equals(Object o) {
              if (this == o) return true;
              if (o == null || getClass() != o.getClass()) return false;
  
              IntArrayWrapper that = (IntArrayWrapper) o;
  
              if (!Arrays.equals(data, that.data)) return false;
  
              return true;
          }
  
          @Override
          public int hashCode() {
              return data != null ? Arrays.hashCode(data) : 0;
          }
      }
  

  并改变你的代码：

  Map<IntArrayWrapper, Double > freqs = new HashMap<IntArrayWrapper, Double>();
  
      for (int[] data : datas) {
          IntArrayWrapper wrapper = new IntArrayWrapper(data);
  
          if ( freqs.containsKey(wrapper)) {
              freqs.put(wrapper, freqs.get(wrapper) + p);
          }
  
          freqs.put(wrapper, p);
      }
  

  回复于 2024-04-26T08:10:44+08:00
• 1

  • 将int []转换为Integer []

  public static Integer[] toConvertInteger(int[] ids) {
  
    Integer[] newArray = new Integer[ids.length];
       for (int i = 0; i < ids.length; i++) {
         newArray[i] = Integer.valueOf(ids[i]);
       }
     return newArray;
  }
  

  • 将Integer []转换为int []

  public static int[] toint(Integer[] WrapperArray) {
  
     int[] newArray = new int[WrapperArray.length];
        for (int i = 0; i < WrapperArray.length; i++) {
           newArray[i] = WrapperArray[i].intValue();
        }
     return newArray;
  }
  

  回复于 2024-04-26T08:10:44+08:00
• 1

  您可以使用IntBuffer来包装现有的int []，而不必将数据复制到Integer数组中，而不是编写自己的代码 .

  int[] a = {1,2,3,4};
  IntBuffer b = IntBuffer.wrap(a);
  

  IntBuffer实现了可比性，因此您可以使用已编写的代码 . 正式映射比较键，使得a.equals（b）用于表示两个键相等，因此两个具有数组1,2,3的IntBuffers - 即使数组位于不同的内存位置 - 也被认为是相同的，因此适合您的频率代码 .

  ArrayList<int[]> data = ... // load a dataset`
  
  Map<IntBuffer, Double> frequencies = new HashMap<IntBuffer, Double>();
  
  for(int[] a : data) {
  
      IntBuffer q = IntBuffer.wrap(a);
  
      if(frequencies.containsKey(q)) {
          frequencies.put(q, tfs.get(q) + p);
      } else {
          frequencies.put(q, p);
      }
  

  }

  希望有所帮助

  回复于 2024-04-26T08:10:44+08:00
• 8

  不确定为什么你需要在你的 Map 中使用Double . 就你要做的事情来说，你有一个int []而你只想要计算每个序列出现的次数？为什么这需要Double呢？

  我要做的是使用适当的.equals和.hashCode方法为int数组创建一个包装器，以解释int []对象本身不考虑这些方法的版本中的数据这一事实 .

  public class IntArrayWrapper {
      private int values[];
  
      public IntArrayWrapper(int[] values) {
          super();
          this.values = values;
      }
  
      @Override
      public int hashCode() {
          final int prime = 31;
          int result = 1;
          result = prime * result + Arrays.hashCode(values);
          return result;
      }
  
      @Override
      public boolean equals(Object obj) {
          if (this == obj)
              return true;
          if (obj == null)
              return false;
          if (getClass() != obj.getClass())
              return false;
          IntArrayWrapper other = (IntArrayWrapper) obj;
          if (!Arrays.equals(values, other.values))
              return false;
          return true;
      }
  
  }
  

  然后使用google guava的multiset，这意味着计算出现的目的，只要你输入的元素类型有正确的.equals和.hashCode方法 .

  List<int[]> list = ...;
  HashMultiset<IntArrayWrapper> multiset = HashMultiset.create();
  for (int values[] : list) {
      multiset.add(new IntArrayWrapper(values));
  }
  

  然后，获取任何特定组合的计数：

  int cnt = multiset.count(new IntArrayWrapper(new int[] { 0, 1, 2, 3 }));
  

  回复于 2024-04-26T08:10:44+08:00
• 8

  Update: 虽然下面编译，但它会在运行时抛出 ArrayStoreException . 太糟糕了 . 我会留待以备参考 .

  ---

  将 int[] 转换为 Integer[] ：

  int[] old;
  ...
  Integer[] arr = new Integer[old.length];
  System.arraycopy(old, 0, arr, 0, old.length);
  

  我必须承认，由于 System.arraycopy 处于低水平和一切，但我确实感到有些惊讶，但确实如此 . 至少在java7中 .

  您可以轻松地转换其他方式 .

  回复于 2024-04-26T08:10:44+08:00
• 73

  这就像一个魅力！

  int[] mInt = new int[10];
  Integer[] mInteger = new Integer[mInt.length];
  
  List<Integer> wrapper = new AbstractList<Integer>() {
      @Override
      public int size() {
          return mInt.length;
      }
  
      @Override
      public Integer get(int i) {
          return mInt[i];
      }
  };
  
  wrapper.toArray(mInteger);
  

  回复于 2024-04-26T08:10:44+08:00
• -2

  你不需要 . int[] 是一个对象，可以在 Map 中用作键 .

  Map<int[], Double> frequencies = new HashMap<int[], Double>();
  

  是频率图的正确定义 .

  这是错的:-) . 也发布了正确的解决方案:-) .

  回复于 2024-04-26T08:10:44+08:00
• 138

  只需使用：

  public static int[] intArrayToIntegerArray(Integer[] array)
      {
          int[] g = new int[array.length];
          for(int i = 0; i < array.length; i++){
              g[i] = array[i];
          }
          return g;
      }
  

  回复于 2024-04-26T08:10:44+08:00