本人正在学习java基础知识,非常感恩能够看到毕向东老师的java视频,他引领了我去思考问题,而不是生硬的去记一些知识点,下面是我对集合学习的总结和思考。
问题1:什么是集合框架?
首先要理解集合这个词,它有另一个更加形象的名词:容器,所谓容器就是装载事物的器皿,而在java中最大的特征就是面向对象,所以可以推断出其实它就是用来装载对象的,便于我们去遍历和处理这些对象,关于框架的含义,其实就是它不是一个单独对象,而是有很多对象,并且相互存在区别和关系。
下图是目前集合的框架图,其中实线是具体的实现类,而虚线是接口或者工具类。
集合框架图
这里要说明的是,原来集合并没有怎么庞大的“家族”,在jdk的api中查看,jdk1.0的时候只有两个类即:Vector和Hashtable,因为后期发展,他们已经不能满足需要,所以2.0以后出现以上的框架图,而主要的优化就是容器丰富了和更加高效。就好比我们以前煮东西只需要一个大铁锅,但是因为后面物质和需求的发展,必须进行精细化,出现更加针对性的炊具。至于它们的优点和区别后面总结。
问题2:java有许多可以装载其它数据的“容器”,比如类、字符串缓冲池等,尤其是数组,不仅可以装载基本数据类型,也可以装载对象,跟我们要学习的集合存在某种程度的冲突,那么他们的区别在哪里?
数组的长度是固定,而集合的长度是可变的,数组一旦初始化以后,它所能装载的对象个数是不能超出它的长度的,而集合创建以后,可以任意的装载对象;具备的现实意义就是,大多数我们的数据是动态的,比如论坛网站的会员信息,门户网站的新闻,社交网站的状态,所以无法在程序中指定一个固定长度数值去装载它,只能要这里的集合去装载。
整个集合框架的学习必须参考上面的集合框架图,首先需要的介绍是Collection,为什么呢?如果你仔细查看上图会发现,它下面有很多分支(向上的尖头指向它),而这正是java继承的特点,就是事物不断向上抽取共性(实际就是指方法),一般顶层都是接口,它包含了子类的共性方法。而我们发现其实集合框架顶层其实只有Collection、Map和Iterator,而Iterator其实不是容器,这一块后面具体介绍,所以首先我们要了解顶层接口有那些共性的方法,然后在去看看不同子类有那些特殊的方法。
而容器从字面来说,它会具备的方法,无非添加、修改、删除、取出等主要功能,翻看API中java.util.Collection的方法:
1、 添加
boolean add(E e);
E可以理解为Object,其它是element(元素)的缩写。
boolean addAll(Colllection extends E> c);
extends E>是泛型,后面介绍。
2、 删除
boolean remove(Object o);
boolean removeAll(Collection> c);
void clear();
移除collection中所有元素。
3、 取出
int size();
Iterator iterator();
迭代器。
4、 判断
boolean isEmpty();
容器中不包含元素,返回true。
boolean contains(object o);
boolean containsAll(Collection> c);
如果此collection 包含指定 collection 中的所有元素,则返回true。
retainAll(Collection> c);
仅保留此 collection 中那些也包含在指定collection 的元素(可选操作),其实就是数学中的取交集。
对上面介绍的collection方法的进行演示,我们需要寻找它的一个子类,这里就用ArrayList来演示。
import java.util.*;
class CollectionDemo {
publicstatic void main(String[] args){
//创建容器1
ArrayListcoll = new ArrayList();
method1(coll);
//创建容器2
ArrayListcoll2 = new ArrayList();
method2(coll2);
//创建容器2
ArrayListcoll3 = new ArrayList();
method3(coll2,coll3);
}
publicstatic void method1(Collection coll){
//添加 字符串
coll.add("abc");
coll.add("123");
coll.add("efg");
//打印容器
System.out.println("size:"+coll.size()+","+coll);
//包含
System.out.println(coll.contains("123"));
//删除
coll.remove("123");
System.out.println("size:"+coll.size()+","+coll);
//清除
coll.clear();
System.out.println("isEmpty:"+coll.isEmpty()+","+coll);
System.out.println("============method1=================");
}
publicstatic void method2(Collection coll){
coll.add(newPerson("zhangsan",23));
coll.add(newPerson("xiaoming",24));
coll.add(newPerson("lisi",25));
coll.add(newPerson("wangwu",26));
System.out.println(coll);
//输出集合中每一个元素的字符串表现形式,即调用toString();
//包含
System.out.println(coll.contains(newPerson("lisi",25)));
System.out.println(coll.contains("123"));
//删除
coll.remove(newPerson("lisi",25));
//打印
System.out.println(coll);
System.out.println("============method2=================");
}
publicstatic void method3(Collection coll,Collectioncoll2){
coll2.add(newPerson("zhangsan",23));
coll2.add(newPerson("xiaoming",24));
//包含-容器
System.out.println(coll.containsAll(coll2));
//删除
//coll.removeAll(coll2);
//System.out.println(coll);
//合集
coll.retainAll(coll2);
System.out.println(coll);
System.out.println("============method3=================");
}
}
class Person {
privateString name;
privateint age;
Person(Stringname,int age){
this.name= name;
this.age= age;
}
publicString toString(){
returnname +":"+ age;
}
publicboolean equals(Object obj) throws ClassCastException{
if(!(obj instanceof Person))
thrownew ClassCastException("不是Person类");
Personp = (Person)obj;
returnname.equals(p.name) && age == p.age;
}
}
注意:在contains和remove方法使用的时候,这里面包含了判断元素是否相等的前提,其实它是调用元素的equals方法,而我们自定义的类是从Object类中继承过来,它比较对象的地址,一般需要根据我们实际情况进行复写。
1、 什么是迭代器?
可以看着获取容器中元素的方法。
2、 迭代器的获取?
Collection中调用iterator()方法。
import java.util.*;
class IteratorDemo {
publicstatic void main(String[] args){
ArrayListcoll = new ArrayList();
coll.add(newPerson("李四",23));
coll.add(newPerson("王五",24));
coll.add(newPerson("张三",22));
Iteratorit = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("===================================");
for(Iteratorit2 = coll.iterator();it2.hasNext();){
System.out.println(it2.next());
}
}
}
1、 为什么要使用迭代器?
集合框架中包含List、Set分支,List下面有(ArrayList、LinkedList),Set下面有(HashSet、TreeSet、LinkedHashSet),它们是不同的容器,最本质的区别就是数据结构不同,即在内存中存放数据的规则不一样。这导致的一个问题,不同容器获取数据的方法是不一样的,比如AarryList是顺序的,可以按角标获取元素get(int index),而set是无序的,不能根据角标去获取元素;在容器使用上是非常不方便的,这时候就需要考虑建立一个统一方法解决这个问题,这就是迭代器的由来。
2、 迭代器的原理?
首先建立统一的方法供调用,实现方式就是让Collection继承了一个Iterable
List:有序,元素可以重复的,元素都有角标。
Set: 无序,元素不可以重复。
最重要的就是元素含有角标,所以可以按角标进行添加、删除、修改和获取。
1、 添加
void add(intindex, E element);
在列表的指定位置插入指定元素
voidadd(int index,Collection Extends E> c);
将指定 collection 中的所有元素都插入到列表中的指定位置
2、 删除
E remove(intindex);
移除列表中指定位置的元素。注意:方法返回被移除的元素。
3、 修改
E set(intindex,E element);
用指定元素替换列表中指定位置的元素;注意:返回替换前的元素。
4、 获取
E get(intindex);
返回列表中指定位置的元素。
intIndexOf(Object o);
返回此列表中第一次出现该指定元素的索引;如果此列表不包含该元素,则返回-1.
intlastIndexof(Object o);
返回比列表中最后出现该指定元素的索引;如果列表中不包含此元素,则返回-1.
List
返回列表中指定的fromIndex和toIndex之间的部分视图。
importjava.util.*;
class ListDemo {
public static void main(String[] args){
ArrayList coll= new ArrayList();
coll.add(new Person("王大",18));
coll.add(new Person("张三",20));
coll.add(new Person("王五",22));
coll.add(new Person("张三",20));
System.out.println(coll);
//添加
coll.add(1,new Person("李二",19));
System.out.println(coll);
//删除
System.out.println(coll.remove(1));
System.out.println(coll);
//修改
System.out.println(coll.set(0,newPerson("李大",17)));//返回替换前的元素
System.out.println(coll);
//获取
for(int i = 0; i
import java.util.*;
class ListIteratorDemo {
public static voidmain(String[] args){
ArrayListcoll = new ArrayList();
coll.add(newPerson("王大",18));
coll.add(newPerson("张三",20));
coll.add(newPerson("王五",22));
Iteratorit = coll.iterator();
while(it.hasNext()){
Person p= it.next();
if(p.age== 20){
coll.add(newPerson("小明",23));
}
System.out.println(p);
}
}
}
如果在迭代器迭代的过程,集合操作列表元素,因为并发操作元素,这是会出现异常“ConcurrentModificationException”,这是需要Iterator的子接口ListIterator,该迭代器可以操作元素,只有List集合有。
import java.util.*;
class ListIteratorDemo {
public static voidmain(String[] args){
ArrayListcoll = new ArrayList();
coll.add(newPerson("王大",18));
coll.add(newPerson("张三",20));
coll.add(newPerson("王五",22));
ListIteratorit = coll.listIterator();
while(it.hasNext()){
Person p= it.next();
if(p.age== 20){
it.add(newPerson("小明",23));
}
System.out.println(p);
}
}
}
List常用子类:
--Vector:数组接口,查询慢,增删慢,因为同步。
--ArrayList:数组结构,查询快,增删慢,非同步。
--LinkedList:链表结合,增删快,查询慢,非同步。
链表
而链表的区间不连续,查询数据时,索引的时间比数组会长。但是如上图所示,增删是比数组快,因为数值增删需要整体位移。
Vector是jdk1.0是推出的集合容器,在2.0以后即被其它容器取代,不做介绍。
LinkedList在使用上具有差异性:链表存在头和尾,所谓含有特有的方法可以对链表头和尾的元素进行操作。
1、 添加。
void addFirst(E e);
将指定元素插入此列表的开头。
void addLast(E e);
将指定元素添加到此列表的结尾。
boolean offer(E e);
将指定元素添加到此列表的末尾。
boolean offerFirst(E e);
在此列表的开头插入指定的元素。
boolean offerLast(E e);
在此列表的末尾插入指定元素。
两者的区别:在使用双端队列且有容量限制的时候,offer方法在遇到容量过小时,返回false,而add则抛出异常,建议使用offer。
2、 修改
E removeFirst();
移除并返回此列表的第一个元素。
E removeLast();
移除并返回此列表的最后一个元素。
3、 获取
E getFirst();
返回此列表的第一个元素。
E getLast();
返回此列表的最后一个元素。
E peek();
获取但不移除此列表的头。
E peekFrist();
获取但不移除此列表的第一个元素;如果此列表为空,则返回null。
E peekLast();
获取但不移除此列表的最后一个元素;如果此列表为空,则返回null。
E poll();
获取并移除此列表的头。
E pollFrist();
获取并移除此列表的第一个元素;如果此列表为空,则返回 null。
E pollLast();
获取并移除此列表的最后一个元素;如果此列表为空,则返回 null。
与remove的区别:当双端队列为空时remove抛出移除,而poll返回null。
import java.util.*;
class LinkedListDemo {
publicstatic void main(String[] args){
DuiLieduiLie = new DuiLie();
duiLie.add("123");
duiLie.add("456");
duiLie.add("789");
System.out.println(duiLie.size());
for(inti = 0;i < duiLie.size(); i++){
System.out.println(duiLie.get(i));
}
DuiZhanduiZhan= new DuiZhan();
duiZhan.add("123");
duiZhan.add("456");
duiZhan.add("789");
System.out.println(duiZhan.size());
for(inti = 0;i < duiZhan.size(); i++){
System.out.println(duiZhan.get(i));
}
}
}
class DuiLie {
privateLinkedList coll ;
DuiLie(){
coll= new LinkedList();
}
publicvoid add(T obj){
coll.add(obj);
}
publicT get(int index){
returncoll.get(index);
}
publicint size(){
returncoll.size();
}
}
class DuiZhan {
privateLinkedList coll ;
DuiZhan(){
coll= new LinkedList();
}
publicvoid add(T obj){
coll.addFirst(obj);
}
publicT get(int index){
returncoll.get(index);
}
publicint size(){
returncoll.size();
}
}
上面已经介绍,需要注意的是在涉及到元素比较的方法,如contains、indexOf、retainAll、remove(Oject obj)时,默认调用的是元素的equals方法。
Set特点:无序,且不能重复的。
1、 Set集合怎么保证内部的元素是不重复的?
HashSet:首先比较元素的Hash码,即调用元素的hashCode()方法,如果不相同则元素不同;如果相同,则还需比较元素是否相同,即调用equals()方法,如果相同,则元素相同,不能装载,反之可以。
LinkedHashSet:同上。
TreeSet:调用元素的compareTo()方法或者是集合实现Comparator接口(优先compareTo()方法)。
2、 Set集合子类都有哪些?它们之间有什么区别?
--HashSet:无序,不重复。
--LinkedHashSet:有序,获取元素的顺序和存入一致。
--TreeSet:加载后的元素可以排序。
哈希表是一种算法,HashSet集合就是按hashCode返回的结果去存储和查询数据。比如我们去查找数元素时,首先拿到元素的hashCode值,然后去查找此hashcode对应的内存。
1、 为什么在jdk关于equlas方法的介绍时,建议equals相同时,hashcode也要相同?
因为部分集合HashSet、HashMap在添加元素时,调用equals的前提就是HashCode相同,如果equals()相同,反回来说明元素的HashCode一定是相同的。因为equals相同,而HashCode不同,存在的问题就是相同元素会添加到HashSet、HashMap中。
其实真正判读是否相同的依据还是equlas,只是从设计上来说,部分集合的逻辑是需要判断HashCode来存储数据的。
import java.util.*;
class HashSetDemo {
publicstatic void main(String[] args){
HashSetcoll = new HashSet();
coll.add(newPerson("小强",25));
coll.add(newPerson("小明",23));
coll.add(newPerson("小张",24));
coll.add(newPerson("小张",24));
for(Iteratorit = coll.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}
class Person {
Stringname;
intage;
Person(Stringname,int age){
this.name= name;
this.age= age;
}
publicString toString(){
returnname +":"+ age;
}
publicboolean equals(Object obj) {
if(!(obj instanceof Person))
thrownew ClassCastException("不是Person类");
Personp = (Person)obj;
returnname.equals(p.name) && age == p.age;
}
publicint hashCode(){
returnname.hashCode()+31*age;
}
}
特点:有序,hashSet的子类,就好像在hashSet基础上用一个链子根据元素存入的先后串联起来。
import java.util.*;
class LinkedHashSetDemo {
publicstatic void main(String[] args){
//HashSeths = new HashSet();
LinkedHashSeths = new LinkedHashSet();
hs.add("xixi");
hs.add("hehe");
hs.add("haha");
hs.add("88");
for(Iteratorit = hs.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}
特点:可以按照元素排序。
1、 TreeSet是怎么实现元素排序的?
有两种方式:
第一种,元素需要实现comparable接口,复写compareTo方法,该方法比较两个元素,返回值为int,如果大于1,则顺序;等于0表示相等;小于0,则倒序。这又叫元素的自然排序。
importjava.util.*;
classTreeSetDemo {
public static void main(String[] args){
TreeSet ts = newTreeSet();
ts.add(new Person("小强",25));
ts.add(new Person("小明",23));
ts.add(new Person("小张",24));
ts.add(new Person("小李",23));
for(Iterator it =ts.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}
classPerson implements Comparable{
String name;
int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name +":"+ age;
}
public boolean equals(Object obj){
if (!(obj instanceof Person))
throw newClassCastException("不是Person类");
Person p = (Person)obj;
return name.equals(p.name) &&age == p.age;
}
public int hashCode(){
return name.hashCode()+31*age;
}
public int compareTo(Object obj){
/*
if (obj.getClass() != Person){
throws newClassCastException("类型错误");
}
*/
//健壮性判断
if (!(obj instanceof Person))
throw newClassCastException("不是Person类");
Person p = (Person)obj;
//return age - ((Person)obj).age;
int temp = this.age - p.age;
return temp == 0?this.name.compareTo(p.name):temp;
}
}
第二种,是集合实现Comparator接口,实现compare()方法,传入两个元素,比较大小,规则如上。
importjava.util.*;
classTreeSetDemo {
public static void main(String[] args){
TreeSet ts = newTreeSet(new MyComparator());
ts.add(new Person("小强",25));
ts.add(new Person("小明",23));
ts.add(new Person("小张",24));
ts.add(new Person("小李",23));
for(Iterator it =ts.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}
classPerson {
String name;
int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name +":"+ age;
}
public boolean equals(Object obj){
if (!(obj instanceof Person))
throw newClassCastException("不是Person类");
Person p = (Person)obj;
return name.equals(p.name) &&age == p.age;
}
public int hashCode(){
return name.hashCode()+31*age;
}
}
classMyComparator implements Comparator {
public int compare(Person o1,Person o2){
int temp = o1.age -o2.age;
return temp == 0? o1.name.compareTo(o2.name) : temp;
}
}
要点:集合自身的比较性优先于元素的比较性。
import java.util.*;
class TreeSetTest {
publicstatic void main(String[] args){
TreeSetts = new TreeSet(new ComparatorByLength());
ts.add("abc");
ts.add("adcdef");
ts.add("ac");
ts.add("abcd");
for(Iteratorit = ts.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}
class ComparatorByLength implementsComparator {
publicint compare(String o1,String o2){
returno1.length() - o2.length();
}
}
import java.util.*;
class TreeSetTest {
publicstatic void main(String[] args){
TreeSetts = new TreeSet(new ComparatorByLength());
ts.add("abc");
ts.add("adcdef");
ts.add("ac");
ts.add("ab");
ts.add("abcd");
for(Iteratorit = ts.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}
class ComparatorByLength implementsComparator
1、 Map集合的特点,与colllection的区别?
Map集合一次可以添加一对元素;collection一次添加一个元素。
Map称为双列集合;collection称为单列集合。
Map集合存放的是键值对,它们是映射关系,不能包含重复的键,一个键最多映射到一个值。
2、 有哪些常用方法?
1、 添加
V put(K key,V value);
返回前一个和key关联的值,如果没有则为null。
2、 删除
void clear();
清空Map集合。
V remove(K key);
根据键删除集合中的键值对。
3、 修改
4、 获取
V get(K key);
通过键获取值,如果没有该键,则返回null。
it size();
获取键值对的个数。
5、 判断
boolean containsKey(k key);
集合中是否包含该键。
boolean containsValue(V value);
集合中是否包含该值。
boolean isEmpty();
集合是否为空。
import java.util.*;
class MapDemo {
public static voidmain(String[] args){
//创建容器
HashMaphm = new HashMap();
//添加
hm.put(1,"abc");
hm.put(3,"efg");
hm.put(2,"hij");
hm.put(4,"小李");
System.out.println(hm);
System.out.println(hm.put(2,"小明"));
System.out.println(hm);
//删除
hm.remove(4);
System.out.println(hm);
//判断
System.out.println(hm.containsKey(2));
System.out.println(hm.containsKey(4));
System.out.println(hm.containsValue("abd"));
System.out.println(hm.containsValue("abc"));
System.out.println(hm.containsValue(hm.isEmpty()));
//获取
System.out.println(hm.size());
System.out.println(hm.get(1));
System.out.println(hm.get(4));
}
}
1、 keySet()方法的介绍和使用?
Set
返回此映射中所包含的键的Set视图。
获取到Set集合,然后通过迭代器的next()方法获取到每一个键值,再通过Map的get(K key)方法,根据每一个键获取到值。
import java.util.*;
class KeySetDemo {
publicstatic void main(String[] args) {
//创建容器
HashMaphm = new HashMap();
//添加
hm.put(1,"abc");
hm.put(3,"efg");
hm.put(2,"hij");
hm.put(4,"小李");
//调用keySet()返回set集合
Setset = hm.keySet();
//调用迭代器,遍历Set元素
for(Iteratorit = set.iterator();it.hasNext();){
Integerkey = it.next();
//通过Map的get(key)方法,再获取到值
Stringvalue = hm.get(key);
System.out.println(key+":"+value);
}
}
}
1、 entrySet()方法的介绍,与keySet()方法的区别?
Set
返回此映射所包含的映射关系的set视图。
与keySet()的区别:它返回的也是Set集合,但是集合中包含的元素却不是
由Map的key值组成,它是Map中key和value的映射关系,它是一个明确类型,类名为Map.Entry
Jdk中关于Map.Entry
import java.util.*;
class EntrySetDemo {
public static voidmain(String[] args) {
//创建容器
HashMaphm = new HashMap();
//添加
hm.put(1,"abc");
hm.put(3,"efg");
hm.put(2,"hij");
hm.put(4,"小李");
//调用keySet()返回set集合
Set>set = hm.entrySet();
//调用迭代器,遍历Set元素
for(Iterator>it = set.iterator();it.hasNext();){
Map.Entryentry = it.next();
Integerkey = entry.getKey();
//修改
if(key==2)
//hm.put(5,"++++++");迭代过程中集合不能操作元素
entry.setValue("=======");
System.out.println(key+":"+entry.getValue());
}
}
}
1、 values()方法介绍?
Collection
返回此映射所包含的值的Collection视图。
它可以看做是keySet()对应的方法;keySet()返回的是key值的集合,因为Map中key值不能重复,所以返回的是Set集合;而values()返回的是Map中value值的集合,因为value可以重复,所以返回集合为Collection;而entrySet()返回的是两者的关系。
import java.util.*;
class ValuesDemo {
public static voidmain(String[] args) {
//创建容器
HashMaphm = new HashMap();
//添加
hm.put(1,"abc");
hm.put(3,"efg");
hm.put(2,"hij");
hm.put(4,"小李");
//调用valuest()返回Collection集合
Collectionvalues = hm.values();
//调用迭代器,遍历Collection元素
for(Iteratorit = values.iterator();it.hasNext();){
System.out.println(it.next());
}
}
}
1、 Map的常见子类对象及特点?
--HashTable:jdk1.0推出,内部结构哈希表,同步的,不允许null作为键,null作为值。
--Properties:用来存储键值对型配置文件的信息,可以和IO技术相集合。
--HashMap:内部结构是哈希表,不是同步的,允许null作为键,null作为值。
--TreeMap:内部结构是二叉树,不是同步的。
--LinkedHashMap:内部结构是链表,不是同步的。
不同Map容器在实际应用中,最大的区别就是可以对键值对不同的处理,比如HashMap会对键做是否相同的判断,即判断hashCode和equlas,和HashSet相同。
特点:HashMap会对键做是否相同的判断,即判断hashCode和equlas,和HashSet相同。
importjava.util.*;
classHashMapDemo {
public static void main(String[] main){
//创建容器,存放个人信息和所属城市
HashMaphm = new HashMap();
//添加
hm.put(new Person("小明",23),"上海");
hm.put(new Person("小李",22),"江苏");
hm.put(new Person("老王",44),"北京");
hm.put(new Person("小强",32),"浙江");
//修改
hm.put(new Person("小强",32),"海南");
//调用entrySet()返回set集合
Set>entrySet = hm.entrySet();
//set迭代器
for(Iterator>it = entrySet.iterator();it.hasNext();){
//获取set中元素
Map.Entryentry = it.next();
//获取key值
Person key =entry.getKey();
//获取value值
String value =entry.getValue();
System.out.println(key.name+":"+key.age+",地址:"+value);
}
}
}
class Person {
String name;
int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name +":"+age;
}
public boolean equals(Object obj){
if (!(obj instanceof Person))
throw newClassCastException("错误类型");
Person p = (Person)obj;
return name.equals(p.name)&& age == p.age;
}
public int hashCode(){
return name.hashCode()+31*age;
}
}
特点:TreeMap会对键做大小判断,即元素中compareTo()方法的结果或者是TreeMap中Comparator接口compare()方法的结果,TreeMap相同。
import java.util.*;
class TreeMapDemo {
public static voidmain(String[] main){
//创建容器,存放个人信息和所属城市
TreeMaptm = new TreeMap(new MyComparator());
//添加
tm.put(newPerson("小明",23),"上海");
tm.put(newPerson("小李",22),"江苏");
tm.put(newPerson("老王",44),"北京");
tm.put(newPerson("小强",32),"浙江");
tm.put(newPerson("小强",19),"北京");
//调用entrySet()返回set集合
Set>entrySet = tm.entrySet();
//set迭代器
for(Iterator>it = entrySet.iterator();it.hasNext();){
//获取set中元素
Map.Entryentry = it.next();
//获取key值
Personkey = entry.getKey();
//获取value值
Stringvalue = entry.getValue();
System.out.println(key.name+":"+key.age+",地址:"+value);
}
}
}
class MyComparator implements Comparator {
public intcompare(Person o1,Person o2){
int temp =o1.age -o2.age;
return temp== 0? o1.name.compareTo(o2.name) : temp;
}
}
09-常用对象API(集合框架-Map集合-LinkedHashMap&关联源码).avi
特点:有序,获取键值对的顺序和添加顺序一致。
import java.util.*;
class LinkedHashMapDemo {
public static voidmain(String[] main){
//创建容器,存放个人信息和所属城市
//HashMaphm = new HashMap();
LinkedHashMaphm = new LinkedHashMap();
//添加
hm.put(newPerson("小明",23),"上海");
hm.put(newPerson("小李",22),"江苏");
hm.put(newPerson("老王",44),"北京");
hm.put(newPerson("小强",32),"浙江");
//调用entrySet()返回set集合
Set>entrySet = hm.entrySet();
//set迭代器
for(Iterator>it = entrySet.iterator();it.hasNext();){
//获取set中元素
Map.Entryentry = it.next();
//获取key值
Personkey = entry.getKey();
//获取value值
Stringvalue = entry.getValue();
System.out.println(key.name+":"+key.age+",地址:"+value);
}
}
}
10-常用对象API(集合框架-Map集合练习-记录字母次数思路).avi
练习:字符串“fdgavcbsacdfs“获取字符串中,每一个字母出现的次数;要求打印的结果是:a(2)b(1)…..;
11-常用对象API(集合框架-Map集合练习-记录字母次数代码).avi
import java.util.*;
class CharCountInString {
public static voidmain(String[] main){
//待处理的字符串
String str ="fdgavcbsacdfs";
showCharCount(str);
}
public static voidshowCharCount(String s){
//首先需要遍历字符串每一个字符。放在数组中最好,当然也可以通过截取的方式。
//把字符串变成字符数组,便于遍历
char[] ch =s.toCharArray();
//创建Map集合,因为是从a开始的,所以是按键排序的,用TreeMap
TreeMaptm = new TreeMap();
//for循环遍历
for(int i=0;i>entrySet = tm.entrySet();
for(Iterator>it = entrySet.iterator();it.hasNext();){
Map.Entryentry = it.next();
Characterkey = entry.getKey();
Integervalue = entry.getValue();
System.out.print(key+"("+value+")");
}
}
}
12-常用对象API(集合框架-Map集合练习-Map查表法).avi
有映射关系,都可以用Map