集合的优势：

（1）数组存储的不足与缺陷：

1. 长度开始必须执行，而且一旦指定，无法修改
2. 保存的必须为同一类型的元素
3. 使用数组进行增加/删除操作比较麻烦

（2）集合的好处：

1. 可以动态保存多个对象，使用方便
2. 提供了一系列方便的操作对象的方法，如add、remove、set、get等
3. 使用集合增加/删除较方便

集合的框架图 (重要)

集合主要是两组：单列集合、双列集合

Collection接口有两个重要的子接口List、Set，他们的实现子类都是单列集合

Map接口的实现子类是双列集合，存放K-V 

Collection 接口和常用方法

1、Collection接口实现类的特点：

public interface Collection<E> extends Iterable<E>

1)Collection实现子类可以存放多个元素，每个元素可以是Object

2）有些Collection的实现类，可以存放重复的元素，有些不可以

3）有些Collection的实现类，可以是有序的(List)， 有些也是无序的(Set)

4）Collection接口没有直接的实现子类，是通过他的子接口Set和List来实现的

2、Collection接口的常用方法，以实现子类ArrayList来演示：

public class T {
    public static void main(String[] args) {
        List list = new ArrayList();
        //add添加元素
        list.add("jack");
        list.add(10);
        list.add(true);
        System.out.println("list = " + list);
        //remove 删除指定元素
        //list.remove(0); //删除第一个元素
        list.remove(true);
        //contains查找元素是否存在
        System.out.println(list.contains("jack"));
        //size:获取元素个数
        System.out.println(list.size());
        //isEmpty判断是否为空
        System.out.println(list.isEmpty());
        //clear 清空
        list.clear();
        System.out.println("list = " + list);

        //addAll添加多个元素
        ArrayList list2 = new ArrayList();
        list2.add("hlm");
        list2.add("sgyy");
        list.addAll(list2);
        System.out.println("list = " + list);
        //containsAll:判断多个元素是否存在
        System.out.println(list.containsAll(list2));
        //removeAll 删除多个元素
        list.add("lz");
        list.removeAll(list2);
        System.out.println("list = " + list);
    }

}

3、Collection接口遍历元素方式：

（1）使用Iterator(迭代器)：

• Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
• 所有实现了Collection接口的集合类都有一个iterator()方法，用于返回一个实现了Iterator接口的对象，即可以返回一个迭代。
• Iterator结构如图所示
• Iterator仅用于遍历集合，Iterator本身不存放对象。

public class CollectionIterator {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("三国演义", "罗贯中", 10.1));
        col.add(new Book("小李飞刀", "古龙", 5.1));
        col.add(new Book("三红楼梦", "曹雪芹", 34.6));
//        System.out.println("col : " + col);
        // 遍历集合:
        //1、 先得到col对应的迭代器
        Iterator iterator = col.iterator();
        //2、使用while循环遍历
        while(iterator.hasNext()) {
            //返回下一个元素， 类型是Object
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
        //快捷键，快速生成while =》 itit

    }
}

class Book {
    private String name;
    private String author;
    private 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 +
                '}';
    }
}

（2）增强for循环(底层是iterator)

基本语法：

for(元素类型 元素名: 集合名/数组名){
    访问元素;
}

List 接口和常用方法

1、List接口的特点

• List集合类中元素有序(添加顺序和取出顺序一致)，且可重复
• List集合中的每个元素都有其对应的顺序索引，即支持索引
• List容器中的元素都对应一个整数型的序号记载其在容器中的位置，额可以根据序号存取容器中的元素
• JDK API中List接口的实现类非常多，常用的有ArrayList、Set、Vector

2、List接口常用方法

public class ListMethod {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("张三丰");
        list.add("贾宝玉");
//        void add(int index, Object ele):在index位置插入ele元素
        //在index = 1的位置插入一个对象
        list.add(1, "韩顺平");
        System.out.println("list=" + list);
//        boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
        List list2 = new ArrayList();
        list2.add("jack");
        list2.add("tom");
        list.addAll(1, list2);
        System.out.println("list=" + list);
//        Object get(int index):获取指定index位置的元素
        //说过
//        int indexOf(Object obj):返回obj在集合中首次出现的位置
        System.out.println(list.indexOf("tom"));//2
//        int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
        list.add("韩顺平");
        System.out.println("list=" + list);
        System.out.println(list.lastIndexOf("韩顺平"));
//        Object remove(int index):移除指定index位置的元素，并返回此元素
        list.remove(0);
        System.out.println("list=" + list);
//        Object set(int index, Object ele):设置指定index位置的元素为ele , 相当于是替换.
        list.set(1, "玛丽");
        System.out.println("list=" + list);
//        List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
        // 注意返回的子集合 fromIndex <= subList < toIndex
        List returnlist = list.subList(0, 2);
        System.out.println("returnlist=" + returnlist);

    }
}

3、List三种遍历方式(ArrayList、LinkedList，Vector)：

ArrayList底层结构和源码分析

1、注意事项：

• 允许存储所有元素，包括null，ArrayList可以加入一个或者多个null
• ArrayList是由数组来实现数据存储的
• ArrayList基本等同于Vector，除了ArrayList是线程不安全的(源码中没有synchronized关键字，执行效率高)，在多线程的情况下不建议使用ArrayList

2、ArrayList底层操作机制源码分析

• ArrayList中维护了一个Object类型的数组elementData：

transient Object[] elementData;//transient关键字表示，该属性不会被序列化

•  当创建ArrayList对象的时候，如果使用的是无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData为10，如需再次扩容， 则扩容elementData1.5倍
• 如果使用的是指定大小的构造器，则初始化elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍

 （1）无参与有参构造器创建和使用ArrayList源码分析：

Vector底层结构和源码分析

1、注意事项：

 2、Vector和ArrayList比较：

3、Vector底层扩容：

public class Vector_ {
    public static void main(String[] args) {
        //无参构造器
        //有参数的构造
        Vector vector = new Vector(8);
        for (int i = 0; i < 10; i++) {
            vector.add(i);
        }
        vector.add(100);
        System.out.println("vector=" + vector);
        //老韩解读源码
        //1. new Vector() 底层
        /*
            public Vector() {
                this(10);
            }
         补充：如果是  Vector vector = new Vector(8);
            走的方法:
            public Vector(int initialCapacity) {
                this(initialCapacity, 0);
            }
         2. vector.add(i)
         2.1  //下面这个方法就添加数据到vector集合
            public synchronized boolean add(E e) {
                modCount++;
                ensureCapacityHelper(elementCount + 1);
                elementData[elementCount++] = e;
                return true;
            }
          2.2  //确定是否需要扩容 条件 ： minCapacity - elementData.length>0
            private void ensureCapacityHelper(int minCapacity) {
                // overflow-conscious code
                if (minCapacity - elementData.length > 0)
                    grow(minCapacity);
            }
          2.3 //如果 需要的数组大小 不够用，就扩容 , 扩容的算法
              //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);
            }
         */

    }
}

LinkedList：

LinkedList说明：

1. LinkedList底层实现了双向链表和双端队列的特点
2. 可以添加任意元素(可以重复)， 包括null
3. 线程不安全，没有实现同步

LinkedList底层机制

1. LinkedList底层维护了一个双向链表
2. LinkedList中维护了两个属性first和last分别指向首节点和尾节点
3. 每个节点(Node对象)，里面又维护了prev、next、item三个属性，其中prev指向前一个，通过next指向后一个节点，最终实现双向链表
4. 所以LinkedList的元素添加和删除，不是通过数组实现的，相对来说效率较高

LinkedList基本操作：

public class LinkedListCRUD {
    public static void main(String[] args) {

        LinkedList linkedList = new LinkedList();
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        System.out.println("linkedList=" + linkedList);

        //演示一个删除结点的
        linkedList.remove(); // 这里默认删除的是第一个结点
        //linkedList.remove(2); //指定删除第几个元素

        System.out.println("linkedList=" + linkedList);

        //修改某个结点对象，按照索引
        linkedList.set(1, 999);
        System.out.println("linkedList=" + linkedList);

        //得到某个结点对象
        //get(1) 是得到双向链表的第二个对象
        Object o = linkedList.get(1);
        System.out.println(o);//999

        //因为LinkedList 是 实现了List接口, 遍历方式
        System.out.println("===LinkeList遍历迭代器====");
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println("next=" + next);

        }

        System.out.println("===LinkeList遍历增强for====");
        for (Object o1 : linkedList) {
            System.out.println("o1=" + o1);
        }
        System.out.println("===LinkeList遍历普通for====");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }


        //老韩源码阅读.
        /* 1. LinkedList linkedList = new LinkedList();
              public LinkedList() {}
           2. 这时 linkeList 的属性 first = null  last = null
           3. 执行 先进行装箱 再调用添加，
               public boolean add(E e) {
                    linkLast(e);
                    return true;
                }
            4.将新的结点，加入到双向链表的最后
            Node(Node<E> prev, E element, Node<E> next) {
                this.item = element;
                this.next = next;
                this.prev = prev;
            }

             void linkLast(E e) {
                final Node<E> l = last;
                final Node<E> newNode = new Node<>(l, e, null);
                last = newNode;
                if (l == null)
                    first = newNode;
                else
                    l.next = newNode;
                size++;
                modCount++;
            }

         */

        /*
          老韩读源码 linkedList.remove(); // 这里默认删除的是第一个结点
          1. 执行 removeFirst
            public E remove() {
                return removeFirst();
            }
         2. 执行
            public E removeFirst() {
                final Node<E> f = first;
                if (f == null)
                    throw new NoSuchElementException();
                return unlinkFirst(f);
            }
          3. 执行 unlinkFirst, 将 f 指向的双向链表的第一个结点拿掉
            private E unlinkFirst(Node<E> f) {
                // assert f == first && f != null;
                final E element = f.item;
                final Node<E> 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;
            }
         */
    }
}

 ArrayList(线程不安全)和LinkedList(线程不安全)的比较：

如何选择ArrayList和LinkedList：

1）如果改查操作多，选择ArrayList

2）如果增删操作多，选择LinkedList

3）一般来说，在程序中，80%-90%都是查询，因此大部分情况下都会选择ArrayList

4）在一个项目中，根据业务灵活选择。

写在之前

在开发中难免会有entity,vo,dto之间的转换那么如何优雅快速的进行转换呢？当然你可以get在set显然不推荐这样做！

对象转换

使用BeanUtils工具类copyProperties方法

像这样

//将merchantDTO赋值给entity(相同的属性)
BeanUtils.copyProperties(merchantDTO,entity);

使用mapstruct转换

首先在项目中引入依赖

<!--       MapStruct代码生成器，对象转换 -->
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct-jdk8</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct-processor</artifactId>
            <version>${org.mapstruct.version}</version>
        </dependency>

新建接口

@Mapper//这里的mapper是包org.mapstruct.Mapper
public interface AppCovert {
    AppCovert INSTANCE = Mappers.getMapper(AppCovert.class);
    /**
     * entity转dto
     */
    AppDTO entityTodto(App entity);

    /**
     * dto转entity
     * @param dto
     * @return
     */
    App dtoToEntity(AppDTO dto);
}

注：使用泛型支持所有类型的List转换
使用

//将entity转换为dto
MerchantDTO merchantDTO = MerchantDetailConvert.INSTANCE.entityTodto(merchantInfo);

List转换

使用BeanUtils工具类

集合转换是不是也想使用copyProperties方法？对你想的没错，想对了一半
只不过要对copyProperties方法进行封装
像这样

 /**
     * @param sources: 数据源类
     * @param target: 目标类
     * @return 赋值后的list
     */
    public static <S, T> List<T> copyListProperties(List<S> sources, Supplier<T> target, BeanCopyUtilCallBack<S, T> callBack) {
        List<T> list = new ArrayList<>(sources.size());
        for (S source : sources) {
            T t = target.get();
            BeanUtils.copyProperties(source, t);
            list.add(t);
        }
        return list;
    }

使用

 List<Merchant> entity = new ArrayList<>();
        Merchant merchant = new Merchant();
        entity.add(merchant);
        List<MerchantDTO> ts = BeanCopyUtil.copyListProperties(entity, MerchantDTO::new);

使用mapstruct转换

定义接口

@Mapper
public interface AppCovert {
AppCovert INSTANCE = Mappers.getMapper(AppCovert.class);
    /**
     * entityList转dtoList
     * @param app
     * @return
     */
    List<AppDTO> listEntityToDto(List<App> app);

}

使用

List<App> apps = new ArrayList<>();
List<AppDTO> appDtos = AppCovert.INSTANCE.listEntityToDto(apps);

对比BeanUtils工具类，mapstruct对象转换显得比较繁琐！