JavaSE集合类
概述
Java中集合类概述
Java中集合类是用来存放对象的
集合相当于一个容器，里面包容着一组对象 —— 容器类
其中的每个对象作为集合的一个元素出现
Java API提供的集合类位于java.util包内
Java中数组与集合的比较
数组也是容器，它是定长的，访问较快，但是数组不会自动扩充
数组可以包含基本数据类型或引用类型的对象，而集合中只能包含引用类型的对象
Java中集合框架层次结构
Collection接口
· 一组称为元素的对象
· 一个Collection中可以放不同类型的数据
· 是Set接口和List接口的父类
· 是否有特定的顺序以及是否允许重复，取决于它的实现
Set － 无序的集合；不允许重复（HashSet）
List － 有序的集合；允许重复（ArrayList，LinkedList）
Collection接口常用方法
| 方法 | 含义 |
|---|---|
| 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 的元素 |
Set接口
Set接口
· Collection的子接口
· 用来包含一组 无序无重复 的对象
无序 — 是指元素存入顺序和集合内存储的顺序不同；
无重复 — 两个对象e1和e2，如果e1.equals(e2)返回true，则认为e1和e2重复，在set中只保留一个。
Set接口的实现类
· HashSet — HashSet的特性在于其内部对象的散列存取，即采用哈希技术
· TreeSet — TreeSet存入的顺序跟存储的顺序不同，但是存储是按照排序存储的
使用foreach方式遍历Set集合
样例代码：
package com.training.csdn;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* Keafmd
*
* @ClassName: MySet
* @Description: Set讲解
* @author: 牛哄哄的柯南
* @date: 2020-11-26 19:23
*/
public class MySet {
public static void main(String[] args) {
//类的构造
Set set = new HashSet(); //面向接口编程
//add
set.add(50);
set.add(60); //int Integer
set.add(200);
set.add(new Integer(200));
//size() 获取集合长度
System.out.println("set.size()： "+set.size());
//使用另外一个集合构造set对象
Set set2 = new HashSet();
set2.addAll(set); // 全部添加进去
// 打印元素个数
System.out.println("set2.size()： "+set2.size());
//isEmpty 是否为空
System.out.println("set2.isEmpty()： "+set2.isEmpty());
//判断是否包含某个元素
System.out.println( "set2.contains(60)： "+set2.contains(60));
System.out.println( "set2.contains(200)： "+set2.contains(new Integer(200)));
//迭代器 遍历Set
Iterator it = set2.iterator();
while(it.hasNext()){
Object item = it.next();
System.out.println("元素： "+item);
}
//移除元素， 通过equals 和hashcode 判断是否存在元素
set.remove(50);
System.out.println("移除后的元素个数： "+set.size());
Set set3 = new HashSet();
set3.add("abc");
set3.add("def");
set3.add("ghi");
set3.add("aaa");
Set set4 = new HashSet();
set4.add("abc");
set4.add("def");
set4.add("kkk");
set4.add("aaa");
System.out.println("set3.size： "+set3.size());
// 从set3中移除set3和set4的 交集元素
// set3.removeAll(set4);
// System.out.println("移除后的集合长度： "+set3.size());
//
//
// for (Object o : set3) {
// System.out.println("set3的元素有： "+o);
// }
// 保留 set3 和 set4 的交集元素
set3.retainAll(set4);
System.out.println("retainAll.size： "+set3.size());
for (Object o : set3) {
System.out.println("set3的元素有： "+o);
}
//清空set集合
set3.clear();
System.out.println(set3.size()); //0
}
}
运行效果：
set.size()： 3
set2.size()： 3
set2.isEmpty()： false
set2.contains(60)： true
set2.contains(200)： true
元素： 50
元素： 200
元素： 60
移除后的元素个数： 2
set3.size： 4
retainAll.size： 3
set3的元素有： aaa
set3的元素有： abc
set3的元素有： def
0
Process finished with exit code 0
List接口
List接口常用方法
| 方法 | 含义 |
|---|---|
| void add(int index,Object element) | 在列表中的index位置，添加element元素 |
| Object get(int index) | 返回列表中指定位置的元素 |
| int indexOf(Object o) | 在list中查询元素的索引值，如不存在，返回－1。 |
| int lastIndexOf(Object o) | List中如果存在多个重复元素，indexOf() |
| ListIterator listIterator() | 返回列表中元素的列表迭代器 |
| Object remove(int index) | 移除列表中指定位置的元素 |
| Object set(int index,Object element) | 用指定元素替换列表中指定位置的元素 |
ArrayList与LinkedList的比较:
存储结构：
ArrayList是线性顺序存储。
LinkedList对象间彼此串连起来的一个链表。
操作性能：
ArrayList适合随机查询的场合。
LinkedList元素的插入和删除操作性高。
LinkedList功能要多一些。
ArrayList
讲解代码：
package com.CSDN.day26;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/**
* Keafmd
*
* @ClassName: MyArrayList
* @Description: ArrayList
* @Author: 牛哄哄的柯南
* @Date: 2020/11/26 21:01
**/
public class MyArrayList {
public static void main(String[] args) {
//
List list1 = new ArrayList();
list1.add("张三");
list1.add("李四");
list1.add("李四");
list1.add("王五");
System.out.println("list1.size()\t"+list1.size());
List list2 = new ArrayList(list1);
System.out.println("list2.size()\t"+list2.size());
System.out.println("========================================================");
//通过下标的形式访问每一个元素
// System.out.println("list1.get(0)\t"+list1.get(0));
// System.out.println("list1.get(1)\t"+list1.get(1));
// System.out.println("list1.get(2)\t"+list1.get(2));
for (int i = 0; i < list1.size(); i++) {
System.out.println("list1.get("+i+")\t"+list1.get(i));
}
System.out.println("=======================增强for遍历=================================");
for (Object o : list2) {
System.out.println("item\t"+o);
}
System.out.println("=======================Iterator遍历=================================");
for(Iterator it = list2.iterator(); it.hasNext() ; ){
System.out.println("iterator Item \t"+it.next());
}
System.out.println("=======================forEach遍历=================================");
// list2.forEach(System.out::println);
list2.forEach(x->System.out.println("forEach item\t"+x));
System.out.println("=======================add(index,Object el)=================================");
List list3 =new ArrayList();
list3.add("abc");
list3.add("def");
list3.add("jqk");
//list3 add(index ,el)
list3.add(1,"insert");
list3.forEach(x->System.out.println("list3 item\t"+x));
System.out.println("=======================add(index,Object el)=================================");
//list3 update(index ,el)
list3.set(1,"update");
list3.forEach(x->System.out.println("list3 item\t"+x));
//indexOf/lastIndexOf ,返回索引位置，如果找不到则返回-1
System.out.println("list3.indexOf(\"def\")\t"+list3.indexOf("def"));
//判断def是否重复
if(list3.indexOf("def") != list3.lastIndexOf("def")){
System.out.println("def重复了");
}
//listIterator
ListIterator listIter = list3.listIterator(list3.size()-1);
while (listIter.hasPrevious()){
System.out.println("listIter.previous()\t"+listIter.previous());
}
}
}
运行结果：
list1.size() 4
list2.size() 4
========================================================
list1.get(0) 张三
list1.get(1) 李四
list1.get(2) 李四
list1.get(3) 王五
=======================增强for遍历=================================
item 张三
item 李四
item 李四
item 王五
=======================Iterator遍历=================================
iterator Item 张三
iterator Item 李四
iterator Item 李四
iterator Item 王五
=======================forEach遍历=================================
forEach item 张三
forEach item 李四
forEach item 李四
forEach item 王五
=======================add(index,Object el)=================================
list3 item abc
list3 item insert
list3 item def
list3 item jqk
=======================add(index,Object el)=================================
list3 item abc
list3 item update
list3 item def
list3 item jqk
list3.indexOf("def") 2
listIter.previous() def
listIter.previous() update
listIter.previous() abc
Process finished with exit code 0
LinkedList
讲解代码：
package com.CSDN.day26;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
/**
* Keafmd
*
* @ClassName: MyLinkedList
* @Description: LinkedList
* @Author: 牛哄哄的柯南
* @Date: 2020/11/26 21:06
**/
public class MyLinkedList {
public static void main(String[] args) {
//
List list1 = new LinkedList();
list1.add("张三");
list1.add("李四");
list1.add("李四");
list1.add("王五");
System.out.println("list1.size()\t"+list1.size());
List list2 = new LinkedList(list1);
System.out.println("list2.size()\t"+list2.size());
System.out.println("========================================================");
//通过下标的形式访问每一个元素
// System.out.println("list1.get(0)\t"+list1.get(0));
// System.out.println("list1.get(1)\t"+list1.get(1));
// System.out.println("list1.get(2)\t"+list1.get(2));
for (int i = 0; i < list1.size(); i++) {
System.out.println("list1.get("+i+")\t"+list1.get(i));
}
System.out.println("=======================增强for遍历=================================");
for (Object o : list2) {
System.out.println("item\t"+o);
}
System.out.println("=======================Iterator遍历=================================");
for(Iterator it = list2.iterator(); it.hasNext() ; ){
System.out.println("iterator Item \t"+it.next());
}
System.out.println("=======================forEach遍历=================================");
// list2.forEach(System.out::println);
list2.forEach(x->System.out.println("forEach item\t"+x));
System.out.println("=======================add(index,Object el)=================================");
List list3 =new LinkedList();
list3.add("abc");
list3.add("def");
list3.add("jqk");
//list3 add(index ,el)
list3.add(1,"insert");
list3.forEach(x->System.out.println("list3 item\t"+x));
System.out.println("=======================add(index,Object el)=================================");
//list3 update(index ,el)
list3.set(1,"update");
list3.forEach(x->System.out.println("list3 item\t"+x));
//indexOf/lastIndexOf ,返回索引位置，如果找不到则返回-1
System.out.println("list3.indexOf(\"def\")\t"+list3.indexOf("def"));
//判断def是否重复
if(list3.indexOf("def") != list3.lastIndexOf("def")){
System.out.println("def重复了");
}
System.out.println("================================================");
ListIterator listIter = list3.listIterator();
while (listIter.hasNext()){
System.out.println("listIter.next()\t"+listIter.next());
}
System.out.println("=============================");
//listIterator
// ListIterator listIter2 = list3.listIterator(list3.size());
// while (listIter2.hasPrevious()){
// System.out.println("listIter2.previous()\t"+listIter2.previous());
// }
LinkedList lList = new LinkedList();
lList.addAll(list3);
Object popItem = lList.pop(); //如果没有元素会抛异常
Object pollItem = lList.poll();
System.out.println(pollItem);
}
}
运行结果：
list1.size() 4
list2.size() 4
========================================================
list1.get(0) 张三
list1.get(1) 李四
list1.get(2) 李四
list1.get(3) 王五
=======================增强for遍历=================================
item 张三
item 李四
item 李四
item 王五
=======================Iterator遍历=================================
iterator Item 张三
iterator Item 李四
iterator Item 李四
iterator Item 王五
=======================forEach遍历=================================
forEach item 张三
forEach item 李四
forEach item 李四
forEach item 王五
=======================add(index,Object el)=================================
list3 item abc
list3 item insert
list3 item def
list3 item jqk
=======================add(index,Object el)=================================
list3 item abc
list3 item update
list3 item def
list3 item jqk
list3.indexOf("def") 2
================================================
listIter.next() abc
listIter.next() update
listIter.next() def
listIter.next() jqk
=============================
update
Process finished with exit code 0
Map接口
Map内存储的是键/值对这样以成对的对象组(可以把一组对象当成一个元素)，通过“键”对象来查询“值”对象。
Map是不同于Collection的另外一种集合接口。
Map中，key值是唯一的(不能重复)，而key对象是与value对象关联在一起的。
Map接口有两个实现：
HashMap — key/value对 是按照Hash算法存储的。
TreeMap — key/value对是排序 (按key排序)存储的。
Map接口常用方法
| 方法 | 含义 |
|---|---|
| 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() | 返回此映射中的键-值映射对数 |
| void clear() | 从此映射中移除所有映射关系 |
| boolean isEmpty() | 若此映射未包含键-值映射关系,返回 true |
| Set keySet() | 返回此映射中包含的键的 set 视图 |
HashMap类
HashMap类是Map接口的实现类 基于哈希表的 Map 接口的实现
Student 类：
package com.CSDN.day26;
/**
* Keafmd
*
* @ClassName: Student
* @Description:
* @Author: 牛哄哄的柯南
* @Date: 2020/11/26 21:16
**/
public class Student {
String name;
int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
讲解代码：
package com.CSDN.day26;
import java.util.*;
/**
* Keafmd
*
* @ClassName: MyMap
* @Description: Map
* @Author: 牛哄哄的柯南
* @Date: 2020/11/26 21:15
**/
public class MyMap {
public static void main(String[] args) {
//对象的创建
Map<String,Student> map = new HashMap<>();
List<Student> stuList = new ArrayList();
stuList.add(new Student("张飞",50));
stuList.add(new Student("张飞1",36));
stuList.add(new Student("张飞2",20));
stuList.add(new Student("张飞3",58));
//如果要查找某一个元素的属性，需要遍历集合后查找元素才能获取舒心
for (Student student : stuList) {
if("张飞3".equals(student.getName())){
System.out.println("student.age\t"+student.getAge());
break;
}
}
//put key不可以重复
map.put("张飞",new Student("张飞",50));
map.put("张飞1",new Student("张飞1",36));
map.put("张飞2",new Student("张飞2",20));
map.put("张飞3",new Student("张飞3",58));
//get根据key获取指定的元素,底层使用hash计算索引，快速查找元素
Student stu = (Student) map.get("张飞3");
System.out.println(stu.getAge());
/**
* int size()
* void clear()
* boolean isEmpty()
*/
// map.clear();
System.out.println("map.size\t"+map.size());
System.out.println("map.isEmpty\t"+map.isEmpty());
Map map2 = new HashMap();
map2.put("张飞3",new Student("张飞3",999));
map2.put("张飞4",new Student("张飞4",20));
Student zf5 = new Student("张飞5", 58);
map2.put("张飞5",zf5);
map.putAll(map2);
System.out.println("map.size\t"+map.size());
System.out.println("map.get(\"张飞3\")\t"+map.get("张飞3").getAge());
System.out.println("map.containsKey(\"张飞\")\t"+map.containsKey("张飞"));
System.out.println("map.containsKey(\"张飞99\")\t"+map.containsKey("张飞99"));
System.out.println("map.containsValue(new Student(\"张飞5\",58)\t"+map.containsValue(zf5));
System.out.println("========================size==============================");
System.out.println("map.size\t"+map.size());
map.remove("张飞3");
System.out.println("map.size\t"+map.size());
//HashMap的遍历
Set<String> keySet = map.keySet();
for (String key : keySet) {
System.out.printf("key:%s\tvalue:%s\r\n",key,map.get(key).toString());
}
System.out.println("================================================");
Set<Map.Entry<String, Student>> entrySet = map.entrySet();
for (Map.Entry<String, Student> stringStudentEntry : entrySet) {
String key = stringStudentEntry.getKey();
Student value = stringStudentEntry.getValue();
System.out.printf("key:%s\tvalue:%s\r\n",key,value.toString());
}
}
}
运行结果：
student.age 58
58
map.size 4
map.isEmpty false
map.size 6
map.get("张飞3") 999
map.containsKey("张飞") true
map.containsKey("张飞99") false
map.containsValue(new Student("张飞5",58) true
========================size==============================
map.size 6
map.size 5
key:张飞5 value:Student{name='张飞5', age=58}
key:张飞4 value:Student{name='张飞4', age=20}
key:张飞 value:Student{name='张飞', age=50}
key:张飞2 value:Student{name='张飞2', age=20}
key:张飞1 value:Student{name='张飞1', age=36}
================================================
key:张飞5 value:Student{name='张飞5', age=58}
key:张飞4 value:Student{name='张飞4', age=20}
key:张飞 value:Student{name='张飞', age=50}
key:张飞2 value:Student{name='张飞2', age=20}
key:张飞1 value:Student{name='张飞1', age=36}
Process finished with exit code 0
HashMap与TreeMap的比较
HashMap基于哈希表实现。
TreeMap基于树实现。
HashMap可以通过调优初始容量和负载因子，优化HashMap空间的使用。
TreeMap没有调优选项，因为该树总处于平衡状态
HashMap性能优于TreeMap。
HashMap与Hashtable的比较
Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。
Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许用null。
看完如果对你有帮助，感谢点赞支持！
如果你是电脑端，看到右下角的 “一键三连” 了吗，没错点它[哈哈]
加油！
共同努力！
Keafmd
