黑马程序员_java基础笔记(06)...集合
——————————?ASP.Net+Android+IOS開發(fā)、.Net培訓、期待與您交流！ ——————————
集合框架：★★★★★，用于存儲數(shù)據(jù)的容器。
特點：
1：對象封裝數(shù)據(jù)，對象多了也需要存儲。集合用于存儲對象。
2：對象的個數(shù)確定可以使用數(shù)組，但是不確定怎么辦？可以用集合。因為集合是可變長度的。
集合和數(shù)組的區(qū)別：
1：數(shù)組是固定長度的；集合可變長度的。
2：數(shù)組可以存儲基本數(shù)據(jù)類型，也可以存儲引用數(shù)據(jù)類型；集合只能存儲引用數(shù)據(jù)類型。
3：數(shù)組存儲的元素必須是同一個數(shù)據(jù)類型；集合存儲的對象可以是不同數(shù)據(jù)類型。
數(shù)據(jù)結(jié)構(gòu)：就是容器中存儲數(shù)據(jù)的方式。
對于集合容器，有很多種。因為每一個容器的自身特點不同，其實原理在于每個容器的內(nèi)部數(shù)據(jù)結(jié)構(gòu)不同。
集合容器在不斷向上抽取過程中。出現(xiàn)了集合體系。
在使用一個體系時，原則：參閱頂層內(nèi)容。建立底層對象。
Map與Collection Map與Collection在集合框架中屬并列存在 Map存儲的是鍵值對 Map存儲元素使用put方法，Collection使用add方法 Map集合沒有直接取出元素的方法，而是先轉(zhuǎn)成Set集合，在通過迭代獲取元素 Map集合中鍵要保證唯一性 集合框架的工具類。 Collections 對集合進行查找 取出集合中的最大值，最小值 對List集合進行排序 ? …… Arrays 將數(shù)組轉(zhuǎn)成List集合 對數(shù)組進行排序 對數(shù)組進行二分查找——<?java.util?>——?Collection接口：
Collection：
|——List：有序(元素存入集合的順序和取出的順序一致)，元素都有索引。元素可以重復。
|——Set：無序(存入和取出順序有可能不一致)，不可以存儲重復元素。必須保證元素唯一性。
1，添加：
add(object)：添加一個元素
addAll(Collection)?：添加一個集合中的所有元素。
2，刪除：
clear()：將集合中的元素全刪除，清空集合。
remove(obj)?：刪除集合中指定的對象。注意：刪除成功，集合的長度會改變。
removeAll(collection)?：刪除部分元素。部分元素和傳入Collection一致。
3，判斷：
boolean?contains(obj)?：集合中是否包含指定元素?。
boolean?containsAll(Collection)?：集合中是否包含指定的多個元素。
boolean?isEmpty()：集合中是否有元素。?
4，獲取：
int?size()：集合中有幾個元素。
5，取交集：
boolean??retainAll(Collection)?：對當前集合中保留和指定集合中的相同的元素。如果兩個集合元素相同，返回flase；如果retainAll修改了當前集合，返回true。
6，獲取集合中所有元素：
Iterator??iterator()：迭代器
7，將集合變成數(shù)組：
toArray();
———————————————————————————————————————————————————————————————
——<?java.util?>——?Iterator接口：
迭代器：是一個接口。作用：用于取集合中的元素。
| ?boolean | hasNext()??如果仍有元素可以迭代，則返回?true。 |
| ?E | next()???返回迭代的下一個元素。 |
| ?void | remove()??從迭代器指向的?collection?中移除迭代器返回的最后一個元素（可選操作）。 |
?
每一個集合都有自己的數(shù)據(jù)結(jié)構(gòu)，都有特定的取出自己內(nèi)部元素的方式。為了便于操作所有的容器，取出元素。將容器內(nèi)部的取出方式按照一個統(tǒng)一的規(guī)則向外提供，這個規(guī)則就是Iterator接口。
也就說，只要通過該接口就可以取出Collection集合中的元素，至于每一個具體的容器依據(jù)自己的數(shù)據(jù)結(jié)構(gòu)，如何實現(xiàn)的具體取出細節(jié)，這個不用關(guān)心，這樣就降低了取出元素和具體集合的耦合性。
Iterator?it?=?coll.iterator();//獲取容器中的迭代器對象，至于這個對象是是什么不重要。這對象肯定符合一個規(guī)則Iterator接口。
———————————————————————————————————————————————————————————————
public?static?void?main(String[]?args)?{
Collection?coll?=?new?ArrayList();
coll.add("abc0");
coll.add("abc1");
coll.add("abc2");
//——————————方式1———————————————
Iterator?it?=?coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//——————————方式2用此種———————————————
for(Iterator?it?=?coll.iterator();it.hasNext();?){
System.out.println(it.next());
}
}
—————————————————————————————————————————————————————————————————
——<?java.util?>——?List接口：
List本身是Collection接口的子接口，具備了Collection的所有方法。現(xiàn)在學習List體系特有的共性方法，查閱方法發(fā)現(xiàn)List的特有方法都有索引，這是該集合最大的特點。
List：有序(元素存入集合的順序和取出的順序一致)，元素都有索引。元素可以重復。
|——ArrayList：底層的數(shù)據(jù)結(jié)構(gòu)是數(shù)組,線程不同步，ArrayList替代了Vector，查詢元素的速度非常快。
|——LinkedList：底層的數(shù)據(jù)結(jié)構(gòu)是鏈表，線程不同步，增刪元素的速度非常快。
|——Vector：底層的數(shù)據(jù)結(jié)構(gòu)就是數(shù)組，線程同步的，Vector無論查詢和增刪都巨慢。
1，添加：
add(index,element)?：在指定的索引位插入元素。
addAll(index,collection)?：在指定的索引位插入一堆元素。
2，刪除：
remove(index)?：刪除指定索引位的元素。?返回被刪的元素。
3，獲取：
Object?get(index)?：通過索引獲取指定元素。
int?indexOf(obj)?：獲取指定元素第一次出現(xiàn)的索引位，如果該元素不存在返回—1；
所以，通過—1，可以判斷一個元素是否存在。
int?lastIndexOf(Object?o)?：反向索引指定元素的位置。
List?subList(start,end)?：獲取子列表。
4，修改：
Object?set(index,element)?：對指定索引位進行元素的修改。
5，獲取所有元素：
ListIterator?listIterator()：list集合特有的迭代器。
List集合支持對元素的增、刪、改、查。
List集合因為角標有了自己的獲取元素的方式：?遍歷。
for(int?x=0;?x<list.size();?x++){
sop("get:"+list.get(x));
}
在進行l(wèi)ist列表元素迭代的時候，如果想要在迭代過程中，想要對元素進行操作的時候，比如滿足條件添加新元素。會發(fā)生.ConcurrentModificationException并發(fā)修改異常。
導致的原因是：
集合引用和迭代器引用在同時操作元素，通過集合獲取到對應的迭代器后，在迭代中，進行集合引用的元素添加，迭代器并不知道，所以會出現(xiàn)異常情況。
如何解決呢？
既然是在迭代中對元素進行操作,找迭代器的方法最為合適.可是Iterator中只有hasNext,next,remove方法.通過查閱的它的子接口,ListIterator,發(fā)現(xiàn)該列表迭代器接口具備了對元素的增、刪、改、查的動作。
ListIterator是List集合特有的迭代器。
ListIterator?it?=?list.listIterator;//取代Iterator?it?=?list.iterator;
| 方法摘要 | |
| ?void | add(E?e)?將指定的元素插入列表（可選操作）。 |
| ?boolean | hasNext()?以正向遍歷列表時，如果列表迭代器有多個元素，則返回?true（換句話說，如果?next?返回一個元素而不是拋出異常，則返回?true）。 |
| ?boolean | hasPrevious()?如果以逆向遍歷列表，列表迭代器有多個元素，則返回?true。 |
| ?E | next()?返回列表中的下一個元素。 |
| ?int | nextIndex()?返回對?next?的后續(xù)調(diào)用所返回元素的索引。 |
| ?E | previous()?返回列表中的前一個元素。 |
| ?int | previousIndex()?返回對?previous?的后續(xù)調(diào)用所返回元素的索引。 |
| ?void | remove()?從列表中移除由?next?或?previous?返回的最后一個元素（可選操作）。 |
| ?void | set(E?e)?用指定元素替換?next?或?previous?返回的最后一個元素（可選操作）。 |
?
可變長度數(shù)組的原理：
當元素超出數(shù)組長度，會產(chǎn)生一個新數(shù)組，將原數(shù)組的數(shù)據(jù)復制到新數(shù)組中，再將新的元素添加到新數(shù)組中。
ArrayList：是按照原數(shù)組的50%延長。構(gòu)造一個初始容量為?10?的空列表。
Vector：是按照原數(shù)組的100%延長。
注意：對于list集合，底層判斷元素是否相同，其實用的是元素自身的equals方法完成的。所以建議元素都要復寫equals方法，建立元素對象自己的比較相同的條件依據(jù)。
LinkedList：的特有方法。
addFirst();
addLast();
在jdk1.6以后。
offerFirst();
offerLast();
?
getFirst():獲取鏈表中的第一個元素。如果鏈表為空，拋出NoSuchElementException;
getLast();
在jdk1.6以后。
peekFirst();獲取鏈表中的第一個元素。如果鏈表為空，返回null。
peekLast();
?
removeFirst()：獲取鏈表中的第一個元素，但是會刪除鏈表中的第一個元素。如果鏈表為空，拋出NoSuchElementException
removeLast();
在jdk1.6以后。
pollFirst();獲取鏈表中的第一個元素，但是會刪除鏈表中的第一個元素。如果鏈表為空，返回null。
pollLast();
———————————————————————————————————————————————————————————————
——<?java.util?>——?Set接口：
Set接口中的方法和Collection中方法一致的。Set接口取出方式只有一種，迭代器。
|——HashSet：底層數(shù)據(jù)結(jié)構(gòu)是哈希表，線程是不同步的。無序，高效；
HashSet集合保證元素唯一性：通過元素的hashCode方法，和equals方法完成的。
當元素的hashCode值相同時，才繼續(xù)判斷元素的equals是否為true。
如果為true，那么視為相同元素，不存。如果為false，那么存儲。
如果hashCode值不同，那么不判斷equals，從而提高對象比較的速度。
|——LinkedHashSet：有序，hashset的子類。
|——TreeSet：對Set集合中的元素的進行指定順序的排序。不同步。TreeSet底層的數(shù)據(jù)結(jié)構(gòu)就是二叉樹。
哈希表的原理：
1，對對象元素中的關(guān)鍵字(對象中的特有數(shù)據(jù))，進行哈希算法的運算，并得出一個具體的算法值，這個值?稱為哈希值。
2，哈希值就是這個元素的位置。
3，如果哈希值出現(xiàn)沖突，再次判斷這個關(guān)鍵字對應的對象是否相同。如果對象相同，就不存儲，因為元素重復。如果對象不同，就存儲，在原來對象的哈希值基礎?+1順延。
4，存儲哈希值的結(jié)構(gòu)，我們稱為哈希表。
5，既然哈希表是根據(jù)哈希值存儲的，為了提高效率，最好保證對象的關(guān)鍵字是唯一的。
這樣可以盡量少的判斷關(guān)鍵字對應的對象是否相同，提高了哈希表的操作效率。
對于ArrayList集合，判斷元素是否存在，或者刪元素底層依據(jù)都是equals方法。
對于HashSet集合，判斷元素是否存在，或者刪除元素，底層依據(jù)的是hashCode方法和equals方法。
TreeSet:
用于對Set集合進行元素的指定順序排序，排序需要依據(jù)元素自身具備的比較性。
如果元素不具備比較性，在運行時會發(fā)生ClassCastException異常。
所以需要元素實現(xiàn)Comparable接口，強制讓元素具備比較性，復寫compareTo方法。
依據(jù)compareTo方法的返回值，確定元素在TreeSet數(shù)據(jù)結(jié)構(gòu)中的位置。
TreeSet方法保證元素唯一性的方式：就是參考比較方法的結(jié)果是否為0，如果return?0，視為兩個對象重復，不存。
注意：在進行比較時，如果判斷元素不唯一，比如，同姓名，同年齡，才視為同一個人。
在判斷時，需要分主要條件和次要條件，當主要條件相同時，再判斷次要條件，按照次要條件排序。
TreeSet集合排序有兩種方式，Comparable和Comparator區(qū)別：
1：讓元素自身具備比較性，需要元素對象實現(xiàn)Comparable接口，覆蓋compareTo方法。
2：讓集合自身具備比較性，需要定義一個實現(xiàn)了Comparator接口的比較器，并覆蓋compare方法，并將該類對象作為實際參數(shù)傳遞給TreeSet集合的構(gòu)造函數(shù)。
第二種方式較為靈活。
———————————————————————————————————————————————————————————————
Map集合：
|——Hashtable：底層是哈希表數(shù)據(jù)結(jié)構(gòu)，是線程同步的。不可以存儲null鍵，null值。
|——HashMap：底層是哈希表數(shù)據(jù)結(jié)構(gòu)，是線程不同步的。可以存儲null鍵，null值。替代了Hashtable.
|——TreeMap：底層是二叉樹結(jié)構(gòu)，可以對map集合中的鍵進行指定順序的排序。
Map集合存儲和Collection有著很大不同：
Collection一次存一個元素；Map一次存一對元素。
Collection是單列集合；Map是雙列集合。
Map中的存儲的一對元素：一個是鍵，一個是值，鍵與值之間有對應(映射)關(guān)系。
特點：要保證map集合中鍵的唯一性。
1，添加。
?put(key,value)：當存儲的鍵相同時，新的值會替換老的值，并將老值返回。如果鍵沒有重復，返回null。
void?putAll(Map);
2，刪除。
void?clear()：清空
value?remove(key)?：刪除指定鍵。
3，判斷。
boolean?isEmpty()：
boolean?containsKey(key)：是否包含key
boolean?containsValue(value)?：是否包含value
4，取出。
int?size()：返回長度
value?get(key)?：通過指定鍵獲取對應的值。如果返回null，可以判斷該鍵不存在。當然有特殊情況，就是在hashmap集合中，是可以存儲null鍵null值的。
Collection?values()：獲取map集合中的所有的值。
5，想要獲取map中的所有元素：
原理：map中是沒有迭代器的，collection具備迭代器，只要將map集合轉(zhuǎn)成Set集合，可以使用迭代器了。之所以轉(zhuǎn)成set，是因為map集合具備著鍵的唯一性，其實set集合就來自于map，set集合底層其實用的就是map的方法。
★?把map集合轉(zhuǎn)成set的方法：
Set?keySet();
Set?entrySet();//取的是鍵和值的映射關(guān)系。
Entry就是Map接口中的內(nèi)部接口；
為什么要定義在map內(nèi)部呢？entry是訪問鍵值關(guān)系的入口，是map的入口，訪問的是map中的鍵值對。
——————————————————————————————————————————————————————————————————
取出map集合中所有元素的方式一：keySet()方法。
可以將map集合中的鍵都取出存放到set集合中。對set集合進行迭代。迭代完成，再通過get方法對獲取到的鍵進行值的獲取。
Set?keySet?=?map.keySet();
Iterator?it?=?keySet.iterator();
while(it.hasNext())?{
Object?key?=?it.next();
Object?value?=?map.get(key);
System.out.println(key+":"+value);
}
—————————————————————————————————————————————————————————————————
取出map集合中所有元素的方式二：entrySet()方法。
Set?entrySet?=?map.entrySet();
Iterator?it?=?entrySet.iterator();
while(it.hasNext())?{
Map.Entry??me?=?(Map.Entry)it.next();
System.out.println(me.getKey()+"::::"+me.getValue());
}
—————————————————————————————————————————————————————————————————
使用集合的技巧：
看到Array就是數(shù)組結(jié)構(gòu)，有角標，查詢速度很快。
看到link就是鏈表結(jié)構(gòu)：增刪速度快，而且有特有方法。addFirst；?addLast；?removeFirst()；?removeLast()；?getFirst()；getLast()；
看到hash就是哈希表，就要想要哈希值，就要想到唯一性，就要想到存入到該結(jié)構(gòu)的中的元素必須覆蓋hashCode，equals方法。
看到tree就是二叉樹，就要想到排序，就想要用到比較。
比較的兩種方式：
一個是Comparable：覆蓋compareTo方法；
一個是Comparator：覆蓋compare方法。
LinkedHashSet，LinkedHashMap:這兩個集合可以保證哈希表有存入順序和取出順序一致，保證哈希表有序。
集合什么時候用？
當存儲的是一個元素時，就用Collection。當存儲對象之間存在著映射關(guān)系時，就使用Map集合。
保證唯一，就用Set。不保證唯一，就用List。
—————————————————————————————————————————————————————————————————
Collections：它的出現(xiàn)給集合操作提供了更多的功能。這個類不需要創(chuàng)建對象，內(nèi)部提供的都是靜態(tài)方法。
靜態(tài)方法：
Collections.sort(list);//list集合進行元素的自然順序排序。
Collections.sort(list,new?ComparatorByLen());//按指定的比較器方法排序。
class?ComparatorByLen?implements?Comparator<String>{
public?int?compare(String?s1,String?s2){
int?temp?=?s1.length()—s2.length();
return?temp==0?s1.compareTo(s2):temp;
}
}
Collections.max(list);?//返回list中字典順序最大的元素。
int?index?=?Collections.binarySearch(list,"zz");//二分查找，返回角標。
Collections.reverseOrder();//逆向反轉(zhuǎn)排序。
Collections.shuffle(list);//隨機對list中的元素進行位置的置換。
將非同步集合轉(zhuǎn)成同步集合的方法：Collections中的??XXX?synchronizedXXX(XXX);
List?synchronizedList(list);
Map?synchronizedMap(map);
原理：定義一個類，將集合所有的方法加同一把鎖后返回。
Collection?和?Collections的區(qū)別：
Collections是個java.util下的類，是針對集合類的一個工具類,提供一系列靜態(tài)方法,實現(xiàn)對集合的查找、排序、替換、線程安全化（將非同步的集合轉(zhuǎn)換成同步的）等操作。
Collection是個java.util下的接口，它是各種集合結(jié)構(gòu)的父接口，繼承于它的接口主要有Set和List,提供了關(guān)于集合的一些操作,如插入、刪除、判斷一個元素是否其成員、遍歷等。
————————————————————————————————————————————————————————————————
Arrays：
用于操作數(shù)組對象的工具類，里面都是靜態(tài)方法。
asList方法：將數(shù)組轉(zhuǎn)換成list集合。
String[]?arr?=?{"abc","kk","qq"};
List<String>?list?=?Arrays.asList(arr);//將arr數(shù)組轉(zhuǎn)成list集合。
將數(shù)組轉(zhuǎn)換成集合，有什么好處呢？用aslist方法，將數(shù)組變成集合；
可以通過list集合中的方法來操作數(shù)組中的元素：isEmpty()、contains、indexOf、set；?
注意（局限性）：數(shù)組是固定長度，不可以使用集合對象增加或者刪除等，會改變數(shù)組長度的功能方法。比如add、remove、clear。（會報不支持操作異常UnsupportedOperationException）；
如果數(shù)組中存儲的引用數(shù)據(jù)類型，直接作為集合的元素可以直接用集合方法操作。
如果數(shù)組中存儲的是基本數(shù)據(jù)類型，asList會將數(shù)組實體作為集合元素存在。
集合變數(shù)組：用的是Collection接口中的方法：toArray();
如果給toArray傳遞的指定類型的數(shù)據(jù)長度小于了集合的size，那么toArray方法，會自定再創(chuàng)建一個該類型的數(shù)據(jù)，長度為集合的size。
如果傳遞的指定的類型的數(shù)組的長度大于了集合的size，那么toArray方法，就不會創(chuàng)建新數(shù)組，直接使用該數(shù)組即可，并將集合中的元素存儲到數(shù)組中，其他為存儲元素的位置默認值null。
所以，在傳遞指定類型數(shù)組時，最好的方式就是指定的長度和size相等的數(shù)組。
將集合變成數(shù)組后有什么好處？限定了對集合中的元素進行增刪操作，只要獲取這些元素即可。
———————————————————————————————————————————————————————————————
Jdk5.0新特性：
Collection在jdk1.5以后，有了一個父接口Iterable，這個接口的出現(xiàn)的將iterator方法進行抽取，提高了擴展性。
————————————————————————————————————————————————————————————————
增強for循環(huán)：foreach語句，foreach簡化了迭代器。
格式：//?增強for循環(huán)括號里寫兩個參數(shù)，第一個是聲明一個變量，第二個就是需要迭代的容器
for(?元素類型?變量名?:?Collection集合?&?數(shù)組?)?{
…
}
高級for循環(huán)和傳統(tǒng)for循環(huán)的區(qū)別：
高級for循環(huán)在使用時，必須要明確被遍歷的目標。這個目標，可以是Collection集合或者數(shù)組，如果遍歷Collection集合，在遍歷過程中還需要對元素進行操作，比如刪除，需要使用迭代器。
如果遍歷數(shù)組，還需要對數(shù)組元素進行操作，建議用傳統(tǒng)for循環(huán)因為可以定義角標通過角標操作元素。如果只為遍歷獲取，可以簡化成高級for循環(huán)，它的出現(xiàn)為了簡化書寫。
高級for循環(huán)可以遍歷map集合嗎？不可以。但是可以將map轉(zhuǎn)成set后再使用foreach語句。
1)、作用：對存儲對象的容器進行迭代：?數(shù)組??collection???map
2)、增強for循環(huán)迭代數(shù)組：
String?[]?arr?=?{"a",?"b",?"c"};//數(shù)組的靜態(tài)定義方式，只試用于數(shù)組首次定義的時候
for(String?s?:?arr)?{
System.out.println(s);
}
3)、單列集合?Collection：
List?list?=?new?ArrayList();
list.add("aaa");
//?增強for循環(huán),?沒有使用泛型的集合能不能使用增強for循環(huán)迭代？能
for(Object?obj?:?list)?{
String?s?=?(String)?obj;
System.out.println(s);
}
4)、雙列集合?Map：
Map?map?=?new?HashMap();
map.put("a",?"aaa");
//?傳統(tǒng)方式：必須掌握這種方式
Set?entrys?=?map.entrySet();?//?1.獲得所有的鍵值對Entry對象
iter?=?entrys.iterator();?//?2.迭代出所有的entry
while(iter.hasNext())?{
Map.Entry?entry?=?(Entry)?iter.next();
String?key?=?(String)?entry.getKey();?//?分別獲得key和value
String?value?=?(String)?entry.getValue();
System.out.println(key?+?"="?+?value);
}
//?增強for循環(huán)迭代： 原則上map集合是無法使用增強for循環(huán)來迭代的，因為增強for循環(huán)只能針對實現(xiàn)了Iterable接口的集合進行迭代；Iterable是jdk5 中新定義的接口，就一個方法iterator方法，只有實現(xiàn)了Iterable接口的類，才能保證一定有iterator方法，java有這樣的限定是因 為增強for循環(huán)內(nèi)部還是用迭代器實現(xiàn)的，而實際上，我們可以通過某種方式來使用增強for循環(huán)。
for(Object?obj?:?map.entrySet())?{
Map.Entry?entry?=?(Entry)?obj;??//?obj?依次表示Entry
System.out.println(entry.getKey()?+?"="?+?entry.getValue());
}
5）、集合迭代注意問題：在迭代集合的過程中，不能對集合進行增刪操作（會報并發(fā)訪問異常）；可以用迭代器的方法進行操作（子類listIterator：有增刪的方法）。
6)、增強for循環(huán)注意問題：在使用增強for循環(huán)時，不能對元素進行賦值；
int[]?arr?=?{1,2,3};
for(int?num?:?arr)?{
num?=?0;?//不能改變數(shù)組的值
}
System.out.println(arr[1]);?//2
————————————————————————————————————————————————————————————————
可變參數(shù)（...）：用到函數(shù)的參數(shù)上，當要操作的同一個類型元素個數(shù)不確定的時候，可是用這個方式，這個參數(shù)可以接受任意個數(shù)的同一類型的數(shù)據(jù)。
和以前接收數(shù)組不一樣的是：
以前定義數(shù)組類型，需要先創(chuàng)建一個數(shù)組對象，再將這個數(shù)組對象作為參數(shù)傳遞給函數(shù)。現(xiàn)在，直接將數(shù)組中的元素作為參數(shù)傳遞即可。底層其實是將這些元素進行數(shù)組的封裝，而這個封裝動作，是在底層完成的，被隱藏了。所以簡化了用戶的書寫，少了調(diào)用者定義數(shù)組的動作。
如果在參數(shù)列表中使用了可變參數(shù)，可變參數(shù)必須定義在參數(shù)列表結(jié)尾(也就是必須是最后一個參數(shù)，否則編譯會失敗。)。
如果要獲取多個int數(shù)的和呢？可以使用將多個int數(shù)封裝到數(shù)組中，直接對數(shù)組求和即可。
StaticImport??靜態(tài)導入。當類名重名時，需要指定具體的包名。當方法重名是，指定具備所屬的對象或者類。 其他常用的API： 3：System類(java.lang)System?類包含一些有用的類字段和方法。它不能被實例化。在?System?類提供的設施中，有標準輸入、標準輸出和錯誤輸出流；對外部定義的屬性和環(huán)境變量的訪問；加載文件和庫的方法；還有快速復制數(shù)組的一部分的實用方法。?
System:類中的方法和屬性都是靜態(tài)的。 out:標準輸出，默認是控制臺。 in：標準輸入，默認是鍵盤。 獲取系統(tǒng)屬性信息：Properties getProperties(); Properties prop = System.getProperties(); //因為Properties是Hashtable的子類，也就是Map集合的一個子類對象。 //那么可以通過map的方法取出該集合中的元素。 //該集合中存儲都是字符串。沒有泛型定義。 ? //如何在系統(tǒng)中自定義一些特有信息呢？ System.setProperty("mykey","myvalue"); //獲取指定屬性信息。 String value = System.getProperty("os.name"); System.out.println("value="+value); //可不可以在jvm啟動時，動態(tài)加載一些屬性信息呢？ String v = System.getProperty("haha"); System.out.println("v="+v); //獲取所有屬性信息。 for(Object obj : prop.keySet()){ String value = (String)prop.get(obj); System.out.println(obj+"::"+value); } 4：Runtime類(java.lang)每個 Java 應用程序都有一個?Runtime?類實例，使應用程序能夠與其運行的環(huán)境相連接。可以通過?getRuntime?方法獲取當前運行時。應用程序不能創(chuàng)建自己的 Runtime 類實例。?
Runtime對象：該類并沒有提供構(gòu)造函數(shù)。說明不可以new對象。那么會直接想到該類中的方法都是靜態(tài)的。發(fā)現(xiàn)該類中還有非靜態(tài)方法。說明該類肯定會提供了方法獲取本類對象。而且該方法是靜態(tài)的，并返回值類型是本類類型。由這個特點可以看出該類使用了單例設計模式完成。該方式是static Runtime getRuntime(); 例 class ?RuntimeDemo{ public static void main(String[] args) throws Exception{ Runtime r = Runtime.getRuntime(); Process p = r.exec("notepad.exe ?SystemDemo.java"); Thread.sleep(4000); p.destroy(); } } 5：Date類(java.util)類?Date?表示特定的瞬間，精確到毫秒。SimpleDateFormat //將模式封裝到SimpleDateformat對象中。 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss"); //調(diào)用format方法讓模式格式化指定Date對象。 String time = sdf.format(d); System.out.println("time="+time); long l = System.currentTimeMillis(); Date d1 = new Date(l); System.out.println("d1:"+d1); 6：Calendar類(java.util)Calendar?類是一個抽象類，它為特定瞬間與一組諸如?YEAR、MONTH、DAY_OF_MONTH、HOUR?等 日歷字段之間的轉(zhuǎn)換提供了一些方法，并為操作日歷字段（例如獲得下星期的日期）提供了一些方法。?Calendar rightNow = Calendar.getInstance();
兩個練習： 1，獲取任意年的二月有多少天。 思路：根據(jù)指定年設置一個時間就是? c.set(year,2,1)//某一年的3月1日。 c.add(Calenar.DAY_OF_MONTH,—1);//3月1日，往前推一天，就是2月最后一天。 2，獲取昨天的現(xiàn)在這個時刻。 c.add(Calenar.DAY_OF_MONTH,—1); import java.util.*; class ?Calendar{ public static void main(String[] args)?{ Calendar c = Calendar.getInstance(); c.set(1980,2,1);???//?1980年的3月1日 c.add(Calendar.DAY_OF_MONTH,—1);//減一是1980年2月的最后一天 printCalendar(c); } public static void printCalendar(Calendar c){ //月份編碼表 String[] mons = {"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"}; //星期編碼表 String[] weeks = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"}; int index = c.get(Calendar.MONTH); int index1 = c.get(Calendar.DAY_OF_WEEK); //獲取年 sop(c.get(Calendar.YEAR)+"年"); //查表法獲取月 sop(mons[index]); //sop((c.get(Calendar.MONTH)+1)+"月"); //獲取日 sop(c.get(Calendar.DAY_OF_MONTH)+"日"); //查表法獲取星期 sop(weeks[index1]); //sop("星期"+c.get(Calendar.DAY_OF_WEEK)); } public static void sop(Object obj){ System.out.println(obj); } } 7：Math類?(java.lang包) Math?類包含用于執(zhí)行基本數(shù)學運算的方法，如初等指數(shù)、對數(shù)、平方根和三角函數(shù)。 UnsupportedOperationException不支持的操作異常 ClassCastException類轉(zhuǎn)換異常 ConcurrentModificationException并發(fā)修改異常 例： 獲取該字符串中的字母出現(xiàn)的次數(shù)。 希望打印結(jié)果：a(1)c(2)..... 通過結(jié)果發(fā)現(xiàn)，每一個字母都有對應的次數(shù)。說明字母和次數(shù)之間都有映射關(guān)系。當發(fā)現(xiàn)有映射關(guān)系時，可以選擇map集合。因為map集合中存放就是映射關(guān)系。 思路： 1，將字符串轉(zhuǎn)換成字符數(shù)組。因為要對每一個字母進行操作。 2，定義一個map集合，因為打印結(jié)果的字母有順序，所以使用treemap集合。 3，遍歷字符數(shù)組。將每一個字母作為鍵去查map集合。如果返回null，將該字母和1存入到map集合中。如果返回不是null，說明該字母在map 集合已經(jīng)存在并有對應次數(shù)。那么就獲取該次數(shù)并進行自增。，然后將該字母和自增后的次數(shù)存入到map集合中，覆蓋調(diào)用原理鍵所對應的值。 4，將map集合中的數(shù)據(jù)變成指定的字符串形式返回。 import?java.util.*; class??Map{ public static void?main(String[] args)?{ String?s= charCount("ak+abAf1c,dCkaAbc—defa"); System.out.println(s); } public static?String?charCount(String?str){ //字符串變成數(shù)組 char[] chs = str.toCharArray(); //定義集合 TreeMap<Character,Integer> tm =?new?TreeMap<Character,Integer>(); int?count = 0; //遍歷字符串 for?(?int?x = 0; x<chs.length; ?x++){ //判斷是不是字母 if ?( ?!(chs[x]>='a' ?&& ?chs[x]<='z' ? || ?chs[x]>='A' ?&& ?chs[x]<='Z')) continue; //字母chs[x]作為鍵找集合返回Integer Integer?value = tm.get(chs[x]); if?( value! =?null?) count = value; count++; tm.put(chs[x],count);//直接往集合中存儲字符和數(shù)字，為什么可以，因為自動裝箱 count = 0; /*if(value==null){ tm.put(chs[x],1); } else{ value = value + 1; tm.put(chs[x],value); }*/ } //打印對應關(guān)系 StringBuilder?sb =?new?StringBuilder(); Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet(); Iterator<Map.Entry<Character,Integer>> ?it = entrySet.iterator(); while?( it.hasNext() ){ Map.Entry<Character,Integer> me = it.next(); Character ch = me.getKey(); Integer?value = me.getValue(); sb.append ( ch+?"("?+ value +?")"?); } return ?sb.toString(); } } ?/*每一個學生都有對應的歸屬地。
學生Student，地址String。
學生屬性：姓名，年齡。
注意：姓名和年齡相同的視為同一個學生。
保證學生的唯一性。
1，描述學生。
2，定義map容器。將學生作為鍵，地址作為值。存入。
3，獲取map集合中的元素。
*/
import java.util.*;
class Student implements Comparable<Student>{
?? ?private String name;
?? ?private int age;
?? ?Student(String name,int age){
?? ??? ?this.name = name;
?? ??? ?this.age = age;
?? ?}
?? ?public int compareTo(Student s){
?? ??? ?int num = new Integer(this.age).compareTo(new Integer(s.age));
?? ??? ?if(num==0)
?? ??? ??? ?return this.name.compareTo(s.name);
?? ??? ?return num;
?? ?}
?? ?public int hashCode(){
?? ??? ?return name.hashCode()+age*34;
?? ?}
?? ?public boolean equals(Object obj){
?? ??? ?if(!(obj instanceof Student))
?? ??? ??? ?throw new ClassCastException("類型不匹配");
?? ??? ?Student s = (Student)obj;
?? ??? ?return this.name.equals(s.name) && this.age==s.age;
?? ?}
?? ?public String getName(){
?? ??? ?return name;
?? ?}
?? ?public int getAge(){
?? ??? ?return age;
?? ?}
?? ?public String toString(){
?? ??? ?return name+":"+age;
?? ?}
}
class? MapTest{
?? ?public static void main(String[] args) {
?? ??? ?HashMap<Student,String> hm = new HashMap<Student,String>();
?? ??? ?hm.put(new Student("lisi1",21),"beijing");
?? ??? ?hm.put(new Student("lisi1",21),"tianjin");
?? ??? ?hm.put(new Student("lisi2",22),"shanghai");
?? ??? ?hm.put(new Student("lisi3",23),"nanjing");
?? ??? ?hm.put(new Student("lisi4",24),"wuhan");
?? ??? ?//第一種取出方式 keySet
?? ??? ?Set<Student> keySet = hm.keySet();
?? ??? ?Iterator<Student> it = keySet.iterator();
?? ??? ?while(it.hasNext()){
?? ??? ??? ?Student stu = it.next();
?? ??? ??? ?String addr = hm.get(stu);
?? ??? ??? ?System.out.println(stu+".."+addr);
?? ??? ?}
?? ??? ?//第二種取出方式 entrySet
?? ??? ?Set<Map.Entry<Student,String>> entrySet = hm.entrySet();
?? ??? ?Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();?? ?
?? ??? ?while(iter.hasNext()){
?? ??? ??? ?Map.Entry<Student,String> me = iter.next();
?? ??? ??? ?Student stu = me.getKey();
?? ??? ??? ?String addr = me.getValue();
?? ??? ??? ?System.out.println(stu+"........."+addr);
?? ??? ?}
?? ?}
}
——————————?ASP.Net+Android+IOS開發(fā)、.Net培訓、期待與您交流！——————————
?詳細請查看：http://edu.csdn.net?轉(zhuǎn)載于:https://www.cnblogs.com/In-order-to-tomorrow/p/3528532.html
總結(jié)
以上是生活随笔為你收集整理的黑马程序员_java基础笔记(06)...集合的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： error: Microsoft Vis
- 下一篇： 汇编语言：汇编程序的hello worl