Java復(fù)習(xí)之集合框架總結(jié)
更新時間：2017年09月06日 11:36:44 作者：maoqitian
本篇文章主要介紹了Java復(fù)習(xí)之集合框架總結(jié)，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧
俗話說：溫故而知新。想想學(xué)過的知識，就算是以前學(xué)得很不錯，久不用了，就會忘記，所以溫習(xí)一下以前學(xué)習(xí)的知識我認(rèn)為是非常有必要的。而本篇文件溫習(xí)的是 Java基礎(chǔ)中的集合框架。
為什么會有集合框架？
平時我們用數(shù)組存儲一些基本的數(shù)據(jù)類型，或者是引用數(shù)據(jù)類型，但是數(shù)組的長度是固定的，當(dāng)添加的元素超過了數(shù)組的長度時，需要對數(shù)組進(jìn)行重新的定義，這樣就會顯得寫程序太麻煩，所以Java內(nèi)部為了我們方便，就提供了集合類，能存儲任意對象，長度是可以改變的，隨著元素的增加而增加，隨著元素的減少而減少。
數(shù)組可以存儲基本數(shù)據(jù)類型，也可以存儲引用數(shù)據(jù)類型，基本數(shù)據(jù)類型存儲的是值，引用數(shù)據(jù)類型存儲的是地址，而集合只能存儲引用數(shù)據(jù)類型（也就是對象），其實集合中也可以存儲基本數(shù)據(jù)類型，但是在存儲的時候會自動裝箱變成對象。
有了集合不意味著我們要拋棄數(shù)組，如果需要存儲的元素個數(shù)是固定的，我們可以使用數(shù)組，而當(dāng)存儲的元素不固定，我們使用集合。
集合的種類
集合分為單列集合和雙列集合。單列集合的根接口為Collection,雙列結(jié)合的根接口為Map,兩種集合都有基于哈希算法的集合類（HashMap和HashSet），現(xiàn)在我們可能會有疑問，到底是雙列集合基于單列集合還是單列集合基于雙列集合呢，下面我們來看往集合HashMap和HashSet添加元素的源碼：
/*
*HashMap的put 方法
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
/*
* HashSet 的add 方法
*/
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
// PRESENT是一個Object 對象
private static final Object PRESENT = new Object();
由上源碼，我們可以看出，雙列集合的put方法源碼中并沒有出現(xiàn)add方法，而單列集合的add源碼只能怪出現(xiàn)了put；我們可以知道單列集合是基于雙列集合實現(xiàn)的。其實道理很簡單，單列集合每次添加元素，只要添加key就可以，而key也是雙列集合元素的唯一標(biāo)識，而其值value則由一個Object對象代替并且隱藏，每次加入，輸出元素都是隱藏單列結(jié)合的這個值， 底層基于雙列集合，隱藏一列是很好實現(xiàn)的，而如果是單列集合要變成雙列集合估計就會有很大的難度，就好比魔術(shù)師變魔術(shù)，魔術(shù)師變東西前肯定事先準(zhǔn)備好要變的東西，只是將其隱藏，但是如果魔術(shù)師變魔術(shù)是真的從無到有，那我估計他就是神仙了，想要什么就變出來什么便是。
單列集合
首先我們看單列結(jié)合的繼承圖，單列集合的根接口是Collection,而List的實現(xiàn)類為ArrayList、LinkedList、Vector，Set接口的實現(xiàn)類是HashSet和TreeSet。
其次我們來看看各個集合的功能
List集合的特有功能概述
* void add(int index,E element) //集合中添加元素
* E remove(int index) //刪除集合中index位置上的元素
* E get(int index) //獲取集合中index位置上的元素
* E set(int index,E element) 將index位置上的元素替換成 element
Vector類特有功能
* public void addElement(E obj) 添加元素
* public E elementAt(int index) //獲取元素
* public Enumeration elements() //獲取元素的枚舉（迭代遍歷的時候用到）
LinkedList類特有功能
* public void addFirst(E e)及addLast(E e) //集合頭添加元素或者集合尾添加元素
* public E getFirst()及getLast() //獲取頭元素 獲取尾元素
* public E removeFirst()及public E removeLast() //刪除頭元素刪除尾元素
* public E get(int index);//獲取index元素
根據(jù)上述LinkedList的功能，我們可以模擬棧獲取隊列的數(shù)據(jù)結(jié)構(gòu)，棧是先進(jìn)后出，隊列為先進(jìn)先出。
/**
* 模擬的棧對象
* @author 毛麒添
* 底層還是使用LinkedList實現(xiàn)
* 如果實現(xiàn)隊列只需要將出棧變?yōu)?removeFirst
*/
public class Stack {
private LinkedList linklist=new LinkedList();
/**
* 進(jìn)棧的方法
* @param obj
*/
public void in(Object obj){
linklist.addLast(obj);
}
/**
* 出棧
*/
public Object out(){
return linklist.removeLast();
}
/**
* 棧是否為空
* @return
*/
public boolean isEmpty(){
return linklist.isEmpty();
}
}
//集合的三種迭代（遍歷集合）刪除
ArrayList<String> list=new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("world");
//1，普通for循環(huán)刪除元素
for(int i=0;i<list,size();i++){//刪除元素b
if("b".equals(list.get(i))){
list.remove(i--);// i-- 當(dāng)集合中有重復(fù)元素的時候保證要刪除的重復(fù)元素被刪除
}
}
//2.使用迭代器遍歷集合
Iterator<String> it=list.iterator();
while(it.hasNext){
if("b".equals(it.next())){
it.remove();//這里必須使用迭代器的刪除方法，而不能使用集合的刪除方法，否則會出現(xiàn)并發(fā)修改異常（ConcurrentModificationException）
}
}
//使用增強(qiáng)for循環(huán)來進(jìn)行刪除
for (String str:list){
if("b".equals(str)){
list.remove("b");//增強(qiáng)for循環(huán)底層依賴的是迭代器，而這里刪除使用的依舊是集合的刪除方法，同理肯定是會出現(xiàn)并發(fā)修改異常（ConcurrentModificationException），所以增強(qiáng)for循環(huán)一直能用來遍歷集合，不能對集合的元素進(jìn)行刪除。
}
}
接下里我們看Set集合，我們知道Set 集合存儲無序，無索引，不可以存儲重復(fù)的對象；我們使用Set集合都是需要去掉重復(fù)元素的, 如果在存儲的時候逐個equals()比較, 效率較低,哈希算法提高了去重復(fù)的效率, 降低了使用equals()方法的次數(shù)，其中HashSet底層基于哈希算法，當(dāng)HashSet調(diào)用add方法存儲對象，先調(diào)用對象的hashCode()方法得到一個哈希值, 然后在集合中查找是否有哈希值相同的對象，如果沒有哈希值相同的對象就直接存入集合，如果有哈希值相同的對象, 就和哈希值相同的對象逐個進(jìn)行equals()比較,比較結(jié)果為false就存入, true則不存。下面給出HashSet存儲自定義對象的一個例子，自定義對象需要重寫hashCode()和equals()方法。
/**
* 自定義對象
* @author 毛麒添
* HashSet 使用的bean 重寫了equals和HashCode方法
*/
public class Person1 {
private String name;
private int age;
public Person1() {
super();
// TODO Auto-generated constructor stub
}
public Person1(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person1 [name=" + name + ", age=" + age + "]";
}
//使HashSet存儲元素唯一
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
System.out.println("equals調(diào)用了");
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person1 other = (Person1) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
public class Demo1_Hashset {
public static void main(String[] args) {
HashSet<Person1> hs=new HashSet<Person1>();
hs.add(new Person1("張三", 23));
hs.add(new Person1("張三", 23));
hs.add(new Person1("李四", 24));
hs.add(new Person1("李四", 24));
hs.add(new Person1("李四", 24));
hs.add(new Person1("李四", 24));
System.out.println(hs);
}
運(yùn)行結(jié)果如圖，達(dá)到了不存儲重復(fù)自定義對象的目的。其實HashSet的下面還有一個LinkedHashSet,底層是鏈表實現(xiàn)的，是set中唯一一個能保證怎么存就怎么取的集合對象,是HashSet的子類，保證元素唯一，與HashSet原理一樣,這里就不多說了。
最后是TreeSet集合，該集合是用來進(jìn)行排序的，同樣也可以保證元素的唯一，可以指定一個順序, 對象存入之后會按照指定的順序排列。
指定排序有兩種實現(xiàn)：
Comparable：集合加入自定義對象的時候，自定義對象需要實現(xiàn)Comparable接口，
- 實現(xiàn)接口的抽象方法中返回0，則集合中只有一個元素
- 返回正數(shù)，則集合中怎么存則怎么取，
- 返回負(fù)數(shù)，集合倒序存儲
Comparator（比較器）：
- 創(chuàng)建TreeSet的時候可以制定 一個Comparator
- 如果傳入了Comparator的子類對象, 那么TreeSet就會按照比較器中的順序排序
- add()方法內(nèi)部會自動調(diào)用Comparator接口中compare()方法排序
- 調(diào)用的對象是compare方法的第一個參數(shù),集合中的對象是compare方法的第二個參數(shù)
原理：
- TreeSet底層二叉排序樹
- 返回小的數(shù)字存儲在樹的左邊（負(fù)數(shù)），大的存儲在右邊（正數(shù)），相等則不存（等于0）
- 在TreeSet集合中如何存取元素取決于compareTo（）方法的返回值
下面來看例子：
/**
* 自定義對象 用于TreeSet
* @author 毛麒添
*
*/
public class Person implements Comparable<Person>{
private String name;
private int age;
public Person(){
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public boolean equals(Object obj) {
Person p=(Person) obj;
return this.name.equals(p.name)&&this.age==p.age;
}
@Override
public int hashCode() {
// TODO Auto-generated method stub
return 1;
}
/*//按照年齡進(jìn)行排序（TreeSet）
@Override
public int compareTo(Person o) {
int number=this.age-o.age;//年齡是比較的主要條件
//當(dāng)年齡一樣的時候比較名字來確定排序
return number==0?this.name.compareTo(o.name):number;
}*/
//按照姓名進(jìn)行排序（TreeSet）
@Override
public int compareTo(Person o) {
int number=this.name.compareTo(o.name);//姓名是比較的主要條件
//當(dāng)姓名一樣的時候比年齡來確定排序
return number==0?this.age- o.age:number;
}
//按照姓名長度進(jìn)行排序（TreeSet）
/*@Override
public int compareTo(Person o) {
int length=this.name.length()-o.name.length();//姓名長度比較的次要條件
int number=length==0?this.name.compareTo(o.name):length;//姓名是比較的次要條件
//比年齡也是次要條件
return number==0?this.age- o.age:number;
}*/
}
/**
*
* @author 毛麒添
* TreeSet集合
* 集合加入自定義對象的時候，自定義對象需要實現(xiàn)Comparable接口，
* 實現(xiàn)接口的抽象方法中返回0，則集合中只有一個元素
* 返回正數(shù)，則集合中怎么存則怎么取，
* 返回負(fù)數(shù)，集合倒序存儲
*
* 將字符按照長度來進(jìn)行排序在TreeSet中,需要使用有比較的構(gòu)造方法進(jìn)行比較。
*/
public class Demo_TreeSet {
public static void main(String[] args) {
// TODO Auto-generated method stub
demo1();//整數(shù)存取排序
demo2();//自定義對象排序
//將字符按照長度來進(jìn)行排序在TreeSet中
TreeSet<String> strLenset=new TreeSet<String>(new compareByLen());
strLenset.add("aaaaa");
strLenset.add("lol");
strLenset.add("wrc");
strLenset.add("wc");
strLenset.add("b");
strLenset.add("wnnnnnnnnnnn");
System.out.println(strLenset);
}
private static void demo2() {
TreeSet<Person> ptreeSet=new TreeSet<Person>();
ptreeSet.add(new Person("李四",12));
ptreeSet.add(new Person("李四",16));
ptreeSet.add(new Person("李青",16));
ptreeSet.add(new Person("王五",19));
ptreeSet.add(new Person("趙六",22));
System.out.println(ptreeSet);
}
private static void demo1() {
TreeSet< Integer> treeSet=new TreeSet<Integer>();
treeSet.add(1);
treeSet.add(1);
treeSet.add(1);
treeSet.add(3);
treeSet.add(3);
treeSet.add(3);
treeSet.add(2);
treeSet.add(2);
treeSet.add(2);
System.out.println(treeSet);
}
}
//TreeSet 構(gòu)造器，實現(xiàn)compare對需要存儲的字符串進(jìn)行比較
class compareByLen implements Comparator<String>{
//按照字符串的長度進(jìn)行比較，該方法的返回值和繼承Comparable的compareTo方法返回值同理。
@Override
public int compare(String o1, String o2) {
int num=o1.length()-o2.length();//以長度為主要條件
return num==0?o1.compareTo(o2):num;//內(nèi)容為次要條件
}
}
下面是運(yùn)行截圖，其中compareTo的實現(xiàn)方法對幾種條件排序進(jìn)行了實現(xiàn)，具體可以查看Person自定義類中的實現(xiàn)。
單列集合復(fù)習(xí)就到這里吧。
雙列集合
同樣的，在復(fù)習(xí)雙列結(jié)合之前我們先看看雙列集合的繼承圖。
Map集合的功能梳理：
添加功能
- V put(K key,V value):添加元素。
- 如果鍵是第一次存儲，就直接存儲元素，返回null
- 如果鍵不是第一次存在，就用值把以前的值替換掉，返回以前的值
刪除功能
- void clear():移除所有的鍵值對元素
- V remove(Object key)：根據(jù)鍵刪除鍵值對元素，并把值返回
判斷功能
- boolean containsKey(Object key)：判斷集合是否包含指定的鍵
- boolean containsValue(Object value):判斷集合是否包含指定的值
- boolean isEmpty()：判斷集合是否為空
獲取功能
- Set<Map.Entry<K,V>> entrySet():
- V get(Object key):根據(jù)鍵獲取值
- Set<K> keySet():獲取集合中所有鍵的集合
- Collection<V> values():獲取集合中所有值的集合
長度功能
- int size()：返回集合中的鍵值對的個數(shù)
Map類集合也有三種遍歷方式：
- 使用迭代器進(jìn)行遍歷
- 使用增強(qiáng)For循環(huán)來進(jìn)行遍歷
- 使用Map.Entry來遍歷集合中的元素
下面我們來看看如何實現(xiàn)上面三種遍歷方式
/**
*
* @author 毛麒添
* Map 集合的遍歷
*/
public class Demo {
public static void main(String[] args) {
Map<String ,Integer> map=new HashMap<String, Integer>();
map.put("張三", 18);
map.put("李四", 19);
map.put("王五", 20);
map.put("趙六", 21);
//使用迭代器進(jìn)行遍歷
/*Set<String> keySet = map.keySet();//獲取所有key的集合
Iterator<String> iterator = keySet.iterator();
while(iterator.hasNext()){
String key = iterator.next();
Integer i=map.get(key);
System.out.println(i);
}*/
//使用增強(qiáng)For循環(huán)來進(jìn)行遍歷
for (String key :map.keySet()) {
Integer integer = map.get(key);
System.out.println(integer);
}
/*---------------------------使用Map.Entry來遍歷集合中的元素--------------------------*/
Set<Map.Entry<String,Integer>> en=map.entrySet();////獲取所有的鍵值對象的集合
/*//使用迭代器來遍歷
Iterator<Entry<String, Integer>> iterator = en.iterator();
while(iterator.hasNext()){
Entry<String, Integer> e=iterator.next();//獲取鍵值對對象
String key = e.getKey();//根據(jù)鍵值對對象獲取鍵
Integer value = e.getValue();//根據(jù)鍵值對對象獲取值
System.out.print(key);
System.out.println(value);
}*/
//使用增強(qiáng)for循環(huán)來遍歷
for (Entry<String, Integer> entry : en) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.print(key);
System.out.println(value);
}
/*---------------------------使用Map.Entry來遍歷集合中的元素--------------------------*/
}
}
LinkHashMap與LinkHashSet一樣，怎么存怎么取，保證元素唯一（key 是唯一判定值）,由于保證元素唯一，其性能肯定會低一些，這里就不細(xì)說了。
TreeMap是雙列集合，其實他和TreeSet是很像的，但是雙列集合的鍵是唯一標(biāo)識，所以TreeMap排序的是每個元素的鍵。對于存儲自定義對象排序，它也有Comparable和Comparator，下面我們來看例子
/**
*
* @author 毛麒添
* TreeMap
* 通TreeSet 原理，存取自定義對象也需要繼承Comparable結(jié)構(gòu)，
* 或者實現(xiàn)比較器Comparator
*/
public class Demo6_TreeMap {
public static void main(String[] args) {
TreeMap<Student, String> tm=new TreeMap<Student, String>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num=s1.getName().compareTo(s2.getName());//以姓名作為主要比較條件
return num==0?s1.getAge()-s2.getAge():num;
}
});
tm.put(new Student("張三",13),"杭州");
tm.put(new Student("張三",14), "賀州");
tm.put(new Student("王五",15), "廣州");
tm.put(new Student("趙六",16), "深圳");
System.out.println(tm);
}
}
/**
* 自定義對象
* @author 毛麒添
* HashMap 存儲對象 與 HashSet 同理 需要重寫 hashcode 和equals 方法
* TreeMap 實現(xiàn) Comparable接口
*/
public class Student implements Comparable<Student>{
private int age;
private String name;
public Student(){
super();
}
public Student(String name,int age){
this.name=name;
this.age=age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student [age=" + age + ", name=" + name + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public int compareTo(Student o) {
int num =this.age-o.age;//以年齡為主要條件
return num==0?this.name.compareTo(o.name):num;//姓名作為次要條件
}
}
到這里，Java集合框架的復(fù)習(xí)基本完成，最后來一個斗地主的例子對集合框架做一個綜合應(yīng)用，只是實現(xiàn)斗地主洗牌和發(fā)牌，至于怎么打牌，邏輯復(fù)雜，這里不做實現(xiàn)。
/**
*
* @author 毛麒添
* 模擬斗地主洗牌和發(fā)牌，牌排序
* 買一副撲克
* 洗牌
* 發(fā)牌
* 看牌
*/
public class Doudizhu_progress {
public static void main(String[] args) {
// TODO Auto-generated method stub
//構(gòu)造一副撲克牌
String[] number={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[]color={"黑桃","紅桃","梅花","方塊"};
HashMap<Integer, String> pokerMap=new HashMap<Integer, String>();//存放牌的map
ArrayList<Integer> list=new ArrayList<Integer>();//存放牌的索引
int index=0; //索引
for (String s1 : number) {
for (String s2 : color) {
pokerMap.put(index,s2.concat(s1));
list.add(index);
index++;
}
}
//加入大小王
pokerMap.put(index,"小王");
list.add(index);
index++;
pokerMap.put(index,"大王");
list.add(index);
//洗牌
Collections.shuffle(list);
//System.out.println(list);
//發(fā)牌，3個人玩 加上底牌3張 使用TreeSet 來存放索引，并自動對索引排好序
TreeSet<Integer> mao=new TreeSet<Integer>();
TreeSet<Integer> li=new TreeSet<Integer>();
TreeSet<Integer> huang=new TreeSet<Integer>();
TreeSet<Integer> dipai=new TreeSet<Integer>();
for(int i=0;i<list.size();i++){
if(i>=list.size()-3){//最后三張牌，作為底牌
dipai.add(list.get(i));
}else if(i%3==0){
mao.add(list.get(i));
}else if(i%3==1){
li.add(list.get(i));
}else {
huang.add(list.get(i));
}
}
//看牌
lookPoker(pokerMap,mao,"mao");
lookPoker(pokerMap,li,"li");
lookPoker(pokerMap,huang,"huang");
lookPoker(pokerMap,dipai,"底牌");
}
/**
* 看牌的方法
* @param pokerMap 存放牌的map
* @param mao 該玩家的牌的索引集合
* @param name 玩家名字
*/
private static void lookPoker(HashMap<Integer, String> pokerMap,
TreeSet<Integer> mao, String name) {
if(name.equals("底牌")){
System.out.print("地主"+name+"的牌是：");
}else{
System.out.print("玩家"+name+"的牌是：");
}
for (Integer integer : mao) {
System.out.print(pokerMap.get(integer)+" ");
}
System.out.println();
}
}
運(yùn)行截圖：
寫在最后：
如果你看到這里，估計你也溫故知新了吧，那就這樣吧，這篇又臭又長的文章就到這里啦。希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。
相關(guān)文章
這篇文章主要介紹了Spring整合junit的配置過程圖解,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2020-02-02
這篇文章主要介紹了SpringMVC中的異常處理的相關(guān)資料，幫助大家更好的理解和學(xué)習(xí)使用SpringMVC，感興趣的朋友可以了解下2021-03-03
這篇文章主要介紹了詳解HTTP請求與響應(yīng)基礎(chǔ)及實例的相關(guān)資料,這里對http的請求和響應(yīng)進(jìn)行詳細(xì)分析并附有實現(xiàn)實例，需要的朋友可以參考下2017-07-07
Java后臺Controller實現(xiàn)文件下載操作
這篇文章主要介紹了Java后臺Controller實現(xiàn)文件下載操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-10-10
這篇文章主要為大家介紹了spring?IOC容器Bean管理基于XML的自動裝配過程，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進(jìn)步，早日升職加薪2022-05-05
Eclipse添加xml文件提示及Hibernate配置學(xué)習(xí)
文件提示功能在開發(fā)過程中很實用的，本文實現(xiàn)了一個Eclipse添加xml文件提示，感興趣的朋友可以了解下啊，希望本文對你有所幫助2013-01-01
今天教大家怎么寫spring項目,文中有非常詳細(xì)的圖文示例及介紹,對正在學(xué)習(xí)java的小伙伴們很有幫助,需要的朋友可以參考下2021-06-06
這篇文章主要介紹了使用java實現(xiàn)手機(jī)短信驗證全過程,文中有非常詳細(xì)的代碼示例,對正在學(xué)習(xí)java的小伙伴們有非常好的幫助,需要的朋友可以參考下2021-04-04
這篇文章主要介紹了Java 利用棧來反轉(zhuǎn)鏈表和排序的操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-02-02
這篇文章主要介紹了Java Dubbo框架知識點梳理,通過詳細(xì)的文字講解和代碼實例,梳理了Dubbo這個框架,需要的朋友可以參考下2021-06-06