Java開發(fā)中的容器概念、分類與用法深入詳解
本文實例講述了Java開發(fā)中的容器概念、分類與用法。分享給大家供大家參考，具體如下：
1、容器的概念
在Java當(dāng)中，如果有一個類專門用來存放其它類的對象，這個類就叫做容器，或者就叫做集合，集合就是將若干性質(zhì)相同或相近的類對象組合在一起而形成的一個整體
2、容器與數(shù)組的關(guān)系
之所以需要容器：
① 數(shù)組的長度難以擴充
② 數(shù)組中數(shù)據(jù)的類型必須相同
容器與數(shù)組的區(qū)別與聯(lián)系：
① 容器不是數(shù)組，不能通過下標的方式訪問容器中的元素
② 數(shù)組的所有功能通過Arraylist容器都可以實現(xiàn)，只是實現(xiàn)的方式不同
③ 如果非要將容器當(dāng)做一個數(shù)組來使用，通過toArraylist方法返回的就是一個數(shù)組
示例程序：
package IT;
import java.util.ArrayList;
import java.util.Iterator;
//數(shù)組的所有功能通過ArrayList容器都可以實現(xiàn)，只是實現(xiàn)的方式不同
public class App
{
public static void main(String[] args)
{
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(12);
arrayList.add(10);
arrayList.add(35);
arrayList.add(100);
Iterator<Integer> iterator = arrayList.iterator();//獲取容器的迭代器
while(iterator.hasNext())
{
Integer value = iterator.next();//獲取當(dāng)前游標右邊的元素，同時游標右移-->
System.out.println(value);
}
System.out.println("通過ArrayList容器獲取一個數(shù)組arr：");
Object[] arr = arrayList.toArray();
for(int i=0;i<arr.length;i++)
{
System.out.println(arr[i]);
}
}
}
輸出結(jié)果：
12 10 35 100
通過ArrayList容器獲取一個數(shù)組arr：
12 10 35 100
3、容器常用的幾個方法
boolean add(Object obj):向容器中添加指定的元素
Iterator iterator()：返回能夠遍歷當(dāng)前集合中所有元素的迭代器
Object[] toArray():返回包含此容器中所有元素的數(shù)組。
Object get(int index)：獲取下標為index的那個元素
Object remove(int index)：刪除下標為index的那個元素
Object set(int index,Object element)：將下標為index的那個元素置為element
Object add(int index,Object element)：在下標為index的位置添加一個對象element
Object put(Object key,Object value):向容器中添加指定的元素
Object get(Object key)：獲取關(guān)鍵字為key的那個對象
int size():返回容器中的元素數(shù)
實例程序：
package IT;
import java.util.ArrayList;
public class App
{
public static void main(String[] args)
{
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(12);
arrayList.add(10);
arrayList.add(35);
arrayList.add(100);
System.out.println("原容器中的元素為:");
System.out.println(arrayList);
System.out.println("\n");
/*******重置set（int index,Object element）*******/
System.out.println("將下標為1位置的元素置為20,將下標為2位置的元素置為70");
arrayList.set(1, 20);
arrayList.set(2, 70);
System.out.println("重置之后容器中的元素為:");
System.out.println(arrayList);
System.out.println("\n");
/*******中間插隊add（int index,Object element）*******/
System.out.println("在下標為1的位置插入一個元素,-----插入元素：此時容器后面的元素整體向后移動");
arrayList.add(1, 80);//在下標為1的位置插入一個元素,此時容量加1,-----位置后面的元素整體向后移動
System.out.println("插入之后容器中的元素為:");
System.out.println(arrayList);
System.out.println("插入之后容器中的容量為:");
System.out.println(arrayList.size());
System.out.println("\n");
/*******中間刪除元素remove（int index）*******/
System.out.println("將下標為3位置的元素70刪除,-----刪除元素:此時容器位置后面的元素整體向前移");
arrayList.remove(3);
System.out.println("刪除之后容器中的元素為:");
System.out.println(arrayList);
System.out.println("刪除之后容器中的容量為:");
System.out.println(arrayList.size());
}
}
運行結(jié)果：
原容器中的元素為: [12, 10, 35, 100] 將下標為1位置的元素置為20,將下標為2位置的元素置為70 重置之后容器中的元素為: [12, 20, 70, 100] 在下標為1的位置插入一個元素,-----插入元素：此時容器后面的元素整體向后移動 插入之后容器中的元素為: [12, 80, 20, 70, 100] 插入之后容器中的容量為: 5 將下標為3位置的元素70刪除,-----刪除元素:此時容器位置后面的元素整體向前移 刪除之后容器中的元素為: [12, 80, 20, 100] 刪除之后容器中的容量為: 4
4、容器的分類
容器分為Set集、List列表、Map映射
Set集合：由于內(nèi)部存儲結(jié)構(gòu)的特點，Set集合中不區(qū)分元素的順序，不允許出現(xiàn)重復(fù)的元素，TreeSet容器特殊，元素放進去的時候自然而然就有順序了，Set容器可以與數(shù)學(xué)中的集合相對應(yīng)：相同的元素不會被加入
List列表：由于內(nèi)部存儲結(jié)構(gòu)的特點，List集合中區(qū)分元素的順序，且允許包含重復(fù)的元素。List集合中的元素都對應(yīng)一個整數(shù)型的序號記載其在容器中的位置，可以根據(jù)序號存取容器中的元素—有序，可以重復(fù)
Map映射：由于內(nèi)部存儲結(jié)構(gòu)的特點，映射中不能包含重復(fù)的鍵值，每個鍵最多只能映射一個值，否則會出現(xiàn)覆蓋的情況(后面的value值會將前面的value值覆蓋掉)，Map是一種把鍵對象和值對象進行映射的集合，即Map容器中既要存放數(shù)據(jù)本身，也要存放關(guān)鍵字:相同的元素會被覆蓋
注意：對于Set和Map來說,元素放進去之后是沒有順序的，如果希望元素放進去之后是有順序的，可以用treeSet和treeMap存儲數(shù)據(jù)。
實例程序：
var set2 = mutable.Set.empty[Int]
set2 += 10
set2 ++= List(50,100,200)
set2 += 500
println("Set輸出的結(jié)果：")
println(set2)
var map3 = mutable.Map.empty[String,Double]
map3 += "Spark"->90.0
map3 += "Hadoop"->80.0
map3 ++= List("Scala"->100.0,"Java"->60.0)
println("Map輸出的結(jié)果：")
println(map3)
運行結(jié)果：
Set輸出的結(jié)果： Set(100, 50, 500, 10, 200) Map輸出的結(jié)果： Map(Hadoop -> 80.0, Spark -> 90.0, Scala -> 100.0, Java -> 60.0)
實例程序：
var treeSet = TreeSet(10,20,30,90,100,200,50)
println(treeSet)
/*鍵值對排序是根據(jù)key的值進行排序的,沒有value的事情,讓我聯(lián)想到了MapReduce中排序的時候之所以根據(jù)k2
而不是v2的值進行排序,這是因為哈希映射內(nèi)部決定的，而不是MapReduce決定的
呵呵！注意：排序區(qū)分大小寫的哦?。?！*/
var treeSet2 = TreeSet[String]("Spark","Anang","Baby","Hello")
println(treeSet2)
var treeMap = TreeMap[String,Integer]("Java"->100,"Scala"->88,"Python"->60,"Anglebaby"->500)
println(treeMap)
運行結(jié)果：
TreeSet(10, 20, 30, 50, 90, 100, 200) TreeSet(Anang, Baby, Hello, Spark) Map(Anglebaby -> 500, Java -> 100, Python -> 60, Scala -> 88)
5、toString()方法的使用：凡是把類對象放到容器中，相應(yīng)的類都應(yīng)該實現(xiàn)Object類中的toString()方法；凡是Java中自帶的數(shù)據(jù)類型，都已經(jīng)重寫完了toString()方法
實例1：(未重寫toString()方法之前)
package IT;
public class App
{
public static void main(String[] args)
{
//Java中自帶的類
System.out.println("-----凡是Java中自帶的數(shù)據(jù)類型都已經(jīng)重寫完了toString()方法！---");
System.out.println(new Integer(2).toString());
System.out.println(new String("zhang").toString());
//用戶自定義的類Student
System.out.println(new Student("zhangsan",99.8).toString());
}
}
class Student
{
public String name;
public double score;
public Student(String name,double score)
{
this.name = name;
this.score = score;
}
}
輸出結(jié)果：
-----凡是Java中自帶的數(shù)據(jù)類型都已經(jīng)重寫完了toString()方法！--- 2 zhang IT.Student@1af2f973
實例2：(重寫完toString()方法之后)
package IT;
import java.util.ArrayList;
public class App
{
public static void main(String[] args)
{
ArrayList<Student> arr = new ArrayList<Student>();
arr.add(new Student("zhangsan",89.8));
arr.add(new Student("lisi",90));
arr.add(new Student("wangwu",60.6));
System.out.println(arr);
}
}
class Student
{
public String name;
public double score;
public Student(String name,double score)
{
this.name = name;
this.score = score;
}
public String toString()
{
return this.name+"\t"+this.score;
}
}
輸出結(jié)果：
[zhangsan 89.8, lisi 90.0, wangwu 60.6]
6、Comparable接口中的compareTo()方法:凡是需要進行比較排序的類都應(yīng)該實現(xiàn)Comparable接口中的compareTo()方法；凡是把類對象放到以樹為內(nèi)部結(jié)構(gòu)的容器中都應(yīng)該實現(xiàn)Comparable接口中的compareTo()方法
實例1：
package IT;
import java.util.ArrayList;
import java.util.Collections;
public class App
{
public static void main(String[] args)
{
ArrayList<Student> arr = new ArrayList<Student>();
arr.add(new Student("zhangsan",89.8));
arr.add(new Student("lisi",90));
arr.add(new Student("wangwu",60.6));
arr.add(new Student("wangting",85.6));
Collections.sort(arr);
for (Student student : arr)
{
System.out.println(student);
}
}
}
class Student implements Comparable<Student>
{
public String name;
public double score;
public Student(String name,double score)
{
this.name = name;
this.score = score;
}
public String toString()
{
return this.name+"\t"+this.score;
}
public int compareTo(Student obj)
{
return (int) (this.score - obj.score);//比較的標準為score進行升序
}
}
輸出結(jié)果：
wangwu 60.6 wangting 85.6 zhangsan 89.8 lisi 90.0
實例2：
package IT;
import java.util.TreeSet;
public class App
{
public static void main(String[] args)
{
TreeSet<Student> treeSet = new TreeSet<Student>();
treeSet.add(new Student("wangwu",60.6));
treeSet.add(new Student("lisi",90.0));
treeSet.add(new Student("wangting",85.6));
treeSet.add(new Student("zhangsan",60.6));
for (Student student : treeSet)
{
System.out.println(student);
}
}
}
class Student implements Comparable<Student>
{
public String name;
public double score;
public Student(String name,double score)
{
this.name = name;
this.score = score;
}
public String toString()
{
return this.name+"\t"+this.score;
}
public int compareTo(Student obj)
{
if(this.score > obj.score)
return 1;
else
return -1;
}
}
輸出結(jié)果：
zhangsan 60.6 wangwu 60.6 wangting 85.6 lisi 90.0
7、凡是把類對象放到以哈希表為內(nèi)部存儲結(jié)構(gòu)的容器中，相應(yīng)的類必須要實現(xiàn)equals方法和hashCode方法，這樣才符合哈希表真實的邏輯功能.
實例程序1：(為重寫之前)
package IT;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class App
{
public static void main(String[] args)
{
//Java中自帶的數(shù)據(jù)類型
System.out.println("先測試Java中自帶的數(shù)據(jù)類型:");
HashMap<String, Double> hashMap1 = new HashMap<String,Double>();
hashMap1.put("zhangsan", 96.0);
hashMap1.put("lisi", 88.6);
hashMap1.put("wangwu", 98.6);
hashMap1.put("wangting", 87.5);
hashMap1.put("zhangsan", 96.0);
hashMap1.put("lisi", 88.6);
hashMap1.put("wangwu", 98.6);
hashMap1.put("wangting", 87.5);
Set<String> keySet = hashMap1.keySet();
Iterator<String> iterator = keySet.iterator();
while(iterator.hasNext())
{
String key = iterator.next();
System.out.println(key+"\t"+hashMap1.get(key));
}
System.out.println("Java中自帶的數(shù)據(jù)類型:相同的對象會覆蓋！");
System.out.println("\n");
//用戶自定義的數(shù)據(jù)類型：為重寫之前
System.out.println("測試用戶自定義的數(shù)據(jù)類型--未重寫兩個方法之前:");
HashMap<Student, String> hashMap2 = new HashMap<Student,String>();
hashMap2.put(new Student("zhangsan",88.8), "beijing");
hashMap2.put(new Student("lisi",88.8), "beijing");
hashMap2.put(new Student("wangwu",66.9), "beijing");
hashMap2.put(new Student("zhangsan",88.8), "beijing");
hashMap2.put(new Student("lisi",88.8), "beijing");
hashMap2.put(new Student("wangwu",66.9), "beijing");
Set<Student> keySet2 = hashMap2.keySet();
Iterator<Student> iterator2 = keySet2.iterator();
while(iterator2.hasNext())
{
Student key = iterator2.next();
System.out.println(key+"\t"+hashMap2.get(key));
}
System.out.println("如果沒有重寫:導(dǎo)致相同的對象不會被覆蓋!");
}
}
class Student implements Comparable<Student>
{
public String name;
public double score;
public Student(String name,double score)
{
this.name = name;
this.score = score;
}
public String toString()
{
return this.name+"\t"+this.score;
}
public int compareTo(Student obj)
{
if(this.score > obj.score)
return 1;
else
return -1;
}
}
輸出結(jié)果:
先測試Java中自帶的數(shù)據(jù)類型: wangting 87.5 wangwu 98.6 lisi 88.6 zhangsan 96.0 Java中自帶的數(shù)據(jù)類型:相同的對象會覆蓋！ 測試用戶自定義的數(shù)據(jù)類型--為重寫兩個方法之前: zhangsan 88.8 beijing wangwu 66.9 beijing lisi 88.8 beijing wangwu 66.9 beijing zhangsan 88.8 beijing lisi 88.8 beijing 如果沒有重寫:導(dǎo)致相同的對象不會被覆蓋!
實例程序2:重寫之后
package IT;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class App
{
public static void main(String[] args)
{
//用戶自定義的數(shù)據(jù)類型：為重寫之后
System.out.println("測試用戶自定義的數(shù)據(jù)類型--重寫兩個方法之后:");
HashMap<Student, String> hashMap2 = new HashMap<Student,String>();
hashMap2.put(new Student("zhangsan",88.8), "beijing");
hashMap2.put(new Student("lisi",88.8), "beijing");
hashMap2.put(new Student("wangwu",66.9), "beijing");
hashMap2.put(new Student("zhangsan",88.8), "beijing");
hashMap2.put(new Student("lisi",88.8), "beijing");
hashMap2.put(new Student("wangwu",66.9), "beijing");
Set<Student> keySet2 = hashMap2.keySet();
Iterator<Student> iterator2 = keySet2.iterator();
while(iterator2.hasNext())
{
Student key = iterator2.next();
System.out.println(key+"\t"+hashMap2.get(key));
}
System.out.println("重寫過后:相同的對象會被覆蓋!");
}
}
class Student implements Comparable<Student>
{
public String name;
public double score;
public Student(String name,double score)
{
this.name = name;
this.score = score;
}
public String toString()
{
return this.name+"\t"+this.score;
}
public int compareTo(Student obj)
{
if(this.score > obj.score)
return 1;
else
return -1;
}
@Override
public int hashCode()
{
return (int) (this.name.hashCode()*score);//保證相同對象映射到同一個索引位置
}
@Override
public boolean equals(Object obj)
{
Student cc = (Student)obj;
return this.name==cc.name&&this.score==cc.score;
}
}
輸出結(jié)果:
測試用戶自定義的數(shù)據(jù)類型--重寫兩個方法之后: wangwu 66.9 beijing zhangsan 88.8 beijing lisi 88.8 beijing 重寫過后:相同的對象會被覆蓋!
8、重要的一個邏輯:邏輯上來講，只要兩個對象的內(nèi)容相同，其地址(hashCode()返回值)以及這兩個對象就應(yīng)該相同(equals())，
實例程序(為重寫之前):
package IT;
public class App
{
public static void main(String[] args)
{
//Java中自帶的數(shù)據(jù)類型
System.out.println(new Integer(1).equals(new Integer(1)));
System.out.println(new Integer(1).hashCode()==new Integer(1).hashCode());
System.out.println(new String("zhang").equals(new String("zhang")));
System.out.println(new String("zhang").hashCode()==new String("zhang").hashCode());
System.out.println("\n");
//用戶自定義的數(shù)據(jù)類型
System.out.println(new Student("zhangsan",98.8).equals(new Student("zhangsan",98.8)));
System.out.println(new Student("zhangsan",98.8).hashCode());
System.out.println(new Student("zhangsan",98.8).hashCode());
}
}
class Student implements Comparable<Student>
{
public String name;
public double score;
public Student(String name,double score)
{
this.name = name;
this.score = score;
}
public String toString()
{
return this.name+"\t"+this.score;
}
public int compareTo(Student obj)
{
if(this.score > obj.score)
return 1;
else
return -1;
}
}
輸出結(jié)果:
true true true true false 488676694 1211729930
重寫之后：
package IT;
public class App
{
public static void main(String[] args)
{
System.out.println(new Student("zhangsan",98.8).equals(new Student("zhangsan",98.8)));
System.out.println(new Student("zhangsan",98.8).hashCode());
System.out.println(new Student("zhangsan",98.8).hashCode());
}
}
class Student implements Comparable<Student>
{
public String name;
public double score;
public Student(String name,double score)
{
this.name = name;
this.score = score;
}
public String toString()
{
return this.name+"\t"+this.score;
}
public int compareTo(Student obj)
{
if(this.score > obj.score)
return 1;
else
return -1;
}
@Override
public int hashCode()
{
return (int) (this.name.hashCode()*score);
}
@Override
public boolean equals(Object obj)
{
Student cc = (Student)obj;
return this.name==cc.name&&this.score==cc.score;
}
}
輸出結(jié)果:
true -2147483648 -2147483648
上面的5、6、7、8可以歸結(jié)為4個”凡是”，1個“邏輯”:
1、凡是把類對象放到容器中，相應(yīng)的類都應(yīng)該實現(xiàn)Object類中的toString()方法；
2、凡是需要進行比較排序的類都應(yīng)該實現(xiàn)Comparable接口中的compareTo()方法；凡是把類對象放到以樹為內(nèi)部結(jié)構(gòu)的容器中都應(yīng)該實現(xiàn)Comparable接口中的compareTo()方法
3、凡是把類對象放到以哈希表為內(nèi)部存儲結(jié)構(gòu)的容器中，相應(yīng)的類必須要實現(xiàn)equals方法和hashCode方法，這樣才符合哈希表真實的邏輯功能.
4、邏輯上來講，只要兩個對象的內(nèi)容相同，其地址(hashCode()返回值)以及這兩個對象就應(yīng)該相同(equals())。
9、哈希沖突的相關(guān)概念
本質(zhì)上講就是:hash(對象1.hashCode())=hash2(對象2.hashCode())，即第一個對象的hashCode()方法返回的哈希碼值帶入到哈希函數(shù)后得到的索引位置與第二個對象的hashCode()方法返回的哈希碼值帶入到哈希函數(shù)后得到的索引位置相同，這就是哈希沖突。
最常見的哈希算法是取模法。
下面簡單講講取模法的計算過程。
比如：數(shù)組的長度是5。這時有一個數(shù)據(jù)是6。那么如何把這個6存放到長度只有5的數(shù)組中呢。按照取模法，計算6％5，結(jié)果是1，那么就把6放到數(shù)組下標是1的位置。那么，7
就應(yīng)該放到2這個位置。到此位置，哈斯沖突還沒有出現(xiàn)。這時，有個數(shù)據(jù)是11，按照取模法，11％5＝1，也等于1。那么原來數(shù)組下標是1的地方已經(jīng)有數(shù)了，是6。這時又計算出1這個位置，那么數(shù)組1這個位置，就必須儲存兩個數(shù)了。這時，就叫哈希沖突。沖突之后就要按照順序來存放了。
如果數(shù)據(jù)的分布比較廣泛，而且儲存數(shù)據(jù)的數(shù)組長度比較大。
那么哈希沖突就比較少。否則沖突是很高的。
10、iterator接口的作用
重要方法:
boolean hasNext():是用來判斷當(dāng)前游標(迭代器)的后面是否存在元素，如果存在返回真，否則返回假
Object next()：先返回當(dāng)前游標右邊的元素，然后游標后移一個位置
void remove()：不推薦使用iterator的remove()方法，而是推薦使用容器自帶的remove方法。
實例程序:
package IT;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class App
{
public static void main(String[] args)
{
HashMap<String, Double> hashMap = new HashMap<String,Double>();
hashMap.put("zhangsan", 88.6);
hashMap.put("lisi", 69.0);
hashMap.put("wanqwu", 100.0);
hashMap.put("lisi", 69.0);
Set<String> keySet = hashMap.keySet();
Iterator<String> iterator = keySet.iterator();
while(iterator.hasNext())
{
String key = iterator.next();//獲取迭代器右邊的元素，同時右移
System.out.println(key+hashMap.get(key));
}
}
}
思考題:
package IT;
import java.util.TreeSet;
public class App
{
public static void main(String[] args)
{
TreeSet<Student> treeSet = new TreeSet<Student>();
treeSet.add(new Student("zhangsan",98));
treeSet.add(new Student("zhangsan",98));
System.out.println(treeSet.size());
System.out.println(treeSet);
//本程序中并沒有重寫equals方法，但是treeSet將識別出兩個new Student("zhangsan",98)為相同的，因為內(nèi)部數(shù)據(jù)結(jié)構(gòu)嗎？
System.out.println(new Student("zhangsan",98).equals(new Student("zhangsan",98)));
}
}
class Student implements Comparable<Object>
{
public String name;
public double score;
public Student(String name,double score)
{
this.name = name;
this.score = score;
}
public String toString()
{
return name + "\t" + score;
}
@Override
public int compareTo(Object obj)
{
Student cc = (Student)obj;
return (int) (this.score - cc.score);
}
}
更多關(guān)于java相關(guān)內(nèi)容感興趣的讀者可查看本站專題：《Java面向?qū)ο蟪绦蛟O(shè)計入門與進階教程》、《Java數(shù)據(jù)結(jié)構(gòu)與算法教程》、《Java操作DOM節(jié)點技巧總結(jié)》、《Java文件與目錄操作技巧匯總》和《Java緩存操作技巧匯總》
希望本文所述對大家java程序設(shè)計有所幫助。
相關(guān)文章
Spring Web MVC是一種基于Java的實現(xiàn)了Web MVC設(shè)計模式的請求驅(qū)動類型的輕量級Web框架，即使用了MVC架構(gòu)模式的思想，將web層進行職責(zé)解耦，基于請求驅(qū)動指的就是使用請求-響應(yīng)模型，框架的目的就是幫助我們簡化開發(fā)2021-06-06
這篇文章主要分析了SpringBoot的啟動原理，幫助大家更好的理解和使用spring boot框架，感興趣的朋友可以了解下2020-09-09
Spring?Boot之Validation自定義實現(xiàn)方式的總結(jié)
這篇文章主要介紹了Spring?Boot之Validation自定義實現(xiàn)方式的總結(jié)，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-07-07
這篇文章主要介紹了java中的實體類時間格式化方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-06-06
詳解Java編程規(guī)約（命名風(fēng)格、常量定義、代碼格式）
這篇文章主要介紹了詳解Java編程規(guī)約（命名風(fēng)格、常量定義、代碼格式），小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2019-10-10
繼承就是可以直接使用前輩的屬性和方法。自然界如果沒有繼承，那一切都是處于混沌狀態(tài)。多態(tài)是同一個行為具有多個不同表現(xiàn)形式或形態(tài)的能力。多態(tài)就是同一個接口，使用不同的實例而執(zhí)行不同操作2022-05-05
這篇文章主要介紹了JAVA中的Token 基于Token的身份驗證實例，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-08-08
Netty作為一個流行的應(yīng)用框架，它的強悍之處是性能強悍，可以輕松承載數(shù)萬并發(fā); 其編程模型簡單，容易上手; 這就給大家打開了一扇通向高性能的大門。高效io模型略去不說，我們今天主要來看看內(nèi)存控制這塊的強大之處2021-06-06
所謂代碼塊是指用"{}"括起來的一段代碼，根據(jù)其位置和聲明的不同，可以分為普通代碼塊、構(gòu)造塊、靜態(tài)塊、和同步代碼塊。如果在代碼塊前加上 synchronized關(guān)鍵字，則此代碼塊就成為同步代碼塊2021-10-10
JAVA中 redisTemplate 和 jedis的配合使用操作
這篇文章主要介紹了JAVA中 redisTemplate 和 jedis的配合使用操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-02-02