01 集合

1 为什么要出现集合类

为了方便对多个对象进行操作，所以java中出现了集合类。

2 数组和集合类都属于容器，有什么区别？

• 数组虽然可以存储到对象，但是长度不变。而集合的长度可变。
• 数组可以存储基本数据类型，但是集合只能存储引用类型。
• 数组只能存储相同数据类型的数据，集合可以存储不同数据类型。

3 ArrayList的基本使用

3.1 基本使用

public static void main(String[] args) {
    //1. 多态， 创建数组集合
    List list = new ArrayList();
    Object[] objs = new Object[5];
    //2. 添加元素
    objs[0] = "1";
    objs[1] = "1";
    objs[2] = "1";
    objs[3] = "1";
    objs[4] = "1";
    list.add("1");
    list.add("2");
    list.add("3");
    list.add("4");
    list.add("5");
    list.add("6");
    list.add(new Object());
    //3. 删除和获取元素
    System.out.println(objs[0]);
    System.out.println(list.get(0));
    System.out.println(list.get(1));
    System.out.println(list.remove(1));
    System.out.println(list.get(1));

    //4. 循环
    for (int i = 0;i < list.size();i++) {
        System.out.println("for : " + list.get(i));
    }

    System.out.println("---------------------");
    for (Object element : list) {
        System.out.println("foreach ----- " + element);
    }
    System.out.println("---------------------");
    //5. 迭代
    Iterator iterator = list.iterator(); // 迭代器
    while (iterator.hasNext()) { // 判断迭代器在对应的集合中是否有元素还可以被迭代，如过有返回true，如果没有返回false
        Object element = iterator.next(); // 1. 获取到当前需要进行迭代的元素， 2. 将迭代器的游标移动到下一个需要迭代的元素上
        System.out.println("iterator -----------》" + element);
    }
}

3.2 迭代和循环集合的区别

• 迭代通常是指对集合中的元素进行逐个访问的过程。迭代其实就是使用循环语句来实现的。
• 循环是一种流程控制的结构。它的功能性更广。

• 3.3 自定义ArrayList

• package com.won.javase.day1;

  import java.util.ArrayList;
  import java.util.List;

  public class TestDemo4 {
      public static void main(String[] args) {
          MyArrayList list2 = new MyArrayList();
          System.out.println(list2.currentCapacity);
          list2.add(1);
          list2.add(1);
          list2.add(1);
          list2.add(1);
          list2.add(1);
          list2.add(1);
          list2.add(1);
          list2.add(1);
          list2.add(1);
          System.out.println(list2.currentCapacity);
          list2.add(1);
          System.out.println(list2.currentCapacity);
          list2.add(1);
      }
  }

  class MyArrayList {
      /**
       * 初始默认数组的容量大小
       */
      private static final int DEFAULT_CAPACITY = 10;
      /**
       * 底层数组的当前容量大小
       */
      public int currentCapacity;
      /**
       * 集合中的元素的个数
       */
      private int size;

      /**
       *  你的底层存储数据元素的数组
       */
      private Object[] elementData;

      /**
       * 默认的创建集合大小的容量指定了
       */
      public MyArrayList() {
          this.elementData = new Object[DEFAULT_CAPACITY];
          this.currentCapacity = DEFAULT_CAPACITY;
      }

      public MyArrayList(int initialCapacity) {
          if (initialCapacity <= DEFAULT_CAPACITY) {
              this.elementData = new Object[DEFAULT_CAPACITY];
              this.currentCapacity = DEFAULT_CAPACITY;
          }else {
              this.elementData = new Object[initialCapacity];
              this.currentCapacity = initialCapacity;
          }
      }

      /**
       * 添加元素
       */
      public void add(Object e) {
          //扩容
          int newSize = size + 1;
          expandCapacity(newSize);
          if (e != null) {
              // 数组要添加一个元素
              this.elementData[size] = e;
              // 集合的元素个数+1
              this.size++;
          }
      }

      /**
       * 扩容
       */
      private void expandCapacity(int size) {
          if (size == currentCapacity) {
              int newCapacity = (int)(currentCapacity * 1.5);
              Object[] newElementData = new Object[newCapacity];
              System.arraycopy(elementData, 0, newElementData, 0, elementData.length);
              this.elementData = newElementData;
              this.currentCapacity = newCapacity;
          }
      }

      /**
       * 返回集合中的元数的个数
       */
      public int size() {
          return this.size;
      }

      public void remove(int index){
          
      }
  }

• 4 lambda表达式

  Lambda就是闭包。

  Lambda表达式中可以实现将一个方法作为另一个方法的参数进行传递

• public class TestDemo5_Lambda {
      public static void main(String[] args) {
          //1. 正常用法
          A a = new AA();
          int num1 = a.a();
          System.out.println(num1);

          //2. 创建的实际上A接口的实现类的对象(匿名内部类)
          A aa2 = new A() {
              @Override
              public int a() {
                  return 2;
              }
          };
          System.out.println(aa2.a());

          //3. lambda， 接口中只能有一个方法
          A aa3 = () -> {
              return 3;
          };
          System.out.println(aa3.a());
      }
  }

  interface A {
      int a();
  }

  class AA implements A {
      @Override
      public int a() {
          return 1;
      }
  }

• 

• 5 LinkedList

  从使用上来说，我们这些使用者使用它和使用ArrayList几乎没有区别。

  他们的最大区别在于他们在底层的实现的数据结构不同，由于数据结构不同，他们的特性就不一样，特性不同就决定了他们的使用场景不同

  ArrayList ： 底层使用数组

  LinkedList ： 底层使用了链表

• 

• 6 Set

  List ： 有序且其中的元素是可以出现重复的

  Set ： 无序（存放到set集合的元素的先后顺序）且不重复

  6.1 HashSet

  底层就是有一个HashMap构成的

  无序且不重复

• 

6.2 TreeSet

有序，以下就是一种树的数据结构，从结构可以看出，它就是有序。

提供了两种排序方式：

• 自然排序：存放到Treeset的元素会按照大小进行排序，默认使用升序排序
• 定制排序
• 

• 7.1 HashMap

  读写性能是介于ArrayList和LinkedList之间的

  读性能比ArrayList差，写性能更好。写性能没有LinkedList强，但是读性能又比LinkedList更好

• 

• 7.2 关于map遍历

•