盤點幾種常見的java排序算法
1.插入排序
這個打麻將或者打撲克的很好理解, 比如有左手有一副牌1,2,4,7 ,來一張3的牌, 是不是就是手拿著這張牌從右往左插到2,4之間
一次插入排序的操作過程：
將待插元素，依次與已排序好的子數(shù)列元素從后到前進(jìn)行比較，如果當(dāng)前元素值比待插元素值大，則將移位到與其相鄰的后一個位置，否則直接將待插元素插入當(dāng)前元素相鄰的后一位置，因為說明已經(jīng)找到插入點的最終位置
public class InsertSort {
public static void sort(int[] arr) {
if (arr.length >= 2) {
for (int i = 1; i < arr.length; i++) {
//挖出一個要用來插入的值,同時位置上留下一個可以存新的值的坑
int x = arr[i];
int j = i - 1;
//在前面有一個或連續(xù)多個值比x大的時候,一直循環(huán)往前面找,將x插入到這串值前面
while (j >= 0 && arr[j] > x) {
//當(dāng)arr[j]比x大的時候,將j向后移一位,正好填到坑中
arr[j + 1] = arr[j];
j--;
}
//將x插入到最前面
arr[j + 1] = x;
}
}
}
}
2.分治排序法,快速排序法
簡單的說, 就是設(shè)置一個標(biāo)準(zhǔn)值, 將大于這個值的放到右邊(不管排序), 將小于這個值的放到左邊(不管排序), 那么這樣只是區(qū)分了左小右大, 沒有排序, 沒關(guān)系, 左右兩邊再重復(fù)這個步驟.直到不能分了為止.
詳細(xì)說就是:
- 選擇待排數(shù)列的首部第一個元素為基準(zhǔn)元素x，設(shè)置兩指針，分別指向數(shù)列首尾部位置，假設(shè)兩指針分別設(shè)為i和j。
- 每次遍歷的過程是這樣的，首先從右到左遍歷指針j所指向的元素，直到j(luò)指向的元素值小于基準(zhǔn)元素x時，停止遍歷，將其放到i的位置(因為i的值已經(jīng)拷貝成了基準(zhǔn)x騰出了位置)
- i往右挪一步, i++,接著輪到指針i從左到右遍歷,直到i所指向的元素值大于基準(zhǔn)元素x時，停止遍歷，將其放到j(luò)的位置(因為上面一步j(luò)的值已經(jīng)占用到了i的位置,騰出位置了)
- 依此類推，兩邊輪流遍歷, 直到指針i與指針j相等或者大于(實際肯定是i==j)時，停止外部循環(huán)。此時必定左邊都是比x小的, 右邊是比x大的.
- 最后直接將基準(zhǔn)元素x直接放置于指針i所指向的位置即可
- 完成分區(qū)操作, 從i的位置一分為二, 左邊和右邊再遞歸執(zhí)行上面的操作. 層層細(xì)分
接下來，我們通過示圖來展示上述分區(qū)算法思路的過程：
public class QuickSort {
public static void sort(int[] arr,int begin,int end) {
//先定義兩個參數(shù)接收排序起始值和結(jié)束值
int a = begin;
int b = end;
//先判斷a是否大于b
if (a >= b) {
//沒必要排序
return;
}
//基準(zhǔn)數(shù),默認(rèn)設(shè)置為第一個值
int x = arr[a];
//循環(huán)
while (a < b) {
//從后往前找,找到一個比基準(zhǔn)數(shù)x小的值,賦給arr[a]
//如果a和b的邏輯正確--a<b ,并且最后一個值arr[b]>x,就一直往下找,直到找到后面的值大于x
while (a < b && arr[b] >= x) {
b--;
}
//跳出循環(huán),兩種情況,一是a和b的邏輯不對了,a>=b,這時候排序結(jié)束.二是在后面找到了比x小的值
if (a < b) {
//將這時候找到的arr[b]放到最前面arr[a]
arr[a] = arr[b];
//排序的起始位置后移一位
a++;
}
//從前往后找,找到一個比基準(zhǔn)數(shù)x大的值,放在最后面arr[b]
while (a < b && arr[a] <= x) {
a++;
}
if (a < b) {
arr[b] = arr[a];
//排序的終止位置前移一位
b--;
}
}
//跳出循環(huán) a < b的邏輯不成立了,a==b重合了,此時將x賦值回去arr[a]
arr[a] = x;
//調(diào)用遞歸函數(shù),再細(xì)分再排序
sort(arr,begin,a-1);
sort(arr,a+1,end);
}
}
3.冒泡排序 low版
每次冒泡過程都是從數(shù)列的第一個元素開始，然后依次和剩余的元素進(jìn)行比較, 跟列隊一樣, 從左到右兩兩相鄰的元素比大小, 高的就和低的換一下位置. 最后最高(值最大)的肯定就排到后面了.
但是這只是把最高的排到后面了, 還得找出第二高的, 于是又從第一個開始兩兩比較, 高的往后站, 然后第二高的也到后面了.
然后是第三高的再往后排…
public class MaoPao {
public static void sort(int[] arr){
for (int i = 1; i < arr.length; i++) { //第一層for循環(huán),用來控制冒泡的次數(shù)
for (int j = 0; j < arr.length-1; j++) { //第二層for循環(huán),用來控制冒泡一層層到最后
//如果前一個數(shù)比后一個數(shù)大,兩者調(diào)換 ,意味著泡泡向上走了一層
if (arr[j] > arr[j+1] ){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
}
4.冒泡排序 bigger版
補充, 改進(jìn)后,看下文的測試結(jié)果發(fā)現(xiàn)提升并不大, 這是正常的, 因為改進(jìn)后省略的是排序成功后的判斷步驟, 而就算沒改進(jìn), 排序成功后也只不過是對數(shù)組進(jìn)行遍歷而已, 沒有進(jìn)行數(shù)據(jù)更新操作, 而我們知道數(shù)組是讀取快更新慢的, 所以和上面的版本相比看起來提升不算大
在這個版本中,改動了兩點
- 第一點是加入了一個布爾值,判斷第二層循環(huán)中的調(diào)換有沒有執(zhí)行,如果沒有進(jìn)行兩兩調(diào)換,說明后面都已經(jīng)排好序了,已經(jīng)不需要再循環(huán)了,直接跳出循環(huán),排序結(jié)束.
- 第二點是第二層循環(huán)不再循環(huán)到arr.length - 1,因為外面的i循環(huán)遞增一次,說明數(shù)組最后就多了一個排好序的大泡泡.第二層循環(huán)也就不需要到最末尾一位了,可以提前結(jié)束循環(huán)
/**
* 終極版冒泡排序
* 加入一個布爾變量,如果內(nèi)循環(huán)沒有交換值,說明已經(jīng)排序完成,提前終止
* @param arr
*/
public static void sortPlus(int[] arr){
if(arr != null && arr.length > 1){
for(int i = 0; i < arr.length - 1; i++){
// 初始化一個布爾值
boolean flag = true;
for(int j = 0; j < arr.length - i - 1 ; j++){
if(arr[j] > arr[j+1]){
// 調(diào)換
int temp;
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
// 改變flag
flag = false;
}
}
if(flag){
break;
}
}
}
}
5.選擇排序
選擇排序也是一種簡單直觀的排序算法，實現(xiàn)原理比較直觀易懂：
首先在未排序數(shù)列中找到最小元素，然后將其與數(shù)列的首部元素進(jìn)行交換，然后，在剩余未排序元素中繼續(xù)找出最小元素，將其與已排序數(shù)列的末尾位置元素交換。以此類推，直至所有元素圴排序完畢.
同理,可以類比與打撲克和打麻將, 和上面插入排序不同, 插入排序相當(dāng)于抽一張牌整理好了再抽一張, 而選擇排序相當(dāng)于一次性給你一副亂牌, 然后慢慢整理的感覺.
這也容易理解為什么選擇排序為啥比插入排序慢了. 插入排序是摸一張牌, 然后直接插入到手中已經(jīng)排好序的牌,再摸下一張牌.
選擇排序相當(dāng)于在一堆牌中, 不斷的找到最小的牌往前面放.
public static void sort(int[] arr){
for(int i = 0; i < arr.length - 1 ; i++){
int min = i; // 遍歷的區(qū)間最小的值
for (int j = i + 1; j < arr.length ;j++){
if(arr[j] < arr[min]){
// 找到當(dāng)前遍歷區(qū)間最小的值的索引
min = j;
}
}
if(min != i){
// 發(fā)生了調(diào)換
int temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
}
}
}
6. 歸并排序
歸并排序,簡單的說把一串?dāng)?shù)
從中平等分為兩份,再把兩份再細(xì)分,直到不能細(xì)分為止. 這就是分而治之的分的步驟.
再從最小的單元,兩兩合并,合并的規(guī)則是將其按從小到大的順序放到一個臨時數(shù)組中,再把這個臨時數(shù)組替換原數(shù)組相應(yīng)位置,這就是治. 圖解如下:
代碼:
public static void mergeSort(int[] a,int s,int e){
int m = (s + e) / 2;
if (s < e){
mergeSort(a,s,m);
mergeSort(a,m+1,e);
//歸并
merge(a,s,m,e);
}
}
private static void merge(int[] a, int s, int m, int e) {
//初始化一個從起始s到終止e的一個數(shù)組
int[] temp = new int[(e - s) + 1];
//左起始指針
int l = s;
//右起始指針
int r = m+1;
int i = 0;
//將s-e這段數(shù)據(jù)在邏輯上一分為二,l-m為一個左邊的數(shù)組,r-e為一個右邊的數(shù)組,兩邊都是有序的
//從兩邊的第一個指針開始遍歷,將其中小的那個值放在temp數(shù)組中
while (l <= m && r <= e){
if (a[l] < a[r]){
temp[i++] = a[l++];
}else{
temp[i++] = a[r++];
}
}
//將兩個數(shù)組剩余的數(shù)放到temp中
while (l <= m){
temp[i++] = a[l++];
}
while (r <= e){
temp[i++] = a[r++];
}
//將temp數(shù)組覆蓋原數(shù)組
for (int n = 0; n < temp.length; n++) {
a[s+n] = temp[n];
}
}
8. 堆排序
堆排序, 顧名思義, 就是將數(shù)據(jù)以堆的結(jié)構(gòu), 或者說類似于二叉樹的結(jié)構(gòu), 每次都整理二叉樹將最大值找到, 然后放到數(shù)組末尾. 個人感覺有點像選擇排序.都是每次遍歷選擇一個最大值或最小值
從下往上調(diào)整堆, 將最大值放到頂部
- 首先我們可以把一個數(shù)組, 從上往下, 從左到右依次放置成為二叉樹
- 接著我們創(chuàng)建最大頂堆, 就是將最大的值調(diào)整到頂部.
- 然后我們開始遍歷, 把這個[0]的最大值放到最末尾, 然后再次整理二叉樹, 當(dāng)然將最后一位排除在外.然后我們將截至末尾的下標(biāo)往前移一位.
- 一直遍歷, 把最大值放到頂部, 再調(diào)換到末尾, 到只剩最后一個元素,
找到最大值后, 放到數(shù)組后面, 并設(shè)置一個標(biāo)記, 表示截止后面的都是已排序的元素, 相當(dāng)于堆刪除一個元素
因為是樹結(jié)構(gòu), 所以整理一次樹的時間復(fù)雜度是O(logn), 但是又因為它需要遍歷一次挨個整理找到剩下數(shù)據(jù)中的最大值, 所以它的最壞，最好，平均時間復(fù)雜度均為O(nlogn)
踩坑
大家可以直奔v3.0版本
v1.0 巨慢不能用
這里說下踩坑, 下面是我寫的堆排序v1.0版本, 寫了個簡單的數(shù)組測試了下發(fā)現(xiàn)也沒有問題, ok. 然后我寫一個10w的數(shù)組來和冒泡排序, 選擇排序等比較, 結(jié)果發(fā)現(xiàn)程序像是卡死了直接花了幾分鐘還沒出結(jié)果. 這已經(jīng)遠(yuǎn)遠(yuǎn)大于冒泡排序的時間了.
/**
* 最大頂堆排序
* @param a
*/
public static void topMaxHeapSort(int[] a){
//先創(chuàng)建最大頂堆
createTopMaxHeap(a);
int end = a.length - 1 ;
while(end > 0 ){
//把0位的最大值放到最后
swaparr(a, 0, end);
//將計算的長度減一.不考慮最后的那個值
end--;
//重新調(diào)整堆結(jié)構(gòu)
handleMaxHeapFromIndex(a, end);
}
//打印下看看
// System.out.println(Arrays.toString(a));
}
/** [3,7,1,4,9,5,6,7,2,6,8,3]
* `````````3
* ``````/ \
* `````7 1
* ````/ \ / \
* ``4 9 5 6
* `/ \ / \ /
* `7 2 6 8 3
* 變成 [9, 7, 6, 7, 6, 5, 1, 4, 2, 3, 8, 3]
* `````````9
* ```````/ \
* `````7 6
* ````/ \ / \
* ``7 6 5 1
* `/ \ / \ /
* `4 2 3 8 3
* 構(gòu)建最大頂堆, 變成父節(jié)點都比子節(jié)點大的樹
* @param a
*/
public static void createTopMaxHeap(int[] a){
//從倒數(shù)第二排最后一個開始, 從下往上, 層層處理把最大的換上去構(gòu)建最大頂堆
//如上面的注釋, 就是從5開始. 再往后就沒意義了
handleMaxHeapFromIndex(a,a.length-1);
//打印下看看
// System.out.println(Arrays.toString(a));
}
private static void handleMaxHeapFromIndex(int[] a,int end){
for (int i = end / 2; i>=0; i--) {
//從i開始往后面調(diào)整它的堆
//左子節(jié)點, 右子節(jié)點
// 設(shè)置一個用于玩下遍歷和判斷的子節(jié)點, 默認(rèn)就是左邊的兒子
int child = 2 * i + 1;
while (child <= end){
//如果右子節(jié)點比左邊大
int leftson = child;
int rightson = child + 1;
if(rightson <= end && a[rightson] > a[leftson]){
//就設(shè)置為右邊的兒子
child++;
}
//再比較父子,如果兒子比父親大,就互換
if(a[i] < a[child]){
swaparr(a,i,child);
}
//繼續(xù)循環(huán)
i = child;
//繼續(xù)選擇它的左兒子
child = 2 * i + 1;
}
}
}
private static void swaparr(int[] arr,int a,int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
v2.0 太慢不能用
考慮肯定調(diào)整堆的代碼有問題
- 在初始構(gòu)建了最大頂堆時, 父親都比兒子大
- 后面每次都只移除頂部元素.即變化了第一層
- 那我在調(diào)整的時候, 如果這個節(jié)點比兒子節(jié)點都大, 那應(yīng)該下面的都是調(diào)整好的不用管.
我選擇在handleMaxHeapFromIndex方法中, 加入了break來提前跳出循環(huán), 如下:
while (child <= end) {
// 如果右子節(jié)點比左邊大
int leftson = child;
int rightson = child + 1;
if (rightson <= end && a[rightson] > a[leftson]) {
// 就設(shè)置為右邊的兒子
child++;
}
// 再比較父子,如果兒子比父親大,就互換
if (a[i] < a[child]) {
swaparr(a, i, child);
} else {
// 否則直接跳出循環(huán), 只要父節(jié)點比子節(jié)點大, 不用管下面的調(diào)整了
break;
}
// 繼續(xù)循環(huán)
i = child;
// 繼續(xù)選擇它的左兒子
child = 2 * i + 1;
}
再跑一次, 發(fā)現(xiàn)還是很慢, 但是比之前好多了, 但是還是耗時很久, 這也還是有問題啊…
v3.0
代碼如下:
/**
* 最大頂堆排序
*
* @param a
*/
public static void topMaxHeapSort(int[] a) {
// 先創(chuàng)建最大頂堆
createTopMaxHeap(a);
System.out.println("創(chuàng)建完畢");
int end = a.length - 1;
while (end > 0) {
// 把0位的最大值放到最后
swaparr(a, 0, end);
// 將計算的長度減一.不考慮最后的那個值
end--;
handleMaxHeapFromIndex(a, 0, end);
}
// 打印下看看
// System.out.println(Arrays.toString(a));
}
/** [3,7,1,4,9,5,6,7,2,6,8,3]
* `````````3
* ``````/ \
* `````7 1
* ````/ \ / \
* ``4 9 5 6
* `/ \ / \ /
* `7 2 6 8 3
* 變成 [9, 7, 6, 7, 6, 5, 1, 4, 2, 3, 8, 3]
* `````````9
* ```````/ \
* `````7 6
* ````/ \ / \
* ``7 6 5 1
* `/ \ / \ /
* `4 2 3 8 3
* 構(gòu)建最大頂堆, 變成父節(jié)點都比子節(jié)點大的樹
* @param a
*/
public static void createTopMaxHeap(int[] a) {
// 從倒數(shù)第二排最后一個開始, 從下往上, 層層處理把最大的換上去構(gòu)建最大頂堆
// 如上面的注釋, 就是從5開始. 再往后就沒意義了
for (int i = (a.length - 1) / 2; i >= 0; i--) {
handleMaxHeapFromIndex(a, i, a.length - 1);
}
// 打印下看看
// System.out.println(Arrays.toString(a));
}
private static void handleMaxHeapFromIndex(int[] a, int i, int end) {
// 從i開始往后面調(diào)整它的堆
// 左子節(jié)點, 右子節(jié)點
// 設(shè)置一個用于玩下遍歷和判斷的子節(jié)點, 默認(rèn)就是左邊的兒子
int child = 2 * i + 1;
while (child <= end) {
// 如果右子節(jié)點比左邊大
int leftson = child;
int rightson = child + 1;
if (rightson <= end && a[rightson] > a[leftson]) {
// 就設(shè)置為右邊的兒子
child++;
}
// 再比較父子,如果兒子比父親大,就互換
if (a[i] < a[child]) {
swaparr(a, i, child);
} else {
// 否則直接跳出循環(huán), 只要父節(jié)點比子節(jié)點大, 不用管下面的調(diào)整了
break;
}
// 繼續(xù)循環(huán)
i = child;
// 繼續(xù)選擇它的左兒子
child = 2 * i + 1;
}
}
private static void swaparr(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
無奈之下參考了別人的博客(也有一些寫的是我1.0版本和2.0版本的), 最后發(fā)現(xiàn)問題
首先再分析為什么要分成兩步, 1. 創(chuàng)建大頂堆. 2. 遍歷調(diào)整 ?
在創(chuàng)建大頂堆的時候, 是從(a.length-1)/2處從下往上整理, 才能確保最大值能像冒泡一樣跑到頂部
那在構(gòu)建完了大頂堆后, 我們還需不需要重新從這個位置倒排往上整理呢? 其實是不需要的. 因為變化的是第一個元素, 除了這個元素以外, 其他的元素經(jīng)過大頂堆的整理肯定父親比兒子大.
所以后面遍歷調(diào)整的時候, 只需要從0下標(biāo)開始找最大值就可以了. 這樣就可以去掉handleMaxHeapFromIndex外層的那個循環(huán):
private static void handleMaxHeapFromIndex(int[] a,int end){
for (int i = end / 2; i>=0; i--) { //這個循環(huán)只在創(chuàng)建大頂堆的時候需要, 這個就可以去掉了
....
while (child <= end){
...
}
}
另外一個坑, child<=end這里要用大于等于號, 以及后面的rightson <= end .因為我就寫著寫著忘記了end是最后處理的下標(biāo), 而不是數(shù)組長度, 習(xí)慣性用的<號, 導(dǎo)致最后2個無法排序
9. 其他排序
比如Arrays工具類提供的排序方法。它內(nèi)部實現(xiàn)也是快速排序
private static void arraysSort(int[] a){
Arrays.sort(a);
}
還有就是將數(shù)組轉(zhuǎn)為list,使用集合的排序方法,但是這無異于兜圈子,因為集合底層也是數(shù)組
private static void listSort(int[] a){
List<Integer> integers = Ints.asList(a);
Collections.sort(integers);
integers.toArray(new Integer[a.length]);
}
10. 比較
試了一下幾個排序的速度,代碼如下:
public static void main(String[] args) {
int[] arr = new int[200000];
int[] a =getRandomArr(arr);
int[] b = a.clone();
int[] c = b.clone();
int[] d = b.clone();
int[] e = b.clone();
int[] f = b.clone();
int[] g = b.clone();
int[] h = b.clone();
long s = Clock.systemDefaultZone().millis();
quickSort(a, 0, a.length - 1);
System.out.println("quickSort耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");
s = Clock.systemDefaultZone().millis();
mergeSort(b,0,b.length-1);
System.out.println("mergeSort: " + (Clock.systemDefaultZone().millis() - s) + " ms");
s = Clock.systemDefaultZone().millis();
listSort(c);
System.out.println("listSort耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");
s = Clock.systemDefaultZone().millis();
arraysSort(d);
System.out.println("arraysSort耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");
s = Clock.systemDefaultZone().millis();
maoPaoSort(e);
System.out.println("maoPaoSort耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");
s = Clock.systemDefaultZone().millis();
maoPaoSortPlus(f);
System.out.println("maoPaoSortPlus耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");
s = Clock.systemDefaultZone().millis();
insertSort(g);
System.out.println("insertSort耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");
s = Clock.systemDefaultZone().millis();
selectSort(h);
System.out.println("selectSort耗時: " + (Clock.systemDefaultZone().millis() - s) + " ms");
}
/**
* 獲取一個打亂的數(shù)組
* @param arr
*/
private static int[] getRandomArr(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = new Random().nextInt(arr.length);
}
return arr;
}
分別對1k,1w,10w,20w大小的隨機數(shù)組排序,結(jié)果如下:
得到綜合結(jié)果是:
速度: 快速排序>>歸并排序>>>>>插入排序>>選擇排序>>冒泡排序
并且可以看到,選擇排序,冒泡排序在數(shù)據(jù)量越來越大的情況下,耗時已經(jīng)呈指數(shù)型上漲,而不是倍數(shù)上漲,在50w的時候已經(jīng)需要足足5分鐘以上
//---1k---
quickSort耗時: 0 ms
mergeSort: 1 ms
listSort耗時: 7 ms
arraysSort耗時: 1 ms
maoPaoSort耗時: 3 ms
maoPaoSortPlus耗時: 4 ms
insertSort耗時: 2 ms
selectSort耗時: 3 ms
//---1w---
quickSort耗時: 2 ms
mergeSort: 3 ms
listSort耗時: 19 ms
arraysSort耗時: 4 ms
maoPaoSort耗時: 166 ms
maoPaoSortPlus耗時: 122 ms
insertSort耗時: 12 ms
selectSort耗時: 52 ms
//---10w---
quickSort耗時: 14 ms
mergeSort: 19 ms
listSort耗時: 65 ms
arraysSort耗時: 12 ms
maoPaoSort耗時: 15242 ms
maoPaoSortPlus耗時: 15044 ms
insertSort耗時: 797 ms
selectSort耗時: 4073 ms
//---20w---
quickSort耗時: 26 ms
mergeSort: 34 ms
listSort耗時: 102 ms
arraysSort耗時: 60 ms
maoPaoSort耗時: 60811 ms
maoPaoSortPlus耗時: 60378 ms
insertSort耗時: 3279 ms
selectSort耗時: 15762 ms
2021年11月25日 更新. 增加了堆排序
// 20w數(shù)據(jù)
quickSort耗時: 39 ms
mergeSort: 32 ms
創(chuàng)建完畢
heapSort耗時: 21 ms
listSort耗時: 111 ms
arraysSort耗時: 20 ms
maoPaoSort耗時: 50410 ms
maoPaoSortPlus耗時: 55862 ms
insertSort耗時: 10127 ms
selectSort耗時: 8619 ms
總結(jié)
到此這篇關(guān)于幾種常見的java排序算法的文章就介紹到這了,更多相關(guān)java排序算法內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
java數(shù)據(jù)結(jié)構(gòu)排序算法之歸并排序詳解
這篇文章主要介紹了java數(shù)據(jù)結(jié)構(gòu)排序算法之歸并排序,結(jié)合具體實例形式詳細(xì)分析了歸并排序的原理、實現(xiàn)技巧與相關(guān)注意事項,需要的朋友可以參考下2017-05-05
這篇文章主要介紹了mybatis如何實現(xiàn)繼承映射的操作，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-08-08
springboot mybatis里localdatetime序列化問題的解決
這篇文章主要介紹了springboot mybatis里localdatetime序列化問題,小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-10-10
在實際應(yīng)用過程中，我們可能需要限流的層面不僅限于接口。可能對于某個方法的調(diào)用限流，對于某個外部資源的調(diào)用限流等都希望做到控制。對此，我們需要學(xué)習(xí)使用@SentinelResource注解，靈活的定義控制資源以及如何配置控制策略2022-08-08
java.util.Properties集合繼承于Hashtable,來表示一個持久的屬性集,他使用鍵值結(jié)構(gòu)存儲數(shù)據(jù),每個鍵及其對應(yīng)的值都是一個字符串,該類被許多java類使用,下面這篇文章主要給大家介紹了關(guān)于如何快速上手Java中Properties集合類的相關(guān)資料,需要的朋友可以參考下2023-02-02
這篇文章主要介紹了Arthas-java程序運行時debug工具使用,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-11-11
SpringBoot靜態(tài)視頻實時播放的實現(xiàn)代碼
這篇文章主要介紹了SpringBoot靜態(tài)視頻實時播放的實現(xiàn)代碼，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-01-01
這篇文章主要介紹了Java構(gòu)造器方法深入理解，本文給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下2021-09-09
下面小編就為大家?guī)硪黄趈ava中cookie和session的比較。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2016-08-08
HashMap原理及手寫實現(xiàn)部分區(qū)塊鏈特征
這篇文章主要為大家介紹了HashMap原理及手寫實現(xiàn)部分區(qū)塊鏈特征，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2022-09-09