Java 带地图的ArrayList<；K、 V>；价值观

我有n个用户名和时间值的用户，例如

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

在ArrayList中

ArrayList userData=newArrayList（）我想要这样的东西


但我对K，V值感到困惑。我应该先分别转换地图中的用户名和时间值吗？像

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

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

Map uName=newhashmap（）；
Map uTime=newhashmap（）；
uName.put（“用户名”，用户名）；
uTime.put（“时间”，时间）；

但是，如何在数组的同一索引中添加这两个值呢

或者我应该先做哪些步骤

请你写一个例子或参考资料，也可以帮助我

谢谢大家!
 我认为你不需要这里的地图列表，我认为还有两个更合适的选择：

创建一个类
User
，该类将有两个字符串变量-name和time，并有一个User的ArrayList
映射该点的名称->时间
任何一种都可以，拥有地图阵列列表似乎是多余的
我认为您不需要地图阵列列表，我认为还有两种更合适的选择：

创建一个类
User
，该类将有两个字符串变量-name和time，并有一个User的ArrayList
映射该点的名称->时间
这两种方法都可以，拥有地图的ArrayList似乎是多余的
如果我正确理解您的问题，您可能需要创建一个类：

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
。
您可能希望时间变量的类型为
String
，以最适合您的类型为准。但我不建议将时间戳存储为字符串。
如果我正确理解您的问题，您可能需要创建一个类：

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
。
您可能希望时间变量的类型为
String
，以最适合您的类型为准。不过，我不建议将时间戳存储为字符串。
只需为每个索引使用一个映射即可。例如：

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);

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);

根据您的问题“是否有可能在每次插入用户时对地图进行排序？”答案是否定的。地图是未排序的。您似乎需要一个可插入订购物品的分类列表。下面是一个简单的实现：

    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();
  }
}

公共类分类列表实现列表{
私人名单代表；
专用比较器顺序；
公共分类列表（列表委托、比较顺序）{
this.delegate=委托；
这个。顺序=顺序；
}
@凌驾
公共整数大小（）{
返回delegate.size（）；
}
@凌驾
公共布尔值为空（）{
返回delegate.isEmpty（）；
}
@凌驾
公共布尔包含（对象o）{
返回委托。包含（o）；
}
@凌驾
公共迭代器迭代器（）{
返回delegate.iterator（）；
}
@凌驾
公共对象[]toArray（）{
返回delegate.toArray（）；
}
@凌驾
公共T1[]toArray（T1[]a）{
将代表返回至阵列（a）；
}
@凌驾
公共布尔加法（T）{
int i=0；
对于（；i

您将举例说明排序整数列表，如下所示：

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

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

   // getters and setters
}

SortedList nums=
新的SortedList（新的ArrayList（），Comparator.naturalOrder（））；
只需为每个索引使用一个映射即可。例如：

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);

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);

根据您的问题“是否有可能在每次插入用户时对地图进行排序？”答案是否定的。地图是未排序的。您似乎需要一个可插入订购物品的分类列表。下面是一个简单的实现：

    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();
  }
}

公共类分类列表实现列表{
私人名单代表；
专用比较器顺序；
公共分类列表（列表委托、比较顺序）{
this.delegate=委托；
这个。顺序=顺序；
}
@凌驾
公共整数大小（）{
返回delegate.size（）；
}
@凌驾
公共布尔值为空（）{
返回delegate.isEmpty（）；
}
@凌驾
公共布尔包含（对象o）{
返回委托。包含（o）；
}
@凌驾
公共迭代器迭代器（）{
返回delegate.iterator（）；
}
@凌驾
公共对象[]toArray（）{
返回delegate.toArray（）；
}
@凌驾
公共T1[]toArray（T1[]a）{
将代表返回至阵列（a）；
}
@凌驾
公共布尔加法（T）{
int i=0；
对于（；i