1. 集合框架介绍
我 们知道,计算机的优势在于处理大量的数据,在编程开发中,为处理大量的数据,必须具备相应的存储结构,数组可以用来存储并处理大量类型相同的数 据,但是会发现数组在应用中的限制:数组长度一旦确定,就无法更改;除非采用建立新数组,再将原数组内容拷贝过来;数组中只能存放指 定类型的数据,操作不方便。在实际开发中,为了操作方便,JDK中提供了List集合。
List集合与数组的用途非常相似,都是用来存储大量数据的,不同处有两点:
1. 数组长度在使用前必须确定,一旦确定不能改变。而List集合长度可变,无需定义。
2. 数组中必须存放同一类型的数据,List集合中可以存放不同类型的数据。
List集合是Java集合框架中的一种,另外两种集合Set和Map会在下面介绍。List集合在JDK中被封装称为接口,针对List接口,有若干种实现,常用的有三个子类,即ArrayList、Vector和LinkedList。这三个类的功能与用法相同,但内部实现方式不同。下面以ArrayList为例介绍集合的常用操作,Vector和LinkedList的使用方法与ArrayList类似。
数组与List集合的常规操作类似,下面通过代码对比两者的用法:
代码演示:数组的基本操作
public class ArrayDemo { public static void main(String[] args) { String[] array = new String[3]; for (int i = 0; i < 3; i++) { array[i] = "Hello"; } String a = array[0]; } } |
代码演示:List集合的基本操作
import java.util.ArrayList; ① public class ListDemo { public static void main(String[] args) { ArrayList list = new ArrayList(); ② for (int i = 0; i < 3; i++) { list.add("Hello"); ③ } String a = (String)list.get(0); ④ } } |
代码解析:
① 集合框架在java.util包中,使用前必须使用import语句引入对应的类。
② List集合的定义时不需要指定大小,也不用指定集合中保存的数据类型。
③ 向List集合中添加数据时不需要制定下标,List集合会自动生成下标。
④ 获取List集合的元素时使用get方法并传入下标,然后强制类型转换为实际类型。
代码演示:使用集合记录学员姓名
public static void main(String[] args) { System.out.println("请输入班级学员姓名,输入OVER结束"); java.util.Scanner scanner = new java.util.Scanner(System.in); ArrayList list = new ArrayList(); do { String name = scanner.next(); if (name.equalsIgnoreCase("OVER")) break; list.add(name); } while (true); System.out.println(list); ① } |
代码解析:
① List集合重写了toString方法,可以将集合中的元素依次输出。
2. List集合的常用方法
下表列出了List集合的常用方法:
返回类型 |
方法名称 |
说明 |
boolean |
add(Object obj) |
加入元素,返回是否添加成功 |
boolean |
clear() |
清除集合中的元素 |
boolean |
contains(Object obj) |
查找集合中是否存在传入的元素 |
Object |
get(int index) |
获取指定位置的元素 |
boolean |
isEmpty() |
判断集合是否为空 |
Object |
remove(int index) |
删除制定位置的元素,并返回该元素 |
int |
size() |
获取集合大小 |
Object[] |
toArray() |
将集合转换成一个数组 |
表: List集合的常用方法
下面通过实例演示各个方法的用途:
代码演示:List集合的常用方法
import java.util.ArrayList; public class Demo { public static java.util.Scanner scanner = new java.util.Scanner(System.in); public static void main(String[] args) { ArrayList listA = new ArrayList(); ArrayList listB = new ArrayList(); System.out.println("请输入A班学员姓名,输入OVER结束"); inputName(listA); System.out.println("请输入B班学员姓名,输入OVER结束"); inputName(listB); //合并集合listA与listB listA.addAll(listB); System.out.println("请输入要查找的学员姓名"); String name = scanner.next(); int pos = listA.indexOf(name); if (pos==-1) { System.out.println("没有找到"); } else { System.out.println("找到了,位置是:" + pos); } System.out.println("请输入要删除的学员姓名"); String delName = scanner.next(); if (listA.remove(delName)) { System.out.println("删除成功!"); } else { System.out.println("没有该学员"); } } public static void inputName(ArrayList list) { do { String name = scanner.next(); if (name.equalsIgnoreCase("OVER")) break; list.add(name); } while (true); } } |
3. 使用List集合保存对象
使用List集合保存对象时,主要注意以下几点:
1. 集合中保存的是对象的引用,观察以下代码:
代码演示:使用集合保存对象
import java.util.ArrayList; class Student { String name; int age; public Student(String name, int age) { this.name = name; this.age = age; } public String toString() { return name + "/" + age; } } public class Demo { public static void main(String[] args) { ArrayList list = new ArrayList(); Student stu = new Student("Tom" , 10); for (int i = 0; i < 3; i++) { stu.age = 10 + i; list.add(stu); } System.out.println(list); } } |
上面代码的原意是在集合中保存三个Student对象,age分别为10、11、12,但实际输出的age值均为12。这是因为list集合中保存的是stu对象的引用,而在循环中stu的引用并没有变化,所以循环结束后集合中的三个元素都指向stu对象,age的值自然也是最后的12。将代码“Student stu = new Student("Tom" , 10);”放入循环内可以解决这一问题。
2. 使用remove、contains、indexOf等方法时,应该重写类的equals方法,观察以下代码:
代码演示:未重写equals方法的代码
//省略了Student类的定义 public class Demo { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add(new Student("Tom" , 11)); list.add(new Student("Jerry" , 22)); list.add(new Student("Alice" , 33)); System.out.println(list.contains(new Student("Tom" , 11))); System.out.println(list.indexOf(new Student("Jerry" , 22))); System.out.println(list.remove(new Student("Alice" , 33))?"成功":"无此项"); } } |
在上例中,我们希望判断学员Tom是否存在,查找学员Jerry,删除学员Alice,但是输出的结果却是不存在,找不到,删不掉。这是因为List集合会调用元素的equals方法来判断对象是否相等,而Student类没有重写equals方法,默认是按引用地址比较,而每个学员对象的地址又不相同,所以出现这个现象。通过给Student类添加equals方法可以解决这个问题:
代码演示:重写equals方法后的Student类
class Student { String name; int age; public Student(String name, int age) { this.name = name; this.age = age; } public boolean equals(Object obj) { if (obj == null) return false; if (!(obj instanceof Student)) return false; Student stu = (Student) obj; return stu.name.equals(this.name) && stu.age == this.age; } } |
4. 三种List集合的比较
我们说过,ArrayList、Vector与LinkedList的使用方法相同,内部实现方式不同。而内部实现方式的不同又决定了三种集合的适用范围,了解三种集合的内部实现,才能正确的选择使用类型。
1.ArrayList与Vector比较
ArrayList与Vector的内部实现类似,Vector设计为线程安全,ArrayList设计为非线程安全。为了保证线程安全,Vector在性能方面稍逊于ArrayList,目前我们编写的都是单线程应用程序,应选择使用ArrayList。
2.ArrayList与LinkedList
ArrayList与LinkedList均设计为非线程安全,ArrayList内部采用数组实现(与Vector相同),LinkedList内部采用链表结构实现。
ArrayList采用数组保存元素,意味着当大量添加元素,数组空间不足时,依然需要通过新建数组、内存复制的方式来增加容量,效率较低;而当进行对数组进行插入、删除操作时,又会进行循环移位操作,效率也较低;只有进行按下标查询时(get方法),使用数组效率很高。
LinkedList采用链表保存元素,在添加元素时只需要进行一次简单的内存分配即可,效率较高;进行插入、删除操作时,只需对链表中相邻的元素进行修改即可,效率也很高;但进行按下标查询时,需要对链表进行遍历,效率较低。下图演示了链表结构的特性:
图: 链表结构,每个元素引用后面的元素
图: 向链表中插入元素,只需修改两处引用
图: 删除链表中的元素,也只需要修改两处引用
可以总结出ArrayList在进行数据的新增、插入、删除时效率较低,按下标对数据进行查找时效率较高;LinkedList正好相反。一般来说ArrayList保存经常进行查询操作的集合,LinkedList适用于保存经常进行修改操作的集合。
5. 章节概述
1. List集合与数组的区别。
2. List集合实际上包含了3个常用的集合类,即ArrayList、Vector和LinkedList。
3. List集合的常用操作。
4. ArrayList采用数组保存元素,意味着当大量添加元素,数组空间不足时,依然需要通过新建数组、内存复制的方式来增加容量,效率较低;而当进行对数组进行插入、删除操作时,又会进行循环移位操作,效率也较低;只有进行按下标查询时(get方法),使用数组效率很高。
5. ArrayList与Vector的内部实现类似,Vector设计为线程安全,ArrayList设计为非线程安全。为了保证线程安全,Vector在性能方面稍逊于ArrayList,目前我们编写的都是单线程应用程序,应选择使用ArrayList。
6. ArrayList与LinkedList均设计为非线程安全,ArrayList内部采用数组实现(与Vector相同),LinkedList内部采用链表结构实现。
7. LinkedList采用链表保存元素,在添加元素时只需要进行一次简单的内存分配即可,效率较高;进行插入、删除操作时,只需对链表中相邻的元素进行修改即可,效率也很高;但进行按下标查询时,需要对链表进行遍历,效率较低。
1. Map集合
在上面讲的List集合中,可用通过List集合提供的各种方法来对其中的元素进行操作,从而可以方便用户操作,但是如果要从List集合中获取一个特定的对象,操作是比较繁琐的。
在类Person中有cardId和name两个属性,分别代表编号和姓名,创建两个Person对象并存储到ArrayList集合中 ,如果要从集合中获取指定的对象,则必须要通过迭代整个集合来获得,如下所示:
代码演示:Person类
public class Person { String cardId; String name; public Person(String cardId, String name) { this.cardId = cardId; this.name = name; } } |
代码演示:从ArrayList中获取特定的对象
public class ArrayListTest { public static void main(String[] args) { Person personA = new Person("001", "Tom"); Person personB = new Person("002", "Jack"); ArrayList list = new ArrayList(); list.add(personA); list.add(personB); for (int i = 0; i < list.size(); i++) { Person person = (Person) list.get(i); if (person.cardId.equals("002")) { System.out.println(person.name); } } } } |
从上面的示例中,我们看到从list集合中获取一个对象的繁琐,有没有简单的方法呢?在JDK中专门提供了Map集合来存储上面这种一对一映射关系的对象。
Map集合用于保存具有映射关系的数据,即以键值对(key->value)的方式来存储数据。因此在Map集合内部有两个集合,一个集合用于保存Map中的key(键),一个集合用于保存Map中的value(值),其中key和value可以是任意数据类型数据。
图: Map集合
Map集合中的常用类有Hashtable和HashMap,两个类的功能和用法相似,下面以HashMap为例介绍Map集合的用法。
代码演示:Map集合使用
public class MapTest { public static void main(String[] args) { HashMap map = new HashMap(); ① map.put("001", "Tom"); ② map.put("002", "Jack"); String name = (String) map.get("002"); ③ System.out.println(name); } } |
代码解析:
① 创建HashMap对象。
② 利用HashMap中的put方法将键值对形式的对象进行存储,put方法中的第一个参数为映射关系中key的值,put方法的第二个参数为映射关系中value的值。
③ 利用HashMap的get方法获取key对应的value,然后强制类型转换为实际类型。get中的参数为key,返回值为key对应的value。
下表列出了HashMap中常用的方法:
返回类型 |
方法名称 |
作用 |
Object |
put(Object key,Object value) |
加入元素,返回与此key关联的原有的value,不存在则返回null |
void |
clear() |
从集合中移除所有的元素 |
boolean |
containsKey(Object key) |
根据key从集合中判断key是否存在 |
boolean |
containsValue(Object value) |
根据value从集合中判断value是否存在 |
Object |
get(Object key) |
根据key返回key对应的值 |
Set |
keySet() |
返回Map集合中包含的键集合 |
Object |
remove(Object key) |
从集合中删除key对应的元素,返回与key对应的原有value,不存在则返回null |
int |
size() |
返回集合中的元素的数量 |
表: HashMap常用方法
Map集合的综合示例:
代码演示:Map集合综合演示
import java.util.HashMap; import java.util.Scanner; public class TestMap { public static void main(String[] args) { HashMap map = new HashMap(); Scanner scanner = new Scanner(System.in); for (int i = 0; i < 5; i++) { System.out.println("请输入身份证号:"); String id = scanner.next(); System.out.println("请输入姓名:"); String name = scanner.next(); map.put(id, name); ① } int size = map.size(); ② System.out.println("数据输入完毕!共" + size + "条数据!\n---------------------------------"); String answer = "no"; do { System.out.println("请输入你要查找的用户的身份证号:"); String id = scanner.next(); if (map.containsKey(id)) { ③ String name = (String) map.get(id); ④ System.out.println("您查找的用户姓名为:" + name); } else { System.out.println("您查找的用户不存在!"); } System.out.println("您还要继续查找吗?(yes/no)"); answer = scanner.next(); } while ("yes".equalsIgnoreCase(answer)); System.out.println("请输入要删除的用户的身份证号:"); String id = scanner.next(); if (map.containsKey(id)) { String name = (String) map.remove(id); ⑤ System.out.println("用户" + name + "删除成功!"); } else { System.out.println("您要删除的用户不存在!"); } System.out.println("要格式化系统吗?(yes/no)"); String format = scanner.next(); if ("yes".equalsIgnoreCase(format)) { map.clear(); ⑥ System.out.println("系统格式化完毕!当前系统中数据为" + map.size() + "条"); } System.out.println("程序运行结束!"); } } |
代码解析:
① 使用put方法将身份证号和姓名存入Map集合中。
② 使用size方法获得集合中的映射关系条数。
③ 使用containsKey方法判断集合是否存在与key对应的映射关系。
④ 使用get方法获得身份证号对应的姓名。
⑤ 使用remove方法删除身份证号对应的用户,返回身份证号对应的姓名。
⑥ 使用clear方法删除Map集合中所有的映射关系。
来看下面的一个示例:
代码演示:Map集合中重复key
import java.util.HashMap; public class DemoMap { public static void main(String[] args) { HashMap map = new HashMap(); map.put("001", "小美"); map.put("002", "阿聪"); ① map.put("002", "小莉"); ② String name = (String) map.get("002"); System.out.println(name); } } |
注意①和②处的代码,在向集合中添加值的时候,使用了重复的key,但是value不同,在下面获得key“002”的value为多少呢?程序运行的结果是“小莉”。从结果可以中可以知道,Map集合中的key不能是重复的,如果重复,那么后面添加的映射关系会覆盖前面的映射关系。导致这样情况的出现主要是因为Map集合中的key的维护是依靠Set集合(马上会学习到)完成的。
HashMap和Hashtable的操作是相同的,他们的区别如下:
? Hashtable是线程安全的,HashMap是非线程安全的。所有HashMap比Hashtable的性能更高。
? Hashtable不允许使用使用null值作为key或value,但是HashMap是可以的。
2. Set集合
Set集合和List集合的很多的用法是相同的。但是Set集合中的元素是无序的,元素也是不能重复的。Set集合中常用类为HashSet。
HashSet类中常用的方法如下:
返回类型 |
方法名称 |
作用 |
boolean |
add(Object obj) |
加入元素 |
void |
clear() |
移除Set集合中所有元素 |
boolean |
contains(Object obj) |
判断Set集合中是否包含指定元素 |
boolean |
isEmpty() |
判断Set集合是否为空 |
Iterator |
iterator() |
返回Set集合中对元素迭代的迭代器 |
boolean |
remove(Object obj) |
从集合中删除元素 |
Int |
size() |
返回集合中的元素数量 |
表: HashSet类常用方法
通过上面的表,可以清楚的看到Set集合的用法和List集合是相似的,但是需要注意Set集合的迭代和List集合是不同的,List的集合的迭代可以通过for循环获得索引来进行,但是Set集合的迭代必须要通过迭代器进行。
代码演示:Set集合的迭代
import java.util.HashSet; import java.util.Iterator; public class SetIterator { public static void main(String[] args) { HashSet set = new HashSet(); set.add("a"); set.add("b"); set.add("c"); Iterator iter = set.iterator(); ① while (iter.hasNext()) { ② String str = (String) iter.next(); ③ System.out.println(str); } } } |
代码解析:
① 通过Set集合的iterator()方法获得该集合的迭代器,迭代器是Iterator类的实例。
② 根据迭代器的hasNext()方法判断集合中是否还有元素,如果有就返回true。
③ 根据迭代器的next()方法获得集合中的元素,并强制类型转换为目标类型。
从上面例子的运行结果,可以看出Set中的元素是无序的。通过Set集合的迭代再来学习Map集合的迭代。
代码演示:Map集合的迭代
import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class MapIter { public static void main(String[] args) { HashMap map = new HashMap(); map.put("001", "小美"); map.put("002", "阿聪"); map.put("003", "小黑"); HashSet keys = (HashSet) map.keySet(); ① Iterator iter = keys.iterator(); while (iter.hasNext()) { String key = (String) iter.next(); ② String value = (String) map.get(key); ③ System.out.println(key + ":" + value); } } } |
代码解析:
① 调用Map集合的keySet方法获得Map集合中的key的集合。
② 获得key。
③ 根据key获得对应的value。
下面通过一个示例演示Set集合中不允许元素重复的特性:
代码演示:向Set集合中添加重复元素
import java.util.HashSet; import java.util.Iterator; public class Demo2 { public static void main(String[] args) { HashSet set = new HashSet(); set.add("a"); set.add("a"); set.add("c"); System.out.println("集合长度为:" + set.size()); Iterator iter = set.iterator(); while (iter.hasNext()) { String str = (String) iter.next(); System.out.println(str); } } } |
上面的代码输出集合的长度为2,而且集合中的元素只有一个a和c,从结果中可以看出Set集合中的元素是不能重复的。带着这个结论再来看下面的示例:
代码演示:向Set集合中添加重复元素
import java.util.HashSet; import java.util.Iterator; public class Demo3 { public static void main(String[] args) { Person personA = new Person("001", "Tom"); Person personB = new Person("001", "Tom"); HashSet set = new HashSet(); set.add(personA); set.add(personB); System.out.println("集合中元素个数:" + set.size()); Iterator iter = set.iterator(); while (iter.hasNext()) { Person p = (Person) iter.next(); System.out.println(p.cardId + ":" + p.name); } } } |
程序的运行结果如下:
集合中元素个数:2 001:Tom 001:Tom |
发现程序的运行结果是有“问题”的,因为Set集合中是不允许存放重复的元素的,但是两个Person对象的属性值是完全相同的,怎么还都能存放进去呢?要找到问题的答案,需要了解下Set集合的存放原理。
图: Set集合存储
从上图中可以看到,Set集合中的元素的无序性,但是Set集合是怎么判断每个元素的存放的位置呢?在向Set集合中存放元素时,Set集合根据元素的hashCode()方法来获取一个int类型的数据,然后根据这个数据来计算元素在集合中的位置。但是在存储元素时会出现两个元素的hashCode()方法返回值相同的情况,比如上图的对象C和D就出现了这种情况,导致计算出元素在集合中的位置相同,这种情况称之为“冲突”。如果发生了冲突,Set集合会根据发生冲突元素之间调用equals()方法进行比较,如果equals()返回值为true,说明两个元素为相同的元素,这样会导致添加操作无效。如果equals()返回值为false,说明两个元素不相同,这样Set集合会将该元素进行偏移存储。“冲突”发生的频率越高,Set集合的性能就越低,要尽可能的避免冲突的发生, 就要在类中重写hashCode()方法,并且要尽可能的保证hashCode()方法返回值是唯一的。在重写hashCode()方法时有个技巧,就是让对象中的数值属性和一个素数相乘,并将积相加,对于对象类型,调用其hashCode()方法即可。
对于hashCode()和equals()两个方法有这样的规律,hashCode()方法返回值相同时,equals()方法比较并不一定相等,但是equals()方法比较相等,hashCode()方法返回值是相同的。
代码演示:实现Person对象的equals和hashCode方法
public class Person { String cardId; String name; public Person(String cardId, String name) { this.cardId = cardId; this.name = name; } public int hashCode() { return cardId.hashCode() + name.hashCode(); } public boolean equals(Object obj) { if (obj == null){ return false; } if(obj instanceof Person){ Person other = (Person) obj; if (cardId == null) { if (other.cardId != null){ return false; } } else if (!cardId.equals(other.cardId)){ return false; } if (name == null) { if (other.name != null){ return false; } } else if (!name.equals(other.name)){ return false; } }else{ return false; } return true; } } |
再次运行Demo3的代码,运行结果如下:
集合中元素个数:1 001:Tom |
3. 本章总结
1. Map集合用于保存具有映射关系的数据,即以键值对(key->value)的方式来存储数据。因此在Map集合内部有两个集合,一个集合用于保存Map中的key(键),一个集合用于保存Map中的value(值),其中key和value可以是任意数据类型数据。
2. Set集合的特点。
3. Set集合的使用及迭代。
4. Map集合的迭代。