第九章.集合
1.集合框架的概述
- 集合,数组都是对多个数据进行存储操作的结构,简称Java容器
说明:此时的存储,主要指的是内存层面的存储,不涉及到持久化的存储。 - 数组在存储多个数据方面的特点:
2.1 一旦初始化以后,其长度就确定了
2.2 数组一旦定义好,其元素的类型也就确定了。我们也就只能操作指定类型的数据了。 - 数组在存储多个数据方面的缺点:
3.1 一旦初始化以后,其长度就不可修改了。
3.2 数组中提供的方法非常有限,对于添加,删除,插入数据等操作,非常不便。
3.3 获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用。
3.4 数组存储数据的特点:有序,可重复。
2.集合框架
3.Collection接口中的方法
1、添加
add(Object obj)
addAll(Collection coll)
2、获取有效元素的个数
int size()
3、清空集合
void clear()
4、是否是空集合
boolean isEmpty()
5、是否包含某个元素
boolean contains(Object obj):判断当前集合中是否包含obj
boolean containsAll(Collection coll1):也是调用元素的equals方法来比较的。判断coll1中的所有元素是否都在当前集合中
6、删除
boolean remove(Object obj) :通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
boolean removeAll(Collection coll):取当前集合的差集
7、取两个集合的交集
boolean retainAll(Collection c):把交集的结果存在当前集合中,不影响c
8、集合是否相等
boolean equals(Object obj)
9、转成对象数组
Object[] toArray()
10、获取集合对象的哈希值
hashCode()
11、遍历
iterator():返回迭代器对象,用于集合遍历
说明
向Collection接口的实现类对象中添加数据obj时,要求obj所在类从写equals()方法
①
package 集合.day01;
import com.sun.xml.internal.ws.spi.db.DatabindingException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
public class CollectionTest {
public static void main(String[] args) {
//add(Object e):将元素e添加到coll集合中
Collection coll = new ArrayList();
coll.add("aa");
coll.add("bb");
coll.add(123);
coll.add(new Date());
//size():获取添加的元素的个数
System.out.println(coll.size());//4
Collection coll1 = new ArrayList();
//addAll(Collection coll1):将coll1集合中的元素添加到当前元素中
coll1.add("qwe");
coll1.add(1254);
coll.addAll(coll1);
System.out.println(coll.size());//6
//isEmpty():判断当前集合是否为空。
System.out.println(coll.isEmpty());//false
//clear():清空集合元素
coll1.clear();
System.out.println(coll1.isEmpty());//true
}
}
②
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
//说明:向Collection接口的实现类对象中添加数据obj时,要求obj所在类从写equals()方法
public class Test1 {
public static void main(String[] args) {
}
@Test
public void test1() {
Collection coll = new ArrayList();
coll.add(12);
coll.add(12232);
coll.add(new String("Tom"));
coll.add(true);
coll.add(new Person("ww",12));
//1.contains(Object obj)判断当前集合中是否包含obj
//调用obj对象所在类的equals()
System.out.println(coll.contains(12));
System.out.println(coll.contains((new Person("ww",12))));
Collection coll1 = new ArrayList();
coll1.add(12);
coll1.add(12232);
//2.containsAll(Collection coll1)判断coll1中的所有元素是否都在当前集合中
System.out.println(coll.containsAll(coll1));
}
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(12);
coll.add(12232);
coll.add(new String("Tom"));
coll.add(true);
Collection coll1 = new ArrayList();
coll1.add(12);
coll1.add(12);
coll1.add(12232);
//remove(Object obj)
//删除第一个与obj相等的元素
System.out.println(coll1);
coll1.remove(12);
System.out.println(coll1);
//removeAll(Collection coll1)从当前集合中一出coll1中所有的元素
System.out.println(coll.removeAll(coll1));
System.out.println(coll);
}
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add(12);
coll.add(12232);
coll.add(new String("Tom"));
coll.add(true);
Collection coll1 = new ArrayList();
coll1.add(12);
coll1.add(89);
coll1.add(12232);
Collection coll2 = new ArrayList();
coll2.add(12);
coll2.add(89);
coll2.add(12232);
Collection coll3 = new ArrayList();
coll3.add(89);
coll3.add(12);
coll3.add(12232);
//1.retainAll(Collection coll1)求交集
coll.retainAll(coll1);
System.out.println(coll);
//2.equals(Object obj)判断集合是否相同
System.out.println(coll1.equals(coll2));//true
System.out.println(coll1.equals(coll3));//false
}
@Test
public void test4(){
Collection coll = new ArrayList();
coll.add(12);
coll.add(12232);
coll.add(new String("Tom"));
coll.add(true);
//hashCode() 返回的当前对象的哈希值
System.out.println(coll.hashCode());
//toArray() 集合--->数组
Object[] arr = coll.toArray();
for (int i = 0 ;i < arr.length ; i++){
System.out.println(arr[i]);
}
}
}
4. Iterator迭代器接口
使用 Iterator 接口遍历集合元素
Iterator对象称为迭代器(设计模式的一种),主要用于遍历 Collection 集合中的元素。
GOF给迭代器模式的定义为:提供一种方法访问一个容器(container)对象中各个元素,而又不需暴露该对象的内部细节。迭代器模式,就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。
Collection接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,那么所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。
Iterator 仅用于遍历集合,Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象,则必须有一个被迭代的集合。
集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前。
4.1使用iterator遍历Collection
说明
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next():①指针下移 ②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
在调用iterator.next()方法之前必须要调用it.hasNext()进行检测。
若不调用,且下一条记录无效,直接调用it.next()会抛出NoSuchElementException异常。
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorTest {
public static void main(String[] args) {
}
@Test
public void test1() {
Collection coll = new ArrayList();
coll.add(12);
coll.add(12232);
coll.add(new String("Tom"));
coll.add(true);
Iterator iterator = coll.iterator();
//方式①
//不能多遍历
//不推荐
for (int i = 0; i < coll.size(); i++) {
System.out.println(iterator.next());
}
//方式②
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
4.2Iterator迭代器remove()的使用
注意:
- Iterator可以删除集合的元素,但是是遍历过程中通过迭代器对象的remove方 法,不是集合对象的remove方法。
- 如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法,再调用remove都会报IllegalStateException。
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorTest {
public static void main(String[] args) {
}
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add(12);
coll.add(12232);
coll.add(new String("Tom"));
coll.add(true);
//移除操作
Iterator iterator = coll.iterator();
while(iterator.hasNext()){
Object obj = iterator.next();
if (obj.equals("Tom")){
iterator.remove();
}
}
//遍历
Iterator iterator1 = coll.iterator();
while(iterator1.hasNext()){
System.out.println(iterator1.next());
}
}
}
5.新特性foreach循环遍历集合或项目
格式:
for(集合元素类型 局部变量 : 集合对象){
}
应用:
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
public class ForTest {
public static void main(String[] args) {
}
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add(12);
coll.add(12232);
coll.add(new String("Tom"));
coll.add(true);
//for(集合元素类型 局部变量 : 集合对象)
//内部仍然掉调用了迭代器
for (Object obj : coll ){
System.out.println(obj);
}
}
@Test
public void test2(){
int[] arr = new int[]{1,2,3,4,5,60};
//for(数组元素类型 局部变量 : 数组对象)
for (int i : arr){
System.out.println(i);
}
}
//面试题、
@Test
public void test3(){
int[] arr = new int[]{1,2,3,4,5,60};
for (int i = 0;i < arr.length;i++){
arr[i] = 1;
}
for(int i : arr){
i = 1;
}
for (int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
}
}
6.Collection子接口之一:List接口
6.1概述
1. 鉴于Java中数组用来存储数据的局限性,我们通常使用List替代数组
2. List集合类中元素有序、且可重复,集合中的每个元素都有其对应的顺序索引。
3. List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
4. JDK API中List接口的实现类常用的有:ArrayList、LinkedList和Vector。
面试题
ArrayList LinkedList Vector三者的异同
同:
都实现了List接口,存储数据的特点相同:存储有序的,可重复的数据。
异:
ArrayList:作为List接口的主要实现类;线程不安全,效率高;底层使用数组存储
LinkedList:对于频繁的插入,删除操作,使用此类效率比ArrayList高;底层使用双链表存储。
Vector:作为List接口的古老实现类;线程安全,效率低;底层使用数组存储
6.2List接口中的常用方法
List除了从Collection集合继承的方法外,List 集合里添加了一些根据索引来操作集合元素的方法。
1.void add(int index, Object ele):在index位置插入ele元素
2.boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
3.Object get(int index):获取指定index位置的元素
4.int indexOf(Object obj):返回obj在集合中首次出现的位置
5.int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
6.Object remove(int index):移除指定index位置的元素,并返回此元素
7.Object set(int index, Object ele):设置指定index位置的元素为ele
8.List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
import org.junit.Test;
import java.util.ArrayList;
public class ListTest {
public static void main(String[] args) {
}
@Test
public void test1(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add(true);
list.add(new Person("Tom",18));
ArrayList list1 = new ArrayList();
list1.add(852);
list1.add(false);
System.out.println(list);
list.add(1,"bb");
System.out.println(list);
list.addAll(1,list1);
System.out.println(list);
System.out.println(list1.get(1));
}
@Test
public void test2(){
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add(true);
list.add(new Person("Tom",18));
list.add(123);
System.out.println(list.indexOf(123));
System.out.println(list.indexOf(18874));//-1
System.out.println(list.lastIndexOf(123));
System.out.println(list.remove(1));
System.out.println(list.set(2,"lhk"));
System.out.println(list);
System.out.println(list.subList(2,4));
}
}
6.3List遍历与方法总结
曾:add(Object obj)
删:remove(int index)/remove(Object obj)
改:set(int index,Object ele)
查:get(int index)
插入:add(int index,Object ele)
长度:size()
遍历:①Iterator迭代器
②增强for循环
③普通for循环
例如
@Test
public void test3(){
ArrayList list = new ArrayList();
list.add(123);
list.add(true);
list.add("lhk");
//1
Iterator iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("*************");
//2
for (Object obj : list){
System.out.println(obj);
}
System.out.println("*************");
//3.
for (int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
}
面试:
@Test
public void testListRemove() {
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
updateList(list);
System.out.println(list);
}
private static void updateList(List list) {
//list.remove(2);
list.remove(new Integer(2));
}
7.Collection子接口之二:Set接口
7.1概述
Set接口中没有额外定义新的方法,使用的都是Collection中定义的方法
说明
HashSet:作为Set接口的主要实现类;线程不安全;可以存储null值
LinkedHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历。
TreeSet:可以按照对象的指定属性,进行排序
Set无序,不可重复的理解
无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据哈希值决定的。
不可重复性:保证添加的元素按照equals()判断时,不能返回true。即;相同的元素只能添加一个。
7.2HashSet中元素的添加过程
HashSet底层:数组+链表的结构
7.3hashCode()和equals()的重写
向Set中添加数据,其所在的类一定要重写equals()和hashCode()方法
重写的equals()和hashCode()尽可能地保持一致性:相等的对象必须具有相等的散列码
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
7.4LinkedHashSet的使用
LinkedHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历。
LinkedHashSet作为HashSet的子类,再添加数据的同时,每个数据还维护了两个引用,记录此数据的前一个数据和后一个数据
优点
对于频繁的遍历操作,LinkedHashSet效率高于HashSet
7.5TreeSet的排序
向TreeSet中添加数据,要求是相同类的对象
7.5.1自然排序(实现Comparable接口)
自然排序中,比较两个对象是否相同的标准为:compareTo()返回0,不再是equals()
//按照姓名从大到小排序,年龄从小到大
@Override
public int compareTo(Object o) {
if (o instanceof Student) {
Student student = (Student) o;
// return -this.name.compareTo(student.name);
int i = -this.name.compareTo(student.name);
if (i !=0){
return -this.name.compareTo(student.name);
}else{
return Integer.compare(this.age,student.age);
}
} else {
throw new RuntimeException("输入类型不匹配!");
}
}
7.5.2 定制排序(Comparator)
定制排序中,比较两个对象是否相同的标准为:compare()返回0,不再是equals()
@Test
public void test3(){
Comparator com = new Comparator() {
//按年龄从小到大排序
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Student && o2 instanceof Student) {
Student s1 = (Student) o1;
Student s2 = (Student) o2;
return Integer.compare(s1.getAge(), s2.getAge());
} else {
throw new RuntimeException("输入数据类不匹配!");
}
}
};
TreeSet set = new TreeSet(com);
set.add(new Student("2om1",12));
set.add(new Student("t7om2",2));
set.add(new Student("1om3",172));
set.add(new Student("7om4",82));
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
8.Set的面试题
例一:在List内去除重复数字值,要求尽量简单
public static List duplicateList(List list) {
HashSet set = new HashSet();
set.addAll(list);
return new ArrayList(set);
}
@Test
public void test4() {
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(2);
list.add(4);
list.add(4);
list.add(4);
List list2 = duplicateList(list);
for (Object integer : list2) {
System.out.println(integer);
}
}
例二
@org.junit.Test
public void test1() {
HashSet set = new HashSet();
Person p1 = new Person(1001, "AA");
Person p2 = new Person(1002, "BB");
set.add(p1);
set.add(p2);
System.out.println(set);
p1.name = "CC";
System.out.println(set.remove(p1));
System.out.println(set);
set.add(new Person(1001, "CC"));
System.out.println(set);
set.add(new Person(1001, "AA"));
System.out.println(set);
}
8.Map接口
8.1概述
概述
1.Map与Collection并列存在。用于保存具有映射关系的数据:key-value
2. Map 中的 key 和 value 都可以是任何引用类型的数据
3. Map 中的 key 用Set来存放,不允许重复,即同一个 Map 对象所对应的类,须重写hashCode()和equals()方法
4. 常用String类作为Map的“键”
5. key 和 value 之间存在单向一对一关系,即通过指定的 key 总能找到唯一的、确定的 value
6. Map接口的常用实现类:HashMap、TreeMap、LinkedHashMap和Properties。其中,HashMap是 Map 接口使用频率最高的实现类
Map多个实现类的对比
-
HashMap
作为Map的主要实现类;线程不安全,效率高;可以存储null的key和value
HaspMap的底层:数组+链表(jdk7及之前)~~~~~~数组+链表+红黑树(jdk8)1.1 LinkedHashMap 保证在遍历map元素是时,可以按照添加的元素的顺序实现遍历。 原因:在原有的HashMap底层结构基础上,添加一对指针,指向前一个元素和后一个元素
-
TreeMap
保证按照添加时的key-value对进行排序,实现排序遍历。此时考虑key的自然排序或定制排序。底层使用红黑树 -
Hashtable
古老的实现类;线程安全,效率低;不能存储null的key和value3.1 Properties 常用来处理配置文件,key和value都是String类型
面试题
1.HashMap的底层实现原理
2.HashMap和Hashtable的异同
8.2Map中key-value的特点
-
Map中的key:
无序,不可重复,使用Set存储所有的key
key所在的类要重写equals()和hashCode()方法 -
Map中的value:
无序,可重复,使用Collection存储所有的value
value所在的类要重写equals() -
一个键值对(key-value):构成一个entry对象
-
Map中的entry:
无序,不可重复,使用Set存储所有的entry
8.3HashMap的底层实现原理
8.3.1jdk7
8.3.2jdk8
8.4Map中常用方法
1. 添加、删除、修改操作:
Object put(Object key,Object value):将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key):移除指定key的key-value对,并返回value
void clear():清空当前map中的所有数据
2. 元素查询的操作:
Object get(Object key):获取指定key对应的value
boolean containsKey(Object key):是否包含指定的key
boolean containsValue(Object value):是否包含指定的value
int size():返回map中key-value对的个数
boolean isEmpty():判断当前map是否为空
boolean equals(Object obj):判断当前map和参数对象obj是否相等
3. 元视图操作的方法:
Set keySet():返回所有key构成的Set集合
Collection values():返回所有value构成的Collection集合
Set entrySet():返回所有key-value对构成的Set集合
1
@Test
public void test1() {
Map map = new HashMap();
//put(key,value)
map.put("李行昆", 1);
map.put("刘德华", 2);
map.put("王祖贤", 3);
//添加
map.put("周星驰", 4);
//修改
map.put("周星驰", 5);
System.out.println(map);
//putAll(Map m)
Map map1 = new HashMap();
map.put("胡歌", 1);
map.put("成龙", 2);
map.putAll(map1);
System.out.println(map);
//remove(key)
System.out.println(map.remove("周星驰"));
//clear()
map.clear();
System.out.println(map);
}
}
2
@Test
public void test2(){
Map map = new HashMap();
//put(key,value)
map.put("李行昆", 1);
map.put("刘德华", 2);
map.put("王祖贤", 3);
//添加
map.put("周星驰", 4);
//修改
map.put("周星驰", 5);
//get(key)
System.out.println(map.get("周星驰"));
//containsKay(key)
System.out.println(map.containsKey("周星驰"));
//containsValue(values)
System.out.println(map.containsValue(8));
//size()
System.out.println(map.size());
//isEmpty()
System.out.println(map.isEmpty());
Map map1 = new HashMap();
map.put("胡歌", 1);
map.put("成龙", 2);
//equals(Object obj)
System.out.println(map.equals(map1));
}
3
@Test
public void test3() {
Map map = new HashMap();
//put(key,value)
map.put("李行昆", 1);
map.put("刘德华", 2);
map.put("王祖贤", 3);
//添加
map.put("周星驰", 4);
//修改
map.put("周星驰", 5);
Set set = map.keySet();
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("**********");
Collection coll = map.values();
for (Object obj : coll){
System.out.println(obj);
}
System.out.println("**********");
Set set1 = map.entrySet();
Iterator iterator1 = coll.iterator();
while (iterator1.hasNext()){
System.out.println(iterator1.next());
}
}
8.5TreeMap两种添加方式的使用
向TreeMap中添加key-value,要求key必须是同一类创建的对象
因为要按照key进行排序:自然排序 定制排序
8.6Properties处理配置文件
import java.io.FileInputStream;
import java.util.Properties;
public class TreeMapTest {
public static void main(String[] args) throws Exception {
Properties pros= new Properties();
FileInputStream fis = new FileInputStream("jdbc.Properties");
pros.load(fis);//加载流对应的文件
String name = pros.getProperty("name");
String password = pros.getProperty("password");
System.out.println("name: " + name + ",password: " + password);
fis.close();
}
}
8.7Collectons工具类常用方法的测试
Collections工具类<--------->操作数组的工具类:Arrays
1. 排序操作:(均为static方法)
reverse(List):反转 List 中元素的顺序
shuffle(List):对 List 集合元素进行随机排序
sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List,Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List,int, int):将指定 list 集合中的 i 处元素和 j 处元素进行交换
2. 查找、替换
Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
Object max(Collection,Comparator):根据 Comparator 指定的顺序,返回
给定集合中的最大元素
Object min(Collection)
Object min(Collection,Comparator)
int frequency(Collection,Object):返回指定集合中指定元素的出现次数
void copy(List dest,List src):将src中的内容复制到dest中
boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换List 对象的所有旧值
1
@org.junit.Test
public void test1() {
List list = new ArrayList();
list.add(12);
list.add(14);
list.add(85);
list.add(-1);
System.out.println(list);
//Collections.reverse(list);
//Collections.shuffle(list);
//Collections.sort(list);
Collections.swap(list, 0, 1);
System.out.println(list);
}
2
@org.junit.Test
public void tes2() {
List list = new ArrayList();
list.add(12);
list.add(14);
list.add(12);
list.add(85);
list.add(-1);
System.out.println(list);
System.out.println(Collections.max(list));
System.out.println(Collections.min(list));
System.out.println(Collections.frequency(list, 12));
//void copy(List dest,List src):将src中的内容复制到dest中
//错误
//原因:在copy(dest,list)中dest.size()>=list.size()才不会报错
// List dest = new ArrayList();
// Collections.copy(dest,list);
List dest = Arrays.asList(new Object[list.size()]);
System.out.println(dest);
Collections.copy(dest, list);
System.out.println(dest);
Collections.replaceAll(list, -1, -100);
System.out.println(list);
}
3
@org.junit.Test
public void test3(){
List list = new ArrayList();
list.add(12);
list.add(14);
list.add(12);
list.add(85);
list.add(-1);
System.out.println(list);
//返回的list1即为线程安全的list
List lsit1 = Collections.synchronizedList(list);
}