集合
一、集合框架
集合、数组都是对多个数据进行存储操作的结构,简称Java容器
说明:这里的存储,主要指的是内存层面的存储,不涉及到持久化的存储(.txt,.jpg.数据库等)
集合框架
Collection接口
Collection接口:单列集合,用来存储一个一个的对象
----List接口:存储有序的、可重复的数据。 —>“动态”数组
----ArrayList、LinkedList、Vector
----Set接口:存储无序的、不可重复的数据
----HashSet、LinkedHashSet、TreeSet
Map接口:双列集合,用来存储一对(key - value)一对的数据 —>y=f(x)
----HashMap、LinkedMap、TreeMap、Hashtable、Properties
集合的初始化和基本使用 非泛型
public class List {
@Test
public void test(){
//初始化
Collection coll=new ArrayList();
//add(Object e):将元素e添加到集合coll中
coll.add("zmj");
coll.add(123);
coll.add(new Date());
//size():获取添加的元素的个数
System.out.println(coll.size());
System.out.println(coll);
//将集合中的元素添加到里另一个集合中
Collection list = new ArrayList();
list.add("ZMJ");
list.add(321);
//addAll(Collection list):将coll集合中的元素添加到当前list的集合中
list.addAll(coll);
System.out.println(coll);//[zmj, 123, Wed Jun 22 18:28:58 CST 2022]
System.out.println(list);//[ZMJ, 321, zmj, 123, Wed Jun 22 18:28:58 CST 2022]
//clear():清空集合元素
coll.clear();
//isEmpty():判断当前集合是否为空
if(coll.isEmpty()){
System.out.println("该集合为空");
}else {
System.out.println(coll);
}
}
}
集合元素的遍历
集合元素的遍历操作:使用迭代器Iterator
接口
- 1.内部方法:hasNext()和 next()
- 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象
- 3.默认游标都在集合的第一个元素之前
/**
* 集合元素的遍历操作:使用迭代器Iterator接口
* 1.内部方法:hasNext()和 next()
* 2.集合对象每次调用iterator()方法都得到一个全新的迭代器对象
* 3.默认游标都在集合的第一个元素之前
* 4.迭代器内部定义了remove(),可以在遍历的时候,删除集合中的元素,此方法不同于集合中的remove()方法
*/
@Test
public void test(){
Collection coll = new ArrayList();
coll.add("124");
coll.add(123);
coll.add(new Person("zmj",22));
coll.add(new String("zmj2"));
coll.add(false);
//迭代器:iterator本身不是容器,只是一个迭代器对象
java.util.Iterator iterator = coll.iterator();
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
// System.out.println(iterator.next());
//推荐使用方法
//hasNext():判断是否还有下一个元素
while (iterator.hasNext()) {
//next():
//1.指针下移
//2.将下移以后的集合位置上的元素返回
System.out.println(iterator.next());
}
}
- 4.迭代器内部定义了remove(),可以在遍历的时候,删除集合中的元素,此方法不同于集合中的remove()方法
//测试Iterator中的remove()
//未调用next()或者上一次调用next()方法后已经调用了remove方法,在调用remove将报异常IllegalStateException
//相当于指针都还没有指向值,删什么?
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add("124");
coll.add(123);
coll.add(new Person("zmj",22));
coll.add(new String("zmj2"));
coll.add(false);
java.util.Iterator iterator = coll.iterator();
while (iterator.hasNext()){
// iterator.remove();//异常操作
Object next = iterator.next();
if("124".equals(next)){
iterator.remove();
}
}
System.out.println(coll);
//一个迭代器处理一个流程
java.util.Iterator iterator1 = coll.iterator();
//使用新的迭代器iterator1执行遍历
while (iterator1.hasNext()){
System.out.println(iterator.next());
}
}
增强型for循环 foreach
- for(集合元素的类型 局部变量 : 集合对象)
- 底层内部任然调用的迭代器
/**
* Created by KingsLanding on 2022/6/24 16:22
*/
public class ForEach {
@Test
public void test(){
Collection coll = new ArrayList();
coll.add("124");
coll.add(123);
coll.add(new Person("zmj",22));
coll.add(new String("zmj2"));
coll.add(false);
//增强型for循环
//for(集合元素的类型 局部变量 : 集合对象)
//底层内部任然调用的迭代器
for(Object obj:coll){
System.out.println(obj);
}
}
@Test
public void test2(){
int[] ints = {1, 2, 3, 4, 5};
for (int i:ints){
System.out.println(i);
}
}
@Test
public void test3(){
String[] strings = {"AA", "AA"};
// for(int i=0;i<strings.length;i++){
// strings[i]="BB";
// System.out.println(strings[i]);
// }
//该方法将查询结果存放到了str中,所以赋值也是赋值给了str而非strings中
for(String str : strings){
str="BB";
System.out.println(str);//BB
}
for(int i=0;i<strings.length;i++){
System.out.println(strings[i]);//AA
}
}
}
List接口
Collection接口:单列集合,用来存储一个一个的对象
----List接口:存储有序的、可重复的数据。 —>“动态”数组,替换原有的数组
----ArrayList:作为List接口的主要实现类;线程不安全,效率高;底层使用Object[] elementData存储(单链表)
----LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高,底层使用双向链表存储(数据结构)
----Vector:作为List接口的古早实现类:线程安全,效率低;底层使用Object[] elementData存储
-
ArrayList
、LinkedList
、Vector
三者异同-
同:三个类都是实现了List接口,存储数据特点相同:有序可重复
-
异:ArrayList:作为List接口的主要实现类;线程不安全,效率高;底层使用Object[] elementData存储
LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高,底层使用双向链表存储(数据结构)
Vector:作为List接口的古早实现类:线程安全,效率低;底层使用Object[] elementData存储
-
/**
* Created by KingsLanding on 2022/6/24 18:45
*
* 三、集合框架
* Collection接口:单列集合,用来存储一个一个的对象
* ----List接口:存储有序的、可重复的数据。 --->“动态”数组,替换原有的数组
* ----ArrayList:作为List接口的主要实现类;线程不安全,效率高;底层使用Object[] elementData存储(单链表)
* ----LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高,底层使用双向链表存储(数据结构)
* ----Vector:作为List接口的古早实现类:线程安全,效率低;底层使用Object[] elementData存储
*
* 面试题:
* ArrayList、LinkedList、Vector三者异同
* 同:三个类都是实现了List接口,存储数据特点相同:有序可重复
* 异: ----ArrayList:作为List接口的主要实现类;线程不安全,效率高;底层使用Object[] elementData存储
* ----LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高,底层使用双向链表存储(数据结构)
* ----Vector:作为List接口的古早实现类:线程安全,效率低;底层使用Object[] elementData存储
*
*/
ArrayList源码分析
- 1、jdk7:(饿汉式)
ArrayList list=new ArrayList();//初始化创建了长度为10的Object[] elementData存储(单链表),
list.add(123);// elementData[0] = new Integer(123);
…
list.add(Xx);//如果此次的添加导致底层elementData数组容量不够,则要进行扩容,默认情况下,扩容为原来容量的1.5倍,即增加原容量的一半。同时将原数组里的数据复制到新的数组中
开发中建议使用带参构造器:ArrayList list = new ArrayList(int capacity)
-
2、jdk8(懒汉式)
ArrayList list=new ArrayList();//底层Object[] elementData存储(单链表),初始化化为{},即没有创建初始长度list.add(123);//第一次调用add()时,底层才创建长度为10的数组,并将数据添加到elementData中
…
list.add(Xx);//如果此次的添加导致底层elementData数组容量不够,则要进行扩容,默认情况下,扩容为原来容量的1.5倍,即增加原容量的一半。同时将原数组里的数据复制到新的数组中jdk8延迟了数组的创建,节省了内存
ArrayList方法测试
public class aListTest {
/**
* ArrayList方法测试
*
* 常用方法:
* 增删改查
* add(Object obj)、remove(int index)\remove(Object obj)、
* set(int index,Object ele)、get(int index)
* 插:add(int index,Object ele)
* 长度:size()
* 遍历:(1)foreach增强
* (2)Iterator迭代器
* (3)普通循环
*/
@Test
public void test2(){
ArrayList<Object> list = new ArrayList<>();
list.add(123);
list.add("124");
list.add(new Person("zmj",22));
list.add(new String("zmj2"));
list.add(false);
//遍历方式:迭代器
java.util.Iterator iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
//遍历方式:foreach
System.out.println("*************");
for(Object obj:list){
System.out.println(obj);
}
//遍历方式:普通;size()返回此列表中的元素数。get()返回此列表中指定位置的元素
System.out.println("************");
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}
}
@Test
public void test(){
ArrayList<Object> list = new ArrayList<>();
list.add(123);
list.add("124");
list.add(new Person("zmj",22));
list.add(new String("zmj2"));
list.add(false);
System.out.println(list);
List<Integer> integers = Arrays.asList(1, 2, 3);
list.addAll(integers);//将integer中的所有元素复制给list集合
System.out.println(list);
System.out.println(list.size());//返回此列表中的元素数
//返回指定的fromIndex (含)和toIndex之间的列表部分的视图;返回列表中的非结构性更改
System.out.println(list.subList(2, 4));//[Person{name='zmj', age=22}, zmj2]
//替换指定位置的元素
list.set(3, new String("zmj"));
System.out.println(list);
}
/**
* 区分List中remove(int index)和remove(Object obj)
*/
@Test
public void test3(){
ArrayList<Object> list = new ArrayList<>();
list.add(123);
list.add("124");
list.add(new Person("zmj",22));
list.add(new String("zmj2"));
list.add(false);
updateList(list);
System.out.println(list);//[124, Person{name='zmj', age=22}, zmj2, false]
}
private void updateList(List list){
//默认是remove(int index),移除第0位的数据
//list.remove(0);
//指定remove(Object obj),移除数据为obj的
list.remove(new Integer(123));
}
}
LinkedList的源码分析
* //初始化:内部声明了Node类型的first和last属性,默认值为null
* LinkedList linkedList = new LinkedList();
* linkedList.add(123);//将123封装到Node中,创建了Node对象
*
* //其中Node定义位:体现了LinkedList的双向链表
* private static class Node<E> {
* E item;
* Node<E> next;
* Node<E> prev;
*
* Node(Node<E> prev, E element, Node<E> next) {
* this.item = element;
* this.next = next;
* this.prev = prev;
* }
* }
Vector源码分析
jdk7和jdk8中Vector()构造器创建对象时,底层都创键了长度为10的数组扩容默认扩容为原来的 数组长度的2倍
Set接口
Collection接口:单列集合,用来存储一个一个的对象
----Set接口:存储无序的、不可重复的数据
----HashSet:作为Set接口的主要实现类;线程不安全;可以存储null值
----LinkedHashSet:作为HashSet的子类;遍历其内部数据时,可以按照添加的顺序遍历
在添加数据的同时,每个数据还维护了两个引用, 记录此数据前一个数据和后一个数据
优点:对于频繁的遍历操作,LinkedHashSet效率高于HashSet
----TreeSet:可以按照添加对象的指定属性进行排序
Set:存储无序的、不可重复的数据
- 无序性:不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加, 而是根据数据的哈希值决定的
- 不可重复性:尽量保证哈希值不同,如果哈希值相同,那就需要保证添加的元素按照equals()判断时,不能返回true,即相同元素只能添加一个
添加元素的过程:以HashSet为例:
* 二、添加元素的过程:以HashSet为例:
* 我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值,
* 此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即:索引位置),判断
* 此数组此位置上是否已经有元素:
* 如果此位置上没有其他元素,则元素a添加成功。--->
* 如果此位置上有其他元素b(或以链表形式存在的多个元素),则比较元素a与元素b的hash值:
* 如果hash值不同,这元素a添加成功。--->
* 如果hash值相同,进而需要调用元素a所在类的equals()方法:
* equals()方法返回true,元素a添加失败
* equals()方法返回false,元素a添加成功。--->
*
* 对于添加成功的情况2和情况3而言:元素a 与已经存在指定索引位置上数据以链表的方式存在
* jdk7:元素a放到数组中,指向原来的元素
* jdk8:原来的元素在数组中,指向元素a
* (七上八下)
HashSet测试
/**
* HashSet底层:数组+链表的结构
*/
@Test
public void test(){
Set<Object> set = new HashSet<>();
set.add(123);
set.add(123);
set.add(new String("zmj"));
set.add(new Person("zmj2",22));
set.add(new Person("zmj2",22));//在Person类中重写equals()方法,以及 hashCode()方法,才能判断其哈希值
set.add("124");
System.out.println(set);//[Person{name='zmj2', age=22}, 124, zmj, 123]
}
LinkedHashSet的使用测试
/**
LinkedHashSet的使用测试
LinkedHashSet作为HashSet的子类,在添加数据的同时,每个数据还维护了两个引用,
记录此数据前一个数据和后一个数据
优点:对于频繁的遍历操作,LinkedHashSet效率高于HashSet
*/
@Test
public void test2(){
LinkedHashSet<Object> set = new LinkedHashSet<>();
set.add(123);
set.add(123);
set.add(new String("zmj"));
set.add(new Person("zmj2",22));
set.add(new Person("zmj2",22));//在Person类中重写equals()方法,以及 hashCode()方法,才能判断其哈希值
set.add("124");
for(Object obj : set){
System.out.println(obj);
}
}
TreeSet
向TreeSet中添加的数据,要求是相同类型的对象。
/**
1.向TreeSet中添加的数据,要求是相同类的对象。
2.两种排序方式:自然排序(实现Comparable借口)和定制排序(在Person类中重写CompareTo(Object o)方法)
3.自然排序中,比较两个对象是否相同的标准为:compareTo()返回0 不再是equals()
*/
@Test
public void test3(){
TreeSet<Object> set = new TreeSet<>();
//不能添加不同类型的对象
set.add(123);
set.add(124);
//set.add("zmj");
set.add(12);
set.add(-14);
System.out.println(set);
}
@Test
public void test4(){
//定制排序:按照年龄从小到大排序
Comparator com=new Comparator(){
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Person && o2 instanceof Person){
Person p1 = (Person)o1;
Person p2 = (Person)o2;
return Integer.compare(p1.getAge(),p2.getAge());
}else {
throw new RuntimeException("输入数据不匹配");
}
}
};
TreeSet<Object> set = new TreeSet<>(com);
set.add(new Person("zmj",22));
set.add(new Person("lnx",21));
set.add(new Person("sbh",22));
set.add(new Person("sbh",23));
/**
* 自然排序:通过在Person类里重写compareTo(Object o)方法实现
@Override
public int compareTo(Object o) {
if(o instanceof Person){
Person person=(Person)o;
int compare = -this.name.compareTo(person.name);
if(compare != 0){
return compare;
}else {
return Integer.compare(this.age,person.age);
}
}else {
throw new RuntimeException("类型不匹配");
}
}
*/
for(Object obj : set){
System.out.println(obj);
}
}
Person类
package collection;
import java.util.Objects;
/**
* Created by KingsLanding on 2022/6/24 13:48
*/
public class Person implements Comparable{
private String name;
private int age;
public Person() {
}
public Person(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 "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person person = (Person) o;
if (age != person.age) return false;
return name != null ? name.equals(person.name) : person.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
//TreeSet自然排序
@Override
public int compareTo(Object o) {
if(o instanceof Person){
Person person=(Person)o;
int compare = -this.name.compareTo(person.name);
if(compare != 0){
return compare;
}else {
return Integer.compare(this.age,person.age);
}
}else {
throw new RuntimeException("类型不匹配");
}
}
}
map接口
----Map:双列数据,存储key-value对的数据 --类似于:y=f(x)
----HashMap
:作为Map的主要实现类:线程不安全,效率高;可以存储null的key
和value
----LinkedHashMap
:保证在遍历map元素时,可以按照添加的顺序实现遍历
原理:在原有的HashMap底层结构基础上,添加了一对指针,指向前一个和后一个元素
对于频繁的遍历操作,此类执行效率高于HashMap
----TreeMap
:保证添加的key-value对进行排序,实现排序遍历,此时考虑key的自然排序或定制排序
底层使用红黑树
----Hashtable
:古早实现类;线程安全的,效率低,不能存储null的key和value
----properties:常用来处理配置文件(数据库链接配置文件)。key和value都是String类型
HashMap的底层:数组+链表 (jdk7)
数组+链表+红黑树 (jdk8)
Map结构的理解
- **Map中的key:**无序的,不可重复的,***使用Set存储所有的key*** --->key所在的类要重写equals()和HashCode()方法
- **Map中的value:**无序的,可重复的,使用Collection存储所有的value —>value所在的类要重写equals()方法
一个键值对:key-value
构成了一个Entry
对象。- **Map中的entry:**无序的,不可重复的,使用Set存储所有的entry
HashMap的底层实现原理
* HashMap的底层实现原理。(以jdk7为例)
* HashMap map = new HashMap();
* 在实例化后,底层创建了长度为16的一维数组Entry[] table
* ...可能已经执行过多次put...
* map.put(key1,value1);
* 首先,调用key1所在的类的hashCode()方法计算key的哈希值,此哈希值经过某种算法计算以后,得到在Entry数组中
* 的存放位置
* 如果此位置上的数据为空,此时key1-value1添加成功。 --->1
* 如果此位置上的存在数据,(意味着此位置上存在一个或多个数据(以链表形式存在),那么就需要比较key1
* 和已经存在的一个或多个数据的哈希值:
* 如果key1的哈希值与已经存在的数据的哈希值都不同,此时key1-value1添加成功 --->2
* 如果key1的哈希值与已经存在的某一个数据(key2-value2)的哈希值相同,则需要继续比较:
* 调用key1所在类的equals(key2)方法:
* 如果equals()返回false:此时key1-value1添加成功 --->3
* 如果equals()返回true:此时key1-value1中的value1将替换原有与key1相同的key2对应的value2
*
* 关于情况2和情况3:此时key1-value1和原来的数据以链表的方式存储
* 在不断的添加过程中,会涉及到扩容问题,当超出临界值(12)且要存放的位置非空时,扩容;默认的扩容方式:扩容为原来容量的2倍,并将原有的数据复制过来
*
* jdk8 相较于jdk7在底层实现方面的不同之处:
* 1.new HashMap();初始化时底层没有创建一个长度为16的数组(懒汉式)
* 2.jdk8底层的数组是:Node[],而不是Entry[]
* 3.首次调用put()方法时,底层创建长度为16的数组
* 4.jdk7底层结构只有:数组+链表。
* 七上八下:jdk7中新的元素指向旧的元素。jdk8中旧的元素指向新的元素
* jdk8底层结构:数组+链表+红黑树;当数组的某一个索引位置上的元素以链表的形式存在的数据个数 > 8
* 且当前数组长度 > 64时,此时索引位置上的所有数据改为使用红黑树存储(二叉树链表,查询遍历效率更高)
*
* DEFAULT_ INITIAL_ CAPACITY : HashMap的默认容量,16
* DEFAULT_ LOAD FACTOR: HashMap的默认加载因子: 0.75
* threshold:扩容的临界值,=容量*填充因子: 16 * 0.75 => 12
* TREEIFY_THRESHOLD: Bucket 中链表长度大于该默认值,转化为红黑树:8
* MIN_TREEIFY_CAPACITY:桶中的Node 被树化时最小的hash表容量:64
*
LinkedHashMap的底层实现原理(了解)
* 源码:
* static class Entry<K,V> extends HashMap.Node<K,V> {
* Entry<K,V> before, after;//记录添加元素的先后顺序
* Entry(int hash, K key, V value, Node<K,V> next) {
* super(hash, key, value, next);
* }
* }
* 总结:常用方法
* 添加:put(Object key,Object value)
* 删除:remove(Object key)\clear()
* 修改:put(Object key,Object value)
* 查询:get(Object key)
* 长度:size()
* 遍历:keySet()\values()\entrySet()
*/
public class MapTest {
/**
方法测试
添加、删除、修改
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中的所有数据
*/
@Test
public void test(){
Map map = new HashMap();
LinkedHashMap linkMap = new LinkedHashMap();
//添加
map.put("AA",123);
map.put("BB",123);
map.put(123,123);
//修改
map.put("AA",124);
System.out.println(map);
Map map1 =new HashMap();
map1.put("CC",123);
map1.put("DD",123);
//将集合map1中的所有元素复制给map
map.putAll(map1);
System.out.println(map);
//remove(Object key)
Object value = map.remove("DD");
System.out.println(value);
System.out.println(map);
//clear()
map.clear();
System.out.println(map);
}
public void test2(){
/**
方法测试:元素查询操作
Object get(Object key):获取指定key对应的value
boolean containsKey(Object key):是否包含指定的key
boolean containsValue(Object key):是否包含指定的value
int size():返回map中key-value对的个数
boolean isEmpty():判断map是否为null
boolean equals(Object obj):判断当前map和指定的集合对象是否相等
*/
Map map = new HashMap();
map.put("AA",123);
map.put("BB",123);
map.put(123,123);
System.out.println(map);
System.out.println(map.get("AA"));
boolean bool = map.containsKey("BB");
System.out.println(bool);
boolean bool1 = map.containsValue("123");
System.out.println(bool1);
System.out.println(map.size());
System.out.println(map.isEmpty());
Map map1 =new HashMap();
map1.put("CC",123);
map1.put("DD",123);
System.out.println(map.equals(map1));
}
@Test
public void test3(){
/**
元视图的遍历操作
Set keySet();返回所有key构成的Set集合
Collection values();返回所有value构成的collection集合
set entrySet();返回所有key-value对构成的Set集合
*/
Map map = new HashMap();
map.put("AA",123);
map.put(22,125);
map.put("BB",124);
//遍历所有的key
Set set = map.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("**********");
//遍历所有的value
Collection values = map.values();
for(Object obj:values){
System.out.println(obj);
}
//遍历所有的key-value
//方式一、entrySet()
Set entrySet = map.entrySet();
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
//entrySet集合中的元素都是entry
Object obj = iterator1.next();
System.out.println(obj);
//将entry强转为map,分别拿到key和value
Map.Entry entry= (Map.Entry) obj;
System.out.println(entry.getKey() + "===>" + entry.getValue());
}
//遍历所有的key-value
//方式二、分别遍历key和value,然后显示
Set set1 = map.keySet();
Collection values1 = map.values();
Iterator iterator2=set.iterator();
Iterator iterator3=values.iterator();
while (iterator2.hasNext()&&iterator3.hasNext()){
System.out.println(iterator2.next() + "===>" + iterator3.next());
}
}
}