java1.8 流学习记录-oracle学习记录

java-stream

根据实体类对象中某个属性进行过滤：
resultList = resultList.stream()
                            .filter(o -> o.getCategory().getCategoryId().equals(dto.getCategoryId()))
                            .collect(Collectors.toList());
根据集合中某个对象的属性值进行排序：
resultList.sort(((o1, o2) -> Integer.parseInt(o1.getDistance()) - 
								Integer.parseInt(o2.getDistance())));
根据日期类型时间执行排序：
list = list.stream().sorted(Comparator.comparing(FunzoneListVo::getUpdateDate).reversed())
        .collect(Collectors.toList());
        
list = list.stream().sorted((o1,o2)->{
		try {
			return (int)(
					(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(o1.getBrand()).getTime())
					-(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(o2.getBrand()).getTime())
					);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return 0;
	}
			)
		.collect(Collectors.toList());
多条件，有null值排序（在前：Comparator.nullsFirst(Integer::compareTo)，在后：Comparator.nullsLast(Integer::compareTo)）：
(.reversed():表示集合按当前字段进行倒叙，之后再按另一个字段进行倒叙；.thenComparing(QueryProxyInfoVo::getTotalAmount,Comparator.reverseOrder())：根据第一个属性进行排序之后，当属性值相同，再根据另一个属性进行排序)
list = list.stream().sorted(Comparator.comparing(QueryProxyInfoVo::getExamineSettleStatus
						,Comparator.nullsFirst(Integer::compareTo)).reversed()
                        .thenComparing(QueryProxyInfoVo::getTotalAmount,Comparator.reverseOrder())
                        .thenComparing(QueryProxyInfoVo::getCreateDate,Comparator.reverseOrder()))
                        .collect(Collectors.toList());
集合转map:
//不保证之前集合的排序
Map<String,ExpandProductDto> map = list.stream().collect(Collectors
						.toMap(ExpandProductDto::getProductId,ExpandProductDto->ExpandProductDto));
//保证之前的排序
Map<String, List<QueryProjectInfoVo>> map = list.stream().filter(o -> StringUtils.isNotEmpty(o.getCategoryName()))
                .collect(Collectors.groupingBy(o->o.getCategoryName(),LinkedHashMap::new,Collectors.toList()));
按字母分组：
Map<String, List<CityInfo>> collect = list.stream().filter(item -> StringUtils.isNotEmpty(item.getFirstLetter()))
                .collect(Collectors.groupingBy(CityInfo::getFirstLetter));
Map操作：
Map<String, List<QueryProjectInfoVo>> map = list.stream().filter(o -> StringUtils.isNotEmpty(o.getCategoryName()))
                .collect(Collectors.groupingBy(QueryProjectInfoVo::getCategoryName));
        if(StringUtils.isBlank(dto.getCategoryId())){//非点击更多操作，商品仅保留前6个
            for (Map.Entry<String, List<QueryProjectInfoVo>> entry : map.entrySet()) {
                if(entry.getValue().size() > 6){
                    entry.setValue(entry.getValue().subList(0,6));
                }
            }
        }
map指定排序：
//Java8中使用Stream对map进行排序
Map<Integer, List> result = map.entrySet().stream()
        .sorted(Map.Entry.comparingByKey())
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                (oldValue, newValue) -> oldValue, LinkedHashMap::new));
//如果是根据关键字进行顺序排序，也可直接将HashMap的数据放入TreeMap中，保证关键字有序
对集合中某个字段进行指定字符的拼接：
a.若想要拼接的属性类型为整型，则需要转为字符串类型，然后进行指定字符的拼接
List<Integer> celebrityIdList = celebrityList().stream().filter(o -> null != 
		o.getCelebrityId()).map(OpenCelebrityVo::getCelebrityId)
		.collect(Collectors.toList());//整型集合
String celebrityId = 
		celebrityIdList.stream().map(String::valueOf).collect(Collectors.joining(","));//整型转字符串拼接
b.对集合中字符串类型执行拼接
String celebrityName = celebrityList().stream().filter(o -> null != 
	o.getName()).map(OpenCelebrityVo::getName).collect(Collectors.joining(","));
集合根据某个字段去重：
funzoneTypeDOList.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getId()))), ArrayList::new));
对两个集合进行比较，判断其中一个集合是否存在另一个集合中的属性值，可根据某个属性值是否存在在另一个集合中
for(FunzoneTypeInfoVo vo : funzoneTypeDOList){
    if(resultList.stream().filter(o -> o.getTypeName().equals(vo.getTypeName())).count() <= 0){//不包含
        //不包含指定的字段值
    }
}
Map转为List：
List<MallSkuStockStateDTO> tempSkuList = mapGiftSku.entrySet().stream()
                        .map(o->new MallSkuStockStateDTO(o.getKey(),o.getValue())).collect(Collectors.toList());
java.stream 集合指定大小切割
public static void main(String[] args) {
	int max = 3;
	List<Integer> list = Lists.newArrayList();
	for(int i=0;i<20;i++){
	    list.add(i);
	}
	System.err.println("----------"+JSONObject.toJSONString(list));
	
	int limit = (list.size() + max - 1) / max;
	
	List<List<Integer>> mglist = new ArrayList<>();
	Stream.iterate(0, n -> n + 1).limit(limit).forEach(i -> {
	    mglist.add(list.stream().skip(i * max).limit(max).collect(Collectors.toList()));
	});
	
	System.err.println("----------"+JSONObject.toJSONString(mglist));
	
	List<List<Integer>> splitList = Stream.iterate(0, n -> n + 1).limit(limit).parallel()
	        .map(a -> list.stream().skip(a * max).limit(max).parallel().collect(Collectors.toList())).collect(Collectors.toList());
	
	System.out.println(splitList);
	}
stream分组过滤：
Map<String, List<QueryScheduleVO>> map = list.stream()
                    .collect(Collectors.groupingBy(QueryScheduleVO::getFilmName));
            List<QueryScheduleVO> temp = null;
            List<QueryScheduleVO> temp0 = null;
            for (Map.Entry<String, List<QueryScheduleVO>> mapList : map.entrySet()) {
                temp = mapList.getValue();//分组结果
                if (CollectionUtils.isEmpty(temp)){
                    continue;
                }
                Map<String, List<QueryScheduleVO>> tempMap = temp.stream()
                        .collect(Collectors.groupingBy(QueryScheduleVO::getShowTime));
                for (Map.Entry<String, List<QueryScheduleVO>> mapList0 : tempMap.entrySet()) {
                    temp0 = mapList0.getValue();//分组结果
                    if (CollectionUtils.isEmpty(temp0)){
                        continue;
                    }
                    //权重值越小，优先级越高
                    Optional<QueryScheduleVO> optional = Optional.ofNullable(temp0.stream().filter(o->o.getChannelStatus()).min(Comparator.comparing(QueryScheduleVO::getSettlePrice)
                            .thenComparing(QueryScheduleVO::getWight))).orElse(null);
                    if(optional.isPresent()){
                        result.add(optional.get());
                    }
                }
            }
            result = result.stream().sorted(Comparator.comparing(QueryScheduleVO::getShowTime))
                    .collect(Collectors.toList());
集合移除：
CopyOnWriteArrayList<MallSkuStockStateDTO> copy = new CopyOnWriteArrayList<>(skuStockQueryDTO.getSkuList());
if(CollectionUtils.isNotEmpty(skuListLockBuy)){//集合为空，不需要执行该逻辑
    for(MallSkuStockStateDTO dto : copy){
        if(skuListLockBuy.stream().filter(o->o.equals(dto.getSkuId())).count() > 0){//该sku不能购买
            copy.remove(dto);
        }
    }
}
list实现数据分页：
/**
 *
 * 开始分页
 * @param list
 * @param pageNum  页码
 * @param pageSize 每页多少条数据
 * @return
 */
public static List startPage(List list, Integer pageNum, Integer pageSize) {
    if (list == null||list.size() == 0) {
        return new ArrayList<>(0);
    }

    Integer count = list.size(); // 记录总数
    Integer pageCount = 0; // 页数
    if (count % pageSize == 0) {
        pageCount = count / pageSize;
    } else {
        pageCount = count / pageSize + 1;
    }

    int fromIndex = 0; // 开始索引
    int toIndex = 0; // 结束索引

    if (pageNum != pageCount) {
        fromIndex = (pageNum - 1) * pageSize;
        toIndex = fromIndex + pageSize;
    } else {
        fromIndex = (pageNum - 1) * pageSize;
        toIndex = count;
    }
    if(fromIndex >= list.size()){
        log.info("当前数据下标超过集合最大数据下标");
        return new ArrayList();
    }
    List pageList = list.subList(fromIndex, toIndex);
    return pageList;
}

java-LocalDateTime

比较时间先后顺序：
DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
OpenFetchTicketWayWithShowVO vo = it.next();
if(StringUtils.isNotBlank(vo.getOnTime()) && StringUtils.isNotBlank(vo.getOffTime())
&& LocalDateTime.now().isBefore(LocalDateTime.parse(vo.getOnTime(),df)) || LocalDateTime.now().isAfter(LocalDateTime.parse(vo.getOffTime(),df))){
	//执行过滤内容
}

oracle-sql

百度/腾讯坐标系转换：
https://blog.csdn.net/myfmyfmyfmyf/article/details/45717797
sql,通过经纬度直接计算当前位置与指定位置的距离
Round(Round(2 * Asin(Sqrt(power(sin(( #{latitude} - v.LATITUDE) * ACOS(- 1) / 180 / 2), 2) +
                cos( #{latitude} * ACOS( - 1 ) /180) * cos(v.LATITUDE * ACOS(- 1) / 180) * power(sin(( #{longitude} - v.LONGITUDE)
                * ACOS(- 1) / 180 / 2), 2))) * 6378137 * 10000) / 10000 ,0) as distance
oracle分页sql方式一写法（第一页取0，第二页取1....）：
select * from (
    	select ORDER_NO as orderNo, STATUS as status, rownum as rn from mall.qst_mall_order_info t where rownum <= (#{pageNum} + 1) * 50) t1 where t1.rn > #{pageNum} * 50;
分页方式二：
SELECT * FROM (
       SELECT TMP_PAGE.*, ROWNUM ROW_ID FROM ( 
           select p.GIFT_NO as giftNo, p.GIFT_NAME as giftName, nvl(p.COST_PRICE,0) as costPrice, p.GIFT_URL as giftUrl, s.SKU_ID as skuId 
           from MALL.QST_MALL_GIFT_PACK p left join MALL.QST_MALL_SKU s on s.PRODUCT_ID = p.GIFT_NO where p.CREATE_USER_ID = 'S11' and p.GROUP_ID = '1' 
       ) TMP_PAGE) WHERE ROW_ID <= 10 AND ROW_ID > 0
mybatis框架.xml注解，<=转义格式：<![CDATA[<=]]>;或者可以使用 &lt;&gt;
判断时间先后：to_date(p.last_show_time,'yyyy-mm-dd hh24:mi:ss') > to_date('2021-11-09 18:00:00', 'yyyy-mm-dd hh24:mi:ss')
sql分组查询获取指定字段排序后的最后几条数据
select t1.id,t1.wx_phone as id from
(
  select t.id,t.wx_phone,row_number() over(partition by t.wx_phone order by t.create_date) rn from mem.qst_member t
) t1
where t1.rn > 1 and t1.wx_phone is not null


oracle数据库根据条件，存在则修改数据，不存在则插入数据
<insert id="mergeIntoProject" parameterType="com.qst.prepay.mall.api.model.dto.AltProjectDto">
        MERGE INTO MALL.QST_MALL_ACTIVITY_INFO t USING (SELECT #{no,jdbcType=VARCHAR} AS NO FROM DUAL) T1
        ON (T1.NO = T.NO)
        WHEN MATCHED THEN
            UPDATE SET
                <if test="actName != null and actName != ''">
                    T.ACT_NAME=#{actName,jdbcType=VARCHAR},
                </if>
                T.CREATE_DATE = sysdate
        WHEN NOT MATCHED THEN
            INSERT (
                NO,ACT_NAME,START_DATE,END_DATE,CREATE_DATE,LOGO_IMG_URL,IS_BIDDING,PRIORITY,ENTRANCE_IMG_URL,
                HOME_GIFT_FLAG,CREATE_SALE_NO,FORECAST_EARN
            )
            values (
                #{no,jdbcType=DECIMAL},
                #{actName,jdbcType=VARCHAR},
                #{startDate,jdbcType=TIMESTAMP},
                #{endDate,jdbcType=TIMESTAMP},
                #{createDate,jdbcType=TIMESTAMP},
                #{logoImgUrl,jdbcType=VARCHAR},
                #{isBidding,jdbcType=DECIMAL},
                #{priority,jdbcType=DECIMAL},
                #{entranceImgUrl,jdbcType=VARCHAR},
                #{homeGiftFlag,jdbcType=DECIMAL},
                #{saleNo,jdbcType=VARCHAR},
                #{forecastEarn,jdbcType=DECIMAL}
            )
    </insert>

<if test="remark != null and remark != ''">
	REMARK = #{remark,jdbcType=VARCHAR},
</if>
<update id="updateCardInfoStatus" parameterType="string">
    update CARD.QST_CARD_INFO set STATUS = 1,UPDATE_DATE = sysdate where CARD_KIND = 1 and CARD_NO in
    <foreach collection="list" index="index" item="item" open="(" close=")" separator=",">
        #{item}
    </foreach>
</update>

mysql-sql

知识点：sql的执行顺序：
from -> join on -> where -> group by -> sum(),avg()...等聚合函数 -> having -> select -> distinct -> order by -> limit
DATE_SUB(SYSDATE(),INTERVAL 3 DAY)：表示当前时间的前三天的那天日期
DATE_ADD(SYSDATE(),INTERVAL 3 DAY)：表示当前时间的后三天的那天日期
update tb_in_out_record t set t.pass_time = DATE_SUB(SYSDATE(),INTERVAL 3 DAY)  WHERE t.id < 20 and t.id >=10;

SYSDATE()：2022-09-02 20:22:37
CURDATE()：2022-09-02 00:00:00

SELECT VERSION(); //查看当前数据库的版本号
show processlist;//查询当前数据库正在执行的进程
select @@global.sql_mode; 
设置当前或是全局用户的该参数（最好直接修改my.cnf数据库配置文件中的参数，永久有效：
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION）：
set GLOBAL sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION';
set session sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION'; 

mysql中的group by方式去重配合max()取值，这样取出的值会与预期效果不符，max方式取出的是所有分组数据中最大的那个字段的值，可能这些数据不是来自同一
条记录，是所有数据的结合体，解决方式如下：
SELECT
	id,
	audit_status
FROM
	(
	SELECT
			DISTINCT(a.id_number) idNumber, a.*
	FROM
			tb_report a
	WHERE
		a.id_number = '140221199511104819'
	ORDER BY
			a.id DESC 
	) t
GROUP BY
	id_number;
提示：如果报数据库语句分组错误，可尝试修改sql_mode参数，5.7版本之后该参数默认包含only_full

json

//解决三方接口大驼峰命名法的字段属性首字母大小写差异，返回数据首字母转为大写
方式一：
JSON.toJSONString(t,new PascalNameFilter());
方式二：
@JSONField(name = "CityId")

//解决json数据转化为对象/集合后使用报错
//引发原因：由于接三方接口json数据泛型后，对象为json数组类型，需要再次执行对象的具体指定，再次使用该对象是避免json类型转换的异常
String jsonStr = JSONObject.toJSONString(res.getData());
OpenVenueVo vo = JSONObject.parseObject(jsonStr, OpenVenueVo.class);
--------------------------------------------------------------------------------
String jsonStr = JSONObject.toJSONString(res.getData());
List<OpenCategoryVo> list = JSONObject.parseArray(jsonStr, OpenCategoryVo.class);

集合元素移除

CopyOnWriteArrayList<MallSkuStockStateDTO> copy = new CopyOnWriteArrayList<>(skuStockQueryDTO.getSkuList());
if(CollectionUtils.isNotEmpty(skuListLockBuy)){//集合为空，不需要执行该逻辑
    for(MallSkuStockStateDTO dto : copy){
        if(skuListLockBuy.stream().filter(o->o.equals(dto.getSkuId())).count() > 0){//该sku不能购买
            copy.remove(dto);
        }
    }
}

定时器：
https://blog.csdn.net/yjltx1234csdn/article/details/105846493