16.禁用双层for循环后的替代方法

判断两个集合/数组中是否有相同值的思路:

1.将内层循环设为索引,new一个HashMap放入其中,遍历原先内层循环的集合或数组,然后map.put(),将key设为原先内层循环的值,将value设为1
2.判断时:原先的外层for循环不变,循环内部用

if(map.get(外层循环数组或集合[i]) != null){
	//进入了if内,则有相同的值,并且相同的值是:外层循环数组或集合[i]
}

判断外层集合/数组和内层集合/数组有无重复值

示例代码:

	/**
	 * 券规则分配
	 * @param couponRuleDistributionResultVOList
	 * @param marketingOrganizationId
	 * @return
	 * @author: michael
	 * @date: 2019/12/23 17:39
	*/
	@Override
	@Transactional
	public Result<?> insertOrUpdateCouponRuleDistribution(
			List<CouponRuleDistributionResultVO> couponRuleDistributionResultVOList) {
		User user = UserUtil.getUserInfo();
		Integer tenantId = user.getTenantId();
		// A是传入的参数 B是数据库中的数据
		// 创建存放 数据库中已有组织id的集合 A和B都有的情况
		List<Integer> updateIds = new ArrayList<Integer>();
		// 创建存放 需要新加入表中的组织id集合 A有B没有的情况
		List<Integer> insertIds = new ArrayList<Integer>();
		// 创建存放 删除数据库中已经取消的组织id集合数组 B有A没有的情况
		List<Integer> deleteIds = new ArrayList<Integer>();
		// 传入的已分配的组织id数组,不为空
		Integer[] targetMarketingOrganizationIdIds = new Integer[couponRuleDistributionResultVOList.size()];
		if (couponRuleDistributionResultVOList != null && couponRuleDistributionResultVOList.size() > 0) {
			for (int i = 0; i < couponRuleDistributionResultVOList.size(); i++) {
				targetMarketingOrganizationIdIds[i] = couponRuleDistributionResultVOList.get(i)
						.getTargetMarketingOrganizationId();
			}
		} else {
			// 传入的为空,删除当前租户下该规则的所有组织(根据租户id+规则id)
			MutipleCondition where = new MutipleCondition();
			where.add(
					new SingleCondition().setField(CouponRuleDistributionDao.ruleId).setOperator(CompareOperator.EQUAL)
							.setLongs(couponRuleDistributionResultVOList.get(0).getRuleId()));
			where.add(new SingleCondition().setField(CouponRuleDistributionDao.tenantId)
					.setOperator(CompareOperator.EQUAL).setIntegers(tenantId));
			Assert.isSaveSuccess(couponRuleDistributionDao.delete(where), ErrorConstant.C000, ErrorConstant.M000,
					"券规则分配时删除异常");
		}
		// 查询已分配的组织
		CouponRuleDistribution arg = new CouponRuleDistribution();
		arg.setTenantId(tenantId);
		arg.setRuleId(couponRuleDistributionResultVOList.get(0).getRuleId());
		// 查询数据库中已分配的组织
		List<CouponRuleDistribution> list = couponRuleDistributionDao.selectRowsByEntity(arg);
		if (list == null || list.size() == 0) {
			// 数据库中没有数据,直接将传入集合新增
			for (int i = 0; i < couponRuleDistributionResultVOList.size(); i++) {
				insertIds.add(couponRuleDistributionResultVOList.get(i).getTargetMarketingOrganizationId());
			}
			// 批量新增传入的组织集合
			insertDistribution(insertIds, couponRuleDistributionResultVOList);
			return Result.success();
		}
		Integer[] alreadyIds = new Integer[list.size()];
		for (int i = 0; i < list.size(); i++) {
			alreadyIds[i] = list.get(i).getTargetMarketingOrganizationId();
		}
		// 将数据库已有的组织id放入map中
		HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
		for (Integer i = 0; i < alreadyIds.length; i++) {
			map.put(alreadyIds[i], 1);
		}
		// 保存 更新的ids
		for (int i = 0; i < targetMarketingOrganizationIdIds.length; i++) {
			// 新分配的在数据库中已有
			if (map.get(targetMarketingOrganizationIdIds[i]) != null) {
				updateIds.add(targetMarketingOrganizationIdIds[i]);
				targetMarketingOrganizationIdIds[i] = 0;
			}
		}
		// 保存 新增的ids,不为0的都是需要新增的
		for (int i = 0; i < targetMarketingOrganizationIdIds.length; i++) {
			if (targetMarketingOrganizationIdIds[i] != 0) {
				insertIds.add(targetMarketingOrganizationIdIds[i]);
			}
		}

		// 重新获取传入的目标组织(因为之前部分置为了0)
		Integer[] newTargetMarketingOrganizationIdIds = new Integer[couponRuleDistributionResultVOList.size()];
		if (couponRuleDistributionResultVOList != null && couponRuleDistributionResultVOList.size() > 0) {
			for (int i = 0; i < couponRuleDistributionResultVOList.size(); i++) {
				newTargetMarketingOrganizationIdIds[i] = couponRuleDistributionResultVOList.get(i)
						.getTargetMarketingOrganizationId();
			}
		}
		HashMap<Integer, Integer> mapDelete = new HashMap<Integer, Integer>();
		for (Integer i = 0; i < newTargetMarketingOrganizationIdIds.length; i++) {
			mapDelete.put(newTargetMarketingOrganizationIdIds[i], 1);
		}
		// 传入的组织在数据库中已有,将其置为0
		for (int i = 0; i < alreadyIds.length; i++) {
			if (mapDelete.get(alreadyIds[i]) != null) {
				alreadyIds[i] = 0;
			}
		}
		// 保存 删除的ids
		for (int i = 0; i < alreadyIds.length; i++) {
			if (alreadyIds[i] != 0) {
				deleteIds.add(alreadyIds[i]);
			}
		}

		// 根据updateIds更新
		CouponRuleDistribution updateArg = new CouponRuleDistribution();
		updateArg.setTenantId(tenantId);
		updateArg.setRuleId(couponRuleDistributionResultVOList.get(0).getRuleId());
		updateArg.setUpdated(user.getId());
		updateArg.setUpdatedAt(LocalDateTime.now());
		updateArg.setDeleted(CommonConstant.FALSE);
		updateDistribution(updateIds, updateArg);
		// 根据insertIds新增
		insertDistribution(insertIds, couponRuleDistributionResultVOList);
		// 根据deleteIds删除(直接删除)
		CouponRuleDistribution deleteArg = new CouponRuleDistribution();
		deleteArg.setTenantId(tenantId);
		deleteArg.setRuleId(couponRuleDistributionResultVOList.get(0).getRuleId());
		deleteDistribution(deleteIds, deleteArg);

		return Result.success();
	}
	
	
	/**
	 * 批量更新分配表
	 * @param updateIds
	 * @param updateArg
	 * @author: michael
	 * @date: 2020/01/07 09:47
	*/
	private void updateDistribution(List<Integer> updateIds,CouponRuleDistribution updateArg) {
		MutipleCondition where = new MutipleCondition();
		where.add(new SingleCondition().setField(CouponRuleDistributionDao.targetMarketingOrganizationId)
				.setOperator(CompareOperator.IN).setIterable(updateIds));
		//根据条件更新
		Assert.isSaveSuccess(couponRuleDistributionDao.updateByCondition(updateArg,where), 
				ErrorConstant.C000,ErrorConstant.M000,"券规则分配时更新异常");
	}
	
	/**
	 * 批量新增分配
	 * @param insertIds
	 * @param insertArg
	 * @author: michael
	 * @date: 2020/01/07 09:48
	*/
	private void insertDistribution(List<Integer> insertIds,List<CouponRuleDistributionResultVO> couponRuleDistributionResultVOList) {
		User user = UserUtil.getUserInfo();
		List<CouponRuleDistribution> list = new ArrayList<CouponRuleDistribution>();
		for (Integer targetMarketingOrganizationId : insertIds) {
			CouponRuleDistribution couponRuleDistribution = new CouponRuleDistribution();
			couponRuleDistribution.setTargetMarketingOrganizationId(targetMarketingOrganizationId);
			couponRuleDistribution.setTenantId(user.getTenantId());
			couponRuleDistribution.setRuleId(couponRuleDistributionResultVOList.get(0).getRuleId());
			couponRuleDistribution.setUpdated(user.getId());
			couponRuleDistribution.setUpdatedAt(LocalDateTime.now());
			couponRuleDistribution.setDeleted(CommonConstant.FALSE);
			couponRuleDistribution.setCreatedAt(LocalDateTime.now());
			couponRuleDistribution.setCreated(user.getId());
			list.add(couponRuleDistribution);
		}
		Assert.isSaveSuccess(couponRuleDistributionDao.inserts(list), 
				ErrorConstant.C000,ErrorConstant.M000,"券规则分配时新增异常");
	}
	
	/**
	 * 批量删除分配
	 * @param deleteIds
	 * @param deleteArg
	 * @author: michael
	 * @date: 2020/01/07 09:48
	*/
	private void deleteDistribution(List<Integer> deleteIds,CouponRuleDistribution deleteArg) {
		//删除券规则分配关系表(根据规则,租户,营销组织)
		MutipleCondition where = new MutipleCondition();
		where.add(new SingleCondition().setField(CouponRuleDistributionDao.targetMarketingOrganizationId)
				.setOperator(CompareOperator.IN).setIterable(deleteIds));
		where.add(new SingleCondition().setField(CouponRuleDistributionDao.ruleId)
				.setOperator(CompareOperator.EQUAL).setLongs(deleteArg.getRuleId()));
		where.add(new SingleCondition().setField(CouponRuleDistributionDao.tenantId)
				.setOperator(CompareOperator.EQUAL).setIntegers(UserUtil.getUserInfo().getTenantId()));
		Assert.isSaveSuccess(couponRuleDistributionDao.delete(where), 
				ErrorConstant.C000,ErrorConstant.M000,"券规则分配时删除异常");
	}