集合与数组区别
数组：长度开始时必须指定，而且一旦指定，不能修改保存的必须为同一类型的元素使用数组进行增加/删除元素比较麻烦集合：可以动态保存任意多个对象，使用比较方便提供了一系列方便操作对象的方法：add、remove、set、get使用集合添加，删除新元素的代码简洁明了
Collection体系框架
单列集合
双列集合
Collection接口和常用方法
特点：
collection实现子类可以存放多个元素，每个元素可以是Object有些Collection的实现类，可以存放重复的元素，有些不可以有些Collection的实现类，有些是有序的(List)，有些不是有序的(Set)有序：指存取顺序一致Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的
操作元素方法
add：添加单个元素remove：删除指定元素contains：查找元素是否存在size：获取元素个数isEmpty：判断是否为空clear：清空addAll：添加多个元素containsAll：查找多个元素是否都存在removeAll：删除多个元素
ArrayList arrayList = new ArrayList();
// 1. add：添加单个元素
arrayList.add('jack');
arrayList.add(10);//arrayList.add(new Integer(10)) 自动装箱
arrayList.add(true);
System.out.println('list:'+arrayList);//list:[jack, 10, true]
// 2. remove：删除指定元素
Object o = arrayList.remove(0);//删除第一个元素
System.out.println('删除的第一个元素为' + o);//删除的第一个元素为jack
arrayList.remove('jack');
arrayList.remove(new Integer(10));//这里就没有默认装箱了，输入10会删除第11个元素
System.out.println('list:'+arrayList);//list:[true]
// 3. contains：查找元素是否存在
System.out.println(arrayList.contains('jack'));//false
// 4. size：获取元素个数
System.out.println(arrayList.size());//1
// 5. isEmpty：判断是否为空
System.out.println(arrayList.isEmpty());//false
// 6. clear：清空
arrayList.clear();
System.out.println(arrayList);//[]
// 7. addAll：添加多个元素
ArrayList使用迭代器遍历
基本介绍
Iterator对象称为迭代器，主要用于遍历Collection集合中的元素。所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器。Iterator的结构Iterator仅用于遍历集合，Iterator本身并不存放对象。
迭代器执行原理
//得到一个集合的迭代器
Iterator iterator = coll.iterator();
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next()作用: 1.下移 2.将下移以后集合位置上的元素返回
System.out.printIn(iterator.next());
}
iterator接口方法
| boolean | hasNext() | 如果迭代具有更多元素，则返回true。 |
| E | next() | 返回迭代中的下一个元素。 |
| default void | remove() | 从底层集合中删除此迭代器返回的最后一个元素（可选操作）。 |
| default void | forEachRemaining(Consumer action) | 对每个剩余元素执行给定的操作，直到所有元素都被处理或动作引发异常。 |
代码示例
public class Demo02_Collection_iterator {
@SuppressWarnings({'all'})//警告抑制
public static void main(String[] args) {
Collection col = new ArrayList();
col.add(new book('三国演义','罗贯中',20.2));
col.add(new book('红楼梦','曹雪芹',150.3));
col.add(new book('小李飞刀','古龙',25.3));
System.out.println(col);
//遍历集合
//1,得到集合对应的迭代器
Iterator iterator = col.iterator();
//2,使用while循环遍历
while (iterator.hasNext()){//判断是否还有数据
//返回下一个元素，类型是Object
Object obj = iterator.next();//编译类型是Object，运行类型取决于对象实际类型
System.out.println('obj=' + obj);
}
//快捷键，快速生成while循环 ==> itit
//Ctrl + J 显示所有快捷键
// while (iterator.hasNext()) {
// Object next = iterator.next();
// }
//3. 当退出while循环后，这是iterator迭代器，指向最后的一个元素
iterator.next();//NoSuchElementException
//4.如果希望再次遍历，
iterator = col.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println('obj=' + next);
}
}
}
class book{
public String name;
public String author;
public double price;
public book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return 'book{' +
'name='' + name + ''' +
', author='' + author + ''' +
', price=' + price +
'}';
}
}
增强for循环遍历
增强for循环，可以替代iterator迭代器，特点：增强for就是简化版的iterator，本质一样。只能用于遍历集合或数组。
基本语法
for(元素类型 元素名 : 集合名或数组名){
访问元素
}
代码示例
Collection col = new ArrayList();
col.add(new book('三国演义','罗贯中',20.2));
col.add(new book('红楼梦','曹雪芹',150.3));
col.add(new book('小李飞刀','古龙',25.3));
//增强for的底层实现依旧是迭代器
//增强for可以理解为简化版的迭代器
//快捷键 ==> I
// for (Object o :) {
//
// }
//使用增强for
for(Object object:col)
{
System.out.println('obj=' + object);
}
List接口方法
List接口基本介绍
List接口是Collection接口的子接口
List集合类中元素有序、且可重复。List集合中的每个元素都有其对应的顺序索引，即支持索引。List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。List接口常用的实现类有很多，常用的有：ArrayList、LinkedList和Vector。
常用方法
| void add ( int index , Object ele) | 在index位置插入ele元素 |
| boolean addAll ( int index , Collection eles) | 从index位置开始将eles中的所有元素添加进来 |
| Object get ( int index ) | 获取指定index位置的元素 |
| int indexOf ( Object obj) | 返回obj在集合中首次出现的位置 |
| int lastIndexOf ( Object obj) | 返回obj在当前集合中末次出现的位置 |
| Object remove ( int index) | 移除指定index位置的元素，并返回此元素 |
| Object set ( int index , Object ele) | 设置指定index位置的元素为ele，相当于是替换 |
| List subList ( int fromIndex , int toIndex) | 返回从fromIndex 到 toIndex 位置的子集合 |
代码示例
//| void add ( int index , Object ele) | 在index位置插入ele元素
//在index=1的位置插入一个对象
list.add(1, 'Jack');
System.out.println(list);//[Tom, Jack, jerry, Tom]
//| boolean addAll ( int index , Collection eles) | 从index位置开始将eles中的所有元素添加进来
List list2 = new ArrayList();
list2.add('张三丰');
list2.add('贾宝玉');
list.addAll(list2);
System.out.println(list);//[Tom, Jack, jerry, Tom, 张三丰, 贾宝玉]
// Object get ( int index ) | 获取指定index位置的元素
System.out.println(list.get(1));//jerry
//| int indexOf ( Object obj) | 返回obj在集合中首次出现的位置 |
System.out.println(list.indexOf('Tom'));//0
System.out.println(list.indexOf('林黛玉'));//-1
//| int lastIndexOf ( Object obj) | 返回obj在当前集合中末次出现的位置 |
System.out.println(list.lastIndexOf('Tom'));//3
//| Object remove ( int index) | 移除指定index位置的元素，并返回此元素 |
list.remove(0);
System.out.println(list);//[Jack, jerry, Tom, 张三丰, 贾宝玉]
//| Object set ( int index , Object ele) | 设置指定index位置的元素为ele，相当于是替换 |
list.set(1,'Marry');
System.out.println(list);
// list.set(5, 'Mike');//IndexOutOfBoundsException ，下标必须存在，不能在最后的后一个使用set加上元素，可以用add
//| List subList ( int fromIndex , int toIndex) | 返回从fromIndex 到 toIndex 位置的子集合 |
//返回的子集合 [fromIndex,toIndex)
System.out.println(list.subList(0,1));//[Jack] 区间左闭右开
List遍历
三种遍历方式，List下所有的实现类都可以用这三种方式遍历元素。
使用iterator使用增强for使用普通for
//List下所有的实现类都可以用这三种方式遍历元素
// List list = new ArrayList();
// List list = new Vector();
List list = new LinkedList();
list.add('Tom');
list.add('jerry');
list.add('Tom');
//遍历
//1 . 迭代器
System.out.println('===迭代器===');
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
//2 . 增强for循环
System.out.println('===增强for===');
// list.forEach(System.out::println);
for (Object o : list) {
System.out.println(o);
}
//3 . 普通for
System.out.println('===普通for===');
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
List实现类–ArrayList
ArrayList注意事项
ArrayList可以加入null，并且多个ArrayList是由数组来实现的ArrayList基本等同于Vector，除了ArrayList是线程不安全，在多线程情况下，不建议使用ArrrayList。源码//ArrayList是线程不安全，源码没有synchronizedpublicbooleanadd(E{ensureCapacityInternal(size+;//IncrementsmodCount!!elementData[size++]=e;returntrue;}
ArrayList的底层操作机制源码分析
ArrayList中维护了一个Object类型的数组elementData。transientObject[]elementData;//transient标识瞬间，短暂的，表示该属性不会被序列化，即仅存于调用者的内存中而不会保存在硬盘上持久化当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData为10，如需再次扩容，则扩容elementData容量为5倍。如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为5倍。
测试程序：
// 关闭警告
@SuppressWarnings({'all'})
public class ArrayListSource {
public static void main(String[] args) {
// 源码分析
// 使用无参构造器创建ArrayList对象
ArrayList list = new ArrayList();
// 使用for循环给list集合添加 1-10 数据
for (int i = 0; i <= 10; i++) {
list.add(i);
}
// 使用for循环给list集合添加 11-15 数据
for (int i = 11; i<=15;i++){
list.add(i);
}
list.add(100);
list.add(200);
list.add(null);
for (Object o : list) {
System.out.println(o);
}
}
}
无参构造器源码分析
有参构造器
⭐️注意Idea默认情况下，Debug显示的数据是简化后的，有些数据看不到。设置：File=>setting=>Build=>Debugger=>DataViews=>Java=>下方设置
List实现类–Vector
基本介绍
定义说明publicclassVector
Vector与ArrayList的比较
| ArrayList | 可变数组 | jdk1.2 | 不安全，效率高 | 如果有参构造1.5倍，如果是无参 1. 第一次10 2. 从第二次开始按1.5倍扩容 |
| Vector | 可变数组 | jdk1.0 | 安全，效率不高 | 如果是无参，默认10，满后，就按2倍扩容。 如果指定大小，则每次直接按2倍扩容 |
源码
public class Demo10_Vector {
public static void main(String[] args) {
//无参构造器
Vector vector = new Vector();
Vector vector1 = new Vector(10);
//1. new Vector()底层
/*
无参构造：
public Vector() {
this(10);
}
有参构造：
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
*/
for (int i = 0; i < 10; i++) {
vector.add(i);
}
//2. vector.add()
/*
2.1 add方法添加数据到vector集合
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
2.2 确定是否需要扩容，判断条件: if (minCapacity - elementData.length > 0)
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
*/
vector.add(100);
//3.需要扩容的vector 两倍扩容
// capacityIncrement：指定扩容大小，默认为0
//扩容算法：int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
/*
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
*/
}
}
List实现类–LinkedList
基本介绍
LinkedList底层实现了双向链表和双端队列特点可以添加任意元素，包括null线程不安全，没有实现同步
LinkedList底层结构
LinkedList底层维护了一个双向链表LinkedList中维护了两个属性first和last分别指向首节点和尾节点每个节点，里面又维护了prev、next、item、三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表。LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。
源码分析
LinkedList linkedList = new LinkedList();
/*源码1：
public LinkedList() {
}
这时的LinkedList属性 first = null , last =null
*/
linkedList.add(1);
/*源码2 执行 添加
2.1:
public boolean add(E e) {
linkLast(e);
return true;
}
2.2: 将新的节点加入到双向链表中，尾插法
void linkLast(E e) {
final Node l = last;
final Node newNode = new Node<>(l, e
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
*/
linkedList.add(2);
linkedList.add(3);
System.out.println('linkedList='+linkedList);
// 删除节点,默认删除首节点
linkedList.remove();
/* 3.源码 ：删除
3.1 默认删除第一个 队列特征，先进先出
public E remove() {
return removeFirst();
}
3.2 当first对象为空时，抛出异常
public E removeFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
3.3 将f指向的双向链表的第一个结点拿掉
private E unlinkFirst(Node f) {
// assert f == first && f != null;
final E element = f.item;
final Node next = f.next;
f.item = null;
f.next = null; // help GC 帮助垃圾回收
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
*/
System.out.println('linkedList='+linkedList);
// 修改某个节点对象
Object set = linkedList.set(0, 666);
System.out.println(set);
System.out.println('linklist='+linkedList);
/* 4. 修改源码
4.1 判断 获取 修改 返回旧值
public E set(int index, E element) {
checkElementIndex(index);
Node x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
4.2 判断index是否合法
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException
}
4.3 获取索引对应的对象
如果索引值小于size的一半，从头开始查找，否则从尾开始查找
Node node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node x = last;
for (int i = size - 1; i > index; i
x = x.prev;
return x;
}
}
*/
// 得到某个节点对象
// get(1)为第二个对象
Object o = linkedList.get(1);
System.out.println(o);
// LinkedList 实现 List 接口 遍历方式与List一致
System.out.println('====linkedList迭代器遍历');
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
System.out.println('====增强for循环遍历');
for (Object o1 : linkedList) {
System.out.println(o1);
}
System.out.println('====传统for循环');
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
| ArrayList | 可变数组 | 较低，数组扩容 | 较高 |
| LinkedList | 双向链表 | 较高，通过链表追加 | 较低 |
如何选择ArrayList和LinkedList:
如果改查的操作较多，选择ArrayList如果增删的操作较多，选择LinkedList一般来说，程序中，80%-90%都是查询，因此大部分情况下选择ArrayList在一个项目中，根据业务灵活选择，也可能这样，一个模块使用的是ArrayList,另外一个模块是LinkedList。根据业务合理选择。
文章为作者独立观点，不代表股票交易接口观点
股民评论