集合框架
为什么会出现这么多容器？
因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构。
一、为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
二、数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。
三、集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
Collection
Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。
所属关系：
Collection
|--List//元素是有序的，元素可以重复。因为该集合体系有索引。
|--Set//元素是无序的，元素不可以重复。
一、Collection接口中的常见操作
1、添加元素
add(Object obj); //add方法的参数类型是Object。以便于接收任意类型对象。
2、删除元素
remove(Object obj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3、判断元素
contains(Object obj);//判断是否存在obj这个元素
isEmpty();//是否为空
4、获取个数，集合长度
size();
5、取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
注：集合中存储的都是对象的引用（地址）。
package atheima; import java.util.ArrayList; import java.util.Iterator; /** * add方法的参数类型是object ，以便于接收任意类型对象。 * 集合中存储的都是对象的引用或是地址 * * */ public class CollectionDemo { public static void main(String[] args) { method_2(); //method_1(); method_get(); } //取元素 public static void method_get() { ArrayList a1=new ArrayList(); //添加元素 a1.add("hhh"); a1.add("h"); a1.add("hhhh"); Iterator it=a1.iterator(); while(it.hasNext()) { sop(it.next()); } } public static void method_2() { ArrayList a1=new ArrayList(); //添加元素 a1.add("hhh"); a1.add("h"); a1.add("hhhh"); ArrayList a2=new ArrayList(); //添加元素 a2.add("hhh"); a2.add("hh"); a2.add("hh"); //a1.retainAll(a2);//取交集，a1中只会保留和a2中相同的元素 a1.removeAll(a2);//删除和a2相同的元素 sop("a1个数:"+a1); sop("a2个数:"+a2); } public static void method_1() { //创建一个集合容器，使用Collection接口的子类ArrayList ArrayList a1=new ArrayList(); //添加元素 a1.add("hhh"); a1.add("hh"); a1.add("hh"); //打印集合 sop(a1); //删除元素 a1.remove("hhh"); //a1.clear();//清空集合 //判断元素 sop("hh是否存在"+a1.contains("hh"));//--->true sop("集合是否为空？"+a1.isEmpty());//-->false //获取个数，集合长度 sop("size--->"+a1.size()); //打印改变后的集合 sop(a1); } private static void sop(Object obj) { System.out.println(obj); } }
二、迭代
1、什么是迭代器：其实就是集合的取出元素的方式。
对于集合的元素取出这个动作：
当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述。就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都具有共性内容： 判断和取出。那么就可以将这些共性抽取。
那么这些内部类都符合一个规则（或者说都抽取出来一个规则）。该规则就是Iterator。通过一个对外提供的方法：iterator();，来获取集合的取出对象。
因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。
2、迭代的常见操作
hasNext();//有下一个元素，返回真
next();//取出下一个元素
remove();//移除
注：在迭代时循环中next调用一次，就要hasNext判断一次。
使用：
ArrayList a=newArrayList();//创建一个集合
Iteratorit=a.iterator();//获取一个迭代器，用于取出集合中的元素。
第一种打印方式：
for(Iterator iter = a.iterator();iter.hasNext(); )
{
System.out.println(iter.next());
}
第二种打印方式：
Iteratoriter = a.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}
第三讲 List
一、List
组成
List：元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
二、List的特有方法
凡是可以操作角标的方法都是该体系特有的方法。
1、增
boolean add(index,element);//指定位置添加元素
Boolean addAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素
2、删
Boolean remove(index);//删除指定位置的元素
3、改
set(index,element);//修改指定位置的元素。
4、查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5、其他
list Iterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1
注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。
三、ListIterator
1、概述
ListIterator是List集合特有的迭代器，是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException并发修改异常。
如下：
public static void method_get()
{
ArrayList a1=new ArrayList();
//添加元素
a1.add("hhh");
a1.add("h");
a1.add("hhhh");
Iterator it=a1.iterator();
while(it.hasNext())
{
Object obj=it.next();
if (obj.equals("h"))
a1.add("jjj");--------->会发生异常，结果输出hhh，h。。。异常。
System.out.println(obj)
}
}
所以在迭代器时，只能用迭代器的方法操作元素。可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加、修改等，就需要使用其子接口：List Iterrator。该接口只能通过List集合的ListIterator方法获取。
2、ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
四、枚举Enumeration
枚举：
就是Vector特有的取出方式。Vector有三种取出方式。
其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
特有方法：
addElement(obj);//添加元素，相当于add(obj);
Enumerationelements();//Vector特有取出方式(枚举)
hasMoreElements();//相当于Iterator的hasNext()方法
nextElements();//相当于Iterator的next()方法
例：
package atheima; import java.util.Enumeration; import java.util.Vector; public class VerctorDemo { public static void sop(Object obj){ System.out.println(obj); } public static void main(String[] args) { Vector v1=new Vector(); v1.add("hh"); v1.add("hahha"); sop(v1); Enumeration e1=v1.elements(); while (e1.hasMoreElements()) { sop(e1.nextElement()); } } }
五、LinkedList
LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
特有方法：
1、增
addFirst();
addLast();//往尾部放
2、获取
//获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();移除并返回此列表的第一个元素。
removeLast();移除并返回此列表的最后一个元素
在JDK1.6以后，出现了替代方法。
1、增
offerFirst();在此列表的开头插入指定的元素。
offerLast();在此列表末尾插入指定的元素。
2、获取
//获取元素，但是不删除。如果集合中没有元素，会返回null。
peekFirst();获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
peekLast();获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null
3、删
//获取元素，并删除元素。如果集合中没有元素，会返回null。
pollFirst();获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
pollLast(); 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
package atheima; import java.util.Enumeration; import java.util.LinkedList; import java.util.Vector; public class LinkedListDemo { public static void sop(Object obj){ System.out.println(obj); } public static void main(String[] args) { LinkedList link=new LinkedList(); link.addFirst("hh0"); link.addFirst("hh1"); link.addFirst("hh2"); link.addFirst("hh3"); // sop(link);//------>输出结果hh3,hh2,hh1,hh0 // sop(link.getFirst());//---->hh3 // sop(link.getLast());//--->hh0 // sop(link.removeFirst());//--->hh3 // sop("size="+link.size());//--->3 sop(link.offerFirst("hh4"));//--->true sop(link.peekFirst());//--->hh4 sop(link.pollFirst());//-->hh4 while(!link.isEmpty()) { sop(link.removeFirst());//--->hh3,hh2,hh1,hh0 } } }
package atheima; //使用Linkedlist模拟一个队列数据结构 import java.util.Enumeration; import java.util.LinkedList; import java.util.Vector; import org.hamcrest.core.IsNull; class DuiLie { private LinkedList link; public DuiLie() { link=new LinkedList(); } public void myAdd(Object obj) { link.addFirst(obj); } public Object myGet() { return link.removeFirst(); } public boolean isNull() { return link.isEmpty(); } } public class LinkedListDemo1 { //输出 public static void sop(Object obj){ System.out.println(obj); } public static void main(String[] args) { DuiLie link=new DuiLie(); link.myAdd("hh0"); link.myAdd("hh1"); link.myAdd("hh2"); link.myAdd("hh3"); while(!link.isNull()) { sop(link.myGet()); } } }
package atheima; import java.util.ArrayList; import java.util.Iterator; //将自定义对象作为元素存到ArrayList集合中，并去除重复元素 //比如：存人对象，同姓名同年龄，视为同一个人，为重复元素 //思路：对人描述，将数据封装到人的对象，，定义容器，将人存入，，取出 //结论：list集合判断元素是否相同，依据是元素的equa方法 class Person1 { private String name; private int age; 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 boolean equals(Object obj) { if (!(obj instanceof Person1)) return false; Person1 p1=(Person1) obj; return this.name.equals(p1.name)&&this.age==p1.age; } } public class ArrayListTest2 { public static void main(String[] args) { ArrayList link=new ArrayList(); link.add(new Person1("han0", 22)); link.add(new Person1("han1", 22)); link.add(new Person1("han2", 23)); link.add(new Person1("han3", 24)); link.add(new Person1("han4", 25)); link.add(new Person1("han4", 25)); link=singleElement(link);//去除重复的元素 Iterator it=link.iterator(); while(it.hasNext())//遍历新的集合元素 { Object obj=it.next(); Person1 p=(Person1) obj; sop(p.getName()+"..."+p.getAge()); } } public static ArrayList singleElement(ArrayList link) { //定义一个临时容器 ArrayList newAl=new ArrayList(); Iterator it= link.iterator(); //遍历原有的容器 while(it.hasNext()) { Object obj=it.next(); if(!newAl.contains(obj))//如果新容器中的元素不包含原有的元素，就添加新的元素进入新容器中。 newAl.add(obj); } return newAl; } //输出 public static void sop(Object obj) { System.out.println(obj); } }
第四讲 Set
一、概述
Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
|--HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。如果不相同，不会判断equals。
|--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。
Set集合的功能和Collection是一致的。
二、HasSet
HashSet：线程不安全，存取速度快。
可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。
注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
package atheima; import java.util.HashSet; import java.util.Iterator; //将自定义对象作为元素存到HashSet集合中，并去除重复元素 //比如：存人对象，同姓名同年龄，视为同一个人，为重复元素 //思路：对人描述，将数据封装到人的对象，，定义容器，将人存入，，取出 class Person2 { private String name; private int age; public Person2(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; } public int hashCode() { System.out.println(this.name+"....hashCode"); return name.hashCode()+age*39; } public boolean equals(Object obj) { if (!(obj instanceof Person2)) return false; Person2 p1=(Person2) obj; System.out.println(this.name+"...equals.."+p1.name); return this.name.equals(p1.name)&&this.age==p1.age; } } public class HashSetTest { public static void main(String[] args) { HashSet link=new HashSet(); link.add(new Person2("han0", 22)); link.add(new Person2("han1", 22)); link.add(new Person2("han2", 23)); link.add(new Person2("han3", 24)); link.add(new Person2("han4", 25)); link.add(new Person2("han4", 25)); Iterator it=link.iterator(); while(it.hasNext())//遍历新的集合元素 { Object obj=it.next(); Person2 p=(Person2) obj; sop(p.getName()+"..."+p.getAge()); } } //输出 public static void sop(Object obj) { System.out.println(obj); } }
三、TreeSet
1、特点
a、底层的数据结构为二叉树结构
b）可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。
java中的很多类都具备比较性，其实就是实现了Comparable接口。
注意：排序时，当主要条件相同时，按次要条件排序。
c、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。
2、TreeSet排序的两种方式
1）第一种排序方式：自然排序
让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。
package atheima; import java.util.Iterator; import java.util.TreeSet; import javax.management.RuntimeErrorException; //将自定义对象作为元素存到TreeSet集合中，对人的年龄进行排序 class Person3 implements Comparable//该接口强制让人具备比较性 { private String name; private int age; public Person3(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 int compareTo(Object obj) { if(!(obj instanceof Person3)) throw new RuntimeErrorException(null, "不是学生对象"); Person3 p1=(Person3) obj; System.out.println(this.name+"...Compareto..."+p1.name); if(this.age>p1.age) return 1; if(this.age==p1.age)//当年龄相同，就需要对名字排序 { return this.name.compareTo(p1.name); } return -1; } } public class TreeSetTest { public static void main(String[] args) { TreeSet link=new TreeSet(); link.add(new Person3("han0", 22)); link.add(new Person3("han1", 22)); link.add(new Person3("han2", 23)); link.add(new Person3("han3", 24)); link.add(new Person3("han4", 25)); link.add(new Person3("han5", 25)); Iterator it=link.iterator(); while(it.hasNext()){ Object obj=it.next(); Person3 p1=(Person3) obj; sop(p1.getName()+"..."+p1.getAge()); } } //输出 public static void sop(Object obj) { System.out.println(obj); } }
2）第二种方式：比较器
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
当两种排序都存在时，以比较器为主。
package atheima; import java.util.Comparator; import java.util.Iterator; import java.util.TreeSet; import javax.management.RuntimeErrorException; //将自定义对象作为元素存到TreeSet集合中，对人的年龄进行排序 class Person3 implements Comparable//该接口强制让人具备比较性 { private String name; private int age; public Person3(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 int compareTo(Object obj) { if(!(obj instanceof Person3)) throw new RuntimeException("不是学生对象"); Person3 p1=(Person3) obj; System.out.println(this.name+"...Compareto..."+p1.name); if(this.age>p1.age) return 1; if(this.age==p1.age)//当年龄相同，就需要对名字排序 { return this.name.compareTo(p1.name); } return -1; } } public class TreeSetTest { public static void main(String[] args) { TreeSet link=new TreeSet(new MyCompare()); link.add(new Person3("han02", 27)); link.add(new Person3("han02", 22)); link.add(new Person3("han007", 29)); link.add(new Person3("han09", 24)); link.add(new Person3("han06", 25)); link.add(new Person3("han06", 25)); Iterator it=link.iterator(); while(it.hasNext()){ Object obj=it.next(); Person3 p1=(Person3) obj; sop(p1.getName()+"..."+p1.getAge()); } } //输出 public static void sop(Object obj) { System.out.println(obj); } } /** * 当元素自身不具备比较性，或者具备的比较性不是所需要的， * 这时需要让容器自身具备比较性 * 定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数 */ class MyCompare implements Comparator { @Override public int compare(Object o1, Object o2) { Person3 p1=(Person3) o1; Person3 p2=(Person3) o2; int num=p1.getName().compareTo(p2.getName()); if(num==0) { return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge())); // if(p1.getAge()>p2.getAge()) // return 1; // if(p1.getAge()==p2.getAge()) // return 0; // return -1; } return num; } }
泛型类
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，早期定义object来完成扩展。现在定义泛型完成扩展。
package atheima; import java.util.*; public class GenericDemo1 { public static void main(String[] args) { TreeSet<String> a1=new TreeSet<String>(new MyGntenericDemo()); a1.add("sda"); a1.add("adad78"); a1.add("akjd9"); Iterator<String> it=a1.iterator(); while(it.hasNext()) { String s2=it.next();//--->泛型后 System.out.println(s2); } } } class MyGntenericDemo implements Comparator<String>//--->加泛型无需强转 { public int compare(String s1,String s2) { //按升序排，如果降序就把s1、s2互换 int num= new Integer(s1.length()).compareTo(new Integer(s2.length())); if(num==0) return s1.compareTo(s2); return num; } }
package atheima; import java.awt.print.Printable; import javax.xml.namespace.QName; class Demoo<T>//在类上定义泛型 { public void show(T t) { System.out.println("show:"+t); } public void print(T t) { System.out.println("print:"+t); } } /** * 泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型 * 类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了 * 为了让不同方法可以操作不同类型，而且类型还不确定那么可以 * 将泛型定义在方法中。 * 特殊之处：静态方法不可以访问类上定义的泛型 * 如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。 * @author Administrator * */ class Demoo1<T> { public <T>void show(T t) { System.out.println("show:"+t); } public <Q>void Print(Q q) { System.out.println("print:"+q); } public static <W> void method(W t) { System.out.println("method:"+t); } } public class GenericDemo2 { public static void main(String[] args) { // Demoo<String>d1=new Demoo<String>();//string类型 // d1.show("kk"); // d1.print("han");//必须都是String类型 Demoo1 d2=new Demoo1(); d2.show("hh");//--1 d2.show(3);//--2,泛型定义在方法上，类型可以不同 d2.method("dd"); } }
泛型定义在接口上
package atheima; interface Inter<T> { void show(T t); } class InterImp implements Inter<String>//-->明确类型string { public void show(String s1) { System.out.println("show:"+s1); } } //不明确类型,使用泛型 class InterImp1<T> implements Inter<T> { public void show(T t) { System.out.println("show:"+t); } } public class GenericDemo3 { public static void main(String[] args) { InterImp i=new InterImp(); i.show("hahah"); //定义整形 InterImp1<Integer>i1=new InterImp1<Integer>(); i1.show(4); } }
？通配符。也可以理解为占位符
泛型的限定：
？extends E：可以接收E类型或者E的子类型。上限
？super E：可以接收E类型或者E的父类型。下限
package atheima; import java.util.*; public class GenericDemo4 { public static void main(String[] args) { ArrayList<Person0>a1=new ArrayList<Person0>(); a1.add(new Person0("abc1")); a1.add(new Person0("abc2")); a1.add(new Person0("abc3")); printColl(a1); ArrayList<Student>a2=new ArrayList<Student>(); a2.add(new Student("ab1")); a2.add(new Student("ab2")); a2.add(new Student("ab3")); printColl(a2); } public static void printColl(ArrayList<? extends Person0>a1)//?不明白类型用通配符 { Iterator<? extends Person0> it=a1.iterator(); while(it.hasNext()) { System.out.println(it.next().getNme()); } } } class Person0 { private String name; public Person0(String name) { this.name=name; } public String getNme() { return name; } } class Student extends Person0 { public Student(String name) { super(name); } }
第五讲 Map集合
一、概述
1、简述：
Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）
2、特点：
1）该集合存储键值对，一对一对往里存
2）要保证键的唯一性。
二、Map集合的子类
Map
|--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。
|--HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。
三、Map集合的常用方法
1、添加
V put(K key,V value);//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。
void putAll(Map <? extends K,? extends V> m);//添加一个集合
2、删除
clear();//清空
V remove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
V get(Object key);//通过键获取对应的值
size();//获取集合的长度
Collection<V> value();//获取Map集合中所有得值，返回一个Collection集合
还有两个取出方法，接下来会逐个讲解：
Set<Map.Entry<K,V>> entrySet(); 返回此映射中包含的映射关系的 Set 视图。
Set<K> keySet();返回此映射中包含的键的 Set 视图。
注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。
package atheima; import java.util.*; public class GenericDemo5 { public static void main(String[] args) { Map<String, String>map=new HashMap<String, String>(); //如果出现添加元素，有相同的键，那么后添加的值会覆盖原有的键对应的值，put方法会返回被覆盖的值 map.put("01", "han1"); map.put("01", "han5"); map.put("02", "han2"); map.put("03", "han3"); sop(map.containsKey("01"));//--true //sop(map.remove("02"));//---han2 sop(map.get("03"));//---han3 map.put(null, "han4");//HashMap可以键入空值 sop(map.get(null));//--han4 Collection<String>coll=map.values(); sop(coll);//[han4, han1, han2, han3] //获取map集合中的所有的值 sop(map);//{null=han4, 01=han1, 02=han2, 03=han3} } public static void sop(Object obj) { System.out.println(obj); } }
四、Map集合的两种取出方式
Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。
1、Set<K> keySet()：将Map中所有的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值，再通过get方法。获取每一个键对应的值。
2、Set<Map.Entry<K,V>> entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry
其实，Entry也是一个接口，它是Map接口中的一个内部接口。
package atheima; import java.util.*; /** * map 集合的两种取出方式 * 1.keySet：将map中的所有的键存入到set集合，因为set具备迭代器， * 所有可以用迭代方式取出所有的键，在根据get方法，获取每一个键对应的值 * * 2， * @author Administrator * */ public class MapDemo2 { public static void main(String[] args) { Map<String, String>map=new HashMap<String, String>(); //如果出现添加元素，有相同的键，那么后添加的值会覆盖原有的键对应的值，put方法会返回被覆盖的值 map.put("01", "han1"); map.put("01", "han5"); map.put("02", "han2"); map.put("03", "han3"); //将map集合中的映射关系取出，存入到set集合中 Set<Map.Entry<String, String>> entrySet=map.entrySet(); Iterator< Map.Entry<String, String>> it1=entrySet.iterator(); while(it1.hasNext()) { Map.Entry<String, String> me=it1.next(); String key=me.getKey(); String value=me.getValue(); sop(key+"--"+value); } //现获取map集合的所有键的set集合，keyset（）； Set<String> keySet=map.keySet(); //有了set集合，就可以获取其迭代器 Iterator<String>it=keySet.iterator(); while(it.hasNext()) { String key=it.next(); //有了键就可以通过map集合的get方法获取其对应的值 String value=map.get(key); sop("key:"+key+",value:"+value); } } public static void sop(Object obj) { System.out.println(obj); } }
package atheima; import java.util.*; import java.util.jar.Attributes.Name; /* * 每一个学生都有对应的归属地。 学生Student，地址String。 学生属性：姓名，年龄。 注意：姓名和年龄相同的视为同一个学生。 保证学生的唯一性。 思路：1、描述学生类 2、定义一个Map集合，将学生作为键，地址作为值 3、获取Map中的元素 */ class Student0 implements Comparable<Student0> { private String name; private int age; public Student0(String name,int age) { 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; } public String toString() { return name+":"+age; } @Override public int hashCode() { return name.hashCode()+age*34; } @Override public boolean equals(Object obj) { if(!(obj instanceof Student0)) throw new ClassCastException("类型不匹配"); Student0 s=(Student0)obj; return this.name.equals(s.name)&&this.age==s.age; } @Override public int compareTo(Student0 o) { int num=new Integer(this.getAge()).compareTo(new Integer(o.getAge())); if(num==0) return this.getName().compareTo(o.getName()); return num; } } public class MapTest { public static void main(String[] args) { HashMap<Student0,String>hm=new HashMap<Student0, String>(); hm.put(new Student0("han1", 18),"beijing"); hm.put(new Student0("han2", 34),"nanjing"); hm.put(new Student0("han3", 42),"shangqiu"); hm.put(new Student0("han4", 12),"nanyang"); //第一种取出方式keySet Set<Student0>keySet=hm.keySet(); Iterator<Student0>it=keySet.iterator(); while(it.hasNext()) { Student0 s1=it.next(); String address=hm.get(s1); sop(s1+":"+address); } //第二种取出方式Map.Entry Set<Map.Entry<Student0, String>>enterSet=hm.entrySet(); Iterator<Map.Entry<Student0, String>>it1=enterSet.iterator(); while(it1.hasNext()) { Map.Entry<Student0, String> entry=it1.next(); Student0 stu1=entry.getKey(); String s1=entry.getValue(); sop(stu1+"...."+s1); } } public static void sop(Object obj) { System.out.println(obj); } }
package atheima; import java.util.*; import java.util.jar.Attributes.Name; /* 需求：对学生对象的年龄进行升序排序 因为数据是以键值对形式存在的 所以要使用可以排序的map集合---》TreeMap */ class Student4 implements Comparable<Student4> { private String name; private int age; public Student4(String name,int age) { 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; } public String toString() { return name+":"+age; } @Override public int hashCode() { return name.hashCode()+age*34; } @Override public boolean equals(Object obj) { if(!(obj instanceof Student4)) throw new ClassCastException("类型不匹配"); Student4 s=(Student4)obj; return this.name.equals(s.name)&&this.age==s.age; } @Override public int compareTo(Student4 o) { int num=new Integer(this.getAge()).compareTo(new Integer(o.getAge())); if(num==0) return this.getName().compareTo(o.getName()); return num; } } //自定义集合按姓名排序 class MyCompar implements Comparator<Student4> { @Override public int compare(Student4 o1, Student4 o2) { int num=o1.getName().compareTo(o2.getName()); if(num==0) return new Integer(o1.getAge()).compareTo(new Integer(o2.getAge())); return num; } } public class MapTest1 { public static void main(String[] args) { TreeMap<Student4,String>hm=new TreeMap<Student4, String>(new MyCompar()); hm.put(new Student4("han1", 18),"beijing"); hm.put(new Student4("ahan2", 34),"nanjing"); hm.put(new Student4("chan3", 42),"shangqiu"); hm.put(new Student4("jhan4", 12),"nanyang"); Set<Map.Entry<Student4, String>>enterSet=hm.entrySet(); Iterator<Map.Entry<Student4, String>>it1=enterSet.iterator(); while(it1.hasNext()) { Map.Entry<Student4, String> entry=it1.next(); Student4 stu1=entry.getKey(); String s1=entry.getValue(); sop(stu1+"...."+s1); } } public static void sop(Object obj) { System.out.println(obj); } }
package atheima; import java.util.*; /* * 练习：sdfgxxvasdfxcvdf获取该字符串中的字母出现的次数 * 结果：a(1)c(2)... * 通过结果发现，每一个字母都有对应的次数，说明字母和次数之间 * 都有映射关系---》选择map集合，因为map集合中存放的就是映射关系。 * 思路： * 1.将字符串转换为字符数组，因为要对每一个字母进行操作 * 2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合 * 3.遍历字符数组 * 将每一个字母作为键去查map集合 * 如果返回null将该字母和1存入到map集合中 * 如果返回不是null，说明该字母在map集合已经存在并有对应次数 * 那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖调用原来键所对应的值 * 4.将map集合中的数据变成指定的字符串形式返回。 */ public class MapTest2 { public static void main(String[] args) { String s=charCount("sdfgxxvasdfxcvdf"); } //定义一个方法获取字符串中字母出现的次数 public static String charCount(String str) { char[] cha=str.toCharArray();//转换为字符数组 //定义一个TreeMap集合，因为TreeMap集合会给键自动排序 TreeMap<Character, Integer>tm=new TreeMap<Character, Integer>(); int count=0;//定义计数变量 for(int x=0;x<cha.length;x++) { if(!(cha[x]>='a'&&cha[x]<='z'||cha[x]>='A'&&cha[x]<='Z')) continue;//如果字符串中非字母，则不计数 Integer values=tm.get(cha[x]);//获取集合中的值 if(values!=null)//如果集合中没有该字母，则存入 count=values; count++; tm.put(cha[x], count);//存入键值对 count=0;//复位计数变量 } StringBuilder sb=new StringBuilder();//定义一个容器 Set<Map.Entry<Character, Integer>> entry=tm.entrySet(); Iterator<Map.Entry<Character, Integer>>it=entry.iterator(); while(it.hasNext()) { Map.Entry<Character, Integer> me=it.next(); Character key=me.getKey(); Integer values=me.getValue(); sb.append(key+"("+values+")"); } System.out.println(sb); return null; } }
package atheima; import java.util.*; /* map扩展知识。 map集合被使用是因为具备映射关系。 以下是班级对应学生，而学生中学号对应着姓名的映射关系： "yureban" Student("01" "zhangsan"); "yureban" Student("02" "lisi"); "jiuyeban" "01" "wangwu"; "jiuyeban" "02" "zhaoliu"; 就如同一个学校有多个教室。每一个教室都有名称。 */ public class MapTest3//第一种方法 { public static void main(String[] args) { //传智博客学校对应的集合：键为：班级，值为：学生其中学生又是一个集合包含学号和姓名 HashMap<String, HashMap<String, String>>czbk=new HashMap<String, HashMap<String,String>>(); //预热班级集合对应的键是学号，值为姓名 HashMap<String, String>yure=new HashMap<String, String>(); //就业班级集合对应的键是学号，值为姓名 HashMap<String, String>jiuye=new HashMap<String, String>(); //传智播客班级集合和名称的映射 czbk.put("yureban", yure); czbk.put("jiuyeban", jiuye); //预热班级中学号与姓名的映射 yure.put("01","zhangsan" ); yure.put("02", "lisi"); //就业班级中学号与姓名的映射 jiuye.put("01", "wangwu"); jiuye.put("02", "zhaoliu"); //遍历czbk集合，获取所有的教室 Iterator<String>it=czbk.keySet().iterator(); while(it.hasNext()) { String roomName=it.next(); HashMap<String, String> room=czbk.get(roomName); System.out.println(roomName); getStudentInfo(room); } } public static void getStudentInfo(HashMap<String, String> roomMap)//变量为班级 { Iterator<String>it=roomMap.keySet().iterator();//用keySet取出方式 while(it.hasNext()) { String id=it.next(); String name=roomMap.get(id); System.out.println(id+":"+name); } } }
package atheima; import java.util.*; /* map扩展知识。 map集合被使用是因为具备映射关系。 以下是班级对应学生，而学生中学号对应着姓名的映射关系： "yureban" Student("01" "zhangsan"); "yureban" Student("02" "lisi"); "jiuyeban" "01" "wangwu"; "jiuyeban" "02" "zhaoliu"; 就如同一个学校有多个教室。每一个教室都有名称。 */ class Students//第二种方法常用到 { private String id; private String name; public Students(String id, String name) { super(); this.id = id; this.name = name; } @Override public String toString() { return "Students [id=" + id + ", name=" + name + "]"; } } public class MapTest4 { public static void demo() { HashMap<String, List<Students>>czbk=new HashMap<String, List<Students>>(); List<Students> yure=new ArrayList<Students>();//yure班 List<Students> jiuye=new ArrayList<Students>();//jiuye班 czbk.put("yureban", yure); czbk.put("jiuyeban", jiuye); yure.add(new Students("03","han3")); yure.add(new Students("04","han4")); jiuye.add(new Students("03","han3")); jiuye.add(new Students("04","han4")); Iterator<String>it=czbk.keySet().iterator(); while(it.hasNext()) { String roomName=it.next(); List<Students> room=czbk.get(roomName); System.out.println(roomName); getInfos(room); } } public static void getInfos(List<Students>list) { Iterator<Students>it1=list.iterator(); while(it1.hasNext()) { Students room=it1.next(); System.out.println(room); } } public static void main(String[] args) { demo(); } public static void getStudentInfo(HashMap<String, String> roomMap)//变量为班级 { Iterator<String>it=roomMap.keySet().iterator();//用keySet取出方式 while(it.hasNext()) { String id=it.next(); String name=roomMap.get(id); System.out.println(id+":"+name); } } }