目录
- Java集合知识树
- 1、集合的概念
- 2、集合和数组的区别
- 3、集合的分类
- 4、List集合
- 5、Set集合
- 6、Map集合
Java集合知识树
集合继承关系结构图Collction部分
Tips：图中标红为常用的集合。
集合继承关系结构图Map部分
1、集合的概念
集合就是一个容器
2、集合和数组的区别
- 集合不定长的可自动扩容;数组定长,访问较快,不可扩容
- 数组一旦规定了类型存放的元素类型必须一致，就相当于垃圾分类一样；集合就像一个垃圾桶什么都能装
- 数组可以包含基本数据类型或引用类型的对象;而集合中只能包含引用类型的对象
3、集合的分类
- 单列集合：父类：Collection
- 单列集合的分类：
- List接口：
- ArrayList集合（类）*
- LinkedList集合（类）*
- Set接口：
- hashSet集合（类）*
- TreeSet集合（类）
- **特点：**在内存中存储方式是单列
方法 | 含义 |
boolean add(Object) | 集合中加入一个对象，成功时返回true |
boolean addAll(Collection) | 集合中加入另外一个集合对象 |
int size() | 集合内容纳的元素数量 |
boolean isEmpty() | 集合是否为空 |
boolean contains(Object) | 集合内是否含有参数对象 |
Iterator iterator() | 产生一个迭代器 |
Object[] toArray() | 返回一个包含所有元素的对象数组 |
boolean remove(Object) | 从集合中删除对象 |
boolean removeAll(Collection) | 清空指定集合 |
boolean containsAll(Collection) | 判断集合内是否包含子集 |
boolean retainAll(Collection) | 仅保留此 collection 中那些也包含在指定 collection 的元素 |
void clear() | 清空集合 |
- 注意：
- 所有的单列集合都可以用这些方法
- Collection是一个接口，要想使用这些方法必须由子类实例去使用
- **双列集合：**Map父类
- 分类：
- HashMap(类)*
- TreeMap(类)
- HashTable(类)
- **特点：**在内存中存储方式是双列 ，通过key获取value值
- 方法：
方法 | 含义 |
Object put(Object key,Object value) | 将指定的值与此映射中的指定键相关联 |
void putAll(Map t) | 将映射t中所有映射关系复制到此映射中 |
Object get(Object key) | 返回此映射中映射到指定键的值 |
Object remove(Object key) | 若存在此键的映射关系,将其从映射中移除 |
boolean containsKey(Object key) | 若此映射包含指定键的映射关系，返回 true |
boolean containsValue(Object value) | 若此映射为指定值映射一个或多个键,返回 true |
int size() | 返回此映射中的键-值映射对数 |
boolean isEmpty() | 若此映射未包含键-值映射关系,返回 true |
Set keySet() | 返回此映射中包含的键的 set 集合 |
Collection values() | 返回此映射中的所有值对象的Collection集合 |
4、List集合
- 特点：三有产品 有序 有重复值 有索引 (有空值)
- ArraysList：
- 特点：ArraysList是基于数组的，数据结构：线性表 存储方式是:顺序存储，也就是在逻辑地址上连续的元素，在物理地址也连续（所有数据的访问都是通过物理地址获取），访问速度非常快，但是插入和删除修改操作非常慢
- **特点：**LinkedList基于链表 数据结构：线性表 存储方式：链式存储，在逻辑地址上连续的在物理地址上不一定连续 ，访问速度慢，但是增加删除修改操作快
- 声明和创建
ArrayList alist1=new ArrayList<>();
List alist2=new ArrayList<>();*以后我么用以下方法创建集合
- Collection中的方法：
/**
* 创建集合：
* ArrayList alist1=new ArrayList<>();
List alist2=new ArrayList<>();
* ArrayList<引用数据类型> l1=new ArrayList<>(); 引用数据类型规定了集合的元素的数据类型
*/
ArrayList alist1=new ArrayList<>();
/*alist1.add(e)*/
alist1.add('c');
alist1.add(123);
alist1.add("zhangsan");
//给集合创建的时候规定元素的数据类型
ArrayList<Integer> l1=new ArrayList<>();
l1.add(12);
l1.add(13);
l1.add(16);
/*l1.add("zhangsan"); 只能存放Integer类型的数据*/
ArrayList<String> l2=new ArrayList<>();
l2.add("zhangsan");
//addAll(collection c)
/*l1.addAll(l2); ArrayList<Integer> is not applicable */
//size() 集合中元素的个数，集合的大小 对比数组用的是length
System.out.println(l1.size());//2
//isEmpty() 判断一个集合是否为空
Item kouhong1=new Item(450.00,"阿玛尼限量款001","送女盆友最佳","阿玛尼");
Item kouhong2=new Item (255.00,"迪奥（Dior）烈艳蓝金唇膏 口红 3.5g 999号 哑光-经典正红","无数杂志的首版！比亮光版偏橘调一点点！黄皮白皮皆安全的大红，适合春天衬衣，夏天黑裙的妆容","dior");
Item kouhong3=new Item (888.00,"迪奥（Dior2）烈艳蓝金唇膏 口红 3.5g 999号 哑光-经典正红","无数杂志的首版！比亮光版偏橘调一点点！黄皮白皮皆安全的大红，适合春天衬衣，夏天黑裙的妆容","dior");
ArrayList<Item> l3=new ArrayList<>();
l3.add(kouhong1);
l3.add(kouhong2);
l3.add(kouhong3);
/**
* 需求：如果集合l3为空就不做往页面传输数据的操作，否则传数据给页面显示
*/
if(l3.isEmpty()) {
System.out.println("请获取数据");
}else {
System.out.println("传输数据");
}
System.out.println(l3);
//boolean contains(Object) 集合内是否含有参数对象
System.out.println(l3.contains("张三"));//false
System.out.println(l3.contains(kouhong1));//true
System.out.println(l1.contains(12));//true
//Object[] toArray() 返回一个包含所有元素的对象数组
System.out.println(alist1);//[c, 123, zhangsan]
Object[] o1=new Object[] {"张三",123,'3'};
Object[] o2=alist1.toArray();
System.out.println(Arrays.toString(o2));//[c, 123, zhangsan]
//boolean remove(Object) 从集合中删除对象
System.out.println(l3.remove(kouhong1));
System.out.println("l3:"+l3+" l3.size():"+l3.size());
//boolean removeAll(Collection) 清空指定集合
ArrayList<Integer> l4=new ArrayList<>();
l4.add(12);
l4.add(13);
ArrayList<Integer> l5=new ArrayList<>();
l5.add(1);
l5.add(2);
l4.addAll(l5);
System.out.println(l4);//[12, 13, 1, 2]
l4.removeAll(l1);
System.out.println(l4);//[1, 2] 因为这个方法会移除源集合中目标集合的元素
//boolean containsAll(Collection) 判断集合内是否包含子集所有元素
ArrayList<Integer> l6=new ArrayList<>();
l6.add(1);
System.out.println(l4.containsAll(l5));//true
System.out.println(l4.containsAll(l6));//true
//clear() 清空集合
l4.clear();
System.out.println(l4);//[]- List中的方法：
/**
* List自有方法
*/
//add(int index,Object element)
ArrayList<Integer> Q7=new ArrayList<>();
/*Q7.add(1,1);//java.lang.IndexOutOfBoundsException: Index: 1, Size: 0*/
Q7.add(12);
Q7.add(13);
Q7.add(14);
System.out.println("Q7:"+Q7);//[12, 13, 14]
Q7.add(1, 2);
System.out.println("Q7:"+Q7);//[12, 2, 13, 14]
// get(int index)返回列表中指定位置的元素
// indexOf(Object o) 在list中查询元素的索引值，如不存在，返回－1
/*List中如果存在多个重复元素，indexOf()方法返回第一个匹配元素的index。
lastIndexOf(o)是返回最后一个匹配元素的index.*/
System.out.println(Q7.indexOf(2));//1
//boolean remove(index) 通过索引从集合中删除对象 List集合特有
Q7.remove(0);
System.out.println(Q7);//[2, 13, 14]
//set(int index,Object element)
Q7.set(2, 15);
System.out.println(Q7);//[2, 13, 15]
//List集合中要重点记住的方法：add() , get(index) ,set(index,值),remove(index),remove(Object)- LinkedList：
- **特点：**LinkedList基于链表 存储方式：链式存储，在逻辑地址上连续的在物理地址上不一定连续 数据结构：线性表 ，访问速度慢，但是增加删除修改操作快
- 注意：
- LinkedList拥有List和单列集合中所有的方法
- LikedList中特有的方法
- 声明和创建：
LinkedList<Integer> l1=new LinkedList<>();
LinkedList l2=new LinkedList<>();
List l3=new LinkedList<>();- LinkedList自有方法：
方法 | 含义 |
void addFirst(Object o) | 将给定元素插入此列表的开头 |
void addLast(Object o) | 将给定元素追加到此列表的结尾 |
Object getFirst() | 返回此列表的第一个元素 |
Object getLast() | 返回此列表的最后一个元素 |
Object removeFirst() | 移除并返回此列表的第一个元素 |
Object removeLast() | 移除并返回此列表的最后一个元素 |
- List集合的遍历
LinkedList<Integer> l1=new LinkedList<>();
/*LinkedList l2=new LinkedList<>();
List l3=new LinkedList<>();*/
l1.add(12);
l1.add(13);
l1.add(14);
l1.add(15);
/**
* List的遍历
* 方式1： for循环
* 方式2：使用迭代器
*/
/* for(int i=0;i<l1.size();i++) {
System.out.println(l1.get(i));
}
for(Integer i:l1) {
System.out.println(i);
}
Item kouhong1=new Item(450.00,"阿玛尼限量款001","送女盆友最佳","阿玛尼");
Item kouhong2=new Item (255.00,"迪奥（Dior）烈艳蓝金唇膏 口红 3.5g 999号 哑光-经典正红","无数杂志的首版！比亮光版偏橘调一点点！黄皮白皮皆安全的大红，适合春天衬衣，夏天黑裙的妆容","dior");
Item kouhong3=new Item (888.00,"迪奥（Dior2）烈艳蓝金唇膏 口红 3.5g 999号 哑光-经典正红","无数杂志的首版！比亮光版偏橘调一点点！黄皮白皮皆安全的大红，适合春天衬衣，夏天黑裙的妆容","dior");
ArrayList<Item> l3=new ArrayList<>();
l3.add(kouhong1);
l3.add(kouhong2);
l3.add(kouhong3);
for(Item i:l3) {
System.out.println(i);
}*/
//方式2 使用迭代器
Iterator it=l1.iterator();
while(it.hasNext()) { //hasNext() 迭代器中是否有下一个元素
System.out.println(it.next());//next()获取迭代器中的值
}
}5、Set集合
- **特点：**三无产品 无序，无索引，无重复值 （可以有null,有且仅有个null） (想去除重复值我们可以使用Set集合)
- 声明和创建
Set<String> s1=new HashSet<>();
HashSet<Integer> s2=new HashSet<>();public static void main(String[] args) {
Set<String> s1=new HashSet<>();
HashSet<Integer> s2=new HashSet<>();
/*
* 无序无索引无重复值
*
* 每次将数据插入Set集合，都会先去判断（使用equals()方法判断）原先的集合中是否有该对象，如果有就替换之前的对象
两个对象e1和e2，如果e1.equals(e2)返回true，则认为e1和e2重复，在set中只保留一个。
*/
s1.add("zhangsan");
s1.add("zhangsan1");
s1.add("zhangsan2");
s1.add("zhangsan3");
s1.add("zhangsan4");
s1.add("zhangsan5");
s1.add("zhangsan5");
s1.add(null);
s1.add(null);
System.out.println(s1);//[null, zhangsan1, zhangsan3, zhangsan2, zhangsan, zhangsan5, zhangsan4]
System.out.println(s1.size());//7
/**
* 访问set集合：
* 先将Set集合转为List集合，再访问
* ArrayList<String> l1=new ArrayList<>(s1);
* l1.get(index)
*
*
*
*/
//单列集合互相转换 数据类型必须一致
/*Set<数据类型>-->List<数据类型> */
ArrayList<String> l1=new ArrayList<>(s1);
System.out.println(l1);
System.out.println(l1.get(1));
/*List<数据类型>-->Set<数据类型>*/
HashSet<String> s3=new HashSet<>(l1);
System.out.println(s3);
Set s4=new HashSet<>();
s4.add('c');
s4.add(123);
s4.add("zhangsan");
s4.add(new Date());
System.out.println(s4);
ArrayList l2=new ArrayList<>(s4);
System.out.println(l2);//[c, zhangsan, 123, Wed Apr 22 14:34:34 CST 2020]
/**
* 遍历
* 1、先将Set集合转为List集合，再遍历
* 2、直接使用forEach
* 3、迭代器 Iterator
*/
/*for(int i=0;i<l1.size();i++) {
System.out.println(l1.get(i));
}*/
/*for(String s:s1) {
System.out.println(s);
}*/
/*for(Object o:s4) {
System.out.println(o);
}*/
/*Iterator it=s4.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}*/
/**
* HashSet，在遍历集合中元素时，不关心元素的顺序，能有null值 基于哈希表
TreeSet，按照升序排列遍历集合中的元素 ,不能有null值 基于红黑树 执行速度慢
*/
Set<Integer> ts=new TreeSet<>();
ts.add(12);
ts.add(11);
ts.add(4);
ts.add(3);
ts.add(20);
ts.add(9);
/*ts.add(null);*/
System.out.println(ts);//[3, 4, 9, 11, 12, 20]
}6、Map集合
- 特点：双列集合，通过key获取value值，数据结构：双向链表+红黑树
- 注意：
- key不可以重复，value可以重复，如果后面添加进集合中的键值对，key不能重复，key重复的话会以最后一次添加的value为主（覆盖之前的value）
- key能有null但有且仅有一个，value可以有null
- Map是不同于Collection的另外一种集合接口，没有继承关系
- key和value都是引用数据类型，都是存储对象的内存地址
- 集合，通过key获取value值，数据结构：双向链表+红黑树
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public class MapTest01 {
public static void main(String[] args) {
// 创建Map集合对象
Map<Integer, String> map = new HashMap<>();
// 向Map集合中添加键值对
map.put(1, "zhangsan"); // 1在这里进行了自动装箱。
map.put(2, "lisi");
map.put(3, "wangwu");
map.put(4, "zhaoliu");
// 通过key获取value
String value = map.get(2);
System.out.println(value);
// 获取键值对的数量
System.out.println("键值对的数量：" + map.size());
// 通过key删除key-value
map.remove(2);
System.out.println("键值对的数量：" + map.size());
// 判断是否包含某个key
// contains方法底层调用的都是equals进行比对的，所以自定义的类型需要重写equals方法。
System.out.println(map.containsKey(new Integer(4))); // true
// 判断是否包含某个value
System.out.println(map.containsValue(new String("wangwu"))); // true
// 获取所有的value
Collection<String> values = map.values();
// foreach
for(String s : values){
System.out.println(s);
}
// 清空map集合
map.clear();
System.out.println("键值对的数量：" + map.size());
// 判断是否为空
System.out.println(map.isEmpty()); // true
}
}- Map集合遍历
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapTest02 {
public static void main(String[] args) {
// 第一种方式：获取所有的key，通过遍历key，来遍历value
Map<Integer, String> map = new HashMap<>();
map.put(1, "zhangsan");
map.put(2, "lisi");
map.put(3, "wangwu");
map.put(4, "zhaoliu");
// 遍历Map集合
// 获取所有的key，所有的key是一个Set集合
Set<Integer> keys = map.keySet();
// 遍历key，通过key获取value
// 迭代器可以
/*Iterator<Integer> it = keys.iterator();
while(it.hasNext()){
// 取出其中一个key
Integer key = it.next();
// 通过key获取value
String value = map.get(key);
System.out.println(key + "=" + value);
}*/
// foreach也可以
for(Integer key : keys){
System.out.println(key + "=" + map.get(key));
}
// 第二种方式：Set<Map.Entry<K,V>> entrySet()
// 以上这个方法是把Map集合直接全部转换成Set集合。
// Set集合中元素的类型是：Map.Entry
Set<Map.Entry<Integer,String>> set = map.entrySet();
// 遍历Set集合，每一次取出一个Node
// 迭代器
/*Iterator<Map.Entry<Integer,String>> it2 = set.iterator();
while(it2.hasNext()){
Map.Entry<Integer,String> node = it2.next();
Integer key = node.getKey();
String value = node.getValue();
System.out.println(key + "=" + value);
}*/
// foreach(效率比较高)
// 这种方式，因为获取key和value都是直接从node对象中获取的属性值。
for(Map.Entry<Integer,String> node : set){
System.out.println(node.getKey() + "--->" + node.getValue());
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
