ITeye博客

黑马学习日记_集合框架之List、Set、Map

小驴变黑马 · 2014-04-03 03:22 · 编程语言 · Markdown

---------------------- android开发、java培训、期待与您交流! ----------------------

1、集合类 和 容器

 

为什么出现集合类?

  面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就要对对象进行存储,集合就是存储对象最常用的一种方式。

数组和集合类同是容器,有何不同?

  数组虽然也可以存储对象,但长度是固定的;集合长度是可变的。数组中可以存储任意数据类型,集合只能存储对象。

集合类的特点

  集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象。

 

两大接口

  Java集合类主要由两个接口派生出来:

  Collection

  Set :不能存放重复对象

  List :可存放重复对象,有序

  Queue :队列

  SortedSet :可对集合数据排序

  Map

  SortedMap :可对集合数据排序

 

 

2、Collection接口

 

方法:

boolean add(Object o):该方法用于向集合里面添加一个元素,若集合对象被添加操作改变了,返回true.

boolean addAll(Collection c):把集合c里面的所有元素添加到指定集合里面去,如果集合对象被添加操作改变了返回true.

void clear():清除集合里面的所有元素,将集合长度变为0。

boolean contains(Object o):返回集合里是否包含指定的元素。

boolean containsAll(Collection c):返回集合里是否包含集合c内所有的元素。

boolean isEmpty():返回集合是否为空(长度是否为0)。

Iterator iterator():返回一个Iterator对象,用于遍历集合里的元素。

boolean remove(Object o):删除集合中指定元素o。

boolean removeAll(Collection c):从集合中删除集合c里面的元素。若删除一个或以上返回true。

boolean retainAll(Collection c):从集合中删除集合c里不包含的元素。

int size():得到集合元素的个数。

Object[] toArray():把集合转成一个数组,所有集合元素编程数组元素。

Eg:

public class Demo10 {

public static void main(String[] args) {

Collection c = new ArrayList();

c.add("A");

c.add("A");

c.add("A");

c.add("A");

//c.add(new Date());上面写了泛型,这个语句就是错误的了,因为泛型规定了加进来的类型!

System.out.println(c);

  }

}

 

3、Iterator接口 

 

Iterator主要遍历Collection集合中的元素,也有称为迭代器或迭代精灵。

boolean hasNext():若被迭代的集合元素还没有被遍历,返回true.

Object  next():返回集合的下一个元素.

void remove():删除集合上一次next()方法返回的元素。(若集合中有多个相同的元素,都可以删掉)

iterator对于集合才能用,for不同,只要是循环都可用。

 

迭代是取出集合中元素的一种方式。

因为Collection中有iterator方法,所以每一个子类集合对象都具备迭代器。

迭代器在Collcection接口中是通用的,它替代了Vector类中的Enumeration(枚举)。迭代器的next方法是自动向下取元素,要避免出现NoSuchElementException。

迭代器的next方法返回值类型是Object,所以要记得类型转换。(学到泛型就可以消除强转!)

 

Eg:Iterator iter = l.iterator();

while(iter.hasNext()){

System.out.println(iter.next());

}

 

 

4、集合遍历输出方式

 

Iterator:迭代输出

一旦操作集合的遍历输出,首选Iterator接口;

ListIterator:Iterator子接口,专门输出List中的元素;

Enumeration:古老的输出方式,迭代Vector元素,被Iterator取代;

foreach:可输出数组和Iterable对象;

总结:

集合遍历输出方式:

Iterable接口(迭代遍历)  注:优先选择Iterator接口,遍历Collection里所有元素,也称为迭代器和迭代精灵;迭代是取出集合中元素的一种推荐方式。

Foreach循环  注:可以直接用,使用场合:数组和Iterable对象!

For循环      注:在()内实例化Iterable对象,进行遍历!

先用toArray方法输出成为数组,再用Foreach循环!

第一个和第三个很类似,第二个和第四个很类似!

 

Eg:

//遍历输出的四种方式

 

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
public class Demo11 {
public static void main(String[] args) {
 
List l = new ArrayList();
 
l.add("1");
l.add("2");
l.add("3");
l.add("4");
 
System.out.println(l);
 
// 1、推荐使用的Iterator对象,迭代输出!
Iterator it = l.iterator();
while (it.hasNext()) {
System.out.println("迭代输出:" + it.next());
}
 
// 2、对集合进行fore循环!
for (String str : l) {
System.out.println("fore集合迭代输出:" + str);
}
 
// 3、for循环迭代,在for方法体内部实例化Iterator对象!
int i = 0;// for方法体内定义项不能出现多种不同类型
for (Iterator iter = l.iterator(); i < l.size(); i++) {
System.out.println("for循环迭代实例化输出:" + iter.next());
}
 
// 4、先将集合转换为数组,再利用数组的遍历输出;
Object[] o = l.toArray();
for (Object object : o) {
System.out.println("转换数组迭代输出:" + object);
}
}
}
 

 5、Set接口(元素不可以重复)

 

Set是Collection子接口;

Set和Collection基本上一样,一点除外:

Set无法记住添加的顺序,不允许包含重复的元素。

  当试图添加两个相同元素进Set集合,添加操作失败,add()方法返回false。

Set判断两个对象是否相等用equals,而不是使用==。

  也就是说两个对象equals比较返回true,Set集合是不会接受这个两个对象的。

常用子类:

  HashSet:散列存放

  TreeSet:有序存放

 

hashCode方法对于HashSet的作用

 

HashSet类是Set接口最常用的实现类,采用hash算法存储数据,具有良好的存储和查找功能。

散列存储:不记录添加顺序;排列顺序时,顺序有可能发生变化;

线程不安全的,多个线程访问一个HashSet要使用同步代码;

HashSet集合元素值允许是null,但是最多只能有一个;//因为Set集合就不可以装重复的对象!

hash(翻译为哈希,或散列)算法的功能:

保证通过一个对象快速找到另一个对象;

其算法价值体现在速度,可以保证查询快速执行;

当从HashSet中访问元素时,HashSet先计算该元素的hashCode(也就是该对象的hashCode方法返回值),然后直接到该HashCode对应的位置取出该元素;

在这里对象的hashCode就好比是数组里的索引,但是不是索引;

 

HashSet元素添加

 

当向HashSet集合中存入一个元素时,HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值,判断已经存储在集合中的对象的hashCode值是否与添加的对象的hashCode值一致:若不一致:直接添加进去;若一致,再进行equals方法比较,equals方法如果返回true,表明对象已经添加进去了,就不会再添加新的对象了,否则添加进去;

如果我们重写了equals方法,也要重写hashCode方法,反之亦然;。

HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等,并且两个对象的hashCode方法返回值也相等。

如果需要某个类的对象保存到HashSet集合中,覆写该类的equals()和hashCode()方法,应该尽量保证两个对象通过equals比较返回true时,他们的hashCode返回也相等。

 

总结:

很重要的一点:理解!往HashSet集合里面存入数据,要先后调用两个方法:hashCode方法和equals方法!!!

备注:使用eclipse添加这两个方法。

 

Eg:

//hashset方法和equals方法判断输入的对象是否重复!

 

import java.util.HashSet;
import java.util.Set;
 
class PersonDemo{
private String name;
 
public PersonDemo(String name) {
super();
this.name = name;
}
 
@Override
public String toString() {
return "name= " + name ;
}
//没有覆写hashcode和equals方法前,显示三次(一样的)。覆写后,只剩下一个了!说明覆写后方法起作用了,重复的输入不进去!
@Override
public int 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)
if (obj == null)
return true;

return false;
if (getClass() != obj.getClass())
return false;
PersonDemo other = (PersonDemo) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
 
public class Demo12 {
public static void main(String[] args) {
Set s = new HashSet();
s.add(new PersonDemo("张三"));
s.add(new PersonDemo("张三"));
s.add(new PersonDemo("张三"));
System.out.println(s);
}
}

  

 

6、TreeSet

 

TreeSet是SortedSet接口唯一的实现,与HashSet相比额外的方法有:

Comparator comparator():返回当前Set使用的Comparator,若返回null,表示以自然顺序排序。

Object first() 返回此 set 中当前第一个(最低)元素。 

Object last() 返回此 set 中当前最后一个(最高)元素。 

SortedSet subSet(Object  fromElement, E toElement) 返回此 set 的部子集,其元素从 fromElement(包括)到 toElement(不包括)。 

SortedSet headSet(Object  toElement)返回此 set 的部分子集,其元素严格小于 toElement。 

SortedSet tailSet(Object  fromElement) 返回此 set 的部分子集,其元素大于等于 fromElement。 

 

 

TreeSet的排序之自然排序

 

TreeSet会调用元素的compareTo(Object o)方法来比较元素之间的大小关系,然后将集合里的元素按升序排列.此时需要排序元素的类必须实现Compareble接口,并覆写其int compareTo(Object o)方法;

该方法用于比较对象,若:obj1,compareTo(obj2),返回0,表示两个对象相等,若返回一个正整数,表示obj1大于obj2,若返回一个负整数,表示obj1小于obj2;

对于TreeSet集合而言,判断两个对象相等的标准是:

compareTo()方法比较返回 0;

 

 

//TreeSet可以自动进行排序!最简单的情况

 

import java.util.Set;
import java.util.TreeSet;
 
public class Demo13 {
public static void main(String[] args) {
Set s = new TreeSet();
s.add(1);
s.add(192);
s.add(123);
s.add(56);
s.add(13);
s.add(96);
System.out.println(s);//[1, 13, 56, 96, 123, 192]
}
}

  

稍复杂点的

 

 

//TreeSet的自然排序,升序
 
import java.util.Set;
import java.util.TreeSet;
 
class Student implements Comparable{//必须实现接口
private Integer age;
 
public Student(Integer age) {
super();
this.age = age;
}
 
@Override
public int compareTo(Object o) {//比较的规则,运用泛型可以消除强转!
if(o instanceof Student){
Student s = (Student)o;
return this.age.compareTo(s.age);
}
return 0;
}
 
@Override
public String toString() {
return age+"" ;
}
}
 
public class Demo14 {
public static void main(String[] args) {
Set s = new TreeSet();
s.add(new Student(140));
s.add(new Student(15));
s.add(new Student(11));
s.add(new Student(63));
s.add(new Student(96));
System.out.println(s);//[11, 15, 63, 96, 140]
}
}

  

 

TreeSet的排序之定制排序

 

TreeSet的自然排序是根据元素的大小进行升序排序的,若想自己定制排序,比如降序排序,就可以使用Comparator接口了:

该接口包含int compare(Object o1,Object o2)方法,用于比较两个对象的大小,比较结果和compareTo方法一致;

要实现定制排序,需要在创建TreeSet集合对象时,提供一个一个Comparator对象,该对象里负责集合元素的排序逻辑;

TreeSet(Comparator comparator) 

 

Eg:

//定制排序的话,必须在创建TreeSet集合对象的时候提供一个Comparator方法

 

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
 
class Student1{
private Integer age;
public Student1(Integer age) {
super();
this.age = age;
}
 
public Integer getAge() {
return age;
}
 
public void setAge(Integer age) {
this.age = age;
}
 
@Override
public String toString() {
return age + "";
}
}
 
class MyComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Student1 & o2 instanceof Student1){
Student1 s1 = (Student1)o1;
Student1 s2 = (Student1)o2;
if(s1.getAge() > s2.getAge()){
return -1;
}else if(s1.getAge() < s2.getAge()){
return 1;
}
}
return 0;
}
}
 
public class Demo15 {
public static void main(String[] args) {
Set s = new TreeSet(new MyComparator());
s.add(new Student1(140));
s.add(new Student1(15));
s.add(new Student1(11));
s.add(new Student1(63));
s.add(new Student1(96));
System.out.println(s);
}
}

  

 

7、List接口

Collection子接口;

List是有序的集合,集合中每个元素都有对应的顺序序列。List集合可使用重复元素,可以通过索引来访问指定位置的集合元素(顺序索引从0开始),List集合默认按元素的添加顺序设置元素的索引,比如第一个元素的索引就是0,好似数组。

List作为Collection子接口当然拥有其所有方法,同时也有自己的方法:

 

void add(int index,Object e):将元素e添加到List集合中的index处;

boolean addAll(int index,Collection c):将集合c所包含的所有元素都插入在List集合的index处;

Object get(int index):返回集合index索引处的元素;

int indexOf(Object o):返回对象o在List集合中第一次出现位置的索引;

int lastIndexOf(object o):返回对象o在List集合中最后一次出现的位置索引;

Object remove(int index):删除并返回index索引处的元素;

Object set(int index,Object e):把集合index处的元素替换为e对象,返回以前在指定位置的元素;

List subList(int fromIndex,int toIndex):返回从所有fromIndex(包括)到toIndex(不包括)处所有集合元素的子集合。

 

ListIterator

 

Iterator的子接口,专门用于操作List集合的输出;

List自己还有一个listIterator()方法,该方法返回ListIterator对象,ListIterator继承了Iterator接口,提供了专门操作List的方法。在Iterator上额外增加的方法:

支持双向输出:

boolean hasPrevious():返回该迭代器关联集合是否还有上一个元素;

Object previous():返回该迭代器的上一个元素;

 

我的总结:这是相对更加特殊的一个接口,只用于List集合,可以完成逆序输出!

 

Eg:

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
 
class Student1{
private Integer age;
public Student1(Integer age) {
super();
this.age = age;
}
 
public Integer getAge() {
return age;
}
 
public void setAge(Integer age) {
this.age = age;
}
 
@Override
public String toString() {
return age + "";
}
}
 
class MyComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Student1 & o2 instanceof Student1){
Student1 s1 = (Student1)o1;
Student1 s2 = (Student1)o2;
if(s1.getAge() > s2.getAge()){
return -1;
}else if(s1.getAge() < s2.getAge()){
return 1;
}
}
return 0;
}
}
 
public class Demo15 {
public static void main(String[] args) {
Set s = new TreeSet(new MyComparator());
s.add(new Student1(140));
s.add(new Student1(15));
s.add(new Student1(11));
s.add(new Student1(63));
s.add(new Student1(96));
System.out.println(s);
}
}

  

输出:

  [12, 24, 36, 23, 37]

  正序:12

  正序:24

  正序:36

  正序:23

  正序:37

  ==================================

  逆序:37

  逆序:23

  逆序:36

  逆序:24

  逆序:12

 

 

8、List接口中常用类

 

Vector:线程安全,但速度慢,已被ArrayList替代。

ArrayList:线程不安全,查询速度快。

LinkedList:链表结构,增删速度快。取出List集合中元素的方式:

get(int  index):通过脚标获取元素。

iterator():通过迭代方法获取迭代器对象。

ArrayList和Vector类都是基于数组实现的List类,Vector比较古老,被ArrayList取代了;

ArrayList是线程不安全的,而Vector是线程安全的,但是即使这样,也不推荐使用Vector,因为Collections有方法可以得到线程安全的ArrayList对象;

Collections类: static  List synchronizedList(List list) 返回指定列表支持的同步(线程安全的)列表。 

 

Queue接口

 

继承Collection接口

模拟队列:先进先出(FIFO);

void add(Object e):将e插入到队列尾部;

Object element():获取队列头部的元素;

boolean offer(Object e):将e插入到队列的尾部,当使用有容量限制的队列时,此方法比add(Object e)方法更好。

Object peek():获取队列头部的元素。如果此双端队列为空,则返回 null。

Object poll():获取并删除队列头部的元素。如果此双端队列为空,则返回 null。

Object remove():获取并删除队列头部的元素。

 

 

Eg:练习:List的使用

 

设计Department  和 Employee 对象类(按照开发的样式没有写在一个文件里面)
//一个员工只可以有一个部门,所以按照普通的写法
//一个部门可以有许多员工,所以按照集合的写法;
 
 
//员工
package re538.Department;
 
public class Emp {
private Dept dept;//一个员工只可以有一个部门,所以按照普通的写法
private String name;
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
public Emp(String name) {
super();
this.name = name;
}
public String toString(){//覆写toString方法
return this.name+"";
}
}
 
 
//部门
package re538.Department;
 
import java.util.List;
public class Dept {
private String name;
private List emp;//一个部门可以有许多员工,所以按照集合的写法;部门里的属性,员工!
public Dept(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List getEmp() {
return emp;
}
public void setEmp(List emp) {
this.emp = emp;
}
private Dept parent;//一个部门只有一个直接主管部门,所以普通写法
private List children;//但是一个部门可以管理很多部门,充当很多部门的直接主管部门,所以使用集合
public Dept getParent() {
return parent;
}
public void setParent(Dept parent) {
this.parent = parent;
}
public List getChildren() {
return children;
}
public void setChildren(List children) {
this.children = children;
}
public String toString(){
return this.name.toString();
}
}
 
//测试类,主方法!
 
package re538.Department;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
public class TestDemo {
 
public static void main(String[] args) {
Emp e1 = new Emp("张三");
Emp e2 = new Emp("李四");
Emp e3 = new Emp("王五");
Emp e4 = new Emp("赵六");
Emp e5 = new Emp("孙七");
List list = new ArrayList();//把员工丢尽集合去
list.add(e1);
list.add(e2);
list.add(e3);
list.add(e4);
list.add(e5);
for (Object object : list) {//把员工给遍历出来,使用的是直接的foreach(四种方法之一)
System.out.println("----->"+object);
}
System.out.println("-------------------");
Dept d = new Dept("部门");//定义出一个部门来接收员工
d.setEmp(list);//把员工这个集合丢到部门去。
Dept d1 = new Dept("itcast");
Dept cditcast = new Dept("大连公司");
Dept gzitcast = new Dept("天津公司");
Dept d4 = new Dept("cbm");
System.out.println(d4);
List children = new ArrayList();
children.add(cditcast);
children.add(gzitcast);
d1.setChildren(children);//定义直接被主管部门(集合)
d1.setParent(d4);//定义直接主管部门
Iterator it = children.iterator();//运用到了迭代遍历,四种之一!
while(it.hasNext()){
System.out.println(it.next());
}
}
}

  

9、Map接口

 

映射关系,也有人称为字典,Map集合里存在两组值,一组是key,一组是value。Map里的key不允许重复。通过key总能找到唯一的value与之对应。

Map里的key集存储方式和对应的Set集合中的元素存储方式一致;

学生都有一个学号,我们能点学号就能找到某个学生,好比这个学号就是key,学生就是value。

Map.Entry是Map接口的内部接口,专门用来保存key-value内容:

 

Map常用方法

 

void clear():删除该Map对象中所有的key-value对。也就是清理该集合;

boolean containsKey(Object key):查询Map中是否包含指定的key;

boolean containsValue(Object  value):查询Map中是否包含至少一个value;

Set entrySet():返回Map所包含的key-value对所组成的Set集合,每个集合元素都是Map.Entry对象(Entry是Map内部类);

Object get(Object key):返回指定key所对应的value,若此Map中不包含该key,返回null;

boolean isEmpty():判断Map集合是否为空;

Set keySet():返回该Map中所有key所组成的Set集合;

Object put(Object key,Object value):添加一个key-value对,若Map中已有与key相等的key-value对,则新的key-value对覆盖原来的key-value对;

void putAll(Map m):将m中的key-value赋值到调用该方法的Map对象中;

Object remove(Object key):删除指定key所对应的key-value对,返回本删除key所关联的value,若key不存在,返回null;

int size():返回该Map里面key-value对的个数;

Collection values():返回Map里所有value组成的Collection。

 

Eg:

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class Demo17 {
public static void main(String[] args) {
Map m = new HashMap();
m.put(1, "jack");
m.put(2, "rose");
m.put(3, "lucy");
System.out.println(m);//{1=jack, 2=rose, 3=lucy}
 
Set s = m.entrySet();
System.out.println(s);//[1=jack, 2=rose, 3=lucy]
s = m.keySet();
System.out.println(s);//[1, 2, 3]
 
for (Object key : s) {
System.out.println(key);//Key
System.out.println(m.get(key));//Value
}
Collection c = m.values();
System.out.println(c);
}
}

  

 

Map.Entry

 

Entry是Map接口里面的一个内部接口.

该接口用于封装key- value,有3个方法:

Object getKey();返回Entry里包含的key值

Object getValue();返回Entry里包含的value值

Object setValue(Object value):设置Entry里包含的value值,并返回新设置的value值;

 

Map集合的输出

 

按照最正统的做法,所有的Map集合的内容都要依靠Iterator输出,以上虽然是完成了输出,但是完成的不标准,Map集合本身并不能直接为Iterator实例化,如果此时非要使用Iterator输出Map集合中内容的话,则要采用如下的步骤:

 

方法一:

  1.通过entrySet方法变成Set对象

  2.调用Set的Iterator方法,此时每个Iterator对象是Map.Entry对象

  3.对Map.Entry分离出 key - value

方法二:

  1.通过keySet得到Map集合多有key的Set集合

  2.调用Set的Iterator方法,此时每个Iterator对象是key值

  3.通过Map的getValue(key)得到value值

 

Eg:

//把Map中的元素取出来
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
 
public class Demo18 {
public static void main(String[] args) {
Map m = new HashMap();
m.put(1, "jack");
m.put(2, "rose");
m.put(3, "lucy");
//第一种方法
Set s = m.entrySet();
Iterator it = s.iterator();
while(it.hasNext()){
Map.Entry me = (Entry) it.next();
System.out.println(me.getKey()+"  "+me.getValue());
}
 
//第二种方法
s = m.keySet();//得到的是key的集合
it = s.iterator();//然后将key迭代出来
while(it.hasNext()){
int i = (int)it.next();
System.out.println(i+"   "+m.get(i));
}
}
}

 ---------------------- android开发、java培训、期待与您交流! ----------------------

评论(0)

暂无评论。

评论功能维护中,当前仅展示历史评论。