从 sql 数据库中获取属性值作为用户在 hashmap 中定义的 object

Question

public class Dashboard {
   int REQUEST_ID, PRICE, PROCESSED;           
   String LOGIN_USER;

public int getREQUEST_ID() {
   return REQUEST_ID;
}

public void setREQUEST_ID(int rEQUEST_ID) {
   REQUEST_ID = rEQUEST_ID;
}

//all getters and setters
public class DBConnection {
   public ArrayList<Dashboard>  getStoreResult() {
      ArrayList<Dashboard> dashRec;

   try{
      Class.forName("");
      Connection con=DriverManager.getConnection("");
      Statement st=con.createStatement();
      ResultSet rs=st.executeQuery("");

      HashMap<Object, List<Dashboard>> map = new HashMap<>();
      while (rs.next()) {
        Integer id = rs.getInt(1);
        if (!map.containsKey(id)) {
            dashRec= new ArrayList<Dashboard>();
            map.put(id, dashRec);
        }
        Dashboard dash = new Dashboard();
        dash.setREQUEST_ID(id);
        dash.setLOGIN_USER(rs.getString(2));
        dash.setPRICE(rs.getInt(3));
        dash.setPROCESSED(rs.getInt(4));
        map.get(id).add(dash);
      }
   }
  }
}

我想在上面的 hashmap 中添加用户定义的 object 的名称和状态。 名称必须像前 3 组的 A，接下来的 2 组行的 B 。我要插入的状态必须是相同 ID 的行集中的最小数字。 也就是说，ID 为 123，我们需要将状态 1 作为 object 插入 hashmap 中，对于 id 456，我们需要状态 2。如何完成？

Answer 1

您可以像这样在 while 循环之后循环 map

检查列表大小是否为 3、2 或 1

根据您的帖子查询，有 3、2 和 1 行，我想

当行为 3 时状态从 1 到 3 当行为 2 时状态从 2 到 3 当 1 行时状态 1

基于此，我写了一个条件来检查：

大小列表：3 -> (3-3) +1 = 2

大小列表：2 -> (3-2) +1 = 2

大小列表：1 -> (3-1) +1 = 3

原子整数

因为我在Foreach中使用Stream Dashboard list ，并且如果您想访问此方法之外的任何变量，请将其标记为 final。 所以我添加了 AtomicInteger 的 Object

更多信息原子 Integer Oracle

        // create another map contains the lowest status for each id
        Map<Integer, Integer> lowestStatus = new HashMap<>();
        for (Integer key : map.keySet()) {

            // get the size of the list related to that id
            int size = map.get(key).size();
            int status = (3 - size) + 1;
            final AtomicInteger statusCounter = new AtomicInteger(status);

            if (status != 3) {
                map.get(key).forEach(dashboard -> {
                    if (!lowestStatus.containsKey(key))
                        lowestStatus.put(key, statusCounter.get());

                    dashboard.setStatus(statusCounter.getAndIncrement());
                });

            } else {
                Dashboard dashboard = map.get(key).get(0);
                dashboard.setStatus(1);
                lowestStatus.put(key, 1);
            }
        }

, 另一个版本

当前状态

必须跟踪该 ID 时的最后状态是什么

最低状态

将第一个匹配项保存到具有给定 id 的给定行集将取 1 个值

        Map<Integer, List<Dashboard>> map = new HashMap<>();
        Map<Integer, Integer> lowestStatus = new HashMap<>();
        Map<Integer, Integer> currentStatus = new HashMap<>();

        while (rs.next()) {
            Integer id = rs.getInt(1);
            if (!map.containsKey(id)) {
                map.put(id, new ArrayList<Dashboard>());
                currentStatus.put(id, 0);
                lowestStatus.put(id, 1);
            }
            Dashboard dash = new Dashboard();
            dash.setRequestId(id);
            dash.setLoginUser(rs.getString(2));
            dash.setPrice(rs.getInt(3));
            dash.setProcessed(rs.getInt(4));
            dash.setStatus(currentStatus.get(id) + 1);
            currentStatus.put(id, currentStatus.get(id) + 1); // update the status for the next iteration
            map.get(id).add(dash);
        }

Answer 2

如果我清楚地理解了您的要求，您想按requestId的升序对Map进行排序，然后按status的升序对具有相同requestId的Dashboard记录列表进行排序。 如果是这样，下面给出的是相同的解决方案：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

class Dashboard {
    private int requestId, price, processed;
    String loginUser;

    public Dashboard(int requestId, String loginUser, int price, int processed) {
        this.requestId = requestId;
        this.price = price;
        this.processed = processed;
        this.loginUser = loginUser;
    }

    public int getRequestId() {
        return requestId;
    }

    public int getPrice() {
        return price;
    }

    public int getProcessed() {
        return processed;
    }

    public String getLoginUser() {
        return loginUser;
    }

    @Override
    public String toString() {
        return requestId + "\t" + price + "\t" + processed + "\t" + loginUser;
    }
}

public class Main {
    public static void main(String[] args) {
        Map<Object, List<Dashboard>> map = new TreeMap<>();
        List<Dashboard> list;

        list = new ArrayList<Dashboard>();
        list.add(new Dashboard(456, "B", 25, 2));
        list.add(new Dashboard(456, "B", 20, 3));
        map.put(456, list);

        list = new ArrayList<Dashboard>();
        list.add(new Dashboard(123, "A", 10, 2));
        list.add(new Dashboard(123, "A", 15, 3));
        list.add(new Dashboard(123, "A", 5, 1));
        map.put(123, list);

        list = new ArrayList<Dashboard>();
        list.add(new Dashboard(789, "C", 30, 1));
        map.put(789, list);

        // Sort the list of Dashboard records with the same requestId in ascending order
        // of status
        for (Entry<Object, List<Dashboard>> entry : map.entrySet()) {
            Collections.sort(entry.getValue(), Comparator.comparing(Dashboard::getProcessed));
        }

        // Display Result
        System.out.println("reqid\tname\tprice\tstatus");
        for (List<Dashboard> recordList : map.values()) {
            for (Dashboard record : recordList) {
                System.out.println(record.getRequestId() + "\t" + record.getLoginUser() + "\t" + record.getPrice()
                        + "\t" + record.getProcessed());
            }
        }
    }
}

Output：

reqid   name    price   status
123     A       5       1
123     A       10      2
123     A       15      3
456     B       25      2
456     B       20      3
789     C       30      1

笔记：

1. 我使用了根据其键的自然顺序排序的TreeMap 。 由于键是int requestId ，我们不需要做任何事情来比较它们。 TreeSet会自动将它们按升序排列。
2. 要按status的升序对具有相同requestId的Dashboard记录列表进行排序，我使用requestId作为键获得了Dashboard记录列表，然后使用Comparator.comparing(Dashboard::getProcessed)对List进行排序。