java 自学日志【十一】---集合框架
2013-05-07 23:41
447 查看
-------android培训,java培训,期待与您交流--------
集合框架
为什么出现集合类?
对象是对数据的封装,而集合是对对象的封装。编程中除了对单个象的操作外,
常常还需要对多个对象进行统一操作,这时就需用一个容器将这些对象存储起来,这样的容器就是集合。
其实,String类也是一个特殊的容器,它存储的是char类型的元素。集合的共性操作就是CRUD。集合的应用比数组更广泛。
集合与数组的区别
他们都是容器,都可以存储对象,他们的区别是:数组的长度是固定的,而集合的长度的可变的;
数组既能存储基本数据类型也能存储引用数据类型,而集合只能存储引用数据类型,
如果给集合添加基本数据类型的元素,这些基本数据类型会自动装箱成对应的引用数据类型;数组存储的元素都是同一类型,而集合可以存储不同类型的元素。
集合的特点: 集合只用于存储对象,它的长度可变,能够存储不同类型的对象。
集合框架为什么有这么多的容器?
因为每一个容器对数据的存储方式都有不同,这个存储方式称之为:数据结构。
提示:学习javaAPI时,通常查阅父类接口,了解其体系的共性方法,而使用时选择具体的子类,以利用子类的特有方法。
Collection
共性方法
Collection是一个接口,它定义了一些共性的方法,包括添加、移除、清空元素,是否为空、是否包括某一元素,获取元素个数等操作。
注意:
1.它里边有一个Iterator方法,专门用于取出元素。
2.集合的add方法的参数类型是Object,以便于接受任意类型的对象。
3.集合中存放的都是对象的引用(地址)。
Iterator(迭代器)
集合中的的元素取出动作,不足以用一个函数来描述(取出前要先判断有没有),同时不同的存储结构,其取出的方式也不同,
所以定义了一个接口Iterator专门用来实现其取出操作。因为要访问集合内部的元素,所以迭代器的实现放在了具体集合的内部。
代码:
Collection
|--List:元素是有序的,元素可以重复。因为该集合体系有索引。
|--ArrarList:底层数据使用的是数据结构。JDK1.2才出现的。特点:查询修改速度很快,但添加删除很慢。线程不同步。
|--LinkedList:底层数据用的是链表数据结构。特点:增删速度很快,查询稍慢。
|--Vector:底层是数组数据结构。JDK1.0出现的,线程同步。被ArrayList替代了,增删查询都很慢。
|--Set:元素是无序的(存入和取出的顺序不一定一致),元素不可重复,没有索引。
|---HashSet:底层数据结构是哈希表。
|---TreeSet:底层数据是二叉树结构。
Set集合的功能和Collection是一致。
List特有方法:List中凡是可以操作角标的方法都是该体系特有的方法。
通用方法
增:
add(index,element);
addAll(index,Collection);
删:
remove(index);
改:
set(index,element);
查:
get(index);
subList(from,to);
ListIterator();
注意:
1. List判断包含、移除等操作都要调用equals方法。所以新建立一个Student类,将值存入集合时,要复写equals方法,以满足对对象相同的设定。
2. List取出元素的方式有三种:for循环,Iterator,ListIterator。
List特有的迭代器:ListIterator
ListIterator是Iterator的子接口。在迭代时,不可以通过集合对象的方法操作集合中的元素,因为会发生ConcurrentModificationException异常。
所以,在迭代时,只能用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判读,取出,删除的操作。
如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator。实现该接口的子类对象只能通过List集合的ListIterator方法获取。
代码:
ArrayList
ArrayList底层是数组结构,线程不同步。
代码:
Vector底层也是数组结构,它是线程同步的,但效率低,它有自己特有的枚举Enumeration,用来取出集合元素。
后来ArrayList取代了Vector,Iterator取代了Enumeration。
代码:
LinkedList的特有方法:
addFirst(); addLast();
getFirst();getLast();
获取元素,但不删除元素.如果集合中没有元素,会出现NoSuchElementException
removeFirst();removeLast();
获取元素,同时删除元素。如果集合中没有元素,会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();offerLast();
peekFirst();peekLast();
获取元素,但是元素不被删除。如果集合中没有元素,会返回null
poolFirst();poolLast();
获取元素,但是元素被删除。如果集合中没有元素,会返回null。
代码:
Set
与List不同,Set中的元素不允许重复,但这里的“不允许”是建立在你正确运用其实现原理的基础上,否则仍可能出现重复的情况。
Set常用的子类为HashSet和TreeSet,这两个子类实现元素唯一性的原理不同:HashSet是通过依次调用元素的hashCode和equals方法,
而TreeSet是通过让元素或集合具备比较性(分别对应Comparable和Comparator两个接口)来实现的。
TreeSet还有一个特点,它的元素是有序的。这里的有序,跟其存入顺序无关,是指其自然顺序或比较器指定的顺序。
HashSet
HashSet是如何保证元素的唯一性?
是通过依次调用hashCode和equals来完成。如果元素的HashCode值相同,才会判断equals是否为true。
如果元素的hashCode值不同,不会调用equals方法。(开发时,往集合存对象时,一般要重写对象所属类的hashCode和equals方法)
HashSet对于判断元素是否存在,删除等操作,依赖的方法也是元素的hashCode和equals方法。
代码:
TreeSet中元素的取出顺序跟存入顺序无关,不可以有重复元素。
TreeSet实现排序的方式有两种:
一、让元素具备比较性(或自然顺序,实现Comparable接口)
TreeSet存入的元素,如果没有实现Comparable接口,往TreeSet中add第一个元素的时候,不会出问题,但add第二个元素时,会出现类型转换异常,
因为TreeSet集合是通过Comparable接口的compareTo方法来完成排序的,它默认其中的元素都实现了Comparable接口。
同时,在compareTo方法中,当主要条件判断相等后,一定要再判断下次要条件。
TreeSet对于判断元素是否存在,删除等操作,依赖的方法也是元素的compareTo方法。
二、让集合具备比较器(集合传入Comparator)
当集合元素没有比较性或具备的比较性不是所需要的时,可以让集合自己具备比较性,即集合初始化时,把一个比较器Comparator作为参数传入集合的构造函数。
Comparator接口里边有个compare(obj,obj)方法。
代码:
泛型:jdk1.5版本以后出现的新特性,用于解决安全问题,是一个安全机制,类型安全机制;
好处:①将运行时的异常转移到了编译时期,方便程序员解决问题,让问题减少,提高安全性;
② 避免了强制类型转换的麻烦。
泛型的格式:通过“<>”定义要操作的引用数据类型,<>是接受类型的,当使用集合时,将集合中要
存储的数据类型作为参数传递到<>中即可。
泛型类:当定义的类中要操作的引用数据类型不确定的时候,早起定义Object来完成,现在定义泛型来完成,
泛型类定义的泛型在整个类中有效,如果某方法使用,那么泛型的对象明确要操作的具体类型后,
所有操作的类型就固定了,为了让不同的方法可以操作不同的类型,可以将泛型定义在方法上;
泛型类:class Demo<T> {public void show(T t)}
泛型方法:public <Q> void show(Q,q);
<> 定义在返回值类型的前面,修饰符的后面;
注意:静态函数不可以访问类上定义的泛型,如果静态方法操作应用的对象数据类型不确定,可以将泛型
定义在方法上。
Map
Map集合:它存储的是键值对,其中键必须保证唯一性,值允许重复。
Map集合没有自身特有的迭代器,它的元素取出是通过将键或键值对放入Set集合中,利用Set集合中的迭代器取出的。
Map是双列集合,Collection是单列集合。
共性方法
Map接口中定义了该体系通用的方法。
1.添加
V put(K key, V value)
void putAll(Map<? extends K,? extends V>m)
注意put与add的不同:put时,如果key已经存在,则新存入的值覆盖原来的值,并把原来的值作为方法的返回值;
add时,如果该元素已经存在,则不能存入集合,方法返回值为false,如果存在,则存入集合,方法返回值为true。
2.删除
clear()
V remove(Object key)
3.判断
boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
4.获取
V get(Object key)
int size()
Collection<V> values()
Set<Map.Entry<K,V>>entrySet()
Set<K> keySet()
代码演示:
Map
|---Hashtable<K,V>:底层是哈希表数据结构,不可以存入null键null值,该集合是同步的。JDK1.0,效率低。,
|---HashMap<K,V>:底层是哈希表数据结构,允许存入null键null值,该集合是不同步的。JDK1.2,效率高。
|---TreeMap<K,V>:底层是二叉树结构,线程不同步,可以用于给Map集合中键进行排序。
和Set很像,其实Set底层就是使用了Map集合。
map集合的两种取出方式:
1.Set<K> keySet;将map中的所有的键存入到Set集合,因为set具有迭代器。
所以可以迭代方式取出所有的键,再根据get方法,获取每一个键对应的值。
Map集合的取出原理:将Map集合转成Set集合,再通过迭代器取出。
2.Set<Map.Entry<K,V>> entrySet:将Map集合中的映射关系存入到了Set集合中,
而这个关系的数据类型就是:Map.Entry.
代码演示:
Map扩展
Map集合中的值还可以是Map集合,这是Map集合嵌套使用的情况。
代码:
集合框架
为什么出现集合类?
对象是对数据的封装,而集合是对对象的封装。编程中除了对单个象的操作外,
常常还需要对多个对象进行统一操作,这时就需用一个容器将这些对象存储起来,这样的容器就是集合。
其实,String类也是一个特殊的容器,它存储的是char类型的元素。集合的共性操作就是CRUD。集合的应用比数组更广泛。
集合与数组的区别
他们都是容器,都可以存储对象,他们的区别是:数组的长度是固定的,而集合的长度的可变的;
数组既能存储基本数据类型也能存储引用数据类型,而集合只能存储引用数据类型,
如果给集合添加基本数据类型的元素,这些基本数据类型会自动装箱成对应的引用数据类型;数组存储的元素都是同一类型,而集合可以存储不同类型的元素。
集合的特点: 集合只用于存储对象,它的长度可变,能够存储不同类型的对象。
集合框架为什么有这么多的容器?
因为每一个容器对数据的存储方式都有不同,这个存储方式称之为:数据结构。
提示:学习javaAPI时,通常查阅父类接口,了解其体系的共性方法,而使用时选择具体的子类,以利用子类的特有方法。
Collection
共性方法
Collection是一个接口,它定义了一些共性的方法,包括添加、移除、清空元素,是否为空、是否包括某一元素,获取元素个数等操作。
注意:
1.它里边有一个Iterator方法,专门用于取出元素。
2.集合的add方法的参数类型是Object,以便于接受任意类型的对象。
3.集合中存放的都是对象的引用(地址)。
Iterator(迭代器)
集合中的的元素取出动作,不足以用一个函数来描述(取出前要先判断有没有),同时不同的存储结构,其取出的方式也不同,
所以定义了一个接口Iterator专门用来实现其取出操作。因为要访问集合内部的元素,所以迭代器的实现放在了具体集合的内部。
代码:
import java.util.*; class CollectionDemo { public static void main(String[] args) { method_get(); //method_1(); } public static void method_get() { ArrayList al = new ArrayList(); //1.添加元素 al.add("java01");//add的参数是Object类型的。 al.add("java02"); al.add("java03"); al.add("java04"); Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素。 sop(it.hasNext()); sop(it.next()); sop(it.hasNext()); while(it.hasNext()) { sop(it.next()); } /* for(Itera tor it = al.iterator();it.hasNext();) { sop(it.next()); } */ } //取交集 public static void method_1() { ArrayList al1 = new ArrayList(); al1.add("java01"); al1.add("java02"); al1.add("java03"); al1.add("java04"); ArrayList al2 = new ArrayList(); al2.add("java02"); al2.add("java05"); al2.add("java07"); al2.add("java08"); //al1.retainAll(al2);//取交集,al1中只会保留和al2中相同的元素。 al1.removeAll(al2); sop("al1:"+al1); sop("al2:"+al2); } public static void base_method() { //创建一个集合容器,使用Collection接口的子类,ArrayList ArrayList al = new ArrayList(); //1.添加元素 al.add("java01");//add的参数是Object类型的。 al.add("java02"); al.add("java03"); al.add("java04"); //打印原集合 sop(al); //3.删除元素 al.remove("java02"); //4.判断元素。 sop("java03是否存在:"+al.contains("java03")); sop("结合是否为零:"+al.isEmpty()); //2,获取个数,集合长度 sop("size="+al.size()); //打印改变后的集合 sop(al); } public static void sop(Object obj) { System.out.println(obj); } }Collection体系结构
Collection
|--List:元素是有序的,元素可以重复。因为该集合体系有索引。
|--ArrarList:底层数据使用的是数据结构。JDK1.2才出现的。特点:查询修改速度很快,但添加删除很慢。线程不同步。
|--LinkedList:底层数据用的是链表数据结构。特点:增删速度很快,查询稍慢。
|--Vector:底层是数组数据结构。JDK1.0出现的,线程同步。被ArrayList替代了,增删查询都很慢。
|--Set:元素是无序的(存入和取出的顺序不一定一致),元素不可重复,没有索引。
|---HashSet:底层数据结构是哈希表。
|---TreeSet:底层数据是二叉树结构。
Set集合的功能和Collection是一致。
List特有方法:List中凡是可以操作角标的方法都是该体系特有的方法。
通用方法
增:
add(index,element);
addAll(index,Collection);
删:
remove(index);
改:
set(index,element);
查:
get(index);
subList(from,to);
ListIterator();
注意:
1. List判断包含、移除等操作都要调用equals方法。所以新建立一个Student类,将值存入集合时,要复写equals方法,以满足对对象相同的设定。
2. List取出元素的方式有三种:for循环,Iterator,ListIterator。
List特有的迭代器:ListIterator
ListIterator是Iterator的子接口。在迭代时,不可以通过集合对象的方法操作集合中的元素,因为会发生ConcurrentModificationException异常。
所以,在迭代时,只能用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判读,取出,删除的操作。
如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator。实现该接口的子类对象只能通过List集合的ListIterator方法获取。
代码:
class ListDemo { public static void main(String[] args) { //演示列表迭代器 ArrayList al = new ArrayList(); //1.添加元素 al.add("java01");//add的参数是Object类型的。 al.add("java02"); al.add("java03"); //在迭代过程中,准备添加或者删除元素。 ListIterator it = al.listIterator(); sop("hasPrevious:"+it.hasPrevious()); while(it.hasNext()) { Object obj = it.next(); if(obj.equals("java02")) it.set("java08"); sop(obj); } while(it.hasPrevious()) { sop("hasPrevious:"+it.previous()); } sop("hasNext:"+it.hasNext()); sop("hasPrevious:"+it.hasPrevious()); sop(al); /* for(Iterator it = al.iterator();it.hasNext();) { Object obj = it.next(); if(obj.equals("java02")) //al.add("java07");//迭代器和集合同时操作元素,会出现ConcurrentModificationException异常。 it.remove();//将java02的引用从集合中删除了。 sop("obj="+obj); } sop(al); */ //method(); } public static void method() { ArrayList al = new ArrayList(); //1.添加元素 al.add("java01");//add的参数是Object类型的。 al.add("java02"); al.add("java03"); sop("原集合:"+al); //在指定位置添加元素。 al.add(1,"java09"); sop(al); //删除指定位置的元素。 //al.remove(2); //修改元素 //al.set(2,"java07"); //通过角标获取元素 sop("a1.get(1):"+al.get(1)); sop(al); //获取所有元素 for(int x = 0;x<al.size();x++) { sop("al("+x+"):"+al.get(x)); } for(Iterator it = al.iterator();it.hasNext();) { sop("next:"+it.next()); } //通过indexOf获取对象的位置 sop("index="+al.indexOf("java02")); List sub = al.subList(1,3); sop("sub:"+sub); } public static void sop(Object obj) { System.out.println(obj); } }
ArrayList
ArrayList底层是数组结构,线程不同步。
代码:
/* 练习:将自定义对象作为元素存到ArrayList集合中,并去除重复元素,比如:存入对象,同姓名同年龄,视为同一个人,为重复元素。 思路: 1.对人描述,将数据封装进人对象。 2.定义容器,将人存入。 3.取出。 List集合判断元素是否相同,依据的是元素的equals方法。 */ import java.util.*; class Person1 { private String name; private int age; Person1(String name,int age) { this.name =name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } //复写equals方法,其实是为集合做判(包含)断服务的。 public boolean equals(Object obj) { if(!(obj instanceof Person1)) return false; Person1 p = (Person1)(obj); return this.name.equals(p.name) && this.age==p.age; } } class ArrayListTest2 { public static void main(String[] args) { ArrayList al = new ArrayList(); Person1 p1=new Person1("mama",23); al.add(new Person1("lisi",20)); al.add(new Person1("zhangsna",23)); al.add(new Person1("wangwu",40)); al.add(new Person1("wangwu",40)); al.add(new Person1("loosi",20)); al.add(p1); al.add(p1); al=singleList(al); // sop("remove 03:"+al.remove(new Person1("zhangsna",23))); Iterator it = al.iterator(); while(it.hasNext()) { Person1 p = (Person1)it.next(); sop(p.getName()+"::"+p.getAge()); } } //去除ArrayList中的重复的元素 public static ArrayList singleList(ArrayList al) { ArrayList newAl = new ArrayList(); Iterator it = al.iterator(); while(it.hasNext()) { Object obj = it.next(); if(!(newAl.contains(obj))) //contains判断是否相同,用的是equals方法,集合中的元素如果没有重写equals方法,那么传入引用没有问题, //但如果传入的是匿名对象,那么就会出现重复元素,该函数的实现就出现了bug newAl.add(obj); } return newAl; } public static void sop(Object obj) { System.out.println(obj); } }Vector
Vector底层也是数组结构,它是线程同步的,但效率低,它有自己特有的枚举Enumeration,用来取出集合元素。
后来ArrayList取代了Vector,Iterator取代了Enumeration。
代码:
import java.util.*; class VectorDemo { public static void main(String[] args) { Vector v = new Vector(); v.add("java01"); v.add("java02"); v.add("java03"); v.add("java04"); Enumeration en =v.elements(); while(en.hasMoreElements()) { sop(en.nextElement()); } } public static void sop(Object obj) { System.out.println(obj); } }LinkedList
LinkedList的特有方法:
addFirst(); addLast();
getFirst();getLast();
获取元素,但不删除元素.如果集合中没有元素,会出现NoSuchElementException
removeFirst();removeLast();
获取元素,同时删除元素。如果集合中没有元素,会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();offerLast();
peekFirst();peekLast();
获取元素,但是元素不被删除。如果集合中没有元素,会返回null
poolFirst();poolLast();
获取元素,但是元素被删除。如果集合中没有元素,会返回null。
代码:
/* 需求:使用LinkedList模拟一个堆栈或者队列数据结构 为什么要模拟? LinkedList名称是固定的,在现实开发中,我们希望制作一个跟项目有关的容器,针对特定的数据结构提供更为简便的方法。 堆栈:先进后出。如同一个杯子。 队列:先进先出。如同一个水管。First In First Out */ import java.util.*; class DuiLie { private LinkedList link ; DuiLie() { link = new LinkedList(); } public void myAdd(Object obj) { link.addFirst(obj); } public Object myGet() { return link.removeLast(); } public boolean isNull() { return link.isEmpty(); } } class LinkedListTest { public static void main(String[] args) { DuiLie dl = new DuiLie(); dl.myAdd("java01"); dl.myAdd("java02"); dl.myAdd("java03"); dl.myAdd("java04"); sop(dl.myGet()); } public static void sop(Object obj) { System.out.println(obj); } }
Set
与List不同,Set中的元素不允许重复,但这里的“不允许”是建立在你正确运用其实现原理的基础上,否则仍可能出现重复的情况。
Set常用的子类为HashSet和TreeSet,这两个子类实现元素唯一性的原理不同:HashSet是通过依次调用元素的hashCode和equals方法,
而TreeSet是通过让元素或集合具备比较性(分别对应Comparable和Comparator两个接口)来实现的。
TreeSet还有一个特点,它的元素是有序的。这里的有序,跟其存入顺序无关,是指其自然顺序或比较器指定的顺序。
HashSet
HashSet是如何保证元素的唯一性?
是通过依次调用hashCode和equals来完成。如果元素的HashCode值相同,才会判断equals是否为true。
如果元素的hashCode值不同,不会调用equals方法。(开发时,往集合存对象时,一般要重写对象所属类的hashCode和equals方法)
HashSet对于判断元素是否存在,删除等操作,依赖的方法也是元素的hashCode和equals方法。
代码:
/* 往HashSet集合中存入自定义对象。 姓名和年龄相同为同一个人,重复元素。 */ 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 int hashCode() { System.out.println(this.name+"之前的hashCode值:"+super.hashCode()); return name.hashCode()+age*37;//所有的目的都是为了让HashSet判断的hashCode值只跟你要保证唯一的那些值有关, //age*37,是为了尽量保证hashCode值的唯一。比如(40+20)和(20+40)的情况。 } public boolean equals(Object obj) { if(!(obj instanceof Person)) return false; Person p = (Person)(obj); System.out.println(this.name+"...equals..."+p.name);//该句没有被打印说明没有调用equals()方法。 return this.name.equals(p.name) && this.age==p.age; } } class HashSetTest { public static void main(String[] args) { HashSet hs = new HashSet(); hs.add(new Person("a1",11)); hs.add(new Person("a2",12)); hs.add(new Person("a3",13)); hs.add(new Person("a2",12)); // hs.add(new Person("a4",14)); //sop("a1存在:"+hs.contains(new Person("a1",11))); sop("a4 exists?"+hs.remove(new Person("a4",14))); Iterator it = hs.iterator(); while(it.hasNext()) { Person p = (Person)it.next(); sop(p.getName()+"::"+p.getAge()); } } public static void sop(Object obj) { System.out.println(obj); } }TreeSet
TreeSet中元素的取出顺序跟存入顺序无关,不可以有重复元素。
TreeSet实现排序的方式有两种:
一、让元素具备比较性(或自然顺序,实现Comparable接口)
TreeSet存入的元素,如果没有实现Comparable接口,往TreeSet中add第一个元素的时候,不会出问题,但add第二个元素时,会出现类型转换异常,
因为TreeSet集合是通过Comparable接口的compareTo方法来完成排序的,它默认其中的元素都实现了Comparable接口。
同时,在compareTo方法中,当主要条件判断相等后,一定要再判断下次要条件。
TreeSet对于判断元素是否存在,删除等操作,依赖的方法也是元素的compareTo方法。
二、让集合具备比较器(集合传入Comparator)
当集合元素没有比较性或具备的比较性不是所需要的时,可以让集合自己具备比较性,即集合初始化时,把一个比较器Comparator作为参数传入集合的构造函数。
Comparator接口里边有个compare(obj,obj)方法。
代码:
import java.util.*; class TreeSetDemo2 { public static void main(String[] args) { TreeSet ts = new TreeSet(new MyCompare()); ts.add(new Student2("a1",15)); ts.add(new Student2("a2",12)); ts.add(new Student2("a2",13)); ts.add(new Student2("a4",16)); ts.add(new Student2("a4",17)); Iterator it = ts.iterator(); while(it.hasNext()) { Student2 stu = (Student2)it.next(); System.out.println(stu.getName()+"::"+stu.getAge()); } } } //第二种排序方式:实现比较器,现在姓名再按年龄排序。 class MyCompare implements Comparator { public int compare(Object o1,Object o2) { Student2 s1 = (Student2)o1; Student2 s2 = (Student2)o2; int num = s1.getName().compareTo(s2.getName()); if(num==0) { /*if(s1.getAge()>s2.getAge()) return 1; if(s1.getAge()==s2.getAge()) return 0; return -1;*/ num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); } return num; } } //第一种排序方式:让集合元素具备比较性,先按年龄再按姓名比较。 class Student2 implements Comparable//该接口让学生具备比较性。 { private String name; private int age=100; Student2(String name,int age) { this.name = name; this.age = age; } public int compareTo(Object obj) { if(!(obj instanceof Student2)) throw new RuntimeException(obj.toString()+"不是学生对象"); Student2 s = (Student2)obj; //System.out.println(this.name+"...compareTo..."+s.name); if(this.age>s.age) return 1; if(this.age==s.age) { return this.name.compareTo(s.name); } return -1; } /* public int compareTo(Object obj){ return 1;//这样做会导致按存入顺序取出元素;改为-1,则逆序;改为0,则永远只能存一个元素。 }*/ public String getName() { return name; } public int getAge() { return age; } }
泛型:jdk1.5版本以后出现的新特性,用于解决安全问题,是一个安全机制,类型安全机制;
好处:①将运行时的异常转移到了编译时期,方便程序员解决问题,让问题减少,提高安全性;
② 避免了强制类型转换的麻烦。
泛型的格式:通过“<>”定义要操作的引用数据类型,<>是接受类型的,当使用集合时,将集合中要
存储的数据类型作为参数传递到<>中即可。
泛型类:当定义的类中要操作的引用数据类型不确定的时候,早起定义Object来完成,现在定义泛型来完成,
泛型类定义的泛型在整个类中有效,如果某方法使用,那么泛型的对象明确要操作的具体类型后,
所有操作的类型就固定了,为了让不同的方法可以操作不同的类型,可以将泛型定义在方法上;
泛型类:class Demo<T> {public void show(T t)}
泛型方法:public <Q> void show(Q,q);
<> 定义在返回值类型的前面,修饰符的后面;
注意:静态函数不可以访问类上定义的泛型,如果静态方法操作应用的对象数据类型不确定,可以将泛型
定义在方法上。
Map
Map集合:它存储的是键值对,其中键必须保证唯一性,值允许重复。
Map集合没有自身特有的迭代器,它的元素取出是通过将键或键值对放入Set集合中,利用Set集合中的迭代器取出的。
Map是双列集合,Collection是单列集合。
共性方法
Map接口中定义了该体系通用的方法。
1.添加
V put(K key, V value)
void putAll(Map<? extends K,? extends V>m)
注意put与add的不同:put时,如果key已经存在,则新存入的值覆盖原来的值,并把原来的值作为方法的返回值;
add时,如果该元素已经存在,则不能存入集合,方法返回值为false,如果存在,则存入集合,方法返回值为true。
2.删除
clear()
V remove(Object key)
3.判断
boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
4.获取
V get(Object key)
int size()
Collection<V> values()
Set<Map.Entry<K,V>>entrySet()
Set<K> keySet()
代码演示:
import java.util.*; class MapDemo { public static void main(String[] args) { Map<String,String> map = new HashMap <String,String>(); System.out.println("put:"+map.put("01","zhangsan01"));//结果为null System.out.println("put:"+map.put("01","wangwu"));//结果我zhangsan01 /* put如果存入了已经存在的键,则新键值会覆盖旧键值,并将旧键值返回;put存入一个未存在的键时,会返回null。 */ map.put("02","zhangsan02"); map.put("03","zhangsan02"); map.put(null,null); System.out.println("containsKey:"+map.containsKey("022")); //System.out.println("remove:"+map.remove("02")); System.out.println("get:"+map.get("023")); map.put("04","null"); System.out.println("get:"+map.get("04")); //可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。(毕老师这点讲的是不是有问题?) //获取map集合中的值 Collection <String> coll =map.values(); System.out.println(coll); System.out.println(map); } }Map的体系
Map
|---Hashtable<K,V>:底层是哈希表数据结构,不可以存入null键null值,该集合是同步的。JDK1.0,效率低。,
|---HashMap<K,V>:底层是哈希表数据结构,允许存入null键null值,该集合是不同步的。JDK1.2,效率高。
|---TreeMap<K,V>:底层是二叉树结构,线程不同步,可以用于给Map集合中键进行排序。
和Set很像,其实Set底层就是使用了Map集合。
map集合的两种取出方式:
1.Set<K> keySet;将map中的所有的键存入到Set集合,因为set具有迭代器。
所以可以迭代方式取出所有的键,再根据get方法,获取每一个键对应的值。
Map集合的取出原理:将Map集合转成Set集合,再通过迭代器取出。
2.Set<Map.Entry<K,V>> entrySet:将Map集合中的映射关系存入到了Set集合中,
而这个关系的数据类型就是:Map.Entry.
代码演示:
import java.util.*; class MapDemo1 //map集合两种取出方式,keySet, entrySet { public static void sop(Object o) { System.out.println(o); } public static void main(String[] args) { Map<String,String> m = new HashMap<String,String>(); m.put("01","andy"); m.put("02","tony"); m.put("03","jack"); sop(m); sop("---------------------"); /* // keySet取出方式; //1.将map集合中所有的键存入到set集合中; Set<String> keySet = m.keySet(); //2.set集合中具备迭代器,用set集合中的迭代器获取map集合的每一个键; Iterator<String> it = keySet.iterator(); while (it.hasNext()) { String key =it.next(); String value = m.get(key);//通过map集合的get方法,获取每一个键对应的值; sop("key="+key+",value="+value); } */ //entrySet取出方式; //1.将map集合中的映射关系存到set集合中 Set<Map.Entry<String,String>> entrySet = m.entrySet(); sop(m); //2.set集合中具备迭代器,用set集合中的迭代器获取map集合的映射关系; Iterator<Map.Entry<String,String>> it = entrySet.iterator(); while (it.hasNext()) { Map.Entry<String,String> me = it.next(); String key = me.getKey(); String value = me.getValue(); sop(key+"--"+value); } } }
Map扩展
Map集合中的值还可以是Map集合,这是Map集合嵌套使用的情况。
代码:
/* map扩展知识 map集合使用是因为具备映射关系。 “yureban” “01” “zhangsan” “yureban” “02” "lisi" "jiuyeban" "01" "zhousi" "jiuyeban" "02" "liuwu" 一个学校有多个教室,每个教室都有自己的名字,而一个教室对应多个学生。 */ import java.util.*; class Student1 { private static String id; private String name; Student1(String id,String name) { this.id = id; this.name = name; } public String toString() { return id+":::"+name; } public static void main(String[] args) { Student1 s1 =new Student1("id","name"); id = "1212"; Integer a = Integer.parseInt(id,10); System.out.println(s1.id); System.out.println(a); } } class MapDemo3 { public static void demo() { HashMap<String,List<Student1>> czbk = new HashMap<String,List<Student1>>(); List<Student1> yure = new ArrayList<Student1>(); List<Student1> jiuye = new ArrayList<Student1>(); czbk.put("yuer:",yure); czbk.put("jiuye:",jiuye); yure.add(new Student1("01","zhangsan")); yure.add(new Student1("02","wagnwu")); jiuye.add(new Student1("01","liuqiang")); jiuye.add(new Student1("02","limeng")); Iterator<String> it = czbk.keySet().iterator(); while(it.hasNext()) { String roomName = it.next(); List<Student1> room = czbk.get(roomName); System.out.println(roomName); getInfos(room); } } public static void getInfos(List<Student1> room) { Iterator<Student1> it = room.iterator(); while(it.hasNext()) { System.out.println(it.next()); } } public static void main(String[] args) { demo(); } public static void getStudentInfo(HashMap<String,String> hm) { Iterator<Map.Entry<String,String>> it = hm.entrySet().iterator(); while(it.hasNext()) { Map.Entry<String,String> me = it.next(); String num =me.getKey(); String name = me.getValue(); System.out.println(num+":"+name); } System.out.println(hm); } }
相关文章推荐
- Java集合框架学习(十一) Hashtable详解
- 黑马自学视频之——java基础——集合框架
- Java基础(十一)——集合框架与泛型
- Java学习日志(17-2-集合框架工具类Arrays及其他特性)
- Java常见集合框架(十一):Set之LinkedHashSet、CopyOnWriteArraySet
- java自学笔记12:java中的集合框架(中)Map&HashMap
- java自学笔记12:java中的集合框架(下)List
- Java学习日志(17-1-集合框架工具类Collections)
- java自学笔记之集合框架
- java自学笔记12:java中的集合框架(上)
- Java之集合框架
- java源码分析之集合框架SortedMap 、 NavigableMap 、Dictionary 09
- Java日志框架——Logback的体系结构
- 开源app后台开源框架集合 java
- JAVA的集合框架
- JAVA 笔记(三) 从源码深入浅出集合框架
- 黑马程序员——java-集合框架(二)
- java程序员最常用的8个日志框架
- Java 集合框架梳理
- 十七、Java基础---------集合框架之Map