雙列集合：

------------------| Map　　如果是實現了Map接口的集合類，具備的特點是：存儲的數據都是以鍵值對的形式存在的鍵不可重復，值可以重復

----------------------| HashMap

----------------------| TreeMap

----------------------| Hashtable

?

Map集合的方法：

添加：
　　put(K key, V value)
　　putAll(Map<? extends K,? extends V> m)

public class Demo2 {public static void main(String[] args) {// TODO Auto-generated method stubMap<String, String> map=new HashMap<String,String>();//添加方法map.put("汪峰", "章子怡");map.put("文章", "馬伊琍");map.put("許一清", "沈某");System.out.println("返回值:"+map.put("許一清", "宋某"));//如果之前沒有存在該鍵，那么返回的是null，如果之前就已經存在該鍵了，那么就返回之前該鍵對應的值map.put("狗娃", "宋某");System.out.println("集合的元素是:"+map);Map<String, String> map2=new HashMap<String,String>();map2.put("系綜", "彭總");map2.put("狗蛋", "郝某");map.putAll(map2);//把map2的元素添加到map集合中 System.out.println("集合的元素:"+map);}}結果： 返回值:沈某 集合的元素是:{狗娃=宋某, 文章=馬伊琍, 汪峰=章子怡, 許一清=宋某} 集合的元素:{狗娃=宋某, 文章=馬伊琍, 狗蛋=郝某, 汪峰=章子怡, 許一清=宋某, 系綜=彭總}

刪除:
　　　　remove(Object key) 　　　　 根據鍵刪除一條map中的數據，返回的是其對應的值
　　　　clear() 　　　　 清空集合的元素數據

獲取：
　　get(Object key)　　根據鍵獲取對應的值
　　size()　　　　獲取map集合中鍵值對的個數

判斷：
　　containsKey(Object key)　　　　　　判斷map集合是否包含指定的鍵
　　containsValue(Object value) 　　　　判斷map集合是否包含指定的值

　　isEmpty()　　　　判斷map是否為空

null可以作為鍵和值存入集合

迭代：
　　keySet()
　　values()
　　entrySet()

public class Demo2 {public static void main(String[] args) {// TODO Auto-generated method stubMap<String, String> map=new HashMap<String,String>();//添加方法map.put("汪峰", "章子怡");map.put("文章", "馬伊琍");map.put("許一清", "沈某");//System.out.println("返回值:"+map.put("許一清", "宋某"));//如果之前沒有存在該鍵，那么返回的是null，如果之前就已經存在該鍵了，那么就返回之前該鍵對應的值map.put("狗娃", "宋某");//添加方法/*Map<String, String> map2=new HashMap<String,String>();map2.put("系綜", "彭總");map2.put("狗蛋", "郝某");map.putAll(map2);//把map2的元素添加到map集合中 */ //System.out.println("集合的元素:"+map);System.out.println("根據指定的鍵獲取對應的值:"+map.get("文章"));System.out.println("map集合中鍵值對的個數:"+map.size());System.out.println(map.isEmpty());System.out.println("集合的元素是:"+map);map.remove("狗娃");map.clear();System.out.println("集合的元素是:"+map);}}結果： 根據指定的鍵獲取對應的值:馬伊琍 map集合中鍵值對的個數:4 false 集合的元素是:{狗娃=宋某, 文章=馬伊琍, 汪峰=章子怡, 許一清=沈某} 集合的元素是:{}

?Map的三種遍歷方式：

package cn.itcast.map;import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set;/*迭代：keySet() 把map集合中的所有鍵都保存到一個Set類型的集合對象中返回 缺點：keySet方法只是返回了所有的鍵，沒有值values() 把所有的值存儲到一個Collection集合中返回 缺點：values方法只能返回所有的值，沒有鍵entrySet()*/ public class Demo3 {public static void main(String[] args) {// TODO Auto-generated method stubMap<String, String> map=new HashMap<String,String>();//添加方法map.put("汪峰", "章子怡");map.put("文章", "馬伊琍");map.put("許一清", "沈某");map.put("成龍", "林鳳嬌");//map集合中遍歷方式一：使用keySet方法進行遍歷Set<String> keys=map.keySet();Iterator<String> it=keys.iterator();while (it.hasNext()) {String key=it.next();System.out.println("鍵:"+key+" 值:"+map.get(key));}//map集合的遍歷方式二：使用values方法進行遍歷Collection<String> c=map.values();Iterator<String> it2=c.iterator();while (it2.hasNext()) {System.out.println("值:"+it2.next());}//map集合的遍歷方式三： 使用entrySet方法進行遍歷Set<Map.Entry<String,String>> entrys=map.entrySet();Iterator<Map.Entry<String,String>> it3=entrys.iterator();while (it3.hasNext()) {Map.Entry<String,String> entry=it3.next();System.out.println("鍵:"+entry.getKey()+" 值:"+entry.getValue());}}}結果： 鍵:文章 值:馬伊琍 鍵:成龍 值:林鳳嬌 鍵:汪峰 值:章子怡 鍵:許一清 值:沈某 值:馬伊琍 值:林鳳嬌 值:章子怡 值:沈某 鍵:文章 值:馬伊琍 鍵:成龍 值:林鳳嬌 鍵:汪峰 值:章子怡 鍵:許一清 值:沈某

HashMap：底層也是基于哈希表實現的

HashMap的存儲原理：

　　　　往HashMap添加元素的時候，首先會調用鍵的hashCode方法，得到元素的哈希碼值，然后經過運算就可以算出該元素在哈希表中的存儲位置

情況一：如果算出的位置目前沒有任何元素存儲，那么該元素可以直接添加到哈希表中

情況二：如果算出的位置目前已經存在其他的元素，那么還會調用該元素d的equals方法與這個位置上的元素進行比較，如果equals方法返回的是false，那么該元素允許被存儲，如果equals方法返回的是true，那么該元素被視為c重復元素，不允許存儲

package cn.itcast.map;import java.util.HashMap;public class Demo5 {public static void main(String[] args) {// TODO Auto-generated method stubHashMap<Person, String> map=new HashMap<Person,String>();map.put(new Person(110, "狗娃"), "001");map.put(new Person(220, "狗剩"), "002");map.put(new Person(330, "鐵蛋"), "003");map.put(new Person(110, "狗娃"), "007");//如果出現了相同的鍵，那么后添加的數據的值會取代之前的值。System.out.println("集合的元素:"+map);}} class Person {int id;String name;public Person(int id, String name) {super();this.id = id;this.name = name;}@Overridepublic String toString() {// TODO Auto-generated method stubreturn "[編號："+this.id+" 姓名："+this.name+"]";}@Overridepublic int hashCode() {// TODO Auto-generated method stubreturn this.id;}@Overridepublic boolean equals(Object obj) {// TODO Auto-generated method stubPerson p=(Person)obj;return this.id==p.id;} }結果： 集合的元素:{[編號：330 姓名：鐵蛋]=003, [編號：220 姓名：狗剩]=002, [編號：110 姓名：狗娃]=007}

TreeMap：TreeMap也是基于紅黑樹（二叉樹）數據結構實現的，特點：會對元素的鍵進行排序存儲

?TreeMap要注意的事項：

往TreeMap添加元素的時候，如果元素的鍵具備自然順序，那么就會按照鍵的自然順序特性進行排序存儲

往TreeMap添加元素的時候，如果元素的鍵不具備自然順序特性，那么鍵所屬的類必須要實現Comparable接口，把鍵的比較規則定義在CompareTo方法上

往TreeMap添加元素的時候，如果元素的鍵不具備自然順序特性，而且鍵所屬的類也沒有實現Comparable接口，那么就必須在創建TreeMap對象的時候傳入比較器

package cn.itcast.map;import java.util.Comparator; import java.util.TreeMap;public class Demo6 {public static void main(String[] args) {// TODO Auto-generated method stub/*TreeMap<Character, Integer> tree=new TreeMap<Character,Integer>();tree.put('c', 10);tree.put('b', 2);tree.put('a', 5);tree.put('h', 12);System.out.println(tree);*///創建一個自定義比較器MyComparator comparator=new MyComparator();TreeMap<Emp, String> tree=new TreeMap<Emp,String>(comparator);tree.put(new Emp("冰冰", 2000), "001");tree.put(new Emp("家寶", 1000), "002");tree.put(new Emp("大總", 3000), "003");tree.put(new Emp("克己", 5000), "005");tree.put(new Emp("克人", 5000), "008");//相同的不會取代，但是值會取代 System.out.println(tree);}} class Emp {//implements Comparable<Emp>{ String name;int salary;public Emp(String name, int salary) {super();this.name = name;this.salary = salary;}@Overridepublic String toString() {// TODO Auto-generated method stubreturn "[姓名："+this.name+" 薪水："+this.salary+"]";}/*@Overridepublic int compareTo(Emp o) {// TODO Auto-generated method stubreturn this.salary-o.salary;}*/ } class MyComparator implements Comparator<Emp> {@Overridepublic int compare(Emp o1, Emp o2) {// TODO Auto-generated method stubreturn o1.salary-o2.salary;}}結果： {[姓名：家寶 薪水：1000]=002, [姓名：冰冰 薪水：2000]=001, [姓名：大總 薪水：3000]=003, [姓名：克己 薪水：5000]=008}

?需求：定義一個TreeMap，鍵存儲的是書對象，值存儲的是字符串。根據書的出版日期排序

package cn.itcast.map;import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.TreeMap;/*需求：定義一個TreeMap，鍵存儲的是書對象，值存儲的是字符串。根據書的出版日期排序*/ public class Demo7 {public static void main(String[] args) {// TODO Auto-generated method stubTreeMap<Book, String> map=new TreeMap<Book,String>();//值存儲書名map.put(new Book("紅樓夢","1990-12-03"),"001");map.put(new Book("西游記","1993-08-13"),"002");map.put(new Book("水滸傳","1989-04-03"),"003");map.put(new Book("三國演義","1997-10-04"),"004");System.out.println(map);}} class Book implements Comparable<Book>{String name;String date;//出版日期public Book() {}public Book(String name, String date) {super();this.name = name;this.date = date;}//利用字符串的CompareTo方法進行排序/*@Overridepublic int compareTo(Book o) {// TODO Auto-generated method stubreturn this.date.compareTo(o.date);}*/@Overridepublic String toString() {// TODO Auto-generated method stubreturn "[ 書名："+this.name+" 出版日期："+this.date+"]";}//先把字符串的日期轉換Date對象，然后再使用Date對象進行比較 @Overridepublic int compareTo(Book o) {// TODO Auto-generated method stub//日期格式化類SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd");//使用日期格式化類把字符轉換成Date對象Date date1=null;Date date2=null;try {date1=dateFormat.parse(this.date);date2=dateFormat.parse(o.date);} catch (ParseException e) {// TODO Auto-generated catch block e.printStackTrace();}return date1.compareTo(date2);}}結果： {[ 書名：水滸傳 出版日期：1989-04-03]=003, [ 書名：紅樓夢 出版日期：1990-12-03]=001, [ 書名：西游記 出版日期：1993-08-13]=002, [ 書名：三國演義 出版日期：1997-10-04]=004}

HashTable:底層也是依賴了哈希表實現的，也就是實現方式與HashMap是一致的，但是HashTable是線程安全的，操作效率低。

Collections：

Collections：常見方法：
1， 對list進行二分查找：
　　　//前提該集合一定要有序。
　　　　int binarySearch(list,key);
　　　　int binarySearch(list,key,Comparator);
2，對list集合進行排序。
　　　　sort(list);
　　　　sort(list,comaprator);
3，對集合取最大值或者最小值。
　　　　max(Collection)
　　　　max(Collection,comparator)
　　　　min(Collection)
　　　　min(Collection,comparator)
4，對list集合進行反轉。
　　　　reverse(list);
8，可以將不同步的集合變成同步的集合。
　　　　Set synchronizedSet(Set<T> s)
　　　　Map synchronizedMap(Map<K,V> m)
　　　　List synchronizedList(List<T> list)　　

?

package cn.itcast.util;import java.util.ArrayList; import java.util.Collections;/*集合的工具類(Collections):說出Collection與Collections的區別1.Collection是一個單例集合的根接口，Collections是操作集合對象的一個工具類 Collections：常見方法： 1， 對list進行二分查找：前提該集合一定要有序。int binarySearch(list,key);int binarySearch(list,key,Comparator); 2，對list集合進行排序。sort(list); sort(list,comaprator); 3，對集合取最大值或者最小值。max(Collection)max(Collection,comparator)min(Collection)min(Collection,comparator) 4，對list集合進行反轉。reverse(list); 8，可以將不同步的集合變成同步的集合。Set synchronizedSet(Set<T> s) Collections.synchronizedSet(Set<T> s)會返回一個線程安全的Set集合Map synchronizedMap(Map<K,V> m)List synchronizedList(List<T> list)*/ public class Demo1 {public static void main(String[] args) {// TODO Auto-generated method stubArrayList<Integer> list=new ArrayList<Integer>();list.add(12);list.add(1);list.add(2);list.add(19);//排序 System.out.println(list);Collections.sort(list);System.out.println(list);System.out.println("元素所在的索引值是:"+Collections.binarySearch(list, 12));System.out.println("最大值是:"+Collections.max(list));System.out.println("最小值是:"+Collections.min(list));Collections.reverse(list);System.out.println(list);//System.out.println(list); }}結果： [12, 1, 2, 19] [1, 2, 12, 19] 元素所在的索引值是:2 最大值是:19 最小值是:1 [19, 12, 2, 1] package cn.itcast.util;import java.util.ArrayList; import java.util.Collections; import java.util.Comparator;public class Demo2 {//如果單例集合存儲的都是不具備自然順序的元素，那么排序需要傳入比較器public static void main(String[] args) {// TODO Auto-generated method stubArrayList<Person> list=new ArrayList<Person>();list.add(new Person("狗娃", 12));list.add(new Person("張三", 22));list.add(new Person("鐵蛋", 2));Collections.sort(list, new AgeComparator());System.out.println("集合中的元素:"+list);System.out.println("找到的索引值是:"+Collections.binarySearch(list,new Person("鐵蛋", 2),new AgeComparator()));System.out.println("最大值是:"+Collections.max(list,new AgeComparator()));System.out.println("最小值是:"+Collections.min(list,new AgeComparator()));}} class Person {String name;int age;public Person(String name, int age) {super();this.name = name;this.age = age;}@Overridepublic String toString() {// TODO Auto-generated method stubreturn "{姓名："+this.name+" 年齡："+this.age+"}";} } class AgeComparator implements Comparator<Person> {@Overridepublic int compare(Person o1, Person o2) {// TODO Auto-generated method stubreturn o1.age-o2.age;}}結果： 集合中的元素:[{姓名：鐵蛋 年齡：2}, {姓名：狗娃 年齡：12}, {姓名：張三 年齡：22}] 找到的索引值是:0 最大值是:{姓名：張三 年齡：22} 最小值是:{姓名：鐵蛋 年齡：2}

?Arrays:

1，二分查找,數組需要有序
　　binarySearch(int[])
　　binarySearch(double[])

2，數組排序
　　sort(int[])
　　sort(char[])
2， 將數組變成字符串。
　　toString(int[])

沒學過:
3， 復制數組。
　　copyOf(boolean[] original, int newLength);
　　　　original:源數組
　　　　newLength:新數組的長度
4， 復制部分數組。
　　copyOfRange(byte[] original, int from, int to)
　　　　original:源數組
　　　　from:開始拷貝的索引值
　　　　to:結束的索引值
5， 比較兩個數組元素是否一致。
　　equals(int[],int[]);
6， 將數組變成集合。
　　List asList(T[]);

package cn.itcast.util;import java.util.Arrays; import java.util.List;/*1，二分查找,數組需要有序binarySearch(int[])binarySearch(double[])2，數組排序sort(int[])sort(char[]) 2， 將數組變成字符串。toString(int[])沒學過: 3， 復制數組。copyOf(boolean[] original, int newLength);original:源數組newLength:新數組的長度 4， 復制部分數組。copyOfRange(byte[] original, int from, int to)original:源數組from:開始拷貝的索引值to:結束的索引值 5， 比較兩個數組元素是否一致。equals(int[],int[]); 6， 將數組變成集合。List asList(T[]);*/ public class Demo3 {public static void main(String[] args) {// TODO Auto-generated method stubInteger[] arr= {10,8,6,9};//如果是int類型的話，后面多余的元素會是0，但是如果是Integer的話，后面的元素就是null了Integer[] arr2=Arrays.copyOf(arr, 6);Integer[] arr3=Arrays.copyOfRange(arr, 1, 3);System.out.println("arr2拷貝后的數組元素是:"+Arrays.toString(arr2));System.out.println("arr3拷貝后的數組元素是:"+Arrays.toString(arr3));System.out.println("判斷兩個數組對應位置的元素是否完全一致:"+Arrays.equals(arr, arr2));List<Integer> list=Arrays.asList(arr);//把數組變集合list.toArray(); //把集合變數組System.out.println("集合的元素:"+list);}}結果： arr2拷貝后的數組元素是:[10, 8, 6, 9, null, null] arr3拷貝后的數組元素是:[8, 6] 判斷兩個數組對應位置的元素是否完全一致:false 集合的元素:[10, 8, 6, 9]

?eclipse：

alt+/ 內容補全鍵
Ctrl+1 快速修復鍵
alt+上下方向鍵 移動代碼
tab 整體向右移動
shift+tab 整體向左移動
ctrl+/ 取消或者添加單行注釋
ctrl+shift+f 代碼格式化
ctrl+sgift+o 快速導包
ctrl+d 刪除當前行代碼
ctrl+shift+t 查看源代碼 ctrl+鼠標點擊或者F3

斷點調試
step over 跳過本行代碼
step into 進入方法內部
step return 結束方法，返回數據

?

正則表達式：正則表達式其實就是用于操作字符串的一個規則，正則表達式的規則使用了特殊的符號表示

需求：校驗一個qq號

package cn.itcast.regex; /*正則表達式:需求：校驗一個qq號1.不能以0開頭2.長度5~113.只能由數字組成*/ public class Demo1 {public static void main(String[] args) {// TODO Auto-generated method stubString qq="45122257";
　　　　　//System.out.println(qq.matches("[1-9]\\d{4,10}")?"合法QQ":"非法QQ");if (!qq.startsWith("0")) {if (qq.length()>=5&&qq.length()<=11) {try {Long.parseLong(qq);System.out.println("恭喜你，你得到了一個合法QQ");}catch (Exception e) {System.out.println("非法QQ，QQ號只能由數字組成");}}else {System.out.println("非法QQ，QQ號的長度只能是5~11位");}}else {//以0開頭System.out.println("非法QQ，QQ號不能以0開頭");}}}結果： 恭喜你，你得到了一個合法QQ

?

預定義字符類
. 任何字符（與行結束符可能匹配也可能不匹配）
\d 數字：[0-9]
\D 非數字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 單詞字符：[a-zA-Z_0-9]
\W 非單詞字符：[^\w]

注意：任何預定義字符沒有加上數量詞之前都只能匹配一個字符而已

數量詞：

Greedy 數量詞
X? X，一次或一次也沒有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X，至少 n 次，但是不超過 m 次

?

范圍詞：

[abc] a、b 或 c（簡單類）
[^abc] 任何字符，除了 a、b 或 c（否定）
[a-zA-Z] a 到 z 或 A 到 Z，兩頭的字母包括在內（范圍）
[a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
[a-z&&[def]] d、e 或 f（交集）
[a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（減去）
[a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（減去）

注意：

范圍詞里面不管內容有多長，沒有數量詞的配合都只能匹配一個而已。

package cn.itcast.regex;import java.util.Arrays;/*匹配 matches()切割 split()看有多少組就看有多少對括號，依次從左往右的每一對括號就為第幾組((A)(B(C)))第一組：((A)(B(C)))第二組：(A)第三組：(B(C))第四組：(C)\1 引用第一組所匹配到的內容替換查找*/ public class Demo3 {public static void main(String[] args) {// TODO Auto-generated method stub//需求：編寫一個正則表達式匹配一個手機號matchesPhone("13835026666");matchesTel("020-38325125");testSplit1();testSplit2();}public static void matchesPhone(String phone) {//String reg="1[34578]\\d{9}";System.out.println(phone.matches("1[34578]\\d{9}")?"合法手機號":"非法手機號");}//需求2:匹配固定電話public static void matchesTel(String tel) {System.out.println(tel.matches("0\\d{2,3}-[1-9]\\d{6,7}")?"合法固話":"非法固話");}//按照空格切割public static void testSplit1() {String str="明 天 放 假";String[] datas=str.split(" +");System.out.println("數組的元素:"+Arrays.toString(datas));}//根絕重疊詞進行切割public static void testSplit2() {String str="大家家家明天天玩得得得得得得得得得得得開心";String[] datas=str.split("(.)\\1+");//如果正則的內容需要被復用，那么需要對正則的內容進行分組。分組的目的就是為了提高正則的復用性。組號不能指定，組號是從1開始System.out.println("數組的元素:"+Arrays.toString(datas));} }結果： 合法手機號 合法固話 數組的元素:[明, 天, 放, 假] 數組的元素:[大, 明, 玩, 開心]

?

轉載于:https://www.cnblogs.com/zhangwugai/p/10720513.html

總結

以上是生活随笔為你收集整理的Java学习笔记（17）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。