面向?qū)ο?泛型
沒有泛型存在的問題
1.往集合當(dāng)中存儲(chǔ)元素,可以存儲(chǔ)任何類型元素
List list = new ArrayList();
list.add(1);
list.add("a");
取出來的都是Object類型
Object obj = list.get(1);
現(xiàn)在想要使用字符串當(dāng)中的特有的方法,必須得要轉(zhuǎn)回來
String str= (String)obj;
str.substring(0, 1);
2.沒有辦法約束集合當(dāng)中只能存儲(chǔ)某一種類型
3.如:設(shè)計(jì)一個(gè)類 點(diǎn)(point x,y)
想要傳入多個(gè)不一樣類型,同樣參數(shù)的,就需要用到泛型
class Point{
private String x;
private String y;
private Integer x1;
private Integer y1;
private Double x2;
private Double y2;
}
泛型定義
什么是泛型?
廣泛通用的類型 (一開始還不清楚是什么類型,在使用的時(shí)候,才能確定是什么類型)
代碼模塊中類型不確定,誰調(diào)用該段代碼,誰就可以來指明這個(gè)類型
定義時(shí)分為兩步
1.在類的后面<> T:代表不確定的類型,在創(chuàng)建對象的時(shí)候,才確定是什么類型
T:type E:element K:key
class Point<T>{
1.可以是字符串類型
2.Integer
3.Double
2.在變量的前面添加上一個(gè) T
把點(diǎn)定義為泛型
T x;
T y;
}
創(chuàng)建對象的時(shí)候并沒有聲明泛型是什么類型
如果沒有指明泛型的類型,它就是Object類型,沒使用泛型,什么類型都能傳進(jìn)去
Point<String> p = new Point<String>();
p.x="10";
p.y="20";
在創(chuàng)建對象指明泛型,這個(gè)類型可以是任意的類型(只能是引用類型)
?
Point<Integer> p2 = new Point<Integer>();
p2.x=10;
p2.y=20;
集合使用泛型的好處
規(guī)定集合當(dāng)中只能存放String類型 (不能是基本數(shù)據(jù)類型,必須得要引用類型)
ArrayList<String> list = new ArrayList<String>();
list.add("my");
list.add("abc");
//list.add(10); 加了泛型以后,在編譯的時(shí)候就報(bào)錯(cuò)了
集合如果沒有指定泛型,取出來的元素都是Object
for (Object obj : list) {
String str = (String) obj;
System.out.println(str.length());
}
for (String str : list) {定義了泛型,就不需要再去強(qiáng)轉(zhuǎn)
System.out.println(str.length());
}
泛型使用注意點(diǎn)及本質(zhì)
泛型注意點(diǎn):
1.泛型前后類型必須得要一致
2.從java 1.7開始,后面的類型可以不寫 new ArrayList<>();菱形語法
3.泛型是沒有繼承的
//錯(cuò)誤的寫法 ArrayList<Object> list = new ArrayList<String>();
4.泛型其實(shí)是一個(gè)語法糖 (本質(zhì)還是Object 內(nèi)部其實(shí)還是要進(jìn)行強(qiáng)轉(zhuǎn)的)
Point<String> p1 = new Point<>();
p1.x = "20";
p1.y = "10";
System.out.println(p1.getY());//里面會(huì)進(jìn)行強(qiáng)轉(zhuǎn)
自定義泛型方法
class Test<T>{
T name;
public T getName() {
return name;
}
}
自定義泛型方法
方法當(dāng)中定義的泛型,是在使用方法時(shí),參數(shù)傳遞確定具體是什么類型
方法想要單獨(dú)使用泛型,必須得要有參數(shù)才有意義
class Student {
<T> void test(T a) {
System.out.println(a.getClass());
}
自定義方法也可以自定義泛型
static <E> void test2(E name) {
System.out.println(name.getClass());
}
添加泛型返回值
static <E> E test3(E name) {
System.out.println(name.getClass());
return name;//需要用傳入什么類型就用什么類型來接收
}
}
1.泛型類:在類上面定義的泛型,在創(chuàng)建對象的時(shí)候,要指明泛型的類型
Test<String> t = new Test<String>();
Test<Integer> t1 = new Test<Integer>();
泛型當(dāng)中定義的泛型只能用在普通方法上面
不能使用在靜態(tài)方法上面
因?yàn)殪o態(tài)方法是直接使用類名調(diào)用,泛型是在創(chuàng)建對象的時(shí)候,才去指定類型
2.泛型方法:就是在方法上面添加了泛型
單獨(dú)對一個(gè)方法上面聲明泛型
方法當(dāng)中定義的泛型
new Student().test("adf");
Student.test2(12);
Integer i = Student.test3(12);
System.out.println(i);//class java.lang.Integer
泛型通配符
通配符:不知道使用什么類型來接收的時(shí)候,可以用?來表示未知
List<Integer> list = new ArrayList<>();
test(list);
只用來接收使用
不能做添加操作
List<?> list2 = new ArrayList<>();
list2.add("a");
泛型的上限和下限
泛型的的上限:用來限定元素的類型必須繼承指定類型(Number的子類)<指定類型或者指定類型的子類>
static void test(List<? extends Number> list) {
}
需要用正確的類型接收指定繼承的類型
List<Integer> list = new ArrayList<>();
test(list);
List<String> list2 = new ArrayList<>();
test(list2);//不是繼承Number,報(bào)錯(cuò)
泛型的的下限:用來限定元素的類型必須繼承指定類型(Number的父類)<指定類型或者指定類型的父類>
static void test2(List<? super Number> list) {
}
List<Number> list3 = new ArrayList<>();
//List<Object> list3 = new ArrayList<>(); 可以
test(list3);//可以接收Number 的 父類和它自己類型本身
泛型擦除
泛型擦除(把泛型去除)
List<String> list = new ArrayList<>();
list.add("a");//定義了泛型,類型限定了傳參
List list2 = null;
list2 = list ;//把list當(dāng)中的泛型擦除掉,沒有了泛型
list2.add(10);
list2.add("aaa");//什么類型都能放進(jìn)去,編譯過后也是這樣,變成了Object類型
List與數(shù)組的互相轉(zhuǎn)換
數(shù)組轉(zhuǎn)成集合
int[] arr = { 10, 20, 30 };
List list = Arrays.asList(arr);//---->List<int[]> list = Arrays.asList(arr);泛型類型:數(shù)組
運(yùn)行時(shí)報(bào)錯(cuò),數(shù)組轉(zhuǎn)換為集合并不能添加元素
list.add(10);//報(bào)錯(cuò)
那為什么要轉(zhuǎn)為集合呢?因?yàn)檗D(zhuǎn)過之后,可以面向?qū)ο蟮姆绞絹聿僮鲾?shù)組(除了不能添加和刪除元素之外,集合當(dāng)中的其他東西都是可以使用的)
@SafeVarargs
@SuppressWarnings("varargs")
public static <T>方法泛型 List<T>返回一個(gè)傳入什么類型的List asList(T...可變參數(shù),本質(zhì)是一個(gè)數(shù)組 a) {
return new ArrayList<>(a);
}
基本數(shù)據(jù)類型,轉(zhuǎn)成集合時(shí),是把基本數(shù)據(jù)類型的數(shù)組,當(dāng)作是一個(gè)對象
在開發(fā)當(dāng)中不會(huì)把基本數(shù)據(jù)類型數(shù)組轉(zhuǎn)成集合,沒意義
System.out.println(list.size());//1 int[] arr = { 10, 20, 30 };
引用數(shù)據(jù)類型的數(shù)組才去轉(zhuǎn)成集合
Integer[] arr2 = { 10, 20, 30 };
List list2 = Arrays.asList(arr2);//---->List<Integer> list2 = Arrays.asList(arr2);泛型類型:對象
System.out.println(list2);//[10, 20, 30]
System.out.println(list2.size());//3
集合轉(zhuǎn)數(shù)組
List<String> list3 = new ArrayList<>();
list3.add("a");
list3.add("b");
list3.add("c");
Object[] o = list3.toArray();//以前Object數(shù)組轉(zhuǎn)法
String[] strArr = list3.toArray(new String[0]);
//靜態(tài)開辟空間,如果開辟的空間少于size,會(huì)自動(dòng)的創(chuàng)建一個(gè)和size一樣空間大小
System.out.println(Arrays.toString(strArr));//[a, b, c]
String[] strArr2 = list3.toArray(new String[10]);
//<T> T[] toArray(T[] a);
System.out.println(Arrays.toString(strArr2));
//[a, b, c, null, null, null, null, null, null, null]
集合嵌套集合
需求:學(xué)科擔(dān)綱總有很多班級,班級當(dāng)中又有很多學(xué)生
public static void main(String[] args) {
Person per1 = new Person("zs");
Person per2 = new Person("ls");
//班級1
List<Person> c1 = new ArrayList<>();
c1.add(per1);
c1.add(per2);
Person per3 = new Person("zs1");
Person per4 = new Person("ls2");
//班級2
List<Person> c2 = new ArrayList<>();
c2.add(per3);
c2.add(per4);
//學(xué)科(集合當(dāng)中又存儲(chǔ)集合)
List<List<Person>> x = new ArrayList<>();
x.add(c1);
x.add(c2);
//把所有班級當(dāng)中的學(xué)生姓名打印出來
for (List<Person> g : x) {
//取出每一個(gè)班級
for (Person person : g) {
System.out.println(person.name);
}
}
}
Set集合特性演示
set當(dāng)中存的元素是無序的,里面沒有重復(fù)的元素
set已經(jīng)覆蓋了toString方法
HashSet<String> hs = new HashSet<>();
boolean res1 = hs.add("a");
boolean res2 = hs.add("a");//添加不成功
hs.add("b");
hs.add("c");
hs.add("1");
System.out.println(res1);//true
System.out.println(res2);//false
System.out.println(hs);//[a, 1, b, c]無序存放排列
Iterator it = hs.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}//a 1 b c
能夠使用迭代器都可以使用增強(qiáng)for循環(huán)(foreach)
for (String str : hs) {
System.out.println(str);
}
Set自定義對象相等判斷
想要在Set中自定義對象中去重
1.覆蓋equals方法
2.覆蓋hasCode方法
? 如果兩個(gè)自定義對象,屬性完全相同,那么就判定你是同一個(gè)對象
public class Demo1 {
public static void main(String[] args) {
Set<Person> s =new HashSet<>();
s.add(new Person("zs",19));
s.add(new Person("zs",19));
s.add(new Person("ls",30));
s.add(new Person("ls",30));
s.add(new Person("ls",30));
System.out.println(s.toString());//[Person [name=zs, age=19], Person [name=ls, age=30]]
}
}
class Person{
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override//覆蓋toString方法
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override//覆蓋hashCode
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//覆蓋equals
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) 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;
}
}
hashCode
每一個(gè)對象都會(huì)有一個(gè)hashCode
hashCode就是跟內(nèi)存地址對應(yīng)的一個(gè)編號
編號就是對應(yīng)你內(nèi)存的地址
每一個(gè)對象的hashCode都是不一樣的
Cat c = new Cat("mm");
System.out.println(c);
System.out.println(c.hashCode());
不覆蓋hashCode會(huì)幫你生成一個(gè)唯一的值
@Override
public int hashCode() {
return 10;
}
HashSet去重原理分析
class Cat {
String name;
Cat(String name) {
this.name = name;
}
// 不覆蓋hashCode會(huì)幫你生成一個(gè)唯一的值(每次生成的值都不一樣)
/*@Override
* public int hashCode() {
System.out.println("執(zhí)行了hashCode");
return 10;
}
public boolean equals(Object obj) {
System.out.println("執(zhí)行了equals");
return false;
}*/
選擇系統(tǒng)覆蓋hashCode和equals方法
@Override
public int hashCode() {
//如果屬性相同,返回相同的hashCode
//屬性不同,hashCode就不相同
final int prime = 31;
int result = 1;
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;
Cat other = (Cat) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
Cat c1 = new Cat("mm");
Cat c2 = new Cat("mm");
Set<Cat> s = new HashSet<>();
添加一個(gè)對象時(shí),會(huì)調(diào)用對象的hashCode
hashCode不相同的時(shí)候,c2對象和集合當(dāng)中的hashCode不相同,就不會(huì)調(diào)用equals
當(dāng)hashCode值相同的時(shí)候才會(huì)去調(diào)用equals方法 如果equals返回為true,就不添加到集合當(dāng)中
s.add(c1);
s.add(c2);
System.out.println(s);//equals為false的時(shí)候,會(huì)添加元素進(jìn)去[集合.泛型.Cat@a, 集合.泛型.Cat@a]
LinkedHashSet
LinkedHashSet是HashSet的子類
它底層是用鏈表實(shí)現(xiàn)的,它是set集合當(dāng)中,唯一一個(gè)保證元素是怎么存怎么取出來的
HashSet 能夠保證元素的唯一性
HashSet<String> set1 = new HashSet<>();
set1.add("a");
set1.add("b");
set1.add("1");
set1.add("e");
System.out.println(set1);//使用普通的HashSet,順序會(huì)掉亂[a, 1, b, e]
LinkedHashSet<String> set2 = new LinkedHashSet<>();
set2.add("a");
set2.add("1");
set2.add("c");
set2.add("e");
System.out.println(set2);//[a, 1, c, e]
生成1到20之間不重復(fù)的隨機(jī)數(shù)
獲取十個(gè)隨機(jī)數(shù)
不允許有重復(fù)
//1.使用Random來生成隨機(jī)數(shù) 創(chuàng)建Random
Random r = new Random();
//2.創(chuàng)建存放生成結(jié)果的集合,HashSet
HashSet<Integer> hs = new HashSet<>();
//3.當(dāng)HashSet.size大于10的時(shí)候,就不放,否則一直生成往里面放
while(hs.size()<10) {
//4.生成1到20之間的隨機(jī)數(shù)
int res = r.nextInt(20)+1;//nextInt(20)生成的是0-19的隨機(jī)整數(shù)
//5.添加到集合當(dāng)中
hs.add(res);
}
System.out.println(hs);//[1, 17, 18, 3, 5, 6, 7, 11, 12, 15]
去除重復(fù)字符串練習(xí)
//aaabbbccc
//abc
//1.獲取從鍵盤上輸入的字符串
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個(gè)字符串:");
String line = sc.nextLine();
//2.拿字符串當(dāng)中的每一個(gè)字符
char[] arr = line.toCharArray();
System.out.println(Arrays.toString(arr));
//3.取出每一個(gè)元素,添加到一個(gè)可以去重的集合當(dāng)中
LinkedHashSet<Character> hs = new LinkedHashSet<>();
for(int i = 0 ; i<arr.length;i++) {
char c = arr[i];//取出數(shù)組當(dāng)中的所有元素
hs.add(c);
}
TreeSet
Tree它是無序的(不是按照你添加的順序展示的)
對添加的元素進(jìn)行排序
TreeSet是用來對元素進(jìn)行排序,里面也是可以保證元素唯一
//按數(shù)字排序
TreeSet<Integer> set = new TreeSet<Integer>();
set.add(10);
set.add(2);
boolean res = set.add(2);
System.out.println(res);//false
set.add(9);
set.add(6);
System.out.println(set);//[2, 6, 9, 10]
//按字母排序
TreeSet<String> set2 = new TreeSet<String>();
set2.add("a");
set2.add("b");
set2.add("d");
set2.add("c");
set2.add("g");
System.out.println(set2);//[a, b, c, d, g]
//漢字是按照unicode-->里面已經(jīng)包含了Assic碼
TreeSet<String> set3 = new TreeSet<String>();
set3.add("我");
set3.add("的");
set3.add("名");
set3.add("字");
System.out.println(set3);//[名, 字, 我, 的]
System.out.println('我' + 0);//25105
System.out.println('的' + 0);//30340
System.out.println('名' + 0);//21517
System.out.println('字' + 0);//23383
//按字母排序,比較了前面,前面相同再比后面
TreeSet<String> set4 = new TreeSet<String>();
set4.add("aa");
set4.add("ac");
set4.add("aba");
System.out.println(set4);//[aa, aba, ac]
TreeSet添加自定義對象
class Person implements Comparable<Person>{
String name;
int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
//如果返回0的話,只添加一個(gè)元素
//如果是一個(gè)正數(shù),都能添加到集合當(dāng)中,順序怎么添加的,怎么顯示
//如果是一個(gè)負(fù)數(shù),順序怎么添加的,倒序顯示(第一個(gè)添加的,顯示到最后)
@Override
public int compareTo(Person o) {
return -1;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class Demo1 {
public static void main(String[] args) {
//TreeSet當(dāng)中存放的類型必須得是同一類型
//TreeSet set = new TreeSet<>();
//set.add(10);
//set.add("a");
//自定義對象不能直接添加到TreeSet當(dāng)中
//想要添加到TreeSet當(dāng)中必須得要遵守一定的規(guī)則
//實(shí)現(xiàn)接口(Comparable)
//還得覆蓋當(dāng)中的compareTo方法
TreeSet<Person> set = new TreeSet<>();
set.add(new Person("zs",20));
set.add(new Person("ls",21));
set.add(new Person("ww",22));
set.add(new Person("zl",23));
System.out.println(set);
//retrun為0的時(shí)候,[Person [name=zs, age=20]]只能顯示頭個(gè)元素
//把return的結(jié)果改為任何一個(gè)正數(shù),能全部顯示在集合當(dāng)中
}
}
TreeSet二叉樹原理分析
二叉樹:在數(shù)據(jù)結(jié)構(gòu)中,就像一棵樹發(fā)叉,根節(jié)點(diǎn)線下衍生子節(jié)點(diǎn),一個(gè)節(jié)點(diǎn)發(fā)兩個(gè)叉
TreeSet自定義對象屬性排序
想要進(jìn)行自定義對象排序,對象必須實(shí)現(xiàn)接口Comparable,覆蓋comparaTo方法
class Person implements Comparable<Person> {
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person obj) {
//進(jìn)行年齡排序
int num = this.age - obj.age;//this.age當(dāng)前的age,減去下一個(gè)傳入來的age的值
/*if (num == 0) {//如果num的值為0
return this.name.compareTo(obj.name);//再進(jìn)行名字的比較
} else {
return num;//非0直接返回num值
}*/
return num == 0 ? this.name.compareTo(obj.name): num;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
需要進(jìn)行年齡排序
TreeSet<Person> set = new TreeSet<>();
set.add(new Person("張三", 20));
set.add(new Person("李四", 25));
set.add(new Person("王五", 22));
set.add(new Person("趙六", 21));
set.add(new Person("趙六1", 21));
System.out.println(set);
//[Person [name=張三, age=20], Person [name=趙六, age=21], Person [name=趙六1, age=21], Person [name=王五, age=22], Person [name=李四, age=25]]
TreeSet比較器
默認(rèn)情況下,比較是會(huì)調(diào)用對象的compareTo進(jìn)行比較
如果傳入了比較器,就不會(huì)調(diào)用compareTo,就會(huì)使用你傳入的比較器進(jìn)行比較
默認(rèn)是使用字母的順序進(jìn)行比較的(compareTo)
TreeSet<String> set = new TreeSet<String>();
set.add("aaaaa");
set.add("z");
set.add("wc");
set.add("wc");
set.add("wzb");
set.add("nba");
System.out.println(set);
//使用比較器進(jìn)行比較,比較字符串的長度排序
//1.實(shí)現(xiàn)一個(gè)接口comparator
//2.定義一個(gè)類來去實(shí)現(xiàn)這個(gè)接口
//3.覆蓋它里面的方法
TreeSet<String> set2 = new TreeSet<String>(new ComparaLength());//需要傳入比較器對象
set2.add("aaaaa");
set2.add("z");
set2.add("wc");
set2.add("wc");
set2.add("wzb");
set2.add("nba");
System.out.println(set2);//[z, wc, nba, wzb, aaaaa]
class ComparaLength implements Comparator<String>{
@Override
//1.代表當(dāng)前正在添加的對象
//2.代表集合當(dāng)中的對象
public int compare(String o1, String o2) {
System.out.println("調(diào)用了比較器當(dāng)中的compare");
int lenght = o1.length() - o2.length();//主要是比長度
return lenght == 0 ?o1.compareTo(o2):lenght ;//如果長度相等,再去比內(nèi)容
}
}
Map映射關(guān)系概述
Map:映射關(guān)系
A集合 B集合 (ArrayList LinkedList Vector HashSet LinkedHashSet TreeSet)
A集合當(dāng)中的元素不能重復(fù)(Set),A集合當(dāng)中的每一個(gè)元素稱它是一個(gè)Key
A集合當(dāng)中的每一個(gè)元素,都可以在B集合當(dāng)中找到一個(gè)唯一的一個(gè)值與之對應(yīng)
B集合當(dāng)中的元素可以重復(fù)(list),B集合當(dāng)中的每一個(gè)元素稱它是一個(gè)Value
Map當(dāng)作是一個(gè)字典(dict)
Key-Value(entry)
Map添加元素
往AB兩個(gè)集合當(dāng)中添加元素,并且關(guān)聯(lián)在一起(value會(huì)跟著key走)
map當(dāng)中的元素并不是有序的
key1=value1 entry鍵值對
Map<String,Object> map = new HashMap<String,Object>();
map.put("key1", "value1");
map.put("key2", "value2");
map.put("key3", "value3");
map.put("key4", "value4");
map.put("key5", "value5");
System.out.println(map);//{key1=value1, key2=value2, key5=value5, key3=value3, key4=value4}
//獲取A集合
Set<String> set = map.keySet();
System.out.println(set);//[key1, key2, key5, key3, key4]
//獲取B集合
Collection<Object> values= map.values();
System.out.println(values);//[value1, value2, value5, value3, value4]
Map修改元素
Map<String,Object> map = new HashMap<>();
//添加功能
Object res1 = map.put("張三", 20);
Object res2 = map.put("李四", 21);
Object res3 = map.put("王五", 22);
System.out.println(map);//{李四=21, 張三=20, 王五=22}
//如果Key值是第一次添加,返回值就是null
System.out.println(res1);
System.out.println(res2);
System.out.println(res3);//null
//添加的Key并不是第一次存在,就用value把以前的值給替換掉,返回以前的值
Object res4 = map.put("張三", 30);
System.out.println(map);//{李四=21, 張三=30, 王五=22}
System.out.println(res4);//20
Map常用方法
1.添加功能
2.刪除功能
//2.1可以根據(jù)key來刪除元素(key-value)
map.remove("張三");//{李四=21, 王五=22}
System.out.println(map);
//2.2清空map當(dāng)中所有的key-value
map.clear();
System.out.println(map);//{} 里面一個(gè)元素都沒有了
//3.長度功能,查看有幾個(gè)鍵值對
//map當(dāng)中有幾個(gè)key-value
System.out.println(map.size());//0
Map獲取元素及遍歷元素
// 雙列集合
Map<String, Object> map = new HashMap<>();
Object res1 = map.put("張三", 20);
Object res2 = map.put("李四", 21);
Object res3 = map.put("王五", 22);
獲取元素
1.獲取一個(gè)元素
根據(jù)相關(guān)的key可以獲取相關(guān)聯(lián)的value
Object values = map.get("張三");
System.out.println(values);// 20
2.獲取所有元素(遍歷)
map當(dāng)中是沒有迭代器,集合沒有迭代器,你就不能用快速遍歷(foreach)
// 取出所有的key
Set<String> allKeys = map.keySet();//map.keySet() 獲取全部key返回Set裝
Iterator<String> it = allKeys.iterator();
while (it.hasNext()) {
// 取出key值
String key = it.next();
Object val = map.get(key);
System.out.println( key + "="+val);
//李四=21,張三=20,王五=22
}
//set能使用迭代器,就能使用foreach
for (String key : allKeys) {
System.out.println(key+"="+map.get(key));
}
Map通過entry對象遍歷元素
// 雙列集合
Map<String, Object> map = new HashMap<>();
Object res1 = map.put("張三", 20);
Object res2 = map.put("李四", 21);
Object res3 = map.put("王五", 22);
//獲取所有的key-value對象entry
Set<Map.Entry<K, V>> set = map.entrySet();
