4.21

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

经过4.21和4.22的不断修改完善，经测试可以用。（有史以来写的最牛逼的一段代码了）

将其设置成CalaculationUtil工具类

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, BigDecimal> 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,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(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);
                                    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);
                                    upDownMap.put("CSI300",divide);
                                    if(upDownMap.get("CSI300")!=null){
                                        flag1=false;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            flag1 =true;
            flag2 =true;
        }

        return upDownMap;
    }

    public static Map<String, BigDecimal> 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,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(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);
                                    upDownMap.put("HSI",subtract);
                                    if(upDownMap.get("HSI")!=null){
                                        flag2=false;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        return upDownMap;
    }

    @SuppressWarnings("unchecked")
    public static Map<String, BigDecimal> 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,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(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);
                                    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);
                                    upDownMap.put("DJI",divide);
                                    if(upDownMap.get("DJI")!=null){
                                        flag1=false;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            flag1 =true;
            flag2 =true;
        }

        return upDownMap;
    }

    public static Map<String, BigDecimal> 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,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(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);
                                        upDownMap.put("HSI",subtract);
                                        if(upDownMap.get("HSI")!=null){
                                            flag2=false;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        return upDownMap;
    }

    @SuppressWarnings("unchecked")
    public static Map<String, BigDecimal> 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,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(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);
                                        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);
                                        upDownMap.put("CSI300",divide);
                                        if(upDownMap.get("CSI300")!=null){
                                            flag1=false;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            flag1 =true;
            flag2 =true;
        }

        return upDownMap;
    }
    @SuppressWarnings("unchecked")
    public static Map<String, BigDecimal> 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,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(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);
                                        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);
                                        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());
        }




    }





}

日期转时间戳，时间戳转日期，时间戳转星期的工具类;DateToStamp

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

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class DateToStamp {

    public static String date2Stamp(String s) throws ParseException {
        String res;
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        if(s != null && !s.equals("")){
            Date date =simpleDateFormat.parse(s);
            long ts = date.getTime();
            res = String.valueOf(ts);
            return res;
        }
        return s;
    }

    public static Map<String,String> stamp2Date(String stamp) throws ParseException {
        String sd0 ="";
        String sd7 ="";
        Date d = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        if(stamp != null && !stamp.equals("")){
            sd0 = sdf.format(new Date(Long.parseLong(stamp)));
            Date sd00 = sdf.parse(sd0);//转成data类型的
            Calendar c1 = Calendar.getInstance();
            Calendar c2 = Calendar.getInstance();
            c1.setTime(sd00);
            c1.add(Calendar.DATE, -8);//一周内的数据，12条
            c2.setTime(sd00);
            c2.add(Calendar.DATE, 1);//加一天
            sd7 = sdf.format(c1.getTime());
            sd0 = sdf.format(c2.getTime());

            sd0 = date2Stamp(sd0);//转成时间戳 当前时间+1天
            sd7 = date2Stamp(sd7);//转成时间戳 当前时间前7天

            Map<String,String> map = new HashMap<String, String>();
            map.put("sd0",sd0);
            map.put("sd7",sd7);
            return map;
        }else{
            Map<String,String> map = new HashMap<String, String>();
            map.put("sd0",stamp);
            map.put("sd7",stamp);
            return map;
        }
    }

    //输入时间戳，输出星期几
    public static String getWeek(String stamp) throws ParseException {
        String sd0 ="";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        if(stamp != null && !stamp.equals("")){
            sd0 = sdf.format(new Date(Long.parseLong(stamp)));
            Date sd00 = sdf.parse(sd0);//转成data类型的
            SimpleDateFormat sdf2 = new SimpleDateFormat("EEEE");
            String week = sdf2.format(sd00);
            return week;
        }else{
            return null;
        }
    }



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

//        Map<String, String> map = stamp2Date("1618217382172");
//        System.out.println( map.get("sd0"));
//        System.out.println( map.get("sd7"));
        System.out.println(getWeek("1618217382172"));
    }


}

 

天才小熊猫啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
chipgenius_v4.21.0701
04-13
chipgenius_v4.21.0701
chipgenius 芯片精灵 v4.21.0701
03-18
USB设备主控芯片检测工具
4.21 python 函数
qq_41945920的博客
04-21 1034
1.map() map()是Python内置的高阶函数，它接收一个函数f和一个lis，并通过把函数f依次作用在list的每个元素上，得到一个新的list并返回。 map() 会根据提供的函数对指定序列做映射，是内置函数(推荐学习：Python视频教程) 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。 语法map(function, iterable, ...) 例如，对于list [1, 2, 3, 4, 5
4.21 4.22
lgl9958123的博客
08-19 108
4.21 #include <iostream> #include <string> #include <cctype> #include <vector> using namespace std; int main() { vector<int> ivec = { 1,2,3,4,5,6,7,8,9 }; for (auto iter = ivec.begin(); iter != ivec.end(); ++iter) { *it
4.21笔记
2302_77767400的博客
05-30 116
绑定对象变量（类似于指针）1.5.1 null配合引用，没有和任何对象关联（绑定）1.5.2代码分离1.main的代码单独分离测试类。
4.21 IO
MONNEYKING的博客
04-22 90
口语 4.21
2301_80185446的博客
04-21 173
haggling 议价这个东西卖多少钱？how much is/for this?how much does this go for?can you quote a price for this?quote:报价send over (发过来) a quote(报价)can you give me a breakdown?明细get me an itemized quote明细的买卖双方都可以用could you do $20?能否接受i can only do $10 我只能付/收how about $15
4.21作业
qq_52016002的博客
04-21 82
要求在共享内存中存入字符串“1234567”，A进程循环打印字符串， B进程循环倒置字符串，要求结果不允许出现乱序
4.21总结
2301_80903641的博客
04-21 163
解决了Javafx的控制和跳转问题，知道了那些数据该怎么命名以及如何返回，以及该怎么设置写入框的字符串返回，尝试打包回服务器处理。这几天在尝试登录注册与客户端和服务器连接起来，想着服务器连接数据库，再由用户端给服务器发送请求来实现增删改查。
4.21 作业
weixin_58579471的博客
04-21 164
要求先在共享内存中存入字符串 “1234567”。
chipgenius芯片精灵 4.21.0701
07-14
chipgenius芯片精灵 4.21.0701 ,U盘制作工具， 芯片精灵是一款USB设备芯片型号检测工具，chipgenius芯片精灵可以自动查询U盘、MP3/MP4、读卡器、移动硬盘等一切USB设备的主控芯片型号、制造商、品牌，并提供相关资料...
联想工程师专用小工具 静态IP设置工具V4.21.1
05-30
联想工程师专用小工具 静态IP设置工具V4.21.1联想工程师专用小工具 静态IP设置工具V4.21.1联想工程师专用小工具 静态IP设置工具V4.21.1联想工程师专用小工具 静态IP设置工具V4.21.1联想工程师专用小工具 静态IP设置...
芯片精灵ChipGenius v4.21.0701
06-22
芯片精灵ChipGenius v4.21.0701 U盘信息监测
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 506
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
最新发布
m0_67496588的博客
06-20 531
JSON，Ajax
Java 中 什么是 lambda 表达式？有什么优点？
liangzai215的专栏
06-13 934
但是，Lambda 表达式绝对不是 Java 8 的银弹，它在消除代码冗余、支持并发这两方面表现优秀，但是在其他方面并未有太多贡献，所以我们在编程的时候，还是需要结合实际情况，灵活选择使用。Lambda表达式在Java 8中是非常强大的工具，但是需要注意的是，Lambda并并不适合所有情况，它主要适用于函数式编程，处理集合操作和Stream操作，在某些具体的业务逻辑操作中就不一定会产生预期的效果。代码块：是 Lambda 表达式需要执行的功能，可以是一行代码，也可以是复杂的多行代码。
基于springboot的青年公寓服务平台源码数据库
s123456sj的博客
06-16 1205
本青年公寓服务平台分为管理员还有用户两个权限，管理员可以管理用户的基本信息内容，可以管理房屋投诉信息以及房屋投诉的租赁信息，能够与用户进行相互交流等操作，用户可以查看房屋信息，可以查看房屋投诉以及查看管理员回复信息等操作。
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 416
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
u盘芯片检测v4.21
06-22
U盘芯片检测V4.21是一种软件工具，用于检测U盘芯片型号。当我们使用U盘时，可能会遇到一些问题，如写入速度缓慢、读取数据失败等。这些问题可能源于U盘芯片型号不匹配，或者U盘本身存在一些质量问题。因此，使用U盘...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值