本文深入讲解Java集合框架，包括Collection和Map接口，探讨数组与集合的区别，详细分析List、Set和Map的实现类及其特点，如ArrayList、HashSet、HashMap等，帮助读者掌握Java集合的高效使用。
集合概述
一.集合:看做一种容器，用来存储对象信息,所有的集合都位于java.util包下。
二.数组和集合的区别
①.数组存储的相同的数据类型,集合可以存储不同的数据类型
②.数组可以存储基本类型的数据,也可以存储对象,集合只能存储对象。
③.数组长度是不可变化的,一旦确定了数组的长度,数组中只能存储固定个数的元素，集合可以存储数量不确定的数据。
三.集合包含的主要接口:Java集合中有两个根接口Collection和Map派生出来的。
1.Collection接口
①.List接口:存储有序的，可以重复的元素。(底层实现是使用数组)
– ArrayList:主要实现类
– LinkList:链表的实现方式.主要对于频繁的插入、删除操作。
– Vector：古老的实现类
②.Set接口：存储无序的,不可重复的元素(添加相同的元素只能存储一份)
– HashSet:主要的实现类
– LinkedHashSet:它是HashSet的一个子类.具有HashSet的特性,是根据元素的hashcode值来决定元素存储的位置,它也使用链表来维护元素的顺序.（性能是低于HashSet）
– TreeSet:它是SortedSet接口的实现类,可以保证元素处于排序状态。(默认是采用自然排序)
自然排序:TreeSet会调用集合元素的compareTo(object)方法比较元素的大小关系,然后将元素按照升序排序。
③.Queue(队列)
2.Map接口:存储的数据是键值对<key,value>
①.key:是不能重复的,使用Set来存储
②.value:是可以重复的,使用Collection来存储。
③.实现类
– HashMap：主要的实现类
– LinkedHashMap
--TreeMap
– Hashtable:子类(Properties:键值对都是string类型)
Collection 接口
-
Collection coll = new ArrayList(); // 创建一个Collection对象
一、Collection 常用方法
①.size()返回集合中元素的个数
System.out.println(coll.size());
②.add(Object obj)添加元素.
coll.add(123);
coll.add("tina");
coll.add(new Date());
coll.add("A");
coll.add("A");
System.out.println(coll.size());
System.out.println(coll);
③.addAll(Collection coll)将集合中的所有元素添加到当前集合
Collection coll1 =Arrays.asList(1,2,3,4,5);
coll.addAll(coll1);
④.isEmpty() 判断该集合是否为空
System.out.println(coll.isEmpty());
⑤.clear() 清空集合元素
coll.clear();
System.out.println(coll.isEmpty());
⑥.contains(Object obj):判断集合中是否可以包含指定的元素
boolean b1 = coll.contains(123);
System.out.println(b1);
⑦.remove(Object obj) 删除集合中的元素
boolean b3 = coll.remove("A");
System.out.println(b3);
System.out.println(coll);
⑧.removeAll(Collection coll):从当前集合中删除另外一个集合
Collection coll1 = new ArrayList();
coll1.add(123);
coll1.add("A");
coll.removeAll(coll1);
⑨.toArray()将集合转化为数组
Object[] array = coll.toArray();
for (Object obj : array) {
System.out.println(obj);
}
⑩.iterator() 迭代器 可以实现对集合的遍历
迭代器是一种设计模式,它是一个轻量级对象。
Iterator是一个接口,是集合的迭代器，集合可以通过Iterator去遍历集合中的元素
hasNext():判断集合中是否存在下一个元素 如果有则返回true
next():返回集合里的下一个元素
Iterator iterator = coll.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println(obj);
}
二、便利集合的方法
- 1.使用迭代器Iterator实现集合的便利
- 2.使用增强for循环实现集合便利
- 3.使用for循环
- 4.将集合转化为数组(toArray),再进行便利
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("张三");
coll.add("abc");
coll.add("china");
coll.add("A");
coll.add(30);
// 1.使用迭代器
Iterator iterator = coll.iterator();
// 判断还有没有下一个元素
while (iterator.hasNext()) {
// 获取下一个集合元素
Object obj = iterator.next();
System.out.println(obj);
}
System.out.println("----------------------------");
// 2.使用增强for循环
for (Object obj : coll) {
System.out.println(obj);
}
System.out.println("----------------------------");
// 3.使用for循环
Iterator iterator2 = coll.iterator();
for(;iterator2.hasNext();) {
Object obj = iterator2.next();
System.out.println(obj);
}
System.out.println("-----------------------");
// 4.将集合转化为数组，再进行便利\
Object[] array = coll.toArray();
for (Object object : array) {
System.out.println(object);
}
}
Collection 子接口 — List接口&Set接口
一、List接口
1.List接口是collection接口的子接口
2.List它是有序的集合，存储元素和取出元素顺序是一致的(存 abc 或者取abc)
3.有索引，包含了一些带索引的方法(底层实现是使用数组，它是一个可变数组)
4.允许存储重复的元素
5.List接口的主要实现类:ArrayList
6.常用方法
void add(int index, Object ele):在指定索引位置添加元素
boolean addAll(int index, Collection eles)
Object get(int index) 获取指定索引位置的元素
int indexOf(Object obj) 返回obj在集合中首次出现的索引位置，如果没有找到索引则返回-1
int lastIndexOf(Object obj) 返回obj在集合中最后一次出现的索引位置，如果没有找到索引则返回-1
Object remove(int index) 删除指定索引位置的元素
Object set(int index, Object ele) 设置指定索引位置的元素
- List类中常用的实现类
1.Arraylist
①.底层实现是使用数组的方法来实现的(动态数组)，允许包含所有元素类型(包括null)
②.可以根据索引位置对象集合进行快速的随机访问(优点)
③.向指定的索引位置插入元素或者删除元素，速度比较慢(缺点)
2.LinkedList
①.LinkedList是采用双向链表来操作数据(通过next和pervious可以移动指针)
②.便于向集合中插入和删除元素，组个值班费效率比较高(优点)
③.使用链表的形式操作数据，访问数据的速度是比较慢(缺点)
3.Vector(用的少)
①.底层实现也是使用数组的方式
②.是线程安全的，效率比较低
4.Arraylist和Linkedlist的区别
①.ArrayList是基于数组的实现方式，LinkedList使用双向链表的数据结构，这是两种技术，决定了不通过的应用场景
②.对于随机访问get和set ArrayList优于LinkedList，因为LinkedLisk要移动指针
③.队友频繁的新增和删除操作，LinkedList优于ArrayList，因为ArrayList要移动数组
List常用方法
@Test
public void testList() {
List list = new ArrayList();
// 添加元素
list.add(123);
list.add("zhangsan");
list.add(new String("eric"));
System.out.println(list);
//指定索引位置添加元素
list.add(0,110);
System.out.println(list);
//获取指定索引位置的元素
Object obj = list.get(1);
// 删除指定索引位置的元素
list.remove(0);
System.out.println(list.get(0));
// 设置指定位置的元素
list.set(0, 119);
System.out.println(list);
list.add(119);
System.out.println(list);
//indexof 获取元素第一次出现的索引位置
int index = list.indexOf(119);
System.out.println(index);
// lastindexof 获取最后一次出现的位置
int lastIndex = list.lastIndexOf(119);
System.out.println(lastIndex);
//addAll()在指定的集合中添加集合
list.add(0, Arrays.asList(new String[] {"张三","李四","忘无"}));
System.out.println(list);
}
@Test
public void testList2() {
// 便利List 集合
List list = new ArrayList();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
//1.使用迭代器
Iterator iterator = list.iterator();
//判断有没有下一个元素
while (iterator.hasNext()) {
// 取出元素
Object object = iterator.next();
System.out.println(object);
}
System.out.println("-----------------------------------");
// 使用增强 for循环
for (Object object : list) {
System.out.println(object);
}
System.out.println("-----------------------------------");
// 3.使用for循环
for(int i = 0;i < list.size(); i++) {
Object element = list.get(i);
System.out.println(element);
}
System.out.println("-----------------------------------");
// 4.使用List集合中的 toArray()方法
System.out.println(list.toArray());
// 5.List集合注意事项
// 没有分配具体实例
List list1 = null;
// 分配了具体实例，但是集合中没有任何元素
List list2 = new ArrayList();
//由于没有分配具体实例，list1引用找不到对象的实例，会报一个空指针异常
//System.out.println(list1.size());
System.out.println(list2);
System.out.println(list2.size());
// 在便利集合之前，通常要判断该集合是否为null且集合中是否有元素
if(list2 != null && list2.size() >0) {
for (int i = 0; i < list2.size(); i++) {
System.out.println(list2.get(1));
}
}
}
二、Set接口
Set
1.Set接口是继承与Collection
2.S·et堆中存储的数据是无序的(不代表乱序:内部有序，外部无序)
3.Set中存储的数组是不可重复的，当Set中添加相同的元素，只能添加一个元素
4.添加进Set中的元素，一定要重写equals和hashCode方法
①.Set中的元素存储使用哈希算法
②.当向Set添加元素时，首先会调用该对象所在类的hashCide方法，计算对象的哈希值，这个哈希值决定了Set元素的存储位置
③.再通过equals方法比较两个对象是否相同，如果相同，则后面的对象不能添加
5.实现类
①.HashSet(主要实现类)
②.LinkHashSet
③.TreeSet
6.HashSet(主要实现类)
①.HashSet是Set接口的主要实现类
②.HashSet是采用哈希算法存储集合的元素，因此有很多存取和查询性能(底层数据结构是哈希表)
哈希表:综合数组和链表的优点(一个链表的数组)
③.HashSet不能保证元素的排列数据，顺序和添加的顺序不一致。
④.内部存储机制:HashSet集合判断两个元素的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode值相等，确保元素的唯一性
⑤.为什么不使用数组，而是用hashSet？
1）HashSet通过哈希值确定存储位置，可以自由的增加长度，并根据哈希值访问元素，不能挨个便利去访问
7.LinkedHashSet
①.linkHashSet是HashSet的一个子类
②.LinkedHashSet是用链表维护元素的顺序
③.输出集合元素时元素顺序和添加顺序是一致的
8.TreeSet
①.TreeSet是SortedSet接口的实现类
②.TreeSet可以确保集合元素处理排序状态
③.TreeSet内部是二叉树 ，默认是从小到大金星排序
④.TreeSet使用两种排序方法:自然白排序个定制排序 默认是自然排序
Set常用方法及代码实现
@Test
public void testHashSet() {
Set set = new HashSet();
Integer number = new Integer(123);
set.add(number);
set.add(123);
set.add(456);
set.add("A");
set.add(null);
Person p1 = new Person("xiaoming",23);
Person p2 = new Person("xiaoming",23);
set.add(p1);
set.add(p2);
System.out.println(set);
//移除元素
set.remove(123);
System.out.println(set);
//清空元素
/*set.clear();
System.out.println(set);*/
// 便利Set集合
// 使用迭代器便利
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object object = iterator.next();
System.out.println(object);
}
System.out.println("------------------------");
// 使用增强for循环
for (Object object : set) {
System.out.println(object);
}
}
List和Set区别 (面试点)
①.List和Set都是Collection的子接口
②.List是存储有序的可以重复的数据
③.Set是存储无序的不能重复的数据
Map接口
Map接口:保存具有映射关系的数据，Map中保存的两组值(一组是key 一组是value)
1.它和Collection接口是一个平行关系
2.存放的数据是键值对(key-value)数据
①.Key：Map中的键 它是不能重复，底层实现是采用Set
②.value：Map中的值可以重复，底层实现是采用Collectopn(List)
③.Map实际上是提供了一个Entry内部类里封装Key-value
3.Map集合的优点
类似于字典一样，通过key找到对应的value。使用这种映射关系 方便查找数据
4.Map类中的常用方法
Object put(Object key,Object value);添加元素
Object remove(Object key);移除元素 删除一个key-value
void putAll(Map t);
void clear();清空元素
Object get(Object key); 获取指定的value，如果没有找到对应的key则返回null
-
boolean containsKey(Object key) 是否包含指定的key
boolean containsValue(Object value) 是否包含指定的value
int size() 集合的长度
boolean isEmpty() 是否为空
boolean equals(Object obj) -
Set keySet() 返回Map中所有key组成的集合 Set
Collection values() 返回Map所有的value组成的集合 Collection
Set entrySet() 返回Map中所有的键值对组成的Set集合
5.内部类 Map.Entry
①.Map中包含一个内部类Entry，它封装了一个键值对
②.常用方法
– getKey();获取Entry中包含的Key值
– getValue; 获取Entry中包含value值
6.实现类
①.HashMap:主要实现类
②.LinkedHashMap：使用链表的方式来添加Map元素的顺序 (迭代顺序和插入顺序一致)
③.TreeMap
④.Hashtable:线程安全的,不建议使用,不允许使用null作为key，value
– PropertLines： 通常同来处理属性文件，键值对都是String类
Map常用方法演示以及Map集合的遍历
package com.hpe.MAP;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import org.junit.Test;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import com.hpe.collcetion.Person;
import com.sun.corba.se.impl.oa.poa.ActiveObjectMap.Key;
/*
* Collection接口
* -- List接口
* -- Set接口
* Map接口:保存具有映射关系的数据，Map中保存的两组值(一组是key 一组是value)
* 1.它和Collection接口是一个平行关系
* 2.存放的数据是键值对(key-value)数据
* ①.Key：Map中的键 它是不能重复，底层实现是采用Set
* ②.value：Map中的值可以重复，底层实现是采用Collectopn(List)
* ③.Map实际上是提供了一个Entry内部类里封装Key-value
* 3.Map集合的优点
* 类似于字典一样，通过key找到对应的value。使用这种映射关系 方便查找数据
* 4.Map类中的常用方法
* Object put(Object key,Object value);添加元素
* Object remove(Object key);移除元素 删除一个key-value
* void putAll(Map t);
* void clear();清空元素
* Object get(Object key); 获取指定的value，如果没有找到对应的key则返回null
* boolean containsKey(Object key) 是否包含指定的key
boolean containsValue(Object value) 是否包含指定的value
int size() 集合的长度
boolean isEmpty() 是否为空
boolean equals(Object obj)
* Set keySet() 返回Map中所有key组成的集合 Set
Collection values() 返回Map所有的value组成的集合 Collection
Set entrySet() 返回Map中所有的键值对组成的Set集合
5.内部类 Map.Entry
①.Map中包含一个内部类Entry，它封装了一个键值对
②.常用方法
-- getKey();获取Entry中包含的Key值
-- getValue; 获取Entry中包含value值
6.实现类
①.HashMap:主要实现类
②.LinkedHashMap：使用链表的方式来添加Map元素的顺序 (迭代顺序和插入顺序一致)
③.TreeMap
④.Hashtable:线程安全的,不建议使用,不允许使用null作为key，value
-- PropertLines： 通常同来处理属性文件，键值对都是String类
--
*/
public class TestMap {
@Test
public void TestMap() {
Map map = new HashMap();
// 添加元素(当向集合中添加相同的元素key相同时,保留的是后面的元素)
map.put("A",123);
map.put("B",456);
map.put("C",null);
map.put("B",123);
map.put(new Person("0",20),111);
//获取元素的个数
System.out.println(map.size());
System.out.println(map);
// 移除元素
map.remove("B");
System.out.println(map);
// 根据key更新value值
map.put("C", 119);
System.out.println(map);
// 获取元素
Object object = map.get("A");
System.out.println(object);
//是否包含某个key值
boolean isContainKey = map.containsKey("C");
System.out.println(isContainKey);
// 清空Map元素
map.clear();
System.out.println(map);
// 判断Map是否为空
boolean emprty = map.isEmpty();
System.out.println(emprty);
}
/*
* Map的遍历
* 1.Map中的Key是使用Set存储，不可重复
* 2.Map中的value使用Collection来存放，可以重复
* 3.一个键值对(Key-value),就是一个Entry，Entry是使用Set来存放，也是不可重复
* 4.当向Map中添加元素时,会调用Key所在类的equals()方法，判断两个key是否相同，如果相同添加后面的元素
*
*/
@Test
public void testMap2(){
Map map = new HashMap();
map.put("C罗",35);
map.put("梅西",33);
map.put("内马尔",29);
map.put(null,null);
// 1.keySet() 遍历key的集合
Set set = map.keySet();
for (Object object : set) {
System.out.println(object);
}
System.out.println("-----------------------");
// 2.values() 遍历values的集合
Collection values = map.values();
Iterator iterator = values.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("--------------------");
// 3.entrySet() 遍历key-value
// 方式一
Set set1 = map.keySet();
for (Object obj : set1) {
// 得到key值
Object key = obj;
// 根据get(Key)方法得到相应的value值
Object value = map.get(key);
System.out.println(key+"-"+value);
}
System.out.println("--------------");
// 方式二
Set entrySet = map.entrySet();
for (Object object : entrySet) {
Entry entry = (Entry) object;
// 通过entry调用getKey方法 得到Key值
Object key = entry.getKey();
// 通过entry调用getValue()方法得到value值
Object value = entry.getValue();
System.out.println(key+"-"+value);
}
System.out.println("---------------------");
// 方式三 通过forEach方法(JDK1.8d的新特性)
map.forEach((key,value) -> System.out.println(key+"-"+value));
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
