算法31:针对算法30货币问题进行拓展 + 时间复杂度 + 空间复杂度优化--------从左往右尝试模型

本文主要是介绍算法31:针对算法30货币问题进行拓展 + 时间复杂度 + 空间复杂度优化--------从左往右尝试模型,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

在算法30中,我们说过从左往右尝试模型,口诀就是针对固定集合,值不同,就是讨论要和不要的累加和

那么对于非固定集合,我们应该怎么做呢?

针对非固定集合,面值固定,张数无限。口诀就是讨论要与不要,要的话逐步讨论要几张的累加和

题目:

* arr是面值数组,其中的值都是正数且没有重复。再给定一个正数aim。

* 每个值都认为是一种面值,且认为张数是无限的。

* 返回组成aim的方法数

分析:

* 例如:arr = {1,2},aim = 4

* 方法如下:1+1+1+1、1+1+2、2+2 * 一共就3种方法,所以返回3

递归写法:

 //递归版本public static int ways(int[] arr, int aim) {if (arr == null || arr.length == 0 || aim < 0) {return 0;}return process(arr, 0, aim);}public static int process (int[] arr, int index, int aim){if (index == arr.length) { // 没钱了return aim == 0 ? 1 : 0;}//讨论不同货币组成aim的可能int ways = 0;//因为货币张数无限,所有需要讨论每一种情况。此次,就不是简单的要与不要的问题了for (int zhangshu = 0; zhangshu * arr[index] <= aim; zhangshu++) {/*** 此处,还是讨论要与不要的问题。* 0张代表不要* 要的话需要讨论要几张 :* 要1 张, 那么后面的数组需要进行递归继续讨论要还是不要,要的话要几张* 要2 张,那么后面的数组需要进行递归继续讨论要还是不要,要的话要几张*  依次类推*/ways += process(arr, index + 1, aim - zhangshu * arr[index]);}return ways;}

动态规划

1. 套路还是老样子。以数组为横坐标,以aim为纵坐标。并且行与列都新增1个。

2. 根据递归

if (index == arr.length) { // 没钱了return aim == 0 ? 1 : 0;
}

可以推导出最后一行的第一列为1,其余全部为0.

aim 0aim 1aim 2aim 3aim 4
index 0 (1)
index 1 (2)
index 210000

3. 根据递归:

int ways = 0;
//因为货币张数无限,所有需要讨论每一种情况。此次,就不是简单的要与不要的问题了
for (int zhangshu = 0; zhangshu * arr[index] <= aim; zhangshu++) {/*** 此处,还是讨论要与不要的问题。* 0张代表不要* 要的话需要讨论要几张 :* 要1 张, 那么后面的数组需要进行递归继续讨论要还是不要,要的话要几张* 要2 张,那么后面的数组需要进行递归继续讨论要还是不要,要的话要几张*  依次类推*/ways += process(arr, index + 1, aim - zhangshu * arr[index]);
}

可以得到:

1. zhangshu * arr[index] <= aim必须成立,否则不做推导;直接返回0

2. 如果zhangshu * arr[index] <= aim成立,那么当前行当前列的值  依赖于下一行的aim - zhangshu * arr[index]列。

aim= 0aim= 1aim= 2aim= 3aim= 4
index 0 (1)
index 1 (2)

aim - zhangshu * arr[index]  = 0 - 张数 *2;

讨论:

面值为2:张数为0,则 计算值为0

dp[1][0] = dp[2][0] = 1; 即只存在1种解法。

讨论:

张数为0

dp[1][1] = dp[2][1] = 0

 

张数为1

可得 1 - 2 < 0;取值0

0+0=0,最终取值0
 

讨论

张数0

dp[1][2] = dp[2][2] = 0;

张数为1,可得 2 - 2 =0;

可得dp[1][2] = dp[2][0] = 1;

张数为2,可得 2 - 2*2 <0;直接取0;

即1种解法,即0+1+0=1

讨论1:

张数为0

dp[1][3] ]= dp[2][3] = 0;

张数为1,可得 3 - 2 =1;

可得:

dp[1][3] = dp[2][1] = 0;

张数为2。

可得3 - 2*2 < 0取值0;

张数为3. 即3-3*2<0,直接取0

0+0+0+0=0,最终取值0

张数为0

dp[1][4] = dp[2][4] = 0;

张数为1,可得 4 - 2 =2;

dp[1][4] = dp[2][2] = 0;

张数为2.

可得4 - 2*2 = 0.

dp[1][4] = dp[2][0] = 1;

张数为3:

4-3*2 < 0;直接取0

张数为4,4-4*2 < 0;直接取0

0+0+1+0+0=1

最终可得1种解法。

index 210000

    接着,我们推导出第一行的数据:

aim= 0aim= 1aim= 2aim= 3aim= 4
index 0 (1)

 面值为1
张数为0,dp[0][0] = dp[1][0] = 1;

  面值为1
张数为0,dp[0][1] = dp[1][1] = 0;

张数为1:

dp[0][1]=dp[1][0] = 1;

累计1种

 张数为0:

dp[0][2] = dp[1][2] = 1;

张数为1:

dp[0][2] = dp[1][1] = 0;

累计1种

张数为0:

dp[0][3] = dp[1][3] = 0;

张数为1:

dp[0][3] = dp[1][2] = 1;

张数为2:

dp[0][3] = dp[1][1] = 0;

累计1种

张数为0;

dp[0][4]=[1][4-0] = dp[1][4] = 1

张数为1:

dp[0][4] = dp[1][4-1*1] = dp[1][3] = 0;

张数为2:

dp[0][4] = dp[1][4-2*1] = dp[1][2] = 1;

张数为3:

dp[0][4] = dp[1][4-3*1] = dp[1][1] = 0;

张数为4:

dp[0][4] = dp[1][4-4*1] = dp[1][0] = 1;

累计1+1+1=3;

index 1 (2)

aim - zhangshu * arr[index]  = 0 - 张数 *2;

讨论:

面值为2:张数为0,则 计算值为0

dp[1][0] = dp[2][0] = 1; 即只存在1种解法。

讨论:

张数为0

dp[1][1] = dp[2][1] = 0

 

张数为1

可得 1 - 2 < 0;取值0

0+0=0,最终取值0
 

讨论

张数0

dp[1][2] = dp[2][2] = 0;

张数为1,可得 2 - 2 =0;

可得dp[1][2] = dp[2][0] = 1;

张数为2,可得 2 - 2*2 <0;直接取0;

即1种解法,即0+1+0=1

讨论1:

张数为0

dp[1][3] ]= dp[2][3] = 0;

张数为1,可得 3 - 2 =1;

可得:

dp[1][3] = dp[2][1] = 0;

张数为2。

可得3 - 2*2 < 0取值0;

张数为3. 即3-3*2<0,直接取0

0+0+0+0=0,最终取值0

 

张数为0,

dp[1][4] = dp[2][4] = 0;

张数为1,可得 4 - 2 =2;

dp[1][4] = dp[2][2] = 0;

张数为2.

可得4 - 2*2 = 0.

dp[1][4] = dp[2][0] = 1;

张数为3:

4-3*2 < 0;直接取0

张数为4,4-4*2 < 0;直接取0

0+0+1+0+0=1

最终可得1种解法。

index 210000

最终需要的是第一行最后一列数据:

1. aim为4,面值为1的一张都没有。可得dp[0][4]=[1][4-0] = dp[1][4] = 1

2. aim 为4, 面值为1的只有一张。可得 dp[0][4] = dp[1][4-1*1] = dp[1][3] = 0;

3. aim 为4, 面值为1的只有两张。可得 dp[0][4] = dp[1][4-2*1] = dp[1][2] = 1;

4. aim 为4, 面值为1的只有三张。可得 dp[0][4] = dp[1][4-3*1] = dp[1][1] = 0;

5. aim 为4, 面值为1的只有四张。可得 dp[0][4] = dp[1][4-4*1] = dp[1][0] = 1;

累计可得1+1+1 = 3, 即3种方法。

  //动态规划public static int ways2(int[] arr, int aim) {if (arr == null || arr.length == 0 || aim < 0) {return 0;}//老样子int N = arr.length;int[][] dp = new int[N + 1][aim + 1];//最后一行的第一列为1,其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到dp[N][0] = 1;//双层for循环,动态规划的老套路。一维数组arr作为横坐标,aim作为纵坐标for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 indexfor (int col = 0; col <= aim; col++) {   //col代表递归中的 aim//此处是比较复杂的,完全套用递归内部的代码。这一层的for循环就是对//要的张数进行讨论。int ways = 0;//此处zhangshu * arr[row] <= col是唯一变化。重点理解for (int zhangshu = 0; zhangshu * arr[row] <= col; zhangshu++) {/*** 此处,还是讨论要与不要的问题。* 0张代表不要* 要的话需要讨论要几张 :* 要1 张, 那么后面的数组需要进行递归继续讨论要还是不要,要的话要几张* 要2 张,那么后面的数组需要进行递归继续讨论要还是不要,要的话要几张*  依次类推*///根据ways += process(arr, row + 1, aim - zhangshu * arr[row]);推导//此处的aim - zhangshu * arr[index] 需要变成 col - zhangshu * arr[index]ways += dp[row + 1][col - (zhangshu * arr[row])];}dp[row][col] = ways;}}return dp[0][aim];}

那么如何进行时间复杂度优化呢?继续观察二维数组:

aim= 0aim= 1aim= 2aim= 3aim= 4
index 0 (1)

 面值为1
张数为0,dp[0][0] = dp[1][0] = 1;

  面值为1
张数为0,dp[0][1] = dp[1][1] = 0;

张数为1:

dp[0][1]=dp[1][0] = 1;

累计1种

 张数为0:

dp[0][2] = dp[1][2] = 1;

张数为1:

dp[0][2] = dp[1][1] = 0;

累计1种

张数为0:

dp[0][3] = dp[1][3] = 0;

张数为1:

dp[0][3] = dp[1][2] = 1;

张数为2:

dp[0][3] = dp[1][1] = 0;

累计1种

张数为0;

dp[0][4]=[1][4-0] = dp[1][4] = 1

张数为1:

dp[0][4] = dp[1][4-1*1] = dp[1][3] = 0;

张数为2:

dp[0][4] = dp[1][4-2*1] = dp[1][2] = 1;

张数为3:

dp[0][4] = dp[1][4-3*1] = dp[1][1] = 0;

张数为4:

dp[0][4] = dp[1][4-4*1] = dp[1][0] = 1;

累计1+1+1=3;

index 1 (2)

aim - zhangshu * arr[index]  = 0 - 张数 *2;

讨论:

面值为2:张数为0,则 计算值为0

dp[1][0] = dp[2][0] = 1; 即只存在1种解法。

讨论:

张数为0

dp[1][1] = dp[2][1] = 0

 

张数为1

可得 1 - 2 < 0;取值0

0+0=0,最终取值0
 

讨论

张数0

dp[1][2] = dp[2][2] = 0;

张数为1,可得 2 - 2 =0;

可得dp[1][2] = dp[2][0] = 1;

张数为2,可得 2 - 2*2 <0;直接取0;

即1种解法,即0+1+0=1

讨论1:

张数为0

dp[1][3] ]= dp[2][3] = 0;

张数为1,可得 3 - 2 =1;

可得:

dp[1][3] = dp[2][1] = 0;

张数为2。

可得3 - 2*2 < 0取值0;

张数为3. 即3-3*2<0,直接取0

0+0+0+0=0,最终取值0

 

张数为0,

dp[1][4] = dp[2][4] = 0;

张数为1,可得 4 - 2 =2;

dp[1][4] = dp[2][2] = 0;

张数为2.

可得4 - 2*2 = 0.

dp[1][4] = dp[2][0] = 1;

张数为3:

4-3*2 < 0;直接取0

张数为4,4-4*2 < 0;直接取0

0+0+1+0+0=1

最终可得1种解法。

index 210000

1. 任何一行的每一列,当张数为0的时候,都是直接依赖下一行的当前列的值。也就是说这个值一定是依赖下一行的当前列的值。

2.  col是aim的值,当 zhangshu * arr[row] <= col 的时候,我们是依赖 dp[row + 1][col - (zhangshu * arr[row])]的值的。这一点是非常非常重要的。由此我们可以推导出;

0张,我们依赖y1处的值

1张,依赖y2处的值。

2张,依赖y3处的值

3张,依赖y4处的值

4张,依赖y5处的值

5张,依赖y6处的值

那 x 不就是 y1 + y2 + y3 + y4 + y5 + y6 吗?

x1 不就是 y2 + y3 + y4 + y5 +y6 吗?

状态转移可得。 x = x1 + y1.

根据以上推导,我们是不是可以直接转化成完整的表格,即

既然我们知道

x = x1 + y1; 假设x处的列下标col为15. 那么x1处的小标不就是 col - value.  此处的value不就是一维数组中的arr[index]的值,即为3。 那么x1处的下标不就是 15 - 3 = 12吗?

 for (int zhangshu = 0; zhangshu * arr[row] <= col; zhangshu++);循环是每次枚举下一行的值的。既然下一行的值已经存储在 x1 x2 x3 .......处,那我们还要这个for循环干嘛呢?

时间复杂度优化代码如下:

 //动态规划 针对时间复杂度的优化版public static int ways3(int[] arr, int aim) {if (arr == null || arr.length == 0 || aim < 0) {return 0;}//老样子int N = arr.length;int[][] dp = new int[N + 1][aim + 1];//最后一行的第一列为1,其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到dp[N][0] = 1;//双层for循环,动态规划的老套路。一维数组arr作为横坐标,aim作为纵坐标for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 indexfor (int col = 0; col <= aim; col++) {   //col代表递归中的 aim// 每一列都存在aim为0张的情况,// 下一行的当前列dp[row][col] = dp[row + 1][col];//当前下标col, 那么前一处的下标不就是 col - arr[row] 吗 ?if (col - arr[row] >= 0) {/*** for循环中的 下一行的 dp[row + 1][col - (zhangshu * arr[row])]列** 直接转化为当前行的 前 col - arr[row] 列。*/dp[row][col] += dp[row][col - arr[row]];}}}return dp[0][aim];}

 以上代码已经对时间复杂度进行了优化,下面按照空间压缩的思维,对空间复杂度再进行优化。

在算法28 算法28:力扣64题,最小路径和------------样本模型-CSDN博客 和 算法29 算法29:不同路径问题(力扣62和63题)--针对算法28进行扩展-CSDN博客中,我已经详细的分析过空间压缩的技巧以及思维。下面直接上代码

空间压缩代码

//动态规划 针对空间复杂度的优化版public static int ways4(int[] arr, int aim) {if (arr == null || arr.length == 0 || aim < 0) {return 0;}//老样子int N = arr.length;int[] dp = new int[aim + 1];//最后一行的第一列为1,其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到dp[0] = 1;//双层for循环,动态规划的老套路。一维数组arr作为横坐标,aim作为纵坐标for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 indexfor (int col = 0; col <= aim; col++) {   //col代表递归中的 aimif (col - arr[row] >= 0) {dp[col] += dp[col - arr[row]];}}}return dp[aim];}

从递归到动态规划,再对动态规划代码进行时间复杂度空间复杂度进行双重优化。本文重点介绍了从左往右模型的技巧、动态规划的推理、时间复杂度的优化。至于空间复杂度,由于前面2篇博客已经重点分析了,所有没有过多累赘叙述。

从左往右模型总结:

1、 针对固定集合,值不同,就是讨论要和不要的累加和

2.    针对非固定集合,面值固定,张数无限。口诀就是讨论要与不要,要的话逐步讨论要几张的累加和

下面贴出完整代码,并加入对数器进行海量数据测试:

package code03.动态规划_07.lesson4;/*** arr是面值数组,其中的值都是正数且没有重复。再给定一个正数aim。* 每个值都认为是一种面值,且认为张数是无限的。* 返回组成aim的方法数* 例如:arr = {1,2},aim = 4* 方法如下:1+1+1+1、1+1+2、2+2* 一共就3种方法,所以返回3*/
public class ContainWaysNotLimitPaper_05 {//递归版本public static int ways(int[] arr, int aim) {if (arr == null || arr.length == 0 || aim < 0) {return 0;}return process(arr, 0, aim);}public static int process (int[] arr, int index, int aim){if (index == arr.length) { // 没钱了return aim == 0 ? 1 : 0;}//讨论不同货币组成aim的可能int ways = 0;//因为货币张数无限,所有需要讨论每一种情况。此次,就不是简单的要与不要的问题了for (int zhangshu = 0; zhangshu * arr[index] <= aim; zhangshu++) {/*** 此处,还是讨论要与不要的问题。* 0张代表不要* 要的话需要讨论要几张 :* 要1 张, 那么后面的数组需要进行递归继续讨论要还是不要,要的话要几张* 要2 张,那么后面的数组需要进行递归继续讨论要还是不要,要的话要几张*  依次类推*/ways += process(arr, index + 1, aim - zhangshu * arr[index]);}return ways;}//动态规划public static int ways2(int[] arr, int aim) {if (arr == null || arr.length == 0 || aim < 0) {return 0;}//老样子int N = arr.length;int[][] dp = new int[N + 1][aim + 1];//最后一行的第一列为1,其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到dp[N][0] = 1;//双层for循环,动态规划的老套路。一维数组arr作为横坐标,aim作为纵坐标for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 indexfor (int col = 0; col <= aim; col++) {   //col代表递归中的 aim//此处是比较复杂的,完全套用递归内部的代码。这一层的for循环就是对//要的张数进行讨论。int ways = 0;//此处zhangshu * arr[row] <= col是唯一变化。重点理解for (int zhangshu = 0; zhangshu * arr[row] <= col; zhangshu++) {/*** 此处,还是讨论要与不要的问题。* 0张代表不要* 要的话需要讨论要几张 :* 要1 张, 那么后面的数组需要进行递归继续讨论要还是不要,要的话要几张* 要2 张,那么后面的数组需要进行递归继续讨论要还是不要,要的话要几张*  依次类推*///根据ways += process(arr, row + 1, aim - zhangshu * arr[row]);推导//此处的aim - zhangshu * arr[index] 需要变成 col - zhangshu * arr[index]ways += dp[row + 1][col - (zhangshu * arr[row])];}dp[row][col] = ways;}}return dp[0][aim];}//动态规划 针对时间复杂度的优化版public static int ways3(int[] arr, int aim) {if (arr == null || arr.length == 0 || aim < 0) {return 0;}//老样子int N = arr.length;int[][] dp = new int[N + 1][aim + 1];//最后一行的第一列为1,其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到dp[N][0] = 1;//双层for循环,动态规划的老套路。一维数组arr作为横坐标,aim作为纵坐标for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 indexfor (int col = 0; col <= aim; col++) {   //col代表递归中的 aim// 每一列都存在aim为0张的情况,// 下一行的当前列dp[row][col] = dp[row + 1][col];//当前下标col, 那么前一处的下标不就是 col - arr[row] 吗 ?if (col - arr[row] >= 0) {/*** for循环中的 下一行的 dp[row + 1][col - (zhangshu * arr[row])]列** 直接转化为当前行的 前 col - arr[row] 列。*/dp[row][col] += dp[row][col - arr[row]];}}}return dp[0][aim];}//动态规划 针对空间复杂度的优化版public static int ways4(int[] arr, int aim) {if (arr == null || arr.length == 0 || aim < 0) {return 0;}//老样子int N = arr.length;int[] dp = new int[aim + 1];//最后一行的第一列为1,其余都为0。 根据递归 return aim == 0 ? 1 : 0;得到dp[0] = 1;//双层for循环,动态规划的老套路。一维数组arr作为横坐标,aim作为纵坐标for (int row = N -1 ; row >= 0; row--) {     //row代表递归中的 indexfor (int col = 0; col <= aim; col++) {   //col代表递归中的 aimif (col - arr[row] >= 0) {dp[col] += dp[col - arr[row]];}}}return dp[aim];}// 为了测试public static int[] randomArray(int maxLen, int maxValue) {int N = (int) (Math.random() * maxLen);int[] arr = new int[N];boolean[] has = new boolean[maxValue + 1];for (int i = 0; i < N; i++) {do {arr[i] = (int) (Math.random() * maxValue) + 1;} while (has[arr[i]]);has[arr[i]] = true;}return arr;}// 为了测试public static void printArray(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}System.out.println();}public static void main(String[] args) {/*   int[] arr = {1,2,3};int aim = 13;System.out.println(ways(arr, aim));System.out.println(ways2(arr, aim));System.out.println(ways3(arr, aim));System.out.println(ways4(arr, aim));*/// 为了测试int maxLen = 10;int maxValue = 30;int testTime = 1000000;System.out.println("测试开始");for (int i = 0; i < testTime; i++) {int[] arr = randomArray(maxLen, maxValue);int aim = (int) (Math.random() * maxValue);int ans1 = ways(arr, aim);int ans2 = ways2(arr, aim);int ans3 = ways3(arr, aim);int ans4 = ways4(arr, aim);if (ans1 != ans2 || ans1 != ans3 || ans1 != ans4) {System.out.println("Oops!");printArray(arr);System.out.println(aim);System.out.println(ans1);System.out.println(ans2);System.out.println(ans3);break;}}System.out.println("测试结束");}
}

这篇关于算法31:针对算法30货币问题进行拓展 + 时间复杂度 + 空间复杂度优化--------从左往右尝试模型的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/572780

相关文章

SpringBoot3实现Gzip压缩优化的技术指南

《SpringBoot3实现Gzip压缩优化的技术指南》随着Web应用的用户量和数据量增加,网络带宽和页面加载速度逐渐成为瓶颈,为了减少数据传输量,提高用户体验,我们可以使用Gzip压缩HTTP响应,... 目录1、简述2、配置2.1 添加依赖2.2 配置 Gzip 压缩3、服务端应用4、前端应用4.1 N

使用Jackson进行JSON生成与解析的新手指南

《使用Jackson进行JSON生成与解析的新手指南》这篇文章主要为大家详细介绍了如何使用Jackson进行JSON生成与解析处理,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1. 核心依赖2. 基础用法2.1 对象转 jsON(序列化)2.2 JSON 转对象(反序列化)3.

springboot循环依赖问题案例代码及解决办法

《springboot循环依赖问题案例代码及解决办法》在SpringBoot中,如果两个或多个Bean之间存在循环依赖(即BeanA依赖BeanB,而BeanB又依赖BeanA),会导致Spring的... 目录1. 什么是循环依赖?2. 循环依赖的场景案例3. 解决循环依赖的常见方法方法 1:使用 @La

C#使用SQLite进行大数据量高效处理的代码示例

《C#使用SQLite进行大数据量高效处理的代码示例》在软件开发中,高效处理大数据量是一个常见且具有挑战性的任务,SQLite因其零配置、嵌入式、跨平台的特性,成为许多开发者的首选数据库,本文将深入探... 目录前言准备工作数据实体核心技术批量插入:从乌龟到猎豹的蜕变分页查询:加载百万数据异步处理:拒绝界面

Python使用自带的base64库进行base64编码和解码

《Python使用自带的base64库进行base64编码和解码》在Python中,处理数据的编码和解码是数据传输和存储中非常普遍的需求,其中,Base64是一种常用的编码方案,本文我将详细介绍如何使... 目录引言使用python的base64库进行编码和解码编码函数解码函数Base64编码的应用场景注意

Spring Boot + MyBatis Plus 高效开发实战从入门到进阶优化(推荐)

《SpringBoot+MyBatisPlus高效开发实战从入门到进阶优化(推荐)》本文将详细介绍SpringBoot+MyBatisPlus的完整开发流程,并深入剖析分页查询、批量操作、动... 目录Spring Boot + MyBATis Plus 高效开发实战:从入门到进阶优化1. MyBatis

MyBatis 动态 SQL 优化之标签的实战与技巧(常见用法)

《MyBatis动态SQL优化之标签的实战与技巧(常见用法)》本文通过详细的示例和实际应用场景,介绍了如何有效利用这些标签来优化MyBatis配置,提升开发效率,确保SQL的高效执行和安全性,感... 目录动态SQL详解一、动态SQL的核心概念1.1 什么是动态SQL?1.2 动态SQL的优点1.3 动态S

Java进行文件格式校验的方案详解

《Java进行文件格式校验的方案详解》这篇文章主要为大家详细介绍了Java中进行文件格式校验的相关方案,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录一、背景异常现象原因排查用户的无心之过二、解决方案Magandroidic Number判断主流检测库对比Tika的使用区分zip

Java实现时间与字符串互相转换详解

《Java实现时间与字符串互相转换详解》这篇文章主要为大家详细介绍了Java中实现时间与字符串互相转换的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录一、日期格式化为字符串(一)使用预定义格式(二)自定义格式二、字符串解析为日期(一)解析ISO格式字符串(二)解析自定义

Java使用Curator进行ZooKeeper操作的详细教程

《Java使用Curator进行ZooKeeper操作的详细教程》ApacheCurator是一个基于ZooKeeper的Java客户端库,它极大地简化了使用ZooKeeper的开发工作,在分布式系统... 目录1、简述2、核心功能2.1 CuratorFramework2.2 Recipes3、示例实践3