宝剑锋从磨砺出,梅花香自苦寒来。这篇文章主要讲述Java Collection接口之: List接口&Set接口相关的知识,希望能为你提供帮助。
【Java Collection接口之( List接口&Set接口)】
1、 List 接口
1.1 List接口的方法
List除了从Collection集合继承的方法外,List 集合里添加了一些根据索引来操作集合元素的方法
1.2 List接口的迭代器ListIterator
除了foreach和Iterator迭代器之外,List 额外提供了一个 listIterator() 方法,该方法返回一个 ListIterator 对象, ListIterator 接口继承了 Iterator 接口,提供了专门操作 List 的方法:
1.3 List的实现类之一:ArrayList
1、ArrayList概述
2、ArrayList 源码分析//底层创建了长度是10的Object[]数组elementData
ArrayList list = new ArrayList();
//elementData[0] = new Integer(123);
list.add(123);
//如果此次的添加导致底层elementData数组容量不够,则扩容。
list.add(11);
JDK7情况下默认情况下,扩容为原来的容量的1.5倍,同时需要将原有数组中的数据复制到新的数组中。
小结:建议开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity)
public class ArrayList<
E>
extends AbstractList<
E>
implements List<
E>
, RandomAccess, Cloneable, java.io.Serializable
private transient Object[] elementData;
/**
* Constructs an empty list with an initial capacity of ten.
*/
public ArrayList()
this(10);
public ArrayList(int initialCapacity)
super();
if (initialCapacity <
0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
// 创建集合的时候,就创建了长度为10的集合
this.elementData = https://www.songbingjia.com/android/new Object[initialCapacity];
public boolean add(E e)
ensureCapacityInternal(size + 1);
// Increments modCount!!
elementData[size++] = e;
return true;
private void ensureCapacityInternal(int minCapacity)
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length >
0)
grow(minCapacity);
private void grow(int minCapacity)
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >
>
1);
if (newCapacity - minCapacity <
0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE >
0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = https://www.songbingjia.com/android/Arrays.copyOf(elementData, newCapacity);
创建集合的时候,就创建了长度为10的集合
Constructs an empty list with an initial capacity of ten
JDK8中ArrayList的变化
//底层Object[] elementData初始化为.并没有创建长度为10的数组
ArrayList list = new ArrayList();
//第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]
list.add(123);
底层Object[] elementData初始化为.并没有创建长度为10的数组
第一次调用add()时,底层才创建了长度10的数组,并将数据123添加到elementData[0]
后续的添加和扩容操作与jdk 7 无异。
小结:jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象的创建类似于单例的懒汉式,延迟了数组的创建,节省内存。
public class ArrayList<
E>
extends AbstractList<
E>
implements List<
E>
, RandomAccess, Cloneable, java.io.Serializable
/**
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = https://www.songbingjia.com/android/;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = https://www.songbingjia.com/android/;
transient Object[] elementData;
// non-private to simplify nested class access
public ArrayList(int initialCapacity)
if (initialCapacity >
0)
this.elementData = https://www.songbingjia.com/android/new Object[initialCapacity];
else if (initialCapacity == 0)
this.elementData = https://www.songbingjia.com/android/EMPTY_ELEMENTDATA;
else
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
public ArrayList()
// 初始化一个空集合
this.elementData = https://www.songbingjia.com/android/DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
public boolean add(E e)
ensureCapacityInternal(size + 1);
// Increments modCount!!
elementData[size++] = e;
return true;
private void ensureCapacityInternal(int minCapacity)
// 添加第一个元素时,进入if判断
// minCapacity=1, DEFAULT_CAPACITY=10,取最大值10
if (elementData =https://www.songbingjia.com/android/= DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
// 不是第一次添加元素
ensureExplicitCapacity(minCapacity);
private void ensureExplicitCapacity(int minCapacity)
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length >
0)
grow(minCapacity);
private void grow(int minCapacity)
// overflow-conscious code
int oldCapacity = elementData.length;
// 新容量是原来的,1.5倍
// 第一次,oldCapacity =0
int newCapacity = oldCapacity + (oldCapacity >
>
1);
if (newCapacity - minCapacity <
0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE >
0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = https://www.songbingjia.com/android/Arrays.copyOf(elementData, newCapacity);
1.4 List的实现类之二:Vector
1.5 List的实现类之三:LinkedList
LinkedList:双向链表,除了保存数据,还定义了两个变量:
对于频繁的插入或删除元素的操作,建议使用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;
问ArrayList/LinkedList/Vector的异同?谈谈你的理解?ArrayList底层是什么?扩容机制?Vector和ArrayList的最大区别?ArrayList:作为List接口的主要实现类;线程不安全的,效率高;底层使用Object[] elementData存储
LinkedList:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表存储
Vector:作为List接口的古老实现类;线程安全的,效率低;底层使用Object[] elementData存储
ArrayList和LinkedList
ArrayList和Vector
2、Set 接口
2.1 Set实现类之一:HashSet
以自定义的Customer类为例,何时需要重写equals()?
我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值,
此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为:索引位置),判断
数组此位置上是否已经有元素:
jdk 7 :元素a放到数组中,指向原来的元素。
equals()方法进行比较
:
jdk 8 :原来的元素在数组中,指向元素a
HashSet底层:数组+链表的结构。
2.3 Set实现类之二:LinkedHashSet
2.4 Set实现类之三:TreeSet
Comparable 的典型实现:
public class User implements Comparable
private String name;
private int age;
public User()
public User(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 "User" +
"name=" + name + \\ +
", age=" + age +
;
@Override
public boolean equals(Object o)
System.out.println("User equals()....");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
if (age != user.age) return false;
return name != null ? name.equals(user.name) : user.name == null;
@Override
public int hashCode()//return name.hashCode() + age;
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
//按照姓名从大到小排列,年龄从小到大排列
@Override
public int compareTo(Object o)
if(o instanceof User)
User user = (User)o;
int compare = -this.name.compareTo(user.name);
if(compare != 0)
return compare;
else
return Integer.compare(this.age,user.age);
else
throw new RuntimeException("输入的类型不匹配");
public void test2()
Comparator com = new Comparator()
//按照年龄从小到大排列
@Override
public int compare(Object o1, Object o2)
if(o1 instanceof User &
&
o2 instanceof User)
User u1 = (User)o1;
User u2 = (User)o2;
return Integer.compare(u1.getAge(),u2.getAge());
else
throw new RuntimeException("输入的数据类型不匹配");
;
TreeSet set = new TreeSet(com);
set.add(new User("Tom",12));
set.add(new User("Jerry",32));
Iterator iterator = set.iterator();
while(iterator.hasNext())
System.out.println(iterator.next());
2.5 为什么用复写hashCode方法,有31这个数字?
推荐阅读
- Linux用户权限小练习
- 运维小白成长记——第二周
- oeasy教您玩转vim - 85 - # 全局命令
- 分布式专题——分布式限流解决方案
- 使用阿里巴巴开源镜像站镜像——Kubernetes 镜像
- #yyds干货盘点#Prometheus 之监控基础知识
- 反向代理负载均衡!优秀的Nginx
- Zabbix部署安装三
- Linux更换国内源--解决终端下载速度慢的问题