【Java 动态数据统计图】动态X轴二级数据统计图思路Demo（动态，排序，动态数组（重点推荐：难）九（131）

news2024/11/17 7:22:17

需求：

1.有一组数据集合，数据集合中的数据为动态；
举例如下：
[{province=陕西省, city=西安市}, {province=陕西省, city=咸阳市}, {province=陕西省, city=宝鸡市}, {province=陕西省, city=延安市}, {province=陕西省, city=汉中市}, {province=四川省, city=成都市}, {province=四川省, city=成都市}, {province=四川省, city=广元市}, {province=四川省, city=绵阳市}, {province=陕西省, city=西安市}, {province=陕西省, city=西安市}, {province=陕西省, city=宝鸡市}, {province=江苏省, city=南京市}, {province=江苏省, city=南京市}, {province=江苏省, city=扬州市}, {province=河北省, city=石家庄市}, {province=山东省, city=济南市}, {province=山东省, city=青岛市}, {province=山东省, city=烟台市}, {province=山东省, city=潍坊市}]
2.通过计算得出统计的数据；省按照大小排序，动态展示，城市按照大小排序，动态展示；

最终绘制如下：
在这里插入图片描述

备注：以下看到的函数名称大多是自定义封装的。

当前案例代码中需要用到的知识技能：

1.Set集合去重：Set hashSet = new HashSet<>();
2.Set集合转数组：String[] provinceArr = hashSet.toArray(new String[hashSet.size()]);
3.一维双数组排序：BubblSortUtils.bubbleSortDescMultiple(provinceSort,provinceArr);
4.创建集合数组（数组里面的元素为set集合）：Set[] setArr = new Set[provinceArr.length];
5.创建二维数组（set集合数组转二维数组）：String[][] stringArr = new String[provinceArr.length][];
6.二维数组，双数组根据第二维度排序：BubblSortUtils.bubbleSortDescMultiple2(countArr,stringArr);
7.String，Int数组间的互相转化；
8.百分比计算函数封装；
9.一维数组和二维数组组合：计算一维数组在二维中的中间位置；
10.返回数据封装：二维数组转一维数组；

Demo案例：代码逻辑比较复杂，需耐心看！

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class day24 {
	public static void main(String[] args) {
		
		List<Map<String,Object>> list = new ArrayList<>();
		Map<String,Object> map1 = new HashMap<>();
		map1.put("province","陕西省");
		map1.put("city","西安市");
		Map<String,Object> map2 = new HashMap<>();
		map2.put("province","陕西省");
		map2.put("city","咸阳市");
		Map<String,Object> map3 = new HashMap<>();
		map3.put("province","陕西省");
		map3.put("city","宝鸡市");
		Map<String,Object> map4 = new HashMap<>();
		map4.put("province","陕西省");
		map4.put("city","延安市");
		Map<String,Object> map5 = new HashMap<>();
		map5.put("province","陕西省");
		map5.put("city","汉中市");
		Map<String,Object> map6 = new HashMap<>();
		map6.put("province","四川省");
		map6.put("city","成都市");
		Map<String,Object> map7 = new HashMap<>();
		map7.put("province","四川省");
		map7.put("city","成都市");
		Map<String,Object> map8 = new HashMap<>();
		map8.put("province","四川省");
		map8.put("city","广元市");
		Map<String,Object> map9 = new HashMap<>();
		map9.put("province","四川省");
		map9.put("city","绵阳市");
		Map<String,Object> map10 = new HashMap<>();
		map10.put("province","陕西省");
		map10.put("city","西安市");
		Map<String,Object> map11 = new HashMap<>();
		map11.put("province","陕西省");
		map11.put("city","西安市");
		Map<String,Object> map12 = new HashMap<>();
		map12.put("province","陕西省");
		map12.put("city","宝鸡市");
		Map<String,Object> map13 = new HashMap<>();
		map13.put("province","江苏省");
		map13.put("city","南京市");
		Map<String,Object> map14 = new HashMap<>();
		map14.put("province","江苏省");
		map14.put("city","南京市");
		Map<String,Object> map15 = new HashMap<>();
		map15.put("province","江苏省");
		map15.put("city","扬州市");
		Map<String,Object> map16 = new HashMap<>();
		map16.put("province","河北省");
		map16.put("city","石家庄市");
		Map<String,Object> map17 = new HashMap<>();
		map17.put("province","山东省");
		map17.put("city","济南市");
		Map<String,Object> map18 = new HashMap<>();
		map18.put("province","山东省");
		map18.put("city","青岛市");
		Map<String,Object> map19 = new HashMap<>();
		map19.put("province","山东省");
		map19.put("city","烟台市");
		Map<String,Object> map20 = new HashMap<>();
		map20.put("province","山东省");
		map20.put("city","潍坊市");
		
		list.add(map1);
		list.add(map2);
		list.add(map3);
		list.add(map4);
		list.add(map5);
		list.add(map6);
		list.add(map7);
		list.add(map8);
		list.add(map9);
		list.add(map10);
		list.add(map11);
		list.add(map12);
		list.add(map13);
		list.add(map14);
		list.add(map15);
		list.add(map16);
		list.add(map17);
		list.add(map18);
		list.add(map19);
		list.add(map20);
		
		System.out.println("入参数据:"+list);
		
		// 一：获取一级维度：
		// 创建Set集合：获取一级维度数据的数据集：去重
		Set<String> hashSet = new HashSet<>();
		
        for (int i = 0; i < list.size(); i++) {
            String province = String.valueOf(list.get(i).get("province"));
            hashSet.add(province);
        }
        // 创建一级维度省份数组：
        String[] provinceArr = new String[hashSet.size()];
        // 创建一级维度省份数量数组：
        int[] provinceSort = new int[hashSet.size()];
        
        // Set转数组
        if(list.size() > 0){
        	provinceArr = hashSet.toArray(new String[hashSet.size()]);
        }
        
        // 根据一级维度省份数组：计算一级维度省份数量数组；
        for (int i = 0; i < provinceArr.length; i++) {
            for (int j = 0; j < list.size(); j++) {
                if(provinceArr[i].equals(String.valueOf(list.get(j).get("province")))){
                	provinceSort[i] = provinceSort[i] + 1;
                }
            }
        }
        
        // 排序：一级维度省份数组；
        BubblSortUtils.bubbleSortDescMultiple(provinceSort,provinceArr); 
        
        // 封装集合测试输出：
        System.out.println("--------------------");
        List<Map<String,Object>> listFinal= new ArrayList<>();
        for (int i = 0; i < provinceArr.length; i++) {
            Map<String,Object> map = new HashMap<>();
            map.put("title",provinceArr[i]);
            map.put("value",provinceSort[i]);
            listFinal.add(map);
        }
        System.out.println("一级维度省份类型和数量:"+listFinal);
        
        // 二：获取二级维度：
        // 创建集合数组（数组里面的元素为set集合）
        Set[] setArr = new Set[provinceArr.length];
        // 创建二维数组（set集合数组转二维数组）
        String[][] stringArr = new String[provinceArr.length][];
        
        // 集合数组:获取二级维度城市类型数据的数据集：去重
        for (int i = 0; i < provinceArr.length; i++) {
        	Set<String> hashSet2 = new HashSet<>();
        	// 获取城市数组；
			for (int j = 0; j < list.size(); j++) {
				if(provinceArr[i].equals(String.valueOf(list.get(j).get("province")))){
					hashSet2.add(String.valueOf(list.get(j).get("city")));
                }
			}
			setArr[i] = hashSet2;
		}
        
        // 二维数组：set集合城市数组转二维城市数组；
        for (int i = 0; i < setArr.length; i++) {
        	Set<String> hashSet2 = setArr[i];
        	String[] provinceArr2 = new String[hashSet2.size()];
        	if(list.size() > 0){
        		provinceArr2 = hashSet2.toArray(new String[hashSet2.size()]);
            }
        	stringArr[i] = provinceArr2;
		}
        
        // 创建城市数量二维数组；
        String[][] countArr = new String[provinceArr.length][];
        
        // 二维数组：根据二维城市类型数组计算：二维城市数量数组；
        for (int i = 0; i < stringArr.length; i++) {
			String [] s = stringArr[i];
			String[] temp = new String[s.length];
			for (int j = 0; j < s.length; j++) {
				for (int k = 0; k < list.size(); k++) {
					if(s[j].equals(String.valueOf(list.get(k).get("city")))) {
						if(String.valueOf(temp[j]).equals("null")) {
							temp[j] = "1";
						}
						else {
							temp[j] = String.valueOf(Integer.valueOf(temp[j]) + 1);
						}
						
					}
				}
			}
			countArr[i] = temp;
		}
        // 数组排序：城市数组和数量数组排序；
        BubblSortUtils.bubbleSortDescMultiple2(countArr,stringArr);
        
        // 三：百分比二维数组：计算百分比
        String[][] percentageArr = new String[provinceArr.length][];
        int sum = list.size();
        for (int i = 0; i < countArr.length; i++) {
        	String [] s = countArr[i];
        	String[] temp = new String[s.length];
        	for (int j = 0; j < s.length; j++) {
				if(list.size() > 0) {
					temp[j] = percentageConversion(Integer.valueOf(s[j]),sum);
				}
			}
        	percentageArr[i] = temp;
		}
        
        
        System.out.println("------------------:");
           
        
        // 四：数据封装返回：
        /*
         * 分析：当前得到了四个数组；
         * 一维数组：provinceArr
         * 二维数组：stringArr,countArr,percentageArr
         * 
         * 需要将一维数组：provinceArr也转成二维数组并且将数据放在中间位置；
         * 
         */
        
        // 将省份添加到每个二维城市数组的末位；用临时二维数组stringArrTemp接收；
        String[][] stringArrTemp = new String[provinceArr.length][];
        for (int i = 0; i < stringArr.length; i++) {
        	String[] s = stringArr[i];
        	String[] temp = new String[s.length+1];
        	for (int j = 0; j < s.length; j++) {
        		temp[j] = s[j];
        		temp[s.length] = provinceArr[i];
			}
        	stringArrTemp[i] = temp;
		}
        
        // 计算一维数组在二维中的中间位置；        
        String[][] provinceNewArr = new String[provinceArr.length][];
        for (int i = 0; i < stringArrTemp.length; i++) {
        	String[] s = stringArrTemp[i];
        	String[] temp = new String[s.length-1];
        	int num = s.length-1;
        	for (int j = 0; j < s.length-1; j++) {
				if(j == num/2) {  // 找数组中间位置
    				if(num % 2 ==0) {  // 中间位置为偶数
    					if(j>0) {  // 首位判断>0
    						temp[j-1] = s[s.length-1];  // 数据向左偏
    						temp[j] = "#";  // 数据左偏完后下个数据需修正；
    					}
    				}
    				else {  // 中间位置为奇数
    					temp[j] = s[s.length-1];
    				}
				}
				else {
					temp[j] = "#";
				}
	
			}
        	provinceNewArr[i] = temp;
        }
        
        // 返回方式一：
        // 最终得到四个二维数组：provinceNewArr,stringArr,countArr,percentageArr
        // 二维数组封装Map返回；
        Map<String,Object> mapResult1 = new HashMap<>();
        mapResult1.put("province", provinceNewArr);
        mapResult1.put("cityType", stringArr);
        mapResult1.put("cityCount", countArr);
        mapResult1.put("cityPercentage", percentageArr);
        
        System.out.println("返回方式一：最终MAP"+mapResult1);

        // 最终：测试输出：
        for (int i = 0; i < stringArr.length; i++) {
        	System.out.println(i+":"+stringArr[i]);
        	String[] s1 = stringArr[i];
        	String[] s2 = countArr[i];
        	String[] s3 = percentageArr[i];
        	String[] s4 = provinceNewArr[i];
        	for (int j = 0; j < s1.length; j++) {
        		System.out.println("二级维度城市类型和数量:"+s1[j]+"--"+s2[j]+"--"+s3[j]+"--"+s4[j]);
			}
		}
        
        // 返回方式二：
        // 前端要求：所有的数据把二维数组拼接成一维数组返回；
        List<String> listArr1 = new ArrayList<>();
        List<String> listArr2 = new ArrayList<>();
        List<String> listArr3 = new ArrayList<>();
        List<String> listArr4 = new ArrayList<>();
        
        for (int i = 0; i < provinceNewArr.length; i++) {
        	String[] s1 = provinceNewArr[i];
        	String[] s2 = stringArr[i];
        	String[] s3 = countArr[i];
        	String[] s4 = percentageArr[i];
        	for (int j = 0; j < s1.length; j++) {
        		listArr1.add(s1[j]);
        		listArr2.add(s2[j]);
        		listArr3.add(s3[j]);
        		listArr4.add(s4[j]);
			}
		}

        String[] provinceNewArr2 = new String[listArr1.size()];
        String[] stringArr2 = new String[listArr2.size()];
        String[] countArr2 = new String[listArr3.size()];
        String[] percentageArr2 = new String[listArr4.size()];
        
        for (int i = 0; i < listArr1.size(); i++) {
        	provinceNewArr2[i] = listArr1.get(i);
        	stringArr2[i] = listArr2.get(i);
        	countArr2[i] = listArr3.get(i);
        	percentageArr2[i] = listArr4.get(i);
		}
        
        Map<String,Object> mapResult2 = new HashMap<>();
        mapResult2.put("province", provinceNewArr2);
        mapResult2.put("cityType", stringArr2);
        mapResult2.put("cityCount", countArr2);
        mapResult2.put("cityPercentage", percentageArr2);
        
        System.out.println("返回方式二：最终MAP"+mapResult2);
        
	}
	
	public static String percentageConversion(long divisor, long dividend) {
        String percentage = "";// 接受百分比的值
        double y = divisor * 1.0;
        double z = dividend * 1.0;
        if (y == 0 || z == 0) {
            return "0.00%";
        }
        double result = y / z;

        DecimalFormat decimalFormat = new DecimalFormat("##.00%"); // ##.00%

        percentage = decimalFormat.format(result);
        // ##.00% 使用这种转换方式，整数位如果是0 则会被删除  即0.35% 会出现 .35%的情况
        char c = percentage.charAt(0);
        if (String.valueOf(c).equals(".")) {
            StringBuffer sb = new StringBuffer();
            sb.append("0").append(percentage);
            return String.valueOf(sb);
        }
        return percentage;
    }
}

测试输出：

入参数据:[{province=陕西省, city=西安市}, {province=陕西省, city=咸阳市}, {province=陕西省, city=宝鸡市}, {province=陕西省, city=延安市}, {province=陕西省, city=汉中市}, {province=四川省, city=成都市}, {province=四川省, city=成都市}, {province=四川省, city=广元市}, {province=四川省, city=绵阳市}, {province=陕西省, city=西安市}, {province=陕西省, city=西安市}, {province=陕西省, city=宝鸡市}, {province=江苏省, city=南京市}, {province=江苏省, city=南京市}, {province=江苏省, city=扬州市}, {province=河北省, city=石家庄市}, {province=山东省, city=济南市}, {province=山东省, city=青岛市}, {province=山东省, city=烟台市}, {province=山东省, city=潍坊市}]
--------------------
一级维度省份类型和数量:[{title=陕西省, value=8}, {title=四川省, value=4}, {title=山东省, value=4}, {title=江苏省, value=3}, {title=河北省, value=1}]
------------------:
返回方式一：最终MAP{cityType=[[Ljava.lang.String;@506e6d5e, province=[[Ljava.lang.String;@96532d6, cityCount=[[Ljava.lang.String;@3796751b, cityPercentage=[[Ljava.lang.String;@67b64c45}
0:[Ljava.lang.String;@4411d970
二级维度城市类型和数量:西安市--3--15.00%--#
二级维度城市类型和数量:宝鸡市--2--10.00%--#
二级维度城市类型和数量:延安市--1--5.00%--陕西省
二级维度城市类型和数量:咸阳市--1--5.00%--#
二级维度城市类型和数量:汉中市--1--5.00%--#
1:[Ljava.lang.String;@6442b0a6
二级维度城市类型和数量:成都市--2--10.00%--#
二级维度城市类型和数量:绵阳市--1--5.00%--四川省
二级维度城市类型和数量:广元市--1--5.00%--#
2:[Ljava.lang.String;@60f82f98
二级维度城市类型和数量:青岛市--1--5.00%--#
二级维度城市类型和数量:济南市--1--5.00%--山东省
二级维度城市类型和数量:烟台市--1--5.00%--#
二级维度城市类型和数量:潍坊市--1--5.00%--#
3:[Ljava.lang.String;@35f983a6
二级维度城市类型和数量:南京市--2--10.00%--江苏省
二级维度城市类型和数量:扬州市--1--5.00%--#
4:[Ljava.lang.String;@7f690630
二级维度城市类型和数量:石家庄市--1--5.00%--河北省
返回方式二：最终MAP{cityType=[Ljava.lang.String;@edf4efb, province=[Ljava.lang.String;@2f7a2457, cityCount=[Ljava.lang.String;@566776ad, cityPercentage=[Ljava.lang.String;@6108b2d7}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/957704.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

用了这么久SpringBoot却还不知道的一个小技巧

用了这么久SpringBoot却还不知道的一个小技巧

前言 你可能调第三方接口喜欢启动application&#xff0c;修改&#xff0c;再启动&#xff0c;再修改&#xff0c;顺便还有个不喜欢写JUnitTest的习惯。 你可能有一天想要在SpringBoot启动后&#xff0c;立马想要干一些事情&#xff0c;现在没有可能是你还没遇到。 那么SpringB…
阅读更多...
windows10默认浏览器总是自动更改为Edge浏览器

windows10默认浏览器总是自动更改为Edge浏览器

在设置的默认应用设置中把默认浏览器改为chrome或其他之后他自动又会改回Edge。不得不说*软真的狗。 解决办法&#xff1a; 后来发现在Edge浏览器的设置中有这么一个选项&#xff0c;会很无耻的默认是Edge。把它关掉后重新设置就行了。
阅读更多...
02. 计算机的组成

02. 计算机的组成

1. 从手机和电脑开始 要是20年前&#xff0c;大家对于计算机还很陌生&#xff0c;但是现在手机和电脑已经非常普及了&#xff0c;即使对于偏远地区可能有人没有接触过电脑&#xff0c;但是手机肯定都用过。其实手机和电脑都是计算机&#xff01; 1.1 手机的8G256G是什么意思?…
阅读更多...
2D-2D对极几何中的基本矩阵、本质矩阵和单应矩阵

2D-2D对极几何中的基本矩阵、本质矩阵和单应矩阵

本文主要参考高翔博士的视觉SLAM十四讲第二版中的7.3章节内容。文章目录 1 对极约束2 本质矩阵E3 单应矩阵 1 对极约束 现在&#xff0c;假设我们从两张图像中得到了一对配对好的特征点&#xff0c;如图7.9所示&#xff08;假如后面我们有若干对这样的匹配点&#xff0c;根据这…
阅读更多...
IDEA打开一个项目时，idea左侧project模式下，不显示项目工程目录的解决方法

IDEA打开一个项目时，idea左侧project模式下，不显示项目工程目录的解决方法

在IDEA打开一个一个已有的项目chapter3时&#xff0c;idea左侧project模式下&#xff0c;左侧也没有project按钮&#xff0c;如下问题截图&#xff1a;&#xff08;ps:项目结构可以显示&#xff0c;但是src等目录不见&#xff09; 在网上查了一些方法&#xff1a; 1、解决办法…
阅读更多...
移动端的概念

移动端的概念

【移动端】 1. 什么是移动端 大前端时代&#xff1a; ​ 前端开发涉及的领域越来越多&#xff0c;如&#xff1a;PC端&#xff0c;移动端&#xff0c;小程序&#xff0c;App&#xff0c;甚至是物联网​ 大前端’的大字体现在地位重要&#xff0c;涉及领域众多​ 前后端完全分…
阅读更多...
从零开始的Hadoop学习（五）| HDFS概述、shell操作、API操作

从零开始的Hadoop学习（五）| HDFS概述、shell操作、API操作

1. HDFS 概述 1.1 HDFS 产出背景及定义 1&#xff09;HDFS 产生背景 随着数据量越来越大&#xff0c;在一个操作系统存不下所有的数据&#xff0c;那么就分配到更多的操作系统管理的磁盘中&#xff0c;但是不方便管理和维护&#xff0c;迫切 需要一种系统来管理多台机器上的…
阅读更多...
OpenCV（八）：图像二值化

OpenCV（八）：图像二值化

目录 1.固定值二值化 2.自适应阈值二值化 3.Android JNI完整代码 1.固定值二值化 固定阈值二值化是OpenCV中一种简单而常用的图像处理技术&#xff0c;用于将图像转换为二值图像。在固定阈值二值化中&#xff0c;像素值根据一个预定义的阈值进行分类&#xff0c;大于阈值的…
阅读更多...
OFDM 系统在 AWGN 信道下对不同载波频率偏移 （CFO） 的 BER 灵敏度研究（Matlab代码实现）

OFDM 系统在 AWGN 信道下对不同载波频率偏移 （CFO） 的 BER 灵敏度研究（Matlab代码实现）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
软件测评国家标准概要总结

软件测评国家标准概要总结

软件测试 软件测评是指针对软件功能、性能、用途使用价值等进行的评价和测试&#xff1b; 软件测评主要依靠标准是GB/T 25000.51-2016 系统与软件工程 系统与软件质量要求和评价&#xff08;SQuaRE&#xff09; 第51部分&#xff1a;就绪可用软件产品&#xff08;RUSP&#x…
阅读更多...
基于JavaWeb和mysql实现校园订餐前后台管理系统（源码+数据库）

基于JavaWeb和mysql实现校园订餐前后台管理系统（源码+数据库）

一、项目简介 本项目是一套基于JavaWeb和mysql实现网上书城前后端管理系统&#xff0c;主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。 包含&#xff1a;项目源码、项目文档、数据库脚本等&#xff0c;该项目附带全部源码可作为毕设使用。 项目都…
阅读更多...
小兔鲜儿---商品分类

小兔鲜儿---商品分类

目录 准备工作​ 渲染轮播图​ 一级分类​ 获取数据​ Tab 交互​ 二级分类​ 骨架屏​ 准备工作​ 参考效果 商品分类页中的广告位&#xff0c;可复用之前定义的轮播图组件 XtxSwiper。 静态结构 商品分类页静态结构&#xff1a; src/pages/category/category.vue …
阅读更多...
Docsify + Gitalk详细配置过程讲解

Docsify + Gitalk详细配置过程讲解

&#x1f496; 作者简介&#xff1a;大家好&#xff0c;我是Zeeland&#xff0c;开源建设者与全栈领域优质创作者。&#x1f4dd; CSDN主页&#xff1a;Zeeland&#x1f525;&#x1f4e3; 我的博客&#xff1a;Zeeland&#x1f4da; Github主页: Undertone0809 (Zeeland)&…
阅读更多...
二进制安全虚拟机Protostar靶场 安装,基础知识讲解,破解STACK ZERO

二进制安全虚拟机Protostar靶场 安装,基础知识讲解,破解STACK ZERO

简介 pwn是ctf比赛的方向之一&#xff0c;也是门槛最高的&#xff0c;学pwn前需要很多知识&#xff0c;这里建议先去在某宝上买一本汇编语言第四版&#xff0c;看完之后学一下python和c语言&#xff0c;python推荐看油管FreeCodeCamp的教程&#xff0c;c语言也是 pwn题目大部…
阅读更多...
FastestDet：比yolov5更快！更强！全新设计的超实时Anchor-free目标检测算法（附源代码下载）...

FastestDet：比yolov5更快！更强！全新设计的超实时Anchor-free目标检测算法（附源代码下载）...

关注并星标 从此不迷路 计算机视觉研究院 公众号ID&#xff5c;ComputerVisionGzq 学习群&#xff5c;扫码在主页获取加入方式 计算机视觉研究院专栏 作者&#xff1a;Edison_G 本篇文章转自于知乎——qiuqiuqiu&#xff0c;主要设计了一个新颖的轻量级网络&#xff01; 代码地…
阅读更多...
【多线程】线程安全（重点）

【多线程】线程安全（重点）

文章目录 1. 观察线程不安全1.1 示例11.2 示例2 2. 线程不安全的原因2.1 修改共享数据2.2 原子性2.3 可见性2.4 顺序性 3. synchronized同步方法3.1 synchronized特性3.1.1 互斥3.1.2 刷新内存3.1.3 可重入 3.2 synchronized使用3.2.1 直接修饰普通方法3.2.2 修饰静态方法3.2.3…
阅读更多...
开源照片管理服务LibrePhotos

开源照片管理服务LibrePhotos

本文是为了解决网友 赵云遇到的问题&#xff0c;顺便折腾的。虽然软件跑起来了&#xff0c;但是他遇到的问题&#xff0c;超出了老苏的认知。当然最终问题还是得到了解决&#xff0c;不过与 LibrePhotos 无关&#xff1b; 什么是 LibrePhotos ? LibrePhotos 是一个自托管的开源…
阅读更多...
uniapp微信小程序用户隐私保护

uniapp微信小程序用户隐私保护

使用wx.requirePrivacyAuthorize实现微信小程序用户隐私保护。 一、前言 微信小程序官方出了一个公告《关于小程序隐私保护指引设置的公告》。不整的话&#xff0c;后果很多授权无法使用&#xff0c;详见《小程序用户隐私保护指引内容介绍》 。 二、隐私相关设置 1、在 微信…
阅读更多...
基于Laravel通用型内容建站企业官网系统源码 可免费商用

基于Laravel通用型内容建站企业官网系统源码 可免费商用

是一个基于 Laravel 企业内容建站系统。模块市场拥有丰富的功能应用&#xff0c;支持后台一键快速安装&#xff0c;让开发者能快的实现业务功能开发。 系统完全开源&#xff0c;免费且不限制商业使用 2023年08月23日增加了以下12个特性&#xff1a; [新功能] 手机端Banner支持…
阅读更多...
视频监控人员行为识别算法

视频监控人员行为识别算法

视频监控人员行为识别算法通过opencvpython网络模型框架算法&#xff0c;视频监控人员行为识别算法可以识别和判断员工的行为是否符合规范要求&#xff0c;一旦发现不符合规定的行为&#xff0c;视频监控人员行为识别算法将自动发送告警信息。OpenCV的全称是Open Source Comput…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023