工作中使用的工具类

集合去重合并

    private List<OrderBillItem> sumItems(List<OrderBillItem> billItems){
        List<OrderBillItem> items = new ArrayList<>();
        for (OrderBillItem oldItem: billItems) {
            int i;
            for(i= 0; i < items.size();i++){
                OrderBillItem newItem = items.get(i);
                if(oldItem.getArticle().getUuid().equals(newItem.getArticle().getUuid())
                        &&oldItem.getQpcStr().equals(newItem.getQpcStr())){
                    newItem.setQtyStr(PubFunction.addDiffQtyStr(newItem.getQtyStr(), oldItem.getQtyStr()));
                    newItem.setReceivedQtyStr(PubFunction.addDiffQtyStr(newItem.getReceivedQtyStr(), oldItem.getReceivedQtyStr()));
                    break;
                }
            }

            if(i == items.size()){
                items.add(oldItem);
            }
        }
        return items;
    }

基本数据类型和包装类之间相互转换

/**
 * @author: YXY
 * @date: 2021/7/13 10:56
 * @Version 1.0
 */
/**
 * 基本类型数组与包装类型数组相互转换的工具类
 */
public  class CastArrayUtil {
    private CastArrayUtil(){}

    /**
     * 将基本类型数组转换为对应的包装类型数组
     *
     * @param original
     * @return
     */
    public static Byte[] toWrap(byte[] original) {
        int length = original.length;
        Byte[] dest = new Byte[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将基本类型数组转换为对应的包装类型数组
     *
     * @param original
     * @return
     */
    public static Float[] toWrap(float[] original) {
        int length = original.length;
        Float[] dest = new Float[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将基本类型数组转换为对应的包装类型数组
     *
     * @param original
     * @return
     */
    public static Double[] toWrap(double[] original) {
        int length = original.length;
        Double[] dest = new Double[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将基本类型数组转换为对应的包装类型数组
     *
     * @param original
     * @return
     */
    public static Boolean[] toWrap(boolean[] original) {
        int length = original.length;
        Boolean[] dest = new Boolean[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将基本类型数组转换为对应的包装类型数组
     *
     * @param original
     * @return
     */
    public static Long[] toWrap(long[] original) {
        int length = original.length;
        Long[] dest = new Long[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将基本类型数组转换为对应的包装类型数组
     *
     * @param original
     * @return
     */
    public static Character[] toWrap(char[] original) {
        int length = original.length;
        Character[] dest = new Character[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将基本类型数组转换为对应的包装类型数组
     *
     * @param original
     * @return
     */
    public static Integer[] toWrap(int[] original) {
        int length = original.length;
        Integer[] dest = new Integer[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将基本类型数组转换为对应的包装类型数组
     *
     * @param original
     * @return
     */
    public static Short[] toWrap(short[] original) {
        int len = original.length;
        Short[] dest = new Short[len];
        for (int i = 0; i < len; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将包装类型数组转换为对应的基本类型数组
     *
     * @param original
     * @return
     */
    public static byte[] toPrimitive(Byte[] original) {
        int length = original.length;
        byte[] dest = new byte[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将包装类型数组转换为对应的基本类型数组
     *
     * @param original
     * @return
     */
    public static float[] toPrimitive(Float[] original) {
        int length = original.length;
        float[] dest = new float[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将包装类型数组转换为对应的基本类型数组
     *
     * @param original
     * @return
     */
    public static double[] toPrimitive(Double[] original) {
        int length = original.length;
        double[] dest = new double[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将包装类型数组转换为对应的基本类型数组
     *
     * @param original
     * @return
     */
    public static boolean[] toPrimitive(Boolean[] original) {
        int length = original.length;
        boolean[] dest = new boolean[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将包装类型数组转换为对应的基本类型数组
     *
     * @param original
     * @return
     */
    public static long[] toPrimitive(Long[] original) {
        int length = original.length;
        long[] dest = new long[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将包装类型数组转换为对应的基本类型数组
     *
     * @param original
     * @return
     */
    public static char[] toPrimitive(Character[] original) {
        int length = original.length;
        char[] dest = new char[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

    /**
     * 将包装类型数组转换为对应的基本类型数组
     *
     * @param original
     * @return
     */
    public static int[] toPrimitive(Integer[] original) {
        int length = original.length;
        int[] dest = new int[length];
        for (int i = 0; i < length; i++) {
            dest[i] = original[i];
        }
        return dest;
    }
    /**
     * 将包装类型数组转换为对应的基本类型数组
     *
     * @param original
     * @return
     */
    public static short[] toPrimitive(Short[] original) {
        int len = original.length;
        short[] dest = new short[len];
        for (int i = 0; i < len; i++) {
            dest[i] = original[i];
        }
        return dest;
    }

}

自定义排序

  private void sortContainerArt(List<ContainerArt> arts){
    Map<BinUsage, Integer> usageOrderMap = Maps.newHashMap();
    usageOrderMap.put(BinUsage.PickUpBin, 1);
    usageOrderMap.put(BinUsage.PickUpStorageBin, 2);
    usageOrderMap.put(BinUsage.StorageBin, 3);
    arts.sort(
            Comparator.<ContainerArt>comparingInt(item -> usageOrderMap.getOrDefault(item.getBinUsage(), 100))
                    .thenComparing(ContainerArt::getBinCode)
                    .thenComparing(s -> s.getArticle().getArticleCode())
                    .thenComparing(ContainerArt::getContainerBarcode));
  }

动态分配

  private Map<String, QtyAndCaseQtyStr> refreshItem(List<PVendorRtnPickBillItem> items,
      VendorPickProfile pickArticle, PickupBillItemState pickState,
      Map<String, QtyAndCaseQtyStr> ntcItemQtyMap, OperateContext<?> operCtx) {
    Map<String, QtyAndCaseQtyStr> itemQtyMap = Maps.newHashMap();

    BigDecimal planQty = pickArticle.getQty();
    String planQtyStr = pickArticle.getQtyStr();
    for (PVendorRtnPickBillItem item : items) {
      SettleUnit settleUnit = SettleUnit.valueOf(item.getSettleUnit());

      if (item.getPickTime() == null) {
        item.setPickTime(operCtx.getTime());
      }

      if (SettleUnit.QTY.equals(settleUnit) && BigDecimal.ZERO.compareTo(planQty) >= 0) {
        item.setState(pickState.name());
        if (StringUtil.isNullOrBlank(item.getRealQtyStr())) {
          item.setRealQtyStr(QpcStrUtils.QTYSTR_ZERO);
        }
        if (!StringUtil.isNullOrEmpty(item.getNtcItemUuid())) {
          QtyAndCaseQtyStr caseQtyStr = ntcItemQtyMap.get(item.getNtcItemUuid());
          if (caseQtyStr != null) {
            ntcItemQtyMap.put(item.getNtcItemUuid(),
                    new QtyAndCaseQtyStr(BigDecimal.ZERO.add(caseQtyStr.getQty()), QpcStrUtils.add(QpcStrUtils.QTYSTR_ZERO,caseQtyStr.getQtyStr())));
          } else {
            ntcItemQtyMap.put(item.getNtcItemUuid(),
                    new QtyAndCaseQtyStr(BigDecimal.ZERO, QpcStrUtils.QTYSTR_ZERO));
          }
        }
        continue;
      }

      if (SettleUnit.WEIGHT.equals(settleUnit) && BigDecimal.ZERO.compareTo(planQty) >= 0
          && BigDecimal.ZERO.compareTo(new BigDecimal(planQtyStr)) >= 0) {
        item.setState(pickState.name());
        if (StringUtil.isNullOrBlank(item.getRealQtyStr())) {
          item.setRealQtyStr(QpcStrUtils.QTYSTR_ZERO);
        }
        if (!StringUtil.isNullOrEmpty(item.getNtcItemUuid())) {
          QtyAndCaseQtyStr caseQtyStr = ntcItemQtyMap.get(item.getNtcItemUuid());
          if (caseQtyStr != null) {
            ntcItemQtyMap.put(item.getNtcItemUuid(),
                    new QtyAndCaseQtyStr(BigDecimal.ZERO.add(caseQtyStr.getQty()), QpcStrUtils.freshAdd(QpcStrUtils.QTYSTR_ZERO,caseQtyStr.getQtyStr())));
          }else {
            ntcItemQtyMap.put(item.getNtcItemUuid(),
                    new QtyAndCaseQtyStr(BigDecimal.ZERO, QpcStrUtils.QTYSTR_ZERO));
          }
        }
        continue;
      }

      BigDecimal unPickQty = item.getQty().subtract(item.getRealQty());
      String unPickQtyStr = SettleUnit.QTY.equals(settleUnit) ?
          QpcStrUtils.toQtyStr(unPickQty, item.getQpcStr()) :
          new BigDecimal(item.getQtyStr()).subtract(new BigDecimal(item.getRealQtyStr()))
              .toString();

      if (planQty.compareTo(unPickQty) >= 0) {
        item.setRealQty(unPickQty.add(item.getRealQty()));
        item.setRealQtyStr(SettleUnit.QTY.equals(settleUnit) ?
            QpcStrUtils.toQtyStr(item.getRealQty(), item.getQpcStr()) :
            new BigDecimal(unPickQtyStr).add(new BigDecimal(item.getRealQtyStr())).toString());

        itemQtyMap.put(item.getUuid(), new QtyAndCaseQtyStr(unPickQty, unPickQtyStr));
        if (!StringUtil.isNullOrEmpty(item.getNtcItemUuid())) {
          if (ntcItemQtyMap.containsKey(item.getNtcItemUuid())) {
            QtyAndCaseQtyStr old = ntcItemQtyMap.get(item.getNtcItemUuid());
            BigDecimal newRealQty = old.getQty().add(unPickQty);
            String newQtyStr = QpcStrUtils.add(old.getQtyStr(), unPickQtyStr);
            ntcItemQtyMap.put(item.getNtcItemUuid(), new QtyAndCaseQtyStr(newRealQty, newQtyStr));
          } else {
            ntcItemQtyMap.put(item.getNtcItemUuid(), new QtyAndCaseQtyStr(unPickQty, unPickQtyStr));
          }
        }
      } else {
        item.setRealQty(planQty.add(item.getRealQty()));
        item.setRealQtyStr(SettleUnit.QTY.equals(settleUnit) ?
            QpcStrUtils.toQtyStr(item.getRealQty(), item.getQpcStr()) :
            new BigDecimal(planQtyStr).add(new BigDecimal(item.getRealQtyStr())).toString());

        itemQtyMap.put(item.getUuid(), new QtyAndCaseQtyStr(planQty, planQtyStr));
        if (!StringUtil.isNullOrEmpty(item.getNtcItemUuid())) {
          if (ntcItemQtyMap.containsKey(item.getNtcItemUuid())) {
            QtyAndCaseQtyStr old = ntcItemQtyMap.get(item.getNtcItemUuid());
            BigDecimal newRealQty = old.getQty().add(planQty);
            String newQtyStr = QpcStrUtils.add(old.getQtyStr(), planQtyStr);
            ntcItemQtyMap.put(item.getNtcItemUuid(), new QtyAndCaseQtyStr(newRealQty, newQtyStr));
          } else {
            ntcItemQtyMap.put(item.getNtcItemUuid(), new QtyAndCaseQtyStr(planQty, planQtyStr));
          }
        }
      }

      planQty = planQty.subtract(unPickQty);
      planQtyStr = SettleUnit.QTY.equals(settleUnit) ?
          QpcStrUtils.toQtyStr(planQty, item.getQpcStr()) :
          new BigDecimal(planQtyStr).subtract(new BigDecimal(unPickQtyStr)).toString();

      item.setState(item.getRealQty().compareTo(item.getQty()) >= 0 ?
          PickupBillItemState.FINISHED.name() :
          pickState.name());
      if (SettleUnit.WEIGHT.equals(settleUnit)) {
        item.setState(item.getRealQty().compareTo(item.getQty()) >= 0
            && new BigDecimal(item.getRealQtyStr()).compareTo(new BigDecimal(item.getQtyStr()))
            >= 0 ? PickupBillItemState.FINISHED.name() : pickState.name());
      }
    }

    return itemQtyMap;
  }