黑马程序员——Java基础---Java集合
2015-05-02 21:47
579 查看
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——-
为了保存数量不确定的数据,以及保存具有映射关系的数据(也被称为关联数组),Java提供了集合类。集合类主要负责保存、盛装其他数据,因此集合类也被称为容器类。所有的集合类都位于java.util包下。
集合类和数组不一样,数组元素既可以是基本数据类型的值,也可以是对象(实际上保存的是对象的引用变量);而集合类里只能保存对象(实际上只是保存对象的引用变量,但通常习惯上认为集合里保存的是对象)。
Java的集合类主要有两个接口派生而出:Collection和Map,Collection和Map是Java集合框架的根接口,这两个接口又包含了一些子接口或实现类。
下图是Collection和Map的集合体系,其中标黑框的是我们常用的集合
所属关系:
Collection
|——–List//元素是有序的,元素可以重复。因为该集合体系有索引。
|——–Set//元素是无序的,元素不可以重复。
add(Object obj); //add方法的参数类型是Object。以便于接收任意类型对象。
addAll(Collection c)
2.删除元素
clear()//清空集合
remove(Object obj)//删除某一个元素
removeAll()//参数是集合
3.判断元素
contains()//判断是否包含obj这个元素
containsAll()//判断是否包含才这个集合
isEmpty()//判断集合是否为空
4.获取
size();//获取集合长度
5.取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
注:集合中存储的都是对象的引用(地址)。
对于集合的元素取出这个动作:
当不足以用一个函数来描述,需要用多个功能来体现,所以就将取出这个动作封装成一个对象来描述。就把取出方式定义在集合的内部,这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同,所以取出的动作细节也不一样。但是都具有共性内容: 判断和取出。那么就可以将这些共性抽取。
那么这些内部类都符合一个规则(或者说都抽取出来一个规则)。该规则就是Iterator。通过一个对外提供的方法:iterator();,来获取集合的取出对象。
因为Collection中有iterator方法,所以每一个子类集合对象都具备迭代器。
2迭代的常见操作
hasNext();//有下一个元素,返回真
next();//取出下一个元素
remove();//移除
注:在迭代时循环中next调用一次,就要hasNext判断一次。
使用:
ArrayList a=newArrayList();//创建一个集合
Iteratorit=a.iterator();//获取一个迭代器,用于取出集合中的元素。
第一种打印方式:
第二种打印方式:
3.迭代注意事项
(1)迭代器在Collcection接口中是通用的,它替代了Vector类中的Enumeration(枚举)。
(2)迭代器的next方法是自动向下取元素,要避免出现NoSuchElementException。
(3)迭代器的next方法返回值类型是Object,所以要记得类型转换。
|——ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|——LinkedList:底层使用的是链表数据结构。特点:增删速度很快,查询稍慢。
|——Vector:底层是数组数据结构。线程同步。被ArrayList替代了。
3.2.1.增
booleanadd(index,element);//指定位置添加元素
BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素,若省略位置参数,则在当前集合的后面依次添加元素
2.删
Booleanremove(index);//删除指定位置的元素
3.改
set(index,element);//修改指定位置的元素。
4.查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5.其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置,如果没有则返回-1
注:List集合判断元素是否相同,移除等操作,依据的是元素的equals方法。
ListIterator是List集合特有的迭代器,是Iterator的子接口。
在迭代时,不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时,只能用迭代器的方法操作元素。可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作。如果想要其他的操作,如添加、修改等,就需要使用其子接口:ListIterrator。该接口只能通过List集合的ListIterator方法获取。
2、ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
特有方法:
addElement(obj);//添加元素,相当于add(obj);
Enumerationelements();//Vector特有取出方式(枚举)
hasMoreElements();//相当于Iterator的hasNext()方法
nextElements();//相当于Iterator的next()方法
特有方法:
1、增
addFirst();
addLast();
2、获取
//获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后,出现了替代方法。
1、增
offFirst();
offLast();
2、获取
//获取元素,但是不删除。如果集合中没有元素,会返回null。
peekFirst();
peekLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会返回null。
pollFirst();
pollLast();
练习一:
|–HashSet:底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理:判断元素的hashCode值是否相同。如果相同,还会继续判断元素的equals方法,是否为true。
|–TreeSet:可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据:compareTo方法return 0。
Set集合的功能和Collection是一致的。
可以通过元素的两个方法,hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同,才会判断equals是否为true。如果元素的hashCode值不同,不会调用equals。
注意:HashSet对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals方法。
练习二:
1)底层的数据结构为二叉树结构(红黑树结构)
2)可对Set集合中的元素进行排序,是因为:TreeSet类实现了Comparable接口,该接口强制让增加到集合中的对象进行了比较,需要复写compareTo方法,才能让对象按指定需求(如人的年龄大小比较等)进行排序,并加入集合。
java中的很多类都具备比较性,其实就是实现了Comparable接口。
3) 保证数据的唯一性的依据:通过compareTo方法的返回值,是正整数、负整数或零,则两个对象较大、较小或相同。相等时则不会存入。
注意:排序时,当主要条件相同时,按次要条件排序。
2.Tree排序的两种方式
1)第一种排序方式:自然排序
让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。这种方式也被称为元素的自然顺序,或者叫做默认顺序。
例:
2)第二种方式:比较器
当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。定义一个比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式:定义一个类,实现Comparator接口,覆盖compare方法。
当两种排序都存在时,以比较器为主。
示例:
2)要保证键的唯一性。
|–Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。JDK1.0,效率低。
|–HashMap:底层是哈希表数据结构。允许使用null键null值,该集合是不同步的。JDK1.2,效率高。
|–TreeMap:底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。
put(K key,V value);//添加元素,如果出现添加时,相同的键,那么后添加的值会覆盖原有键对应值,并put方法会返回被覆盖的值。
voidputAll();//添加一个集合
2、删除
clear();//清空
Vremove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
Vget(Object key);//通过键获取对应的值
size();//获取集合的长度
Collectionvalue();//获取Map集合中所以得值,返回一个Collection集合
1、Set keySet():将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值,再通过get方法。获取每一个键对应的值。
例:
2、Set< Map.entry< K, V>> entrySet():将Map集合中的映射关系存入到Set集合中,而这个关系的数据类型就是:Map.Entry
其实,Entry也是一个接口,它是Map接口中的一个内部接口。
例:
关于Map.Entry:
Map是一个接口,其实,Entry也是一个接口,它是Map的子接口中的一个内部接口,就相当于是类中有内部类一样。为何要定义在其内部呢?
原因:a、Map集合中村的是映射关系这样的两个数据,是先有Map这个集合,才可有映射关系的存在,而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员,所以定义在内部。
如:
Java集合
要想学好Java集合这一部分其实很简单,每一种集合的特点、方法以及使用特点必须牢记,张嘴就能说出来,这些都是记忆性的东西,没什么难度。清楚了各种集合的特点用的时候才会信手拈来。
一.Java集合概述
在编程时,常常需要集中存放多个数据,当然我们可以使用数组来保存多个数据,但是数组长度不可变化,一旦在初始化数组时指定了数组长度,这个数组长度就是不可变的,如果需要保存数量变化的数据,数组就有点无能为力了;而且数组无法保存具有映射关系的数据。如成绩表:语文—79,数学—80,这种数据看上去像两个数组,但是这两个数组的元素之间有一定的关联关系。为了保存数量不确定的数据,以及保存具有映射关系的数据(也被称为关联数组),Java提供了集合类。集合类主要负责保存、盛装其他数据,因此集合类也被称为容器类。所有的集合类都位于java.util包下。
集合类和数组不一样,数组元素既可以是基本数据类型的值,也可以是对象(实际上保存的是对象的引用变量);而集合类里只能保存对象(实际上只是保存对象的引用变量,但通常习惯上认为集合里保存的是对象)。
Java的集合类主要有两个接口派生而出:Collection和Map,Collection和Map是Java集合框架的根接口,这两个接口又包含了一些子接口或实现类。
下图是Collection和Map的集合体系,其中标黑框的是我们常用的集合
二.Collection
Collection是集合框架中的常用接口。其下有两个子接口:List,Set。所属关系:
Collection
|——–List//元素是有序的,元素可以重复。因为该集合体系有索引。
|——–Set//元素是无序的,元素不可以重复。
2.1.Collection接口中的常见操作
1.添加元素add(Object obj); //add方法的参数类型是Object。以便于接收任意类型对象。
addAll(Collection c)
2.删除元素
clear()//清空集合
remove(Object obj)//删除某一个元素
removeAll()//参数是集合
3.判断元素
contains()//判断是否包含obj这个元素
containsAll()//判断是否包含才这个集合
isEmpty()//判断集合是否为空
4.获取
size();//获取集合长度
5.取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
注:集合中存储的都是对象的引用(地址)。
2.2.Iterator接口
Iterator是一个迭代器,迭代是取出集合中元素的一种方式。对于集合的元素取出这个动作:
当不足以用一个函数来描述,需要用多个功能来体现,所以就将取出这个动作封装成一个对象来描述。就把取出方式定义在集合的内部,这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同,所以取出的动作细节也不一样。但是都具有共性内容: 判断和取出。那么就可以将这些共性抽取。
那么这些内部类都符合一个规则(或者说都抽取出来一个规则)。该规则就是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()); }
3.迭代注意事项
(1)迭代器在Collcection接口中是通用的,它替代了Vector类中的Enumeration(枚举)。
(2)迭代器的next方法是自动向下取元素,要避免出现NoSuchElementException。
(3)迭代器的next方法返回值类型是Object,所以要记得类型转换。
三.List
3.1.List体系
List:元素是有序的,元素可以重复。因为该集合体系有索引。|——ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢。线程不同步。
|——LinkedList:底层使用的是链表数据结构。特点:增删速度很快,查询稍慢。
|——Vector:底层是数组数据结构。线程同步。被ArrayList替代了。
3.2.List的特有方法
凡是可以操作角标的方法都是该体系特有的方法。3.2.1.增
booleanadd(index,element);//指定位置添加元素
BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素,若省略位置参数,则在当前集合的后面依次添加元素
2.删
Booleanremove(index);//删除指定位置的元素
3.改
set(index,element);//修改指定位置的元素。
4.查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5.其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置,如果没有则返回-1
注:List集合判断元素是否相同,移除等操作,依据的是元素的equals方法。
3.3.ListIterator
1、概述ListIterator是List集合特有的迭代器,是Iterator的子接口。
在迭代时,不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时,只能用迭代器的方法操作元素。可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作。如果想要其他的操作,如添加、修改等,就需要使用其子接口:ListIterrator。该接口只能通过List集合的ListIterator方法获取。
2、ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
3.4.Vector
Vector有三种取出方式。其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
特有方法:
addElement(obj);//添加元素,相当于add(obj);
Enumerationelements();//Vector特有取出方式(枚举)
hasMoreElements();//相当于Iterator的hasNext()方法
nextElements();//相当于Iterator的next()方法
3.5.LinkedList
LinkedList:底层使用的是链表数据结构。特点:增删速度很快,查询稍慢。特有方法:
1、增
addFirst();
addLast();
2、获取
//获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后,出现了替代方法。
1、增
offFirst();
offLast();
2、获取
//获取元素,但是不删除。如果集合中没有元素,会返回null。
peekFirst();
peekLast();
3、删
//获取元素,并删除元素。如果集合中没有元素,会返回null。
pollFirst();
pollLast();
练习一:
/* 使用LinkedList模拟一个堆栈或者队列数据结构。 堆栈:先进后出 如同一个杯子。 队列:先进先出 First in First out FIFO 如同一个水管。 */ import java.util.*; class LinkedListTest { public static void main(String[] args) { LinkedList l=new LinkedList(); l.addFirst("java01"); l.addFirst("java02"); l.addFirst("java03"); l.addFirst("java04"); l.addFirst("java05"); //堆栈输出 // stack(l); //队列输出 queue(l); } //堆栈 public static void stack(LinkedList l) { while (!l.isEmpty()) { sop(l.removeFirst()); } } //队列 public static void queue(LinkedList l) { while(!l.isEmpty()) { sop(l.removeLast()); } } //输出 public static void sop(Object obj) { System.out.println(obj); } }
四.Set
1.概述
Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复。|–HashSet:底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理:判断元素的hashCode值是否相同。如果相同,还会继续判断元素的equals方法,是否为true。
|–TreeSet:可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据:compareTo方法return 0。
Set集合的功能和Collection是一致的。
2.HasSet
HashSet:线程不安全,存取速度快。可以通过元素的两个方法,hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同,才会判断equals是否为true。如果元素的hashCode值不同,不会调用equals。
注意:HashSet对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashCode和equals方法。
练习二:
/* 往hashSet集合中存入自定对象 姓名和年龄相同为同一个人,重复元素。去除重复元素 思路:1、对人描述,将人的一些属性等封装进对象 2、定义一个HashSet容器,存储人对象 3、取出 */ import java.util.*; //人描述 class Person { private String name; private int age; Person(String name,int age) { this.name=name; this.age=age; } public String getName() { return name; } public int getAge() { return age; } public boolean equals(Object obj) { if(!(obj instanceof Person)) return false; Person p=(Person)obj; return this.name.equals(p.name)&&this.age==p.age; } public int hashCode() { return this.name.hashCode()+this.age; } } class HashSetTest { public static void main(String[] args) { HashSet h=new HashSet(); h.add(new Person("shenm",10)); h.add(new Person("shenm2",6)); h.add(new Person("shenm1",30)); h.add(new Person("shenm0",10)); h.add(new Person("shenm0",10)); getOut(h); } //取出元素 public static void getOut(HashSet h) { for (Iterator it=h.iterator(); it.hasNext(); ) { Person p=(Person)it.next(); sop(p.getName()+"..."+p.getAge()); } } //打印 public static void sop(Object obj) { System.out.println(obj); } }
3.TreeSet
1.特点1)底层的数据结构为二叉树结构(红黑树结构)
2)可对Set集合中的元素进行排序,是因为:TreeSet类实现了Comparable接口,该接口强制让增加到集合中的对象进行了比较,需要复写compareTo方法,才能让对象按指定需求(如人的年龄大小比较等)进行排序,并加入集合。
java中的很多类都具备比较性,其实就是实现了Comparable接口。
3) 保证数据的唯一性的依据:通过compareTo方法的返回值,是正整数、负整数或零,则两个对象较大、较小或相同。相等时则不会存入。
注意:排序时,当主要条件相同时,按次要条件排序。
2.Tree排序的两种方式
1)第一种排序方式:自然排序
让元素自身具备比较性。元素需要实现Comparable接口,覆盖compareTo方法。这种方式也被称为元素的自然顺序,或者叫做默认顺序。
例:
import java.util.*; //学生类 class Student implements Comparable { private String name; private int age; Student(String name,int age) { this.name=name; this.age=age; } public String getName() { return name; } public int getAge() { return age; } //复写hashCode以便HashSet集合调用 public int hashCode() { return name.hashCode()+age; } //复写equals以便HashSet集合和集合中一些比较方法调用 public boolean equals(Object obj) { if(!(obj instanceof Student)) throw new RuntimeException(); Student s = (Student)obj; return this.name.equals(s.name)&&this.age==s.age; } //复写compareTo以便TreeSet集合调用 public int compareTo(Object obj) { Student s=(Student)obj; if(this.age==s.age) return this.name.compareTo(s.name); return this.age-s.age; //return new Integer(this.age).compareTo(new Integer(s.age)); } } class TreeSetTest { public static void main(String[] args) { TreeSet<Student> t=new TreeSet<Student>(); t.add(new Student("wo1",12)); t.add(new Student("wosj",2)); t.add(new Student("wo1sdj",12)); t.add(new Student("wo6sd",12)); t.add(new Student("wo",22)); for (Iterator<Student> it=t.iterator(); it.hasNext(); ) { Student s=it.next(); System.out.println(s.getName()+"....."+s.getAge()); } } }
2)第二种方式:比较器
当元素自身不具备比较性时,或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。定义一个比较器,将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式:定义一个类,实现Comparator接口,覆盖compare方法。
当两种排序都存在时,以比较器为主。
示例:
/* 需求: 往TreeSet集合中存储自定义对象学生。 想按照学生的年龄进行排序。 */ import java.util.*; //学生类 class Student implements Comparable { private String name; private int age; Student(String name,int age) { this.name=name; this.age=age; } public String getName() { return name; } public int getAge() { return age; } //复写hashCode以便HashSet集合调用 public int hashCode() { return name.hashCode()+age; } //复写equals以便HashSet集合和集合中一些比较方法调用 public boolean equals(Object obj) { if(!(obj instanceof Student)) throw new RuntimeException(); Student s = (Student)obj; return this.name.equals(s.name)&&this.age==s.age; } //复写compareTo以便TreeSet集合调用 public int compareTo(Object obj) { Student s=(Student)obj; if(this.age==s.age) return this.name.compareTo(s.name); return this.age-s.age; //return new Integer(this.age).compareTo(new Integer(s.age)); } } class TreeSetTest { public static void main(String[] args) { TreeSet<Student> t=new TreeSet<Student>(new LenCompare()); t.add(new Student("wo1",12)); t.add(new Student("wosj",2)); t.add(new Student("wo1sdj",12)); t.add(new Student("wo6sd",12)); t.add(new Student("wo",22)); for (Iterator<Student> it=t.iterator(); it.hasNext(); ) { Student s=it.next(); System.out.println(s.getName()+"....."+s.getAge()); } } } //定义一个比较器,以姓名长度为主要比较 class LenCompare implements Comparator<Student> { public int compare(Student s1,Student s2) { int num=new Integer(s1.getName().length()).compareTo(new Integer(s2.getName().length())); if (num==0) { return new Integer(s1.getAge()).compareTo(s2.getAge()); } return num; } }
五. Map集合
1.概述:
Map< K,V >集合是一个接口,和List集合及Set集合不同的是,它是双列集合,并且可以给对象加上名字,即键(Key)2.特点:
1)该集合存储键值对,一对一对往里存2)要保证键的唯一性。
3.Map集合的子类
Map|–Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。JDK1.0,效率低。
|–HashMap:底层是哈希表数据结构。允许使用null键null值,该集合是不同步的。JDK1.2,效率高。
|–TreeMap:底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。
4.Map集合的常用方法
1、添加put(K key,V value);//添加元素,如果出现添加时,相同的键,那么后添加的值会覆盖原有键对应值,并put方法会返回被覆盖的值。
voidputAll();//添加一个集合
2、删除
clear();//清空
Vremove(Object key);//删除指定键值对
3、判断
containsKey(Objectkey);//判断键是否存在
containsValue(Objectvalue)//判断值是否存在
isEmpty();//判断是否为空
4、获取
Vget(Object key);//通过键获取对应的值
size();//获取集合的长度
Collectionvalue();//获取Map集合中所以得值,返回一个Collection集合
5.Map集合的两种取出方式
Map集合的取出原理:将Map集合转成Set集合。再通过迭代器取出。1、Set keySet():将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值,再通过get方法。获取每一个键对应的值。
例:
/* 每一个学生都有对应的归属地。 学生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 String getName() { return name; } public int getAge() { return age; } //复写hashCode public int hashCode() { return name.hashCode()+age*33; } //复写equals,比较对象内容 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; } //复写compareTo,以年龄为主 public int compareTo(Student c) { int num=new Integer(this.age).compareTo(new Integer(c.age)); if(num==0) { return this.name.compareTo(c.name); } return num; } //复写toString,自定义输出内容 public String toString() { return name+"..."+age; } } class HashMapTest { public static void main(String[] args) { HashMap<Student,String > hm=new HashMap<Student,String >(); hm.put(new Student("zhangsan",12),"beijing"); hm.put(new Student("zhangsan",32),"sahnghai"); hm.put(new Student("zhangsan",22),"changsha"); hm.put(new Student("zhangsan",62),"USA"); hm.put(new Student("zhangsan",12),"tianjing"); keyset(hm); } //keySet取出方式 public static void keyset(HashMap<Student,String> hm) { Iterator<Student> it=hm.keySet().iterator(); while(it.hasNext()) { Student s=it.next(); String addr=hm.get(s); System.out.println(s+":"+addr); } } }
2、Set< Map.entry< K, V>> entrySet():将Map集合中的映射关系存入到Set集合中,而这个关系的数据类型就是:Map.Entry
其实,Entry也是一个接口,它是Map接口中的一个内部接口。
例:
class HashMapTest { public static void main(String[] args) { HashMap<Student,String > hm=new HashMap<Student,String >(); hm.put(new Student("zhangsan",12),"beijing"); hm.put(new Student("zhangsan",32),"sahnghai"); hm.put(new Student("zhangsan",22),"changsha"); hm.put(new Student("zhangsan",62),"USA"); hm.put(new Student("zhangsan",12),"tianjing"); entryset(hm); } //entrySet取出方式 public static void entryset(HashMap<Student,String> hm) { Iterator<Map.Entry<Student,String>> it=hm.entrySet().iterator(); while(it.hasNext()) { Map.Entry<Student,String> me=it.next(); Student s=me.getKey(); String addr=me.getValue(); System.out.println(s+":::"+addr); } } }
关于Map.Entry:
Map是一个接口,其实,Entry也是一个接口,它是Map的子接口中的一个内部接口,就相当于是类中有内部类一样。为何要定义在其内部呢?
原因:a、Map集合中村的是映射关系这样的两个数据,是先有Map这个集合,才可有映射关系的存在,而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员,所以定义在内部。
六.Map扩展
在很多项目中,应用比较多的是一对多的映射关系,这就可以通过嵌套的形式将多个映射定义到一个大的集合中,并将大的集合分级处理,形成一个体系。如:
/* map扩展知识。 map集合被使用是因为具备映射关系。 以下是班级对应学生,而学生中学号对应着姓名的映射关系: "yureban" Student("01" "zhangsan"); "yureban" Student("02" "lisi"); "jiuyeban" "01" "wangwu"; "jiuyeban" "02" "zhaoliu"; 就如同一个学校有多个教室。每一个教室都有名称。 */ import java.util.*; class MapExpandKnow { public static void main(String[] args) { //预热班集合 HashMap<String,String> yureban=new HashMap<String,String>(); //就业班集合 HashMap<String,String> jiuyeban=new HashMap<String,String>(); //学校集合 HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>(); //学校中班级集合和名称的映射 czbk.put("yureban",yureban); czbk.put("jiuyueban",jiuyeban); //预热班级中学号与姓名的映射 yureban.put("01","zhangsan"); yureban.put("02","lisi"); //就业班级中学号与姓名的映射 jiuyeban.put("01","wangwu"); jiuyeban.put("02","zhouqi"); //直接显示全部学生信息 getAllStudentInfo(czbk); } //定义一个方法获取全部学生信息,包括在哪个班级,叫什么名字,学号多少 public static void getAllStudentInfo(HashMap<String ,HashMap<String,String>> hm) { for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )//用keySet取出方式 { String s= it.next();//班级名称 System.out.println(s+":"); HashMap<String,String> stu=hm.get(s);//班级集合 getStudentInfo(stu); } } //获取班级中学生的信息,包括姓名和学号 public static void getStudentInfo(HashMap<String,String> hm) { for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; ) { String key=it.next();//学号 String value=hm.get(key);//姓名 System.out.println(key+"..."+value); } } }
相关文章推荐
- 黑马程序员--Java基础之集合框架(2)
- 黑马程序员——【Java基础】——集合框架
- 黑马程序员——Java基础->集合框架
- 黑马程序员——java基础-集合
- 黑马程序员——java基础-泛型和集合框架工具类
- 黑马程序员-java基础(六)-集合
- 黑马程序员——Java基础---集合(Set接口及其子类、Map接口及其子类)
- 黑马程序员-JAVA基础-Java 集合之Collection 接口和遍历方法
- 黑马程序员:Java基础——List集合共性方法,Iterator迭代和集合具体对象的特点
- 黑马程序员—————Java基础--------集合
- 黑马程序员——java基础——集合工具类
- 【黑马程序员】Java基础07:集合框架与典型应用
- 黑马程序员——Java基础---集合2
- 黑马程序员_Java基础_集合(Map类)
- 黑马程序员——Java基础---泛型、集合框架工具类:collections和Arrays
- 黑马程序员 11 Java基础教学 - 11 - 集合框架总结
- 黑马程序员 Java基础<七>---> 集合框架
- 黑马程序员——Java基础---泛型、集合框架工具类:collections和Arrays
- 黑马程序员-JAVA基础-集合
- 黑马程序员——Java基础---集合