使用数组来保存其他数组的索引

Question

我正在开发一个需要大量索引用于各种数组的程序。我想，这样做的一种方法是拥有一个包含所有索引的数组。例如：

int[] indices = {1, 2, 3, 4, 5};
char[] chars = {'a', 'b', 'c', 'd', 'e'};

结果是“a”会输出一次，“b”会输出两次，以此类推

最好的方法是什么？

Answer 1

更好的数据结构是地图界面

Map 是将键映射到值的对象。地图不能包含 重复键：每个键最多可以映射到一个值。

地图接口有多种实现方式：

1. HashMap：HashMap 类使用哈希表来实现 Map 接口。这使得 get( ) 和 put( ) 等基本操作的执行时间即使对于大型集合也保持不变。

2. TreeMap：TreeMap 类使用树实现 Map 接口。 TreeMap 提供了一种按排序顺序存储键/值对的有效方法，并允许快速检索。

3. LinkedHashMap：该类扩展了 HashMap 并维护映射中条目的链表，按照它们被插入的顺序。 这允许在地图上进行插入顺序迭代。也就是说，在迭代 LinkedHashMap 时，元素将按照插入的顺序返回。

视觉呈现：

╔══════════════╦═════════════════════╦═══════════════════╦══════════════════════╗
║   Property   ║       HashMap       ║      TreeMap      ║     LinkedHashMap    ║
╠══════════════╬═════════════════════╬═══════════════════╬══════════════════════╣
║              ║  no guarantee order ║ sorted according  ║                      ║
║   Order      ║ will remain constant║ to the natural    ║    insertion-order   ║
║              ║      over time      ║    ordering       ║                      ║
╠══════════════╬═════════════════════╬═══════════════════╬══════════════════════╣
║  Get/put     ║                     ║                   ║                      ║
║   remove     ║         O(1)        ║      O(log(n))    ║         O(1)         ║
║ containsKey  ║                     ║                   ║                      ║
╠══════════════╬═════════════════════╬═══════════════════╬══════════════════════╣
║              ║                     ║   NavigableMap    ║                      ║
║  Interfaces  ║         Map         ║       Map         ║         Map          ║
║              ║                     ║    SortedMap      ║                      ║
╠══════════════╬═════════════════════╬═══════════════════╬══════════════════════╣
║              ║                     ║                   ║                      ║
║     Null     ║       allowed       ║    only values    ║       allowed        ║
║ values/keys  ║                     ║                   ║                      ║
╠══════════════╬═════════════════════╩═══════════════════╩══════════════════════╣
║              ║   Fail-fast behavior of an iterator cannot be guaranteed       ║
║   Fail-fast  ║ impossible to make any hard guarantees in the presence of      ║
║   behavior   ║           unsynchronized concurrent modification               ║
╠══════════════╬═════════════════════╦═══════════════════╦══════════════════════╣
║              ║                     ║                   ║                      ║
║Implementation║      buckets        ║   Red-Black Tree  ║    double-linked     ║
║              ║                     ║                   ║       buckets        ║
╠══════════════╬═════════════════════╩═══════════════════╩══════════════════════╣
║      Is      ║                                                                ║
║ synchronized ║              implementation is not synchronized                ║
╚══════════════╩════════════════════════════════════════════════════════════════╝

Read about HashMap

Read about TreeMap

Read about LinkedHashMap

source for visual presentation

Answer 2

这些天我的很多答案似乎都使​​用HashMap。我觉得它的用途被低估了，特别是因为它在处理相关数据方面非常通用。

HashMap<Char, Integer> foo = new HashMap<Char, Integer>();
foo.add('a', 1);
foo.add('b', 2);
foo.add('c', 3);
foo.add('d', 4);
foo.add('e', 5);

for(Entry<Char, Integer> e : foo.getEntrySet()) {
    for(int i = 0; i < e.getValue(); i++) {
        System.out.print(entry.getKey());
    }
}

当然，这假设您不喜欢订购。如果你这样做了，那么你应该使用ArrayList 和一个存储字符和整数的对象。

创建多个相互依赖的数组是相对不安全的，所以你不妨创建一个对象来为你处理一切。

Answer 3

由于我相信您确实想按顺序迭代您的列表，因此此处不适合使用 Map。更好的方法是意识到您使用的是面向对象的语言。创建一个对象来为您的数据建模：

class CharCounter {
  private final char toPrint;
  private final int times;
  public CharCounter(final char toPrint, final int times) {
    this.toPrint = toPrint;
    this.times = times;
  }
}

CharCounter[] arr = new CharCounter[]{ new CharCounter('a', 1), new CharCounter('b', 2), ...};