4.22

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量136 收藏
点赞数
分类专栏： practice 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mcdull__/article/details/116006765
版权

第二个接口算是写完了。。太坑了，主要难点在于，查数据库中没有的字段的值，要通过取的数据库中有的字段，然后写逻辑计算。而且还要与时间挂钩。

我的思路是，输入一个时间，然后把它分成一周的时间在sql里查取一周的数据（因为用到了周五的数据，所以查一周），然后对于不同种类的指数，进行逻辑计算。

呜呜呜~~~~

被== 和equals折磨了一天，才找到问题所在！！！血的教训

            if(list.get(0).getType().equals("SSEC")){
                list.get(0).setUpDown(new BigDecimal(888));
                list.get(1).setUpDown(new BigDecimal(999));
            }else if(list.get(0).getType().equals("CSI300")){
                list.get(0).setUpDown(new BigDecimal(999));
                list.get(1).setUpDown(new BigDecimal(888));
            }

上面如果写成== 则赋值不了。原因是，我们这里要比较的是内容，而不是地址！！！

1、功能不同

"=="是判断两个变量或实例是不是指向同一个内存空间。

"equals"是判断两个变量或实例所指向的内存空间的值是不是相同。

2、定义不同

"equals"在JAVA中是一个方法。

"=="在JAVA中只是一个运算符合。

 以StockByChinaCommandImpl为例，取出列表要这样写：从第97行开始。

package com.simnectzbank.lbs.processlayer.stock.service.command.impl;

import com.alibaba.fastjson.JSON;
import com.csi.sbs.common.business.constant.SuccessConstant;
import com.csi.sbs.common.business.model.HeaderModel;
import com.csi.sbs.common.business.util.ResponseUtil;
import com.csi.sbs.common.business.util.ResultUtil;
import com.simnectzbank.lbs.processlayer.stock.clientmodel.*;
import com.simnectzbank.lbs.processlayer.stock.component.LocaleMessage;
import com.simnectzbank.lbs.processlayer.stock.constant.ExceptionConstant;
import com.simnectzbank.lbs.processlayer.stock.constant.ResultConstant;
import com.simnectzbank.lbs.processlayer.stock.constant.SysConstant;
import com.simnectzbank.lbs.processlayer.stock.exception.RecordNotFoundException;
import com.simnectzbank.lbs.processlayer.stock.service.command.Command;
import com.simnectzbank.lbs.processlayer.stock.service.proxy.stockinfoservice.StockInfoService;
import com.simnectzbank.lbs.processlayer.stock.service.proxy.sysadminservice.SysTransactionLogService;
import com.simnectzbank.lbs.processlayer.stock.util.CalculationUtil;
import com.simnectzbank.lbs.processlayer.stock.util.DateToStamp;
import com.simnectzbank.lbs.processlayer.stock.util.IOperationLogUtil;
import com.simnectzbank.lbs.processlayer.stock.util.IRSendLogUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Component
public class StockByChinaCommandImpl extends Command {

    @Resource
    private LocaleMessage localeMessage;

    @Resource
    private IRSendLogUtil logUtil;

    @Autowired
    private SysTransactionLogService sysTransactionLogService;

    @Resource
    private StockInfoService stockInfoService;

    @Resource
    private IOperationLogUtil operationLogUtil;

    private String classname = StockByChinaCommandImpl.class.getName();


    @Override
    public void initialize(BusinessModel model, Map<String, Object> context) throws Exception {
        // debug log
        String method = "stockByChina-initialize";
        long threadId = Thread.currentThread().getId();
        HeaderModel header = model.getHeaderModel();
        logUtil.sendDebug(new Date().getTime() + "|" + threadId + "|" + SysConstant.SEND_DEBUG_HEADER + header.toString() + "|" + classname + "|" + method + SysConstant.SEND_DEBUG_METHOD_START);

        // Operation Log
        operationLogUtil.log(
                localeMessage.getMessage(ResultConstant.GET_STOCK_LIST),
                SysConstant.OPERATION_START,
                localeMessage.getMessage(ResultConstant.GET_STOCK_LIST),
                SysConstant.LOCAL_SERVICE_NAME,
                (String) context.get(SysConstant.TRANSACTION_ID),
                header);

        logUtil.sendDebug(new Date().getTime() + "|" + threadId + "|" + SysConstant.SEND_DEBUG_HEADER + header.toString() + "|" + classname + "|" + method + SysConstant.SEND_ERROR_LOG_METHOD_END);

    }

    @Override
    public ResultUtil execute(BusinessModel model) throws RecordNotFoundException, ParseException {
        String method = "stockByChina-execute";
        long threadId = Thread.currentThread().getId();
        logUtil.sendDebug(new Date().getTime() + "|" + threadId + "|" + classname + "|" + method  + SysConstant.SEND_DEBUG_METHOD_START);

        ResultUtil result = null;
        StockIndexModel stockIndexModel = (StockIndexModel) model.getTransctionModel();
        GetStockIndexModel getStockIndexModel = new GetStockIndexModel();
        //getStockIndexModel.setType(stockIndexModel.getType());

        Map<String, String> selectMap = DateToStamp.stamp2Date(stockIndexModel.getSelectDate());
        getStockIndexModel.setSelectDate(selectMap.get("sd0"));//获取一下值先，不参与逻辑
        getStockIndexModel.setFromDate(selectMap.get("sd7"));//过去七天
        getStockIndexModel.setToDate(selectMap.get("sd0"));


        ResultUtil stockResult = stockInfoService.findManyByChina(getStockIndexModel);
        List<StockIndexHistoryModel> list = JSON.parseArray((String) stockResult.getData(), StockIndexHistoryModel.class);
        if(list == null || list.size() == 0){
            throw new RecordNotFoundException(localeMessage.getMessage(ResultConstant.RECORD_NOTFOUND), ExceptionConstant.ERROR_CODE404010);
        }else{
            //  计算升跌
            if(list.get(0).getType().equals("SSEC")){
                list.get(0).setUpDown(CalculationUtil.calculateChinaUpDown(list).get("SSEC"));
                list.get(1).setUpDown(CalculationUtil.calculateChinaUpDown(list).get("CSI300"));
            }else if(list.get(0).getType().equals("CSI300")){
                list.get(0).setUpDown(CalculationUtil.calculateChinaUpDown(list).get("CSI300"));
                list.get(1).setUpDown(CalculationUtil.calculateChinaUpDown(list).get("SSEC"));
            }
            // 计算升跌率
            if(list.get(0).getType().equals("SSEC")){
                list.get(0).setUpDownPercentage(CalculationUtil.calculateChinaUpDownPercentage(list).get("SSEC"));
                list.get(1).setUpDownPercentage(CalculationUtil.calculateChinaUpDownPercentage(list).get("CSI300"));
            }else if(list.get(0).getType().equals("CSI300")){
                list.get(0).setUpDownPercentage(CalculationUtil.calculateChinaUpDownPercentage(list).get("CSI300"));
                list.get(1).setUpDownPercentage(CalculationUtil.calculateChinaUpDownPercentage(list).get("SSEC"));
            }
            //计算本周升跌
            if(list.get(0).getType().equals("SSEC")){
                list.get(0).setUpDownWeek(CalculationUtil.calculateChinaUpDownWeek(list).get("SSEC"));
                list.get(1).setUpDownWeek(CalculationUtil.calculateChinaUpDownWeek(list).get("CSI300"));
            }else if(list.get(0).getType().equals("CSI300")){
                list.get(0).setUpDownWeek(CalculationUtil.calculateChinaUpDownWeek(list).get("CSI300"));
                list.get(1).setUpDownWeek(CalculationUtil.calculateChinaUpDownWeek(list).get("SSEC"));
            }

            List<StockIndexHistoryModel> listTwo = new ArrayList<>();
            for(int i=0;i<2;i++){
                listTwo.add(list.get(i));
            }
            result = ResponseUtil.success(SuccessConstant.SUCCESS_CODE200, listTwo , localeMessage.getMessage(ResultConstant.SUCCESS_MSG));
        }

        logUtil.sendDebug(new Date().getTime() +"|" + threadId + "|" + classname + "|" + method  +  SysConstant.SEND_ERROR_LOG_METHOD_END );
        return result;
    }



    @Override
    public void finalize(BusinessModel model, Map<String, Object> context) throws Exception {
        // debug log
        String method = "stockByChina-finalize";
        long threadId = Thread.currentThread().getId();
        HeaderModel header = model.getHeaderModel();
        logUtil.sendDebug(new Date().getTime() + "|" + threadId + "|" + SysConstant.SEND_DEBUG_HEADER + header.toString() + "|" + classname + "|" + method + SysConstant.SEND_DEBUG_METHOD_START);

        boolean flag = (boolean) context.get(SysConstant.LOGICFLAG);
        // Operation Log
        operationLogUtil.log(
                localeMessage.getMessage(ResultConstant.GET_STOCK_LIST),
                flag? SysConstant.OPERATION_SUCCESS:SysConstant.OPERATION_ERROR,
                localeMessage.getMessage(ResultConstant.GET_STOCK_LIST),
                SysConstant.LOCAL_SERVICE_NAME,
                (String) context.get(SysConstant.TRANSACTION_ID),
                header);

        logUtil.sendDebug(new Date().getTime() + "|" + threadId + "|" + SysConstant.SEND_DEBUG_HEADER + header.toString() + "|" + classname + "|" + method + SysConstant.SEND_ERROR_LOG_METHOD_END);

    }
}

汇报完了，要修改的地方：（小意思）

1.swagger显示的时候要默认参数

2.算出来的每周升跌率要加%

package com.simnectzbank.lbs.processlayer.stock.util;

import com.simnectzbank.lbs.processlayer.stock.clientmodel.StockIndexHistoryModel;
import java.math.BigDecimal;
import java.text.ParseException;
import java.util.*;
import java.util.stream.Collectors;

public class CalculationUtil {
    @SuppressWarnings("unchecked")
    public static Map<String, BigDecimal> calculateChinaUpDown(List<StockIndexHistoryModel> list){

        //获取list对象的last字段组装成新list
        List<BigDecimal> lastList1 = list.stream().map(StockIndexHistoryModel::getLast).collect(Collectors.toList());
        List<String> typeList1 = list.stream().map(StockIndexHistoryModel::getType).collect(Collectors.toList());
        //创建UpDown的Map
        Map<String,BigDecimal> upDownMap = new HashMap<>();

        boolean flag1= true;
        boolean flag2= true;
        for(int i=0;i<2;i++){
            for(int j=0;j<list.size();j++){
                if(flag1 && flag2){
                    if(typeList1.get(i).equals("SSEC")){
                        for(int m =i+1;m<list.size();m++){
                            if(flag2){
                                if(typeList1.get(m).equals("SSEC")){
                                    BigDecimal subtract = lastList1.get(i).subtract(lastList1.get(m));
                                    upDownMap.put("SSEC",subtract);
                                    if(upDownMap.get("SSEC")!=null){
                                        flag2=false;
                                    }
                                }
                            }
                        }
                    }else if(typeList1.get(i).equals("CSI300")){
                        for(int n =i+1;n<list.size();n++){
                            if(flag1){
                                if(typeList1.get(n).equals("CSI300")){
                                    BigDecimal subtract = lastList1.get(i).subtract(lastList1.get(n));
                                    upDownMap.put("CSI300",subtract);
                                    if(upDownMap.get("CSI300")!=null){
                                        flag1=false;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            flag1 =true;
            flag2 =true;
        }

        return upDownMap;
    }

    public static Map<String, BigDecimal> calculateHkUpDown(List<StockIndexHistoryModel> list){

        //获取list对象的last字段组装成新list
        List<BigDecimal> lastList1 = list.stream().map(StockIndexHistoryModel::getLast).collect(Collectors.toList());
        List<String> typeList1 = list.stream().map(StockIndexHistoryModel::getType).collect(Collectors.toList());
        //创建UpDown的Map
        Map<String,BigDecimal> upDownMap = new HashMap<>();

        boolean flag2= true;
        for(int i=0;i<2;i++){
            for(int j=0;j<list.size();j++){
                if(flag2){
                    if(typeList1.get(i).equals("HSI")){
                        for(int m =i+1;m<list.size();m++){
                            if(flag2){
                                if(typeList1.get(m).equals("HSI")){
                                    BigDecimal subtract = lastList1.get(i).subtract(lastList1.get(m));
                                    upDownMap.put("HSI",subtract);
                                    if(upDownMap.get("HSI")!=null){
                                        flag2=false;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        return upDownMap;
    }

    public static Map<String, BigDecimal> calculateWorldUpDown(List<StockIndexHistoryModel> list){

        //获取list对象的last字段组装成新list
        List<BigDecimal> lastList1 = list.stream().map(StockIndexHistoryModel::getLast).collect(Collectors.toList());
        List<String> typeList1 = list.stream().map(StockIndexHistoryModel::getType).collect(Collectors.toList());
        //创建UpDown的Map
        Map<String,BigDecimal> upDownMap = new HashMap<>();

        boolean flag1= true;
        boolean flag2= true;
        for(int i=0;i<2;i++){
            for(int j=0;j<list.size();j++){
                if(flag1 && flag2){
                    if(typeList1.get(i).equals("IXIC")){
                        for(int m =i+1;m<list.size();m++){
                            if(flag2){
                                if(typeList1.get(m).equals("IXIC")){
                                    BigDecimal subtract = lastList1.get(i).subtract(lastList1.get(m));
                                    upDownMap.put("IXIC",subtract);
                                    if(upDownMap.get("IXIC")!=null){
                                        flag2=false;
                                    }
                                }
                            }
                        }
                    }else if(typeList1.get(i).equals("DJI")){
                        for(int n =i+1;n<list.size();n++){
                            if(flag1){
                                if(typeList1.get(n).equals("DJI")){
                                    BigDecimal subtract = lastList1.get(i).subtract(lastList1.get(n));
                                    upDownMap.put("DJI",subtract);
                                    if(upDownMap.get("DJI")!=null){
                                        flag1=false;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            flag1 =true;
            flag2 =true;
        }

        return upDownMap;
    }


    @SuppressWarnings("unchecked")
    public static Map<String, String> calculateChinaUpDownPercentage(List<StockIndexHistoryModel> list){

        //获取list对象的last字段组装成新list
        List<BigDecimal> upDownList = list.stream().map(StockIndexHistoryModel::getUpDown).collect(Collectors.toList());
        List<BigDecimal> lastList = list.stream().map(StockIndexHistoryModel::getLast).collect(Collectors.toList());
        List<String> typeList = list.stream().map(StockIndexHistoryModel::getType).collect(Collectors.toList());
        //创建UpDown的Map
        Map<String,String> upDownMap = new HashMap<>();

        boolean flag1= true;
        boolean flag2= true;
        for(int i=0;i<2;i++){
            for(int j=0;j<list.size();j++){
                if(flag1 && flag2){
                    if(typeList.get(i).equals("SSEC")){
                        for(int m =i+1;m<list.size();m++){
                            if(flag2){
                                if(typeList.get(m).equals("SSEC")){
                                    BigDecimal divide = upDownList.get(i).divide(lastList.get(m),3,BigDecimal.ROUND_HALF_UP);
                                    divide = divide.multiply(new BigDecimal(100));
                                    upDownMap.put("SSEC",divide+"%");
                                    if(upDownMap.get("SSEC")!=null){
                                        flag2=false;
                                    }
                                }
                            }
                        }
                    }else if(typeList.get(i).equals("CSI300")){
                        for(int n =i+1;n<list.size();n++){
                            if(flag1){
                                if(typeList.get(n).equals("CSI300")){
                                    BigDecimal divide = upDownList.get(i).divide(lastList.get(n),3,BigDecimal.ROUND_HALF_UP);
                                    divide = divide.multiply(new BigDecimal(100));
                                    upDownMap.put("CSI300",divide+"%");
                                    if(upDownMap.get("CSI300")!=null){
                                        flag1=false;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            flag1 =true;
            flag2 =true;
        }

        return upDownMap;
    }

    public static Map<String, String> calculateHkUpDownPercentage(List<StockIndexHistoryModel> list){

        //获取list对象的last字段组装成新list
        List<BigDecimal> lastList = list.stream().map(StockIndexHistoryModel::getLast).collect(Collectors.toList());
        List<String> typeList = list.stream().map(StockIndexHistoryModel::getType).collect(Collectors.toList());
        List<BigDecimal> upDownList = list.stream().map(StockIndexHistoryModel::getUpDown).collect(Collectors.toList());

        //创建UpDown的Map
        Map<String,String> upDownMap = new HashMap<>();

        boolean flag2= true;
        for(int i=0;i<2;i++){
            for(int j=0;j<list.size();j++){
                if(flag2){
                    if(typeList.get(i).equals("HSI")){
                        for(int m =i+1;m<list.size();m++){
                            if(flag2){
                                if(typeList.get(m).equals("HSI")){
                                    BigDecimal subtract = upDownList.get(i).divide(lastList.get(m),3,BigDecimal.ROUND_HALF_UP);
                                    subtract = subtract.multiply(new BigDecimal(100));
                                    upDownMap.put("HSI",subtract+"%");
                                    if(upDownMap.get("HSI")!=null){
                                        flag2=false;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        return upDownMap;
    }

    @SuppressWarnings("unchecked")
    public static Map<String, String> calculateWorldUpDownPercentage(List<StockIndexHistoryModel> list){

        //获取list对象的last字段组装成新list
        List<BigDecimal> upDownList = list.stream().map(StockIndexHistoryModel::getUpDown).collect(Collectors.toList());
        List<BigDecimal> lastList = list.stream().map(StockIndexHistoryModel::getLast).collect(Collectors.toList());
        List<String> typeList = list.stream().map(StockIndexHistoryModel::getType).collect(Collectors.toList());
        //创建UpDown的Map
        Map<String,String> upDownMap = new HashMap<>();

        boolean flag1= true;
        boolean flag2= true;
        for(int i=0;i<2;i++){
            for(int j=0;j<list.size();j++){
                if(flag1 && flag2){
                    if(typeList.get(i).equals("IXIC")){
                        for(int m =i+1;m<list.size();m++){
                            if(flag2){
                                if(typeList.get(m).equals("IXIC")){
                                    BigDecimal divide = upDownList.get(i).divide(lastList.get(m),3,BigDecimal.ROUND_HALF_UP);
                                    divide = divide.multiply(new BigDecimal(100));
                                    upDownMap.put("IXIC",divide+"%");
                                    if(upDownMap.get("IXIC")!=null){
                                        flag2=false;
                                    }
                                }
                            }
                        }
                    }else if(typeList.get(i).equals("DJI")){
                        for(int n =i+1;n<list.size();n++){
                            if(flag1){
                                if(typeList.get(n).equals("DJI")){
                                    BigDecimal divide = upDownList.get(i).divide(lastList.get(n),3,BigDecimal.ROUND_HALF_UP);
                                    divide = divide.multiply(new BigDecimal(100));
                                    upDownMap.put("DJI",divide+"%");
                                    if(upDownMap.get("DJI")!=null){
                                        flag1=false;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            flag1 =true;
            flag2 =true;
        }

        return upDownMap;
    }

    public static Map<String, String> calculateHkUpDownWeek(List<StockIndexHistoryModel> list) throws ParseException {

        //获取list对象的last字段组装成新list
        List<BigDecimal> lastList = list.stream().map(StockIndexHistoryModel::getLast).collect(Collectors.toList());
        List<String> typeList = list.stream().map(StockIndexHistoryModel::getType).collect(Collectors.toList());
        List<BigDecimal> timeList = list.stream().map(StockIndexHistoryModel::getUpdateTime).collect(Collectors.toList());


        //创建UpDown的Map
        Map<String,String> upDownMap = new HashMap<>();

        boolean flag2= true;
        for(int i=0;i<2;i++){
            for(int j=0;j<list.size();j++){
                if(flag2){
                    if(typeList.get(i).equals("HSI")){
                        for(int m =i+1;m<list.size();m++){
                            if(flag2){
                                if(typeList.get(m).equals("HSI")){
                                    if(DateToStamp.getWeek(String.valueOf(timeList.get(m))).equals("星期五")){
                                        BigDecimal subtract = lastList.get(i).subtract(lastList.get(m)).divide(lastList.get(m),3,BigDecimal.ROUND_HALF_UP);
                                        subtract = subtract.multiply(new BigDecimal(100));
                                        upDownMap.put("HSI",subtract+"%");
                                        if(upDownMap.get("HSI")!=null){
                                            flag2=false;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        return upDownMap;
    }

    @SuppressWarnings("unchecked")
    public static Map<String, String> calculateChinaUpDownWeek(List<StockIndexHistoryModel> list) throws ParseException {

        //获取list对象的last字段组装成新list
        List<BigDecimal> lastList = list.stream().map(StockIndexHistoryModel::getLast).collect(Collectors.toList());
        List<String> typeList = list.stream().map(StockIndexHistoryModel::getType).collect(Collectors.toList());
        List<BigDecimal> timeList = list.stream().map(StockIndexHistoryModel::getUpdateTime).collect(Collectors.toList());

        //创建UpDown的Map
        Map<String,String> upDownMap = new HashMap<>();

        boolean flag1= true;
        boolean flag2= true;
        for(int i=0;i<2;i++){
            for(int j=0;j<list.size();j++){
                if(flag1 && flag2){
                    if(typeList.get(i).equals("SSEC")){
                        for(int m =i+1;m<list.size();m++){
                            if(flag2){
                                if(typeList.get(m).equals("SSEC")){
                                    if(DateToStamp.getWeek(String.valueOf(timeList.get(m))).equals("星期五")){
                                        BigDecimal divide = lastList.get(i).subtract(lastList.get(m)).divide(lastList.get(m),3,BigDecimal.ROUND_HALF_UP);
                                        divide = divide.multiply(new BigDecimal(100));
                                        upDownMap.put("SSEC",divide+"%");
                                        if(upDownMap.get("SSEC")!=null){
                                            flag2=false;
                                        }
                                    }
                                }
                            }
                        }
                    }else if(typeList.get(i).equals("CSI300")){
                        for(int n =i+1;n<list.size();n++){
                            if(flag1){
                                if(typeList.get(n).equals("CSI300")){
                                    if(DateToStamp.getWeek(String.valueOf(timeList.get(n))).equals("星期五")){
                                        BigDecimal divide = lastList.get(i).subtract(lastList.get(n)).divide(lastList.get(n),3,BigDecimal.ROUND_HALF_UP);
                                        divide = divide.multiply(new BigDecimal(100));
                                        upDownMap.put("CSI300",divide+"%");
                                        if(upDownMap.get("CSI300")!=null){
                                            flag1=false;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            flag1 =true;
            flag2 =true;
        }

        return upDownMap;
    }
    @SuppressWarnings("unchecked")
    public static Map<String, String> calculateWorldUpDownWeek(List<StockIndexHistoryModel> list) throws ParseException {

        //获取list对象的last字段组装成新list
        List<BigDecimal> lastList = list.stream().map(StockIndexHistoryModel::getLast).collect(Collectors.toList());
        List<String> typeList = list.stream().map(StockIndexHistoryModel::getType).collect(Collectors.toList());
        List<BigDecimal> timeList = list.stream().map(StockIndexHistoryModel::getUpdateTime).collect(Collectors.toList());

        //创建UpDown的Map
        Map<String,String> upDownMap = new HashMap<>();

        boolean flag1= true;
        boolean flag2= true;
        for(int i=0;i<2;i++){
            for(int j=0;j<list.size();j++){
                if(flag1 && flag2){
                    if(typeList.get(i).equals("IXIC")){
                        for(int m =i+1;m<list.size();m++){
                            if(flag2){
                                if(typeList.get(m).equals("IXIC")){
                                    if(DateToStamp.getWeek(String.valueOf(timeList.get(m))).equals("星期五")){
                                        BigDecimal divide = lastList.get(i).subtract(lastList.get(m)).divide(lastList.get(m),3,BigDecimal.ROUND_HALF_UP);
                                        divide = divide.multiply(new BigDecimal(100));
                                        upDownMap.put("IXIC",divide+"%");
                                        if(upDownMap.get("IXIC")!=null){
                                            flag2=false;
                                        }
                                    }
                                }
                            }
                        }
                    }else if(typeList.get(i).equals("DJI")){
                        for(int n =i+1;n<list.size();n++){
                            if(flag1){
                                if(typeList.get(n).equals("DJI")){
                                    if(DateToStamp.getWeek(String.valueOf(timeList.get(n))).equals("星期五")){
                                        BigDecimal divide = lastList.get(i).subtract(lastList.get(n)).divide(lastList.get(n),3,BigDecimal.ROUND_HALF_UP);
                                        divide = divide.multiply(new BigDecimal(100));
                                        upDownMap.put("DJI",divide+"%");
                                        if(upDownMap.get("DJI")!=null){
                                            flag1=false;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            flag1 =true;
            flag2 =true;
        }

        return upDownMap;
    }

    public static void main(String[] args) throws ParseException {

        List<StockIndexHistoryModel> list = new ArrayList<>();
        StockIndexHistoryModel s1 = new StockIndexHistoryModel(1,new BigDecimal ("4947.75"),new BigDecimal ("3314.03"),new BigDecimal ("3349.05"),new BigDecimal ("3314.03"),"2018年1月2日",new BigDecimal ("1618217381883"),"CSI300",new BigDecimal (-43.42),null,null);
        StockIndexHistoryModel s2 = new StockIndexHistoryModel(2,new BigDecimal ("3412.95"),new BigDecimal ("3347.74"),new BigDecimal ("3379.92"),new BigDecimal ("3345.29"),"2018年1月3日",new BigDecimal ("1617897600000"),"SSEC",new BigDecimal (-16.6),null,null);
        StockIndexHistoryModel s3 = new StockIndexHistoryModel(3,new BigDecimal ("3450.68"),new BigDecimal ("3371"),new BigDecimal ("3392.83"),new BigDecimal ("3365.3"),"2018年1月4日",new BigDecimal ("1617811200000"),"SSEC",new BigDecimal (-1),null,null);
        StockIndexHistoryModel s4 = new StockIndexHistoryModel(4,new BigDecimal ("5035.34"),new BigDecimal ("3386.46"),new BigDecimal ("3402.07"),new BigDecimal ("3380.24"),"2018年1月5日",new BigDecimal ("1617897600000"),"CSI300",new BigDecimal (-2),null,null);
        StockIndexHistoryModel s5 = new StockIndexHistoryModel(5,new BigDecimal ("5035.34"),new BigDecimal ("3386.46"),new BigDecimal ("3482.55"),new BigDecimal ("3380.24"),"2018年1月5日",new BigDecimal ("1515081600000"),"SSEC",null,null,null);
        StockIndexHistoryModel s6 = new StockIndexHistoryModel(6,new BigDecimal ("5035.34"),new BigDecimal ("3386.46"),new BigDecimal ("5112.21"),new BigDecimal ("3380.24"),"2018年1月5日",new BigDecimal ("1515081600000"),"CSI300",null,null,null);
        StockIndexHistoryModel s7 = new StockIndexHistoryModel(7,new BigDecimal ("5035.34"),new BigDecimal ("3386.46"),new BigDecimal ("5112.21"),new BigDecimal ("3380.24"),"2018年1月5日",new BigDecimal ("1515081600000"),"SSEC",null,null,null);
        StockIndexHistoryModel s8 = new StockIndexHistoryModel(8,new BigDecimal ("5035.34"),new BigDecimal ("3386.46"),new BigDecimal ("5112.21"),new BigDecimal ("3380.24"),"2018年1月5日",new BigDecimal ("1515081600000"),"CSI300",null,null,null);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        list.add(s5);
        list.add(s6);
        list.add(s7);
        list.add(s8);


//        list.get(0).setUpDownWeek(CalculationUtil.calculateHkUpDownWeek(list).get("HSI"));
//        System.out.println(list.get(0).getUpDownWeek());

        //计算本周升跌
        if(list.get(0).getType().equals("SSEC")){
            list.get(0).setUpDownWeek(CalculationUtil.calculateChinaUpDownWeek(list).get("SSEC"));
            list.get(1).setUpDownWeek(CalculationUtil.calculateChinaUpDownWeek(list).get("CSI300"));
        }else if(list.get(0).getType().equals("CSI300")){
            list.get(0).setUpDownWeek(CalculationUtil.calculateChinaUpDownWeek(list).get("CSI300"));
            list.get(1).setUpDownWeek(CalculationUtil.calculateChinaUpDownWeek(list).get("SSEC"));
        }

        List<StockIndexHistoryModel> listTwo = new ArrayList<>();
        for(int i=0;i<2;i++){
            listTwo.add(list.get(i));
        }
        for(int i =0;i<2;i++){
            System.out.println(listTwo.get(i).getUpDownWeek());
        }
    }
}

 

 

天才小熊猫啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
i18n vue 多语言配置，切换刷新（setLocaleMessage，mergeLocaleMessage）
Allen的博客
11-16 6231
i18n vue 多语言配置，切换刷新（setLocaleMessage，mergeLocaleMessage）
Spring Boot 实现国际化消息提示
wangzhihao的博客
09-04 2868
Internationalization Spring Boot国际化信息(i18n)示例。 官方文档：boot-features-internationalization 默认国际化配置 SpringBoot提供了自动配置类org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration。 可以看到自动配置类中提供的可配置参数为spring.messages，其中典型配置为： #默认配置国际化文件路径 spring.
国际化Locale，ResourceBundle，MessageFormat
m0_62520968的博客
04-28 253
Locale类是用来国际化数据的 每一个locale对象都代表一个特定的的确，政治文化，地区和创建方法 首先是创建方法： // 方法一：调用默认的locale Locale locale = Locale.getDefault(); // zh-CN 华 - 中国 zh-HK 华 - 香港 SARzh-MO 华 - 澳门 System.out.println("locale:"+loc.
spring boot中配置国际化返回
lw18751836671的专栏
03-15 998
目录 前言 代码 测试 前言 在项目中要面临后端返回给前端展示，而展示给别人的告警信息是需要面向不同的语言，比如展示中文还是英文等等。 这个时候就需要在返回的json中将告警信息根据选择的语言来返回不同的信息。 代码 首先新建一个spring boot工程，这里就不多赘述。 在工程中配置自己的国际化文件，XXX.properties,如下图所示，这里的Resource Bundle 'mess'是idea自动生成的，不用管，只需要...
JavaScript 4.22
qq505955846的博客
04-23 1034
JS 1.数据可视化 1.1可视化库 ECharts.js Highcharts.js 2.EChars 2.1使用 下载并引入echarts.js 准备具备大小的DOM容器 初始化echarts实例化对象 var myChart = echarts.init(document.querySelector('.box')); 指定配置项和数据 官网复制，具体配置项可查阅手册 将配置项设置给echarts实例对象 myChart.setOption(option); 2.2配置项
ArcGIS API for JavaScript 4.22版 API+SDK
03-10
ArcGIS API for JavaScript用于构建高性能的WebGIS应用程序，同时结合现代网络技术和强大的地理空间功能，利用ArcGIS Online、ArcGIS Server发布的地图服务以及网络上的其他服务内容，使用户在web端能够进行应用程序...
libev4.22库
01-16
`libev4.22`库以其高效和灵活性成为许多高性能网络服务的选择。了解其背后的事件驱动模式、与libevent的差异，以及如何利用libev的API来构建和优化应用，是提升系统性能的关键。通过实践和探索，开发者可以充分利用...
MemTest 4.22.dmg
05-26
**MemTest 4.22 for Mac：内存测试详解** MemTest 4.22.dmg 是一个专为Mac用户设计的内存诊断工具，用于检测和检查计算机内存（RAM）的稳定性和错误。这个版本是4.22，提供了一个可靠的方式来确保你的Mac电脑的内存...
Notepad2-4.22.11r4478-64bit-Green
12-03
Notepad2 是一个相当优秀的轻量级文本编辑器，基于 Scintilla 开发，体积小巧、运行快速，与系统默认记事本具备相同资源消耗，但提供了大量实用功能，如代码高亮、编码转换、行号显示、多步 Ctrl+Z、增强的查找替换...
libev-4.22.tar.gz_libev_libev 下载_libev-4.19.tar.gz_libev-4.22.ta
07-14
"libev-4.22.tar.gz" 和 "libev-4.19.tar.gz" 是libev的不同版本源代码包，用户可以根据需求选择下载。 libev的特性与优势主要体现在以下几个方面： 1. **事件类型**： - **IO事件**：libev可以监听文件描述符的...
Java —— MessageFormat类 处理国际化
永远的北极光
04-17 9783
一、MessageFormat 概览 java.text包中的 Fomart 接口是所有处理格式的基础接口，有三个子类：DateFormat、MessageFormat、NumberFormat。 MessageFormat 是专门处理文本格式的类，且没有子类。 二、MessageFormat 细节 1、构造函数： MessageFormat(String pattern
使用vue-i18n进行项目国际化
小冷_Blog
09-09 3219
vue-i18n方案文档 简介 安装 npm i -S vue-i18n 配置 cd project-path/src/*** mkdir i18n cd i18n touch index.js mkdir lang touch zh-CN.js en-US.js 1.zh-CN.js和en-US.js为具体语言包； 2.index.js负责实例化V...
配置Java开发环境
最新发布
Broken_x的博客
07-10 777
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 264
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1716
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1171
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 341
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
harepacker4.22
07-24
Harepacker是一款功能强大的软件打包工具，而4.22是其特定版本号。 Harepacker能够将多个文件或文件夹打包成一个单独的可执行文件，这个文件可以在没有特定环境支持的情况下运行。它可以用于将多个资源文件、配置...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值