1.29学习

ArrayList类，基于数组算法的列表，通过查看源代码会发现底层其实就是一个Object数组

​ ArrayList是一个List接口的实现类,实现了可变数组,当添加一个元素时,如果容量足够,直接添加,如果容量不够,按照newCapacity = oldCapacity + oldCapacity/2 原则拓容

​ 由于ArrayList底层数据结构是数组,决定了该实现类在查询的场景下比较适用,添加和删除的场景效率稍低

public class ArrayListDemo1 {
    /**
        ArrayList的常用API    
    **/
public static void main(String[] args) {
//创建一个默认长度的列表对象
List list = new ArrayList();
//打印集合中元素的个数
System.out.println("元素数量："+list.size());//0
//添加操作：向列表中添加4个元素
list.add("Will");
list.add(100);
list.add(true);
list.add("Lucy");
//查询操作:
System.out.println("列表中所有元素："+list);//输出:[Will, 100, true, Lucy]
System.out.println("元素数量："+list.size());//4
System.out.println("第一个元素："+list.get(0));//Will
//修改操作：把索引为2的元素，替换为wolfcode
list.set(2, "wolfcode");
System.out.println("修改后："+list);//输出:[Will, 100, wolfcode, Lucy]
//删除操作：删除索引为1的元素
list.remove(1);
System.out.println("删除后："+list);//输出:[Will, wolfcode, Lucy]
}
}

画出ArrayList的内存图可以发现集合类中存储的对象,都存储的是对象的引用,而不是对象本身

五、LinkedList类
​ LinkedList由于底层数据结构是链表,在添加元素和删除元素时效率很高,查询元素效率低。
​ LinkedList类，底层采用链表算法，实现了链表，队列，栈的数据结构。无论是链表还是队列主要操作的都是头和尾的元素，因此在LinkedList类中除了List接口的方法，还有很多操作头尾的方法。常用的方法如下：

//将指定元素插入此列表的开头。
void addFirst(Object e);
//将指定元素添加到此列表的结尾。
void addLast(Object e); 
//返回此列表的第一个元素。
Object getFirst();
//返回此列表的最后一个元素。
Object getLast();
//移除并返回此列表的第一个元素。
Object removeFirst(); 
//移除并返回此列表的最后一个元素。
Object removeLast();

//在此列表的开头插入指定的元素。
boolean offerFirst(Object e);
//在此列表末尾插入指定的元素。
boolean offerLast(Object e);
获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
Object peekFirst();
获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
Object peekLast();
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
Object pollFirst();
//获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
Object pollLast();

//将元素推入此列表所表示的栈。
void push(Object e);
//从此列表所表示的栈处弹出一个元素。
Object pop();
//获取但不移除此列表的头（第一个元素）。
Object peek() 

import java.util.LinkedList;
public class LinkedListDemo {
  public static void main(String[] args) {
    LinkedList list = new LinkedList();
//添加元素
    list.addFirst("A");
    list.addFirst("B");
    System.out.println(list);
    list.addFirst("C");
    System.out.println(list);
    list.addLast("D");
    System.out.println(list);
//获取元素
    System.out.println("获取第一个元素：" + list.getFirst());//C
    System.out.println("获取最后一个元素：" + list.getLast());//D
//删除元素
    list.removeFirst();
    System.out.println("删除第一个元素后：" + list);//[B, A, D]
    list.removeLast();
    System.out.println("删除最后一个元素后：" + list);//[B, A]
  }
}

六、Stack和Vector类
​ Vector类：基于数组算法实现的列表，其实就是ArrayList类的前身。和ArrayList的区别在于方法使用synchronized修饰，所以相对于ArrayList来说，线程安全，但是效率就低了点。
​ Stack类：表示栈，是Vector类的子类，具有后进先出(LIFO)的特点，拥有push（入栈），pop（出栈）方法。

七、集合的遍历
List<String> list = new ArrayList<>();
    list.add("西施");
    list.add("王昭君");
    list.add("貂蝉");
    list.add("杨玉环");
1

7.1、for循环
for (int index = 0; index < list.size(); index++) {
    String ele = list.get(index);
    System.out.println(ele);
}


7.2、使用迭代器
​ 在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口java.util.Iterator。

​ 想要遍历Collection集合，那么就要获取该集合迭代器完成迭代操作，下面介绍一下获取迭代器的方法：

public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素的。
Iterator表示迭代器对象，迭代器中拥有一个指针，默认指向第一个元素之前，有如下几个方法：

public E next()：判断指针后是否存在下一个元素
public boolean hasNext()：获取指针位置下一个元素，获取后指针向后移动一位，如果仍有元素可以迭代，则返回 true
Iterator iterator = list.iterator();
    while (iterator.hasNext()){
      System.out.println(iterator.next());
    }
 

注意：

在进行集合元素获取时，如果集合中已经没有元素了，还继续使用迭代器的next方法，将会抛出java.util.NoSuchElementException没有集合元素异常。
在进行集合元素获取时，如果添加或移除集合中的元素 , 将无法继续迭代 , 将会抛出ConcurrentModificationException并发修改异常。
7.3、for-each遍历（增强for循环）
语法：

for(数据类型 迭代变量: 实例对象){
    //TODO
}

for (String ele : list) {
    System.out.println(ele);
}

orEach的函数式编程遍历
list.forEach(object -> System.out.println(object));
1
7.5、并发修改异常
​ 在迭代集合时删除集合元素，比如删除王昭君

List<String> list = new ArrayList<>();
    list.add("西施");
    list.add("王昭君");
    list.add("貂蝉");
    list.add("杨玉环");
    for (String ele : list){
      if ("王昭君".equals(ele)){
        list.remove(ele);
      }
      System.out.println(ele);
    }

​ 执行完会发现报错了：

​ 造成该错误的原因是，不允许在迭代过程中改变集合的长度（不能删除和增加）。

​ 如果要在迭代过程中删除元素，就不能使用集合的remove方法，只能使用迭代器的remove方法，此时只能使用迭代器来操作，不能使用foreach。

   List<String> list = new ArrayList<>();
    list.add("西施");
    list.add("王昭君");
    list.add("貂蝉");
    list.add("杨玉环");
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()){
      if ("王昭君".equals(iterator.next())){
        iterator.remove();
      }
    }
    System.out.println(list);

package come.java;

import org.junit.Test;

import java.util.*;

public class CollectionTest {
    @Test
    public void CollectionTest(){
        Collection collection = new ArrayList();
        System.out.println(collection);
        boolean b = collection.add("one");
        System.out.println("b = " + b);
        collection.add(2);
        collection.add('a');
        collection.add(3.14);
        collection.add("凯");
        System.out.println(collection);
        System.out.println("--------------");
        b = collection.contains("two");
        System.out.println("b = " + b);
        b = collection.contains("one");
        System.out.println("b = " + b);
        b = collection.isEmpty();
        System.out.println("b = " + b);
        System.out.println("元素 " + collection);
        b = collection.remove("one");
        System.out.println("b = " + b);
        System.out.println("元素 " + collection);
        System.out.println("--------------");
        Object[] objects = collection.toArray();
        System.out.println(objects);
        for (int i =0;i < objects.length;i++){
            System.out.println(objects[i]);
        }
        List objects1 = Arrays.asList(objects);
        System.out.println(objects1);
        System.out.println("----------");
        Iterator it = objects1.iterator();
        b = it.hasNext();
        System.out.println("b = " + b);
        Object obj = it.next();
        System.out.println("元素" + obj);
        while(it.hasNext() == true){
            obj = it.next();
            System.out.println(obj);
        }
        System.out.println("-------------");
        for (Object o :objects1){
            System.out.println(o);
        }


    }
    @Test
    public void listTest(){
        List list = new ArrayList();
        int size = list.size();
        System.out.println(size);
        System.out.println(list);
        list.add(1,"one");
        list.add(1,2);
        list.add(2,'3');
        list.add(3,3.14);
        System.out.println(list);
        List list1 = new ArrayList();
        list1.add("two");
        list1.add(10);
        list1.add(list1);
        System.out.println(list);
        System.out.println("----");
        Object o = list.get(3);
        System.out.println(o);
        o = list.set(0,1);
        System.out.println("修改" + o);
        System.out.println(list);
}}