Question

我有 n 用户名及时间值，例如

String userName = "user1"
String time = "09:30"

在ArrayList ArrayList<Map<String,String>> userData = new ArrayList<>( );中，我希望有类似的东西

但我对K，V值感到困惑。我应该首先单独转换Map值中的 userName 和时间吗？像

Map<String, String> uName = new HashMap<String, String>();
Map<String, String> uTime = new HashMap<String, String>();

uName.put("userName",userName);
uTime.put("time",time);

但是，如何在Array的同一索引中添加这两个值？

或者我应该先做哪些步骤？

请你写下一个可以帮助我的例子或参考文献。

谢谢！

Answer 1

如果我理解你的问题，你可能想要创建一个类：

public class MyClass {
    private String userName;
    private LocalTime time;
    public MyClass(String userName, LocalTime time) { 
        this.userName = userName;
        this.time = time;
    }

    public String getUserName() { return userName; }
    public LocalTime getUserName() { return time; }
}

你可以简单地拥有一个ArrayList<MyClass>。您可能希望时间变量为String类型，无论哪种方式最适合您。我不建议将时间戳存储为字符串。

Answer 2

我认为你不需要这里有一个ArrayList of Maps，在我看来还有两个更合适的选择：

创建一个类User，它将包含两个字符串变量 - 名称和时间，并且具有一个用户的ArrayList
点名称 - >时间

要么会这样做，因为地图的ArrayList似乎是多余的

Answer 3

只为每个索引使用一张地图。例如：

List<Map<String, String>> userData = new ArrayList<Map<String, String>>();
Map<String, String> user1 = new HashMap<String, String>();
user1.put("name", "John");
user1.put("time", "9:03");
userData.add(user1);

虽然这样做有效，但如果你需要寻找任何用户，你必须通过列表找到你正在寻找的用户，方法是访问地图。因此，您可以通过以下方式获取地图地图：Map<String, Map<String, String>>：

Map<String, Map<String, String>> userData = new HashMap<String, Map<String, String>>();
Map<String, String> user1 = new HashMap<String, String>();
user1.put("time", "9:03");
userData.put("John", user1);

这样，如果您正在寻找John的数据，您只需执行userData.get("John")

更好的解决方案是使用具有已定义属性的User类。例如：

public class User {
    private String name;
    private String time;
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getTime() { return time; }
    public void setTime(String time) { this.time = time; }
}

Map<String, User> userData = new HashMap<String, User>();
User user1 = new User();
user1.setName("John");
user1.setTime("9:03");
userData.put(user1.getName(), user1);

根据您的问题＆＃34;是否可以在每次插入用户时对地图进行排序？＆＃34;答案是不。地图未分类。您似乎需要一个插入已排序项目的SortedList。这是一个简单的实现：

    public class SortedList<T> implements List<T> {
  private List<T> delegate;
  private Comparator<T> order;

  public SortedList(List<T> delegate, Comparator<T> order) {
    this.delegate = delegate;
    this.order = order;
  }

  @Override
  public int size() {
    return delegate.size();
  }

  @Override
  public boolean isEmpty() {
    return delegate.isEmpty();
  }

  @Override
  public boolean contains(Object o) {
    return delegate.contains(o);
  }

  @Override
  public Iterator<T> iterator() {
    return delegate.iterator();
  }

  @Override
  public Object[] toArray() {
    return delegate.toArray();
  }

  @Override
  public <T1> T1[] toArray(T1[] a) {
    return delegate.toArray(a);
  }

  @Override
  public boolean add(T t) {
    int i=0;
    for(; i < delegate.size(); i++) {
      if(order.compare(t, delegate.get(i)) < 0) {
        break;
      }
    }
    delegate.add(i, t);
    return true;
  }

  @Override
  public boolean remove(Object o) {
    return delegate.remove(o);
  }

  @Override
  public boolean containsAll(Collection<?> c) {
    return delegate.containsAll(c);
  }

  @Override
  public boolean addAll(Collection<? extends T> c) {
    if (c!= null && !c.isEmpty()) {
      return c.stream().map(this::add).reduce(Boolean.FALSE, (l, r) -> l || r);
    }
    return false;
  }

  @Override
  public boolean addAll(int index, Collection<? extends T> c) {
    throw new IllegalStateException("Can only add in order");
  }

  @Override
  public boolean removeAll(Collection<?> c) {
    return delegate.removeAll(c);
  }

  @Override
  public boolean retainAll(Collection<?> c) {
    return delegate.retainAll(c);
  }

  @Override
  public void clear() {
    delegate.clear();
  }

  @Override
  public T get(int index) {
    return delegate.get(index);
  }

  @Override
  public T set(int index, T element) {
    throw new IllegalStateException("Can only add in order");
  }

  @Override
  public void add(int index, T element) {
    throw new IllegalStateException("Can only add in order");
  }

  @Override
  public T remove(int index) {
    return delegate.remove(index);
  }

  @Override
  public int indexOf(Object o) {
    return delegate.indexOf(o);
  }

  @Override
  public int lastIndexOf(Object o) {
    return delegate.lastIndexOf(o);
  }

  @Override
  public ListIterator<T> listIterator() {
    return delegate.listIterator();
  }

  @Override
  public ListIterator<T> listIterator(int index) {
    return delegate.listIterator(index);
  }

  @Override
  public List<T> subList(int fromIndex, int toIndex) {
    return new SortedList<>(delegate.subList(fromIndex, toIndex), order);
  }

  @Override
  public String toString() {
    return delegate.toString();
  }
}

您将为排序的整数列表实例化，例如：

SortedList<Integer> nums = 
new SortedList<Integer>(new ArrayList<Integer>(), Comparator.naturalOrder());

Answer 4

或者，您可以定义自己的数据结构，例如User。然后就是这样的：

public class User {
    private String name;
    private String time;

   // getters and setters
}

使用数据结构而不是Map<String, String>的主要优点包括：

易于使用（不再需要Map，只需User类型元素列表），
灵活性（可能在稍后阶段您决定添加位置信息，这需要修改Map的工作方式，但这就像添加字段＆＃34; location＆＃34;一样简单数据结构）。
API和代码意图的清晰度。 Map<String, String>并未对其所拥有的内容或所使用的内容进行过多说明。相反，List<User>可以立即标识为用户列表。
作为纯数据结构或Java Bean，它可以很容易地被IDE和其他框架选中。例如，将这样的类序列化为json变成了一项微不足道的任务。

＆＃34; User＆＃34;可能不是该类型的正确名称，但该概念仍适用。

Answer 5

您可以使用Map.Entry加载列表：

 final List<Map.Entry<String,String>> listOfEntries =
        new ArrayList<>();
listOfEntries.add(new AbstractMap.SimpleEntry<>("Name", "01:01"));
listOfEntries.add(new AbstractMap.SimpleEntry<>("Name2", "05:10"));

或者，如果您有Guava依赖项，则可以使用Maps.immutableEntry("firstValue", "secondValue")加载此列表。

带有Map <k，v>值

5 个答案: