经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
【选择排序算法详解】Java/Go/Python/JS/C 不同语言实现
来源：cnblogs　　作者：刀法如飞　　时间：2023/3/8 11:00:25　　对本文有异议

【选择排序算法详解】Java/Go/Python/JS/C 不同语言实现

 

说明

选择排序（Selection Sort）是一种简单直观的排序算法。跟冒泡、插入排序一样，它将数列分为已排序和待排序两个区间。首先在待排序序列中找到最小（或最大）的元素，追加到已排序序列中，然后继续从待排序序列中寻找最小（或最大）的元素，追加到已排序序列的尾部。以此类推，直到所有元素均排序完毕。可以通过同时找出最小和最大项来优化性能，详见源码。

 

实现过程

  1. 先建立两个循环，外循环用于逐个交换数据，内循环用来遍历找到最小(或最大)值。
  2. 设第 1 项为最小值，在内循环中将其逐个与后项进行比较，如果遇到更小的值，则更新最小值，并记录下最小值的下标。
  3. 在外循环中将第 1 项与最小值进行交换，然后以第 2 项作为最小值，再重复执行步骤 2，直到遍历完全部待排序区间。

 

示意图

 

 

 

性能分析

  1. 平均时间复杂度：O(N^2)
  2. 最佳时间复杂度：O(N^2)
  3. 最差时间复杂度：O(N^2)
  4. 空间复杂度：O(1)
  5. 排序方式：In-place
  6. 稳定性：不稳定
  7.  
  8. 选择排序的交换操作介于和(n-1)次之间。选择排序的比较操作为n(n-1)/2次之间。选择排序的赋值操作介于0和3(n-1)次之间。
  9. 比较次数O(n^2)，比较次数与关键字的初始状态无关，总的比较次数N = (n-1) + (n-2) +…+ 1 = n x (n-1)/2。交换次数O(n)，最好情况是，已经有序，交换0次；最坏情况是，逆序，交换n-1次。

代码

Java

 

  1. // java选择排序标准版，更多版本请看源码文件
  2. class SelectionSort {
  3.   static int[] selectionSort1(final int[] arr) {
  4.     int min;
  5.     int minIdx;
  6.     int tmp;
  7.     int l = arr.length;
  8.     for (int i = 0; i < l - 1; i++) {
  9.       min = arr[i];
  10.       minIdx = i;
  11.       int j = i + 1;
  12.       for (; j < l; j++) {
  13.         // 从待排序列表找到最小值和位置
  14.         if (arr[j] < min) {
  15.           min = arr[j];
  16.           minIdx = j;
  17.         }
  18.       }
  19.       System.out.println("i=" + i + " j=" + j + " min=" + min + "minIdx=" + minIdx + " arr[]" + Arrays.toString(arr));
  20.       // 将待排序里最小值交换到已排序最后面
  21.       if (minIdx != i) {
  22.         tmp = arr[i];
  23.         arr[i] = min;
  24.         arr[minIdx] = tmp;
  25.       }
  26.     }
  27.     return arr;
  28.   }
  29. }
  32. // 选择排序优化版，同时找出最小和最大值进行交换，可减少1半遍历
  33. // 把数列分为前中后三个区间，分别代表最小已排序、中间待排序以及最大已排序区间
  34. // 遍历中间待排序同时找最大和最小值，分别交换到最小值区间和最大值区间
  35. class SelectionSort {
  37.   static int[] sort(final int[] arr) {
  38.     int minValue, maxValue, minIdx, maxIdx;
  39.     int minListIdx, maxListIdx;
  40.     int arrLen = arr.length;
  41.     for (int i = 0; i < arrLen - 1; i++) {
  42.       // 待排序里面初始最小值和下标
  43.       minIdx = i;
  44.       minValue = arr[minIdx];
  45.       // 待排序里面初始最大值和下标
  46.       maxIdx = i;
  47.       maxValue = arr[maxIdx];
  48.       // 最小和最大序列里最新待交换的下标
  49.       // 最小序列的下标从0开始，自前往后递加
  50.       minListIdx = minIdx;
  51.       // 最大序列的下标从数组最后1位开始，自后往前递减
  52.       maxListIdx = arrLen - 1 - i;
  53.       // 如果最小和最大下标相同，说明只剩下1个数字，则终止循环
  54.       if (minListIdx == maxListIdx) {
  55.         break;
  56.       }
  58.       // 逐一遍历待排序区间，找出最小和最大值
  59.       // 待排序区间在最小值序列和和最大值序列之间
  60.       // 待比较区间的下标j从i+1开始，到最大已排序前结束
  61.       for (int j = i + 1; j < arrLen - i; j++) {
  62.         // 从待排序列表中分别找到最小值和最大值
  63.         if (arr[j] < minValue) {
  64.           minIdx = j;
  65.           minValue = arr[minIdx];
  66.         } else if (arr[j] > maxValue) {
  67.           maxIdx = j;
  68.           maxValue = arr[maxIdx];
  69.         }
  70.       }
  72.       // 如果最小值等于最小序列待交换的值，且最大值等于最大序列里待交换的值，则跳过
  73.       if (arr[minIdx] == arr[minListIdx] && arr[maxIdx] == arr[maxListIdx]) {
  74.         continue;
  75.       }
  77.       // 先交换小值，再交换大值
  78.       arr[minIdx] = arr[minListIdx];
  79.       arr[minListIdx] = minValue;
  80.       // 如果最大值被交换了，则需要更新最大值的下标
  81.       if (arr[minIdx] == maxValue) {
  82.         maxIdx = minIdx;
  83.       }
  84.       arr[maxIdx] = arr[maxListIdx];
  85.       arr[maxListIdx] = maxValue;
  86.     }
  87.     return arr;
  88.   }
  89. }

 

Python

 

  1. # python选择排序标准版本，更多实现版本请查看源文件
  2. # 新建数组版，无需交换
  3. def selection_sort2(arr):
  4.     new_list = []
  5.     i = 0
  6.     l = len(arr)
  7.     while (i < l):
  8.         min = arr[i]
  9.         min_idx = i
  10.         j = i + 1
  11.         while (j < l):
  12.             # 找到并记录下最小值和位置
  13.             if (arr[j] < min):
  14.                 min = arr[j]
  15.                 min_idx = j
  16.             
  17.             j += 1
  18.  
  19.         # 将待排序里最小值添加到新数组中去
  20.         new_list.append(min)
  21.         # 原数组中删除对应的项
  22.         arr.remove(min)
  23.         l -= 1
  24.  
  25.     return new_list
  28. """
  29. # 选择排序优化版，同时找出最小和最大值进行交换，可减少1半遍历
  30. # 把数列分为前中后三个区间，分别代表最小已排序、中间待排序以及最大已排序区间
  31. # 遍历中间待排序同时找最大和最小值，分别交换到最小值区间和最大值区间
  32. """
  33. def selection_sort(arr):
  34.     arr_len = len(arr)
  35.     for i in range(arr_len - 1):
  36.         # 初始最小值和下标
  37.         min_idx = i
  38.         min_value = arr[min_idx]
  39.         # 初始最大值和下标
  40.         max_idx = i
  41.         max_value = arr[max_idx]
  43.         # 最小和最大序列里最新待交换的下标
  44.         # 最小序列的下标从0开始，自前往后递加
  45.         min_list_idx = min_idx
  46.         # 最大序列的下标从数组最后1位开始，自后往前递减
  47.         max_list_idx = arr_len - 1 - i
  48.         # 如果最小和最大下标相同，说明只剩下1个数字，则终止循环
  49.         if min_list_idx == max_list_idx:
  50.             break
  51.  
  52.         # 逐一遍历待排序区间，找出最小和最大值
  53.         # 待排序区间在最小值序列和和最大值序列之间
  54.         # 待比较区间的下标j从i+1开始，到最大已排序前结束
  55.         j = i + 1
  56.         while j < arr_len - i:
  57.             # 从待排序列表找到最小值和最大值及位置
  58.             if arr[j] < min_value:
  59.                 min_idx = j
  60.                 min_value = arr[min_idx]
  61.             elif arr[j] > max_value:
  62.                 max_idx = j
  63.                 max_value = arr[max_idx]
  64.             j += 1
  65.  
  66.         # 如果最小值等于最小序列待交换的值，且最大值等于最大序列里待交换的值，则跳过
  67.         if arr[min_idx] == arr[min_list_idx] and arr[max_idx] == arr[
  68.                 max_list_idx]:
  69.             continue
  70.  
  71.         print('min_value=', min_value, 'max_value=', max_value, 'min_idx=',
  72.               min_idx, 'max_idx=', max_idx, 'min_list_idx=', min_list_idx,
  73.               'max_list_idx=', max_list_idx)
  75.         # 先交换小值，再交换大值
  76.         arr[min_list_idx], arr[min_idx] = arr[min_idx], arr[min_list_idx]
  77.         # 如果最大值被交换了，则需要更新最大值的下标
  78.         if arr[min_idx] == max_value:
  79.             max_idx = min_idx
  80.         arr[max_list_idx], arr[max_idx] = arr[max_idx], arr[max_list_idx]
  82.     return arr

 

Go

 

  1. // go选择排序标准版，其他版本请查看源文件
  2. func selectionSort1(arr []int) []int {
  3.   var min = arr[0]
  4.   var minIdx = 0
  5.   var tmp = -1
  6.   var arrLen = len(arr)
  7.   for i := 0; i < arrLen-1; i++ {
  8.     min = arr[i]
  9.     minIdx = i
  10.     var j = i + 1
  11.     for ; j < arrLen; j++ {
  12.       // 从待排序列表中找到最小值和位置，用作交换
  13.       if arr[j] < min {
  14.         min = arr[j]
  15.         minIdx = j
  16.       }
  17.     }
  18.     fmt.Println("i=", i, " j=", j, "min=", min, "minIdx=", minIdx, "arr[]=", arr)
  19.     // 将待排序里最小值交换到已排序最后面
  20.     if minIdx != i {
  21.       tmp = arr[i]
  22.       arr[i] = min
  23.       arr[minIdx] = tmp
  24.     }
  25.   }
  27.   return arr
  28. }
  32. // 选择排序优化版，同时找出最小和最大值进行交换，可减少1半遍历
  33. // 把数列分为前中后三个区间，分别代表最小已排序、中间待排序以及最大已排序区间
  34. // 遍历中间待排序同时找最大和最小值，分别交换到最小值区间和最大值区间
  35. func selectionSort(arr []int) []int {
  37.   var minValue int
  38.   var maxValue int
  39.   var minIdx int
  40.   var maxIdx int
  41.   var minListIdx int
  42.   var maxListIdx int
  43.  
  44.   var arrLen = len(arr)
  45.   for i := 0; i < arrLen-1; i++ {
  46.     // 待排序里面初始最小值和下标
  47.     minIdx = i
  48.     minValue = arr[minIdx]
  49.     // 待排序里面初始最大值和下标
  50.     maxIdx = i
  51.     maxValue = arr[maxIdx]
  52.     // 最小和最大序列里最新待交换的下标
  53.     // 最小序列的下标从0开始，自前往后递加
  54.     minListIdx = minIdx
  55.     // 最大序列的下标从数组最后1位开始，自后往前递减
  56.     maxListIdx = arrLen - 1 - i
  57.     // 如果最小和最大下标相同，说明只剩下1个数字，则终止循环
  58.     if minListIdx == maxListIdx {
  59.       break
  60.     }
  62.     // 逐一遍历待排序区间，找出最小和最大值
  63.     // 待排序区间在最小值序列和和最大值序列之间
  64.     // 待比较区间的下标j从i+1开始，到最大已排序前结束
  65.     for j := i + 1; j < arrLen-i; j++ {
  66.       // 从待排序列表中分别找到最小值和最大值
  67.       if arr[j] < minValue {
  68.         minIdx = j
  69.         minValue = arr[minIdx]
  70.       } else if arr[j] > maxValue {
  71.         maxIdx = j
  72.         maxValue = arr[maxIdx]
  73.       }
  74.     }
  76.     // 如果最小值等于最小序列待交换的值，且最大值等于最大序列里待交换的值，则跳过
  77.     if arr[minIdx] == arr[minListIdx] && arr[maxIdx] == arr[maxListIdx] {
  78.       continue
  79.     }
  80.     fmt.Println("minValue=", minValue, " maxValue=", maxValue, " minIdx=", minIdx, " maxIdx=", maxIdx, " minListIdx=", minListIdx, " maxListIdx=", maxListIdx)
  81.     // 先交换小值，再交换大值
  82.     arr[minListIdx], arr[minIdx] = arr[minIdx], arr[minListIdx]
  83.     // 如果最大值被交换了，则需要更新最大值的下标
  84.     if arr[minIdx] == maxValue {
  85.       maxIdx = minIdx
  86.     }
  87.     arr[maxListIdx], arr[maxIdx] = arr[maxIdx], arr[maxListIdx]
  88.   }
  90.   return arr
  91. }

 

JS

  1. // js选择排序徐标准版，更多实现版本详见源码文件
  2. // 新建数组版，无需交换
  3. function selectionSort2(arr) {
  4.   var min, minIdx
  5.   var newArr = []
  6.   var arrLen = arr.length
  7.   for (var i = 0; i < arrLen; i++) {
  8.     min = arr[i]
  9.     minIdx = i
  10.     let j = i + 1
  11.     for (; j < arrLen; j++) {
  12.       // 找到并记录下最小值和位置
  13.       if (arr[j] < min) {
  14.         min = arr[j]
  15.         minIdx = j
  16.       }
  17.     }
  18.     console.log('i=' + i, ' j=' + j, 'min=' + min, 'minIdx=' + minIdx, 'arr[]=', arr)
  19.     // 将待排序里最小值添加到新数组中去
  20.     newArr.push(min)
  21.     // 原数组中删除对应的项
  22.     arr.splice(minIdx, 1)
  23.     arrLen--
  24.     i--
  25.   }
  26.   return newArr
  27. }
  31. // 选择排序优化版，同时找出最小和最大值进行交换，可减少1半遍历
  32. // 把数列分为前中后三个区间，分别代表最小已排序、中间待排序以及最大已排序区间
  33. // 遍历中间待排序同时找最大和最小值，分别交换到最小值区间和最大值区间
  34. function selectionSort(arr) {
  35.   let minValue, maxValue, minIdx, maxIdx
  36.   let minListIdx, maxListIdx
  37.   const arrLen = arr.length
  38.   // 外循环，从第1项开始与后面待排序项逐个对比，最后1位无需再比较
  39.   for (let i = 0; i < arrLen - 1; i++) {
  40.     // 待排序里面初始最小值和下标
  41.     minIdx = i
  42.     minValue = arr[minIdx]
  43.     // 待排序里面初始最大值和下标
  44.     maxIdx = i
  45.     maxValue = arr[maxIdx]
  46.     // 最小和最大序列里最新待交换的下标
  47.     // 最小序列的下标从0开始，自前往后递加
  48.     minListIdx = minIdx
  49.     // 最大序列的下标从数组最后1位开始，自后往前递减
  50.     maxListIdx = arrLen - 1 - i
  51.     // 如果最小和最大下标相同，说明只剩下1个数字，则终止循环
  52.     if (minListIdx === maxListIdx) {
  53.       break
  54.     }
  56.     // 逐一遍历待排序区间，找出最小和最大值
  57.     // 待排序区间在最小值序列和和最大值序列之间
  58.     // 待比较区间的下标j从i+1开始，到最大已排序前结束
  59.     for (let j = i + 1; j < arrLen - i; j++) {
  60.       // 从待排序列表中分别找到最小值和最大值
  61.       if (arr[j] < minValue) {
  62.         minIdx = j
  63.         minValue = arr[minIdx]
  64.       } else if (arr[j] > maxValue) {
  65.         maxIdx = j
  66.         maxValue = arr[maxIdx]
  67.       }
  68.     }
  70.     // 如果最小值等于最小序列待交换的值，且最大值等于最大序列里待交换的值，则跳过
  71.     if (arr[minIdx] === arr[minListIdx] && arr[maxIdx] === arr[maxListIdx]) {
  72.       continue
  73.     }
  74.     console.log('minValue=', minValue, 'maxValue=', maxValue, 'minIdx=', minIdx, 'maxIdx=', maxIdx, 'minListIdx=', minListIdx, 'maxListIdx=', maxListIdx)
  75.     // 先交换小值，再交换大值
  76.     ;[arr[minListIdx], arr[minIdx]] = [arr[minIdx], arr[minListIdx]]
  77.     // 如果最大值被交换了，则需要更新最大值的下标
  78.     if (arr[minIdx] === maxValue) {
  79.       maxIdx = minIdx
  80.     }
  81.     ;[arr[maxListIdx], arr[maxIdx]] = [arr[maxIdx], arr[maxListIdx]]
  82.   }
  84.   return arr
  85. }

 

 

TS

  1. // TS标准版，其他版本请查看源码文件
  2. class SelectionSort {
  3.   constructor() {}
  4.   // 标准版
  5.   selectionSort1(arr: Array<number>) {
  6.     let min: number, minIdx: number, tmp: number
  7.     let l = arr.length
  8.     for (let i = 0; i < l - 1; i++) {
  9.       min = arr[i]
  10.       minIdx = i
  11.       let j = i + 1
  12.       for (; j < l; j++) {
  13.         // 从待排序列表找到最小值和位置
  14.         if (arr[j] < min) {
  15.           min = arr[j]
  16.           minIdx = j
  17.         }
  18.       }
  20.       // 将待排序里最小值交换到已排序最后面
  21.       if (minIdx !== i) {
  22.         tmp = arr[i]
  23.         arr[i] = min
  24.         arr[minIdx] = tmp
  25.       }
  26.     }
  28.     return arr
  29.   }
  30. }

  32. class SelectionSort {
  33.   // 选择排序优化版，同时找出最小和最大值进行交换，可减少1半遍历
  34.   // 把数列分为前中后三个区间，分别代表最小已排序、中间待排序以及最大已排序区间
  35.   // 遍历中间待排序同时找最大和最小值，分别交换到最小值区间和最大值区间
  36.   sort(arr: Array<number>) {
  37.     let minValue: number, maxValue: number, minIdx: number, maxIdx: number
  38.     let minListIdx: number, maxListIdx: number
  39.     const arrLen = arr.length
  40.     // 外循环，从第1项开始与后面待排序项逐个对比，最后1位无需再比较
  41.     for (let i = 0; i < arrLen - 1; i++) {
  42.       // 待排序里面初始最小值和下标
  43.       minIdx = i
  44.       minValue = arr[minIdx]
  45.       // 待排序里面初始最大值和下标
  46.       maxIdx = i
  47.       maxValue = arr[maxIdx]
  48.       // 最小和最大序列里最新待交换的下标
  49.       // 最小序列的下标从0开始，自前往后递加
  50.       minListIdx = minIdx
  51.       // 最大序列的下标从数组最后1位开始，自后往前递减
  52.       maxListIdx = arrLen - 1 - i
  53.       // 如果最小和最大下标相同，说明只剩下1个数字，则终止循环
  54.       if (minListIdx === maxListIdx) {
  55.         break
  56.       }
  58.       // 逐一遍历待排序区间，找出最小和最大值
  59.       // 待排序区间在最小值序列和和最大值序列之间
  60.       // 待比较区间的下标j从i+1开始，到最大已排序前结束
  61.       for (let j = i + 1; j < arrLen - i; j++) {
  62.         // 从待排序列表中分别找到最小值和最大值
  63.         if (arr[j] < minValue) {
  64.           minIdx = j
  65.           minValue = arr[minIdx]
  66.         } else if (arr[j] > maxValue) {
  67.           maxIdx = j
  68.           maxValue = arr[maxIdx]
  69.         }
  70.       }
  72.       // 如果最小值等于最小序列待交换的值，且最大值等于最大序列里待交换的值，则跳过
  73.       if (arr[minIdx] === arr[minListIdx] && arr[maxIdx] === arr[maxListIdx]) {
  74.         continue
  75.       }
  77.       // 先交换小值，再交换大值
  78.       arr[minIdx] = arr[minListIdx];
  79.       arr[minListIdx] = minValue;
  80.       // 如果最大值被交换了，则需要更新最大值的下标
  81.       if (arr[minIdx] == maxValue) {
  82.         maxIdx = minIdx;
  83.       }
  84.       arr[maxIdx] = arr[maxListIdx];
  85.       arr[maxListIdx] = maxValue;
  86.     }
  88.     return arr
  89.   }
  90. }

 

 

C

  1. // c语言选择排序标准版，其他版本请查看源码文件
  2. void *selection_sort1(int arr[], int len)
  3. {
  4.   int min_value, min_idx, tmp;
  5.   for (int i = 0; i < len - 1; i++)
  6.   {
  7.     min_value = arr[i];
  8.     min_idx = i;
  9.     int j = i + 1;
  10.     for (; j < len; j++)
  11.     {
  12.       // 从待排序列表找到最小值和位置
  13.       if (arr[j] < min_value)
  14.       {
  15.         min_value = arr[j];
  16.         min_idx = j;
  17.       }
  18.     }
  20.     // 将待排序里最小值交换到已排序最后面
  21.     if (min_idx != i)
  22.     {
  23.       tmp = arr[i];
  24.       arr[i] = min_value;
  25.       arr[min_idx] = tmp;
  26.     }
  27.   }
  28.   return arr;
  29. }

  31. // 选择排序优化版，同时找出最小和最大值进行交换，可减少1半遍历
  32. // 把数列分为前中后三个区间，分别代表最小已排序、中间待排序以及最大已排序区间
  33. // 遍历中间待排序同时找最大和最小值，分别交换到最小值区间和最大值区间
  34. void *selection_sort(int arr[], int len)
  35. {
  36.   int min_value, max_value, min_idx, max_idx;
  37.   int min_list_idx, max_list_idx;
  38.   for (int i = 0; i < len - 1; i++)
  39.   {
  40.     // 待排序里面初始最小值和下标
  41.     min_idx = i;
  42.     min_value = arr[min_idx];
  43.     // 待排序里面初始最大值和下标
  44.     max_idx = i;
  45.     max_value = arr[max_idx];
  46.     // 最小和最大序列里最新待交换的下标
  47.     // 最小序列的下标从0开始，自前往后递加
  48.     min_list_idx = min_idx;
  49.     // 最大序列的下标从数组最后1位开始，自后往前递减
  50.     max_list_idx = len - 1 - i;
  51.     // 如果最小和最大下标相同，说明只剩下1个数字，则终止循环
  52.     if (min_list_idx == max_list_idx)
  53.     {
  54.       break;
  55.     }
  57.     // 逐一遍历待排序区间，找出最小和最大值
  58.     // 待排序区间在最小值序列和和最大值序列之间
  59.     // 待比较区间的下标j从i+1开始，到最大已排序前结束
  60.     for (int j = i + 1; j < len - i; j++)
  61.     {
  62.       // 从待排序列表中分别找到最小值和最大值
  63.       if (arr[j] < min_value)
  64.       {
  65.         min_idx = j;
  66.         min_value = arr[min_idx];
  67.       }
  68.       else if (arr[j] > max_value)
  69.       {
  70.         max_idx = j;
  71.         max_value = arr[max_idx];
  72.       }
  73.     }
  75.     // 如果最小值等于最小序列待交换的值，且最大值等于最大序列里待交换的值，则跳过
  76.     if (arr[min_idx] == arr[min_list_idx] && arr[max_idx] == arr[max_list_idx])
  77.     {
  78.       continue;
  79.     }
  81.     // 先交换小值，再交换大值
  82.     arr[min_idx] = arr[min_list_idx];
  83.     arr[min_list_idx] = min_value;
  84.     // 如果最大值被交换了，则需要更新最大值的下标
  85.     if (arr[min_idx] == max_value)
  86.     {
  87.       max_idx = min_idx;
  88.     }
  89.     arr[max_idx] = arr[max_list_idx];
  90.     arr[max_list_idx] = max_value;
  91.   }
  92.   return arr;
  93. }

 

 

链接

选择排序算法源码：https://github.com/microwind/algorithms/tree/master/sorts/selectionsort

其他排序算法源码：https://github.com/microwind/algorithms

原文链接：https://www.cnblogs.com/letjs/p/17188965.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号