集合框架：Collection--List--ArrayList类、LinkedList类、Vector类、Stack类

1.ArrayList里面放的是一个空的Object类型数组，但你构建一个ArrayList对象时，其Object类型数组长度为0，执行add操作，首先会给数组扩容，如果数组长度为0，直接扩容为10个（即第一次），以后直接放入，直到达到第一次扩容的10个，继续进行扩容。
2.调用add（int index，E element）方法时，先判断索引是否越界，然后判断是否需要扩容，再执行移动数组元素操作，最后将待插入元素插入到index位置上，size+1。
3.调用get（int index）方法，先判断索引是否越界，然后得到当前索引的值。
4.调用remove（int index）方法时，先判断索引是否越界，然后得到要移除的值，再得到要移动元素的个数，再向前移动索引到结束的元素，最后将最后一个元素赋null
5.调用remove（Object index）方法时，先判断此值是否为null，若是遍历数组找到并移动元素删除，若不是，遍历数组找到元素并移动其余元素删除它。
6.调用set（int index,E element）方法时，先检查索引是否越界，然后取出索引处的值，然后将索引处的值替换为element，然后返回索引出的值
7.调用boolean contains（object o）方法时，调用indexOf方法，循环遍历比较元素到size，通过o.equals（数组元素）来判断是否有此值。
8.调用int indexOf(object o)方法时，从前到后遍历数组，通过o.equals（数组元素）来判断是否有此值，返回下标。
9.调用int lastIndexOf(object o)方法时，从后到前遍历数组，通过o.equals（数组元素）来判断是否有此值，返回下标。

package xzy0718;
//讲解泛型
public class DemoD<E>{
    private E e;
    public E a(E e){
        return e;
    }


    public static void main(String[] args) {
        DemoD<Integer> dd = new DemoD();//前面写了类型后面可以不用写
        Object e = dd.a(5);//没有赋值，默认为Object类型
        System.out.println(e);
    }
}


package xzy0718;

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

//集合框架:java.util包
//Collection---》List（接口）----》ArrayList（类）
//ArrayList：就是动态数组，其实就是将数组进行了包装
public class DemoC {
    public static void a(){
        //如何产生一个ArrayList类的对象
        List list1 = new ArrayList();//产生了一个空集合
        List list2 = new ArrayList(5);//定义了一个初始容量为5的集合，但集合长度仍然为0（没放东西）
        List list3 = new ArrayList(list1);//以list1为模板产生了一个新集合（集合赋值，所有内容与list1相同）

    }

    //如何产生一个存放特定类型的集合  泛型
    public static void b(){
        List<String> list1 = new ArrayList<String>();
        List<Integer> list2 = new ArrayList<Integer>();
        List<DemoA> list3 = new ArrayList<DemoA>();
    }

    //常用方法
    public static void c(){
        List<Integer> list = new ArrayList<>();
        //如何向ArrayList集合中存放元素
        list.add(55);//添加
        list.add(34);
        list.add(37);
        list.add(34);
        list.add(2,27);//插入  集合的第三个位置(也就是下标为2的位置)插入27
        System.out.println(list.toString());
        //如何获取集合的元素
        int v1 = list.get(3);//得到下标为3的元素
        System.out.println(v1);
        //如歌删除集合的元素
        list.remove(1);//删除第2个（下标为1）的元素     删除1个
        list.remove(new Integer(37));//删除哪一个(值)元素   删除1个
        //将一个元素赋给索引处
        list.set(2,4);//将4赋给list下标为2的地方  //返回4
        //获取到集合的长度
        int size = list.size();
    }

    //探讨ArrayList集合的存放方式---按引用传值,即里面存的是地址
    public static void d(){
        List<String> list = new ArrayList<>();
        String a = "张三";
        String b ="李四";
        list.add(a);
        list.add(b);
        System.out.println(list.toString());
        a="wangwu";
        System.out.println(list.toString());//String类型的对象是常量，所以没变
    }

    public static void e(){
        List<StuInfo> list = new ArrayList<>();
        StuInfo si1 = new StuInfo(1,"张三");
        StuInfo si2 = new StuInfo(2,"张三");
        StuInfo si3 = new StuInfo(3,"张三");
        System.out.println(si1.hashCode());
        System.out.println(si2.hashCode());
        System.out.println(si3.hashCode());
        list.add(si1);
        list.add(si2);
        list.add(si3);
        System.out.println(list);
        si2.setName("李四");
        System.out.println(list);//改变了，因为ArrayList集合存放的是地址值
    }

    public static void main(String[] args) {
        e();
    }
}


public class DemoE {
    public static void a(){
        List<Integer> list = new ArrayList<>();
        list.add(34);
        list.add(53);
        list.add(21);
        list.add(53);
        //判断55在集合中是否存在
        boolean b1 = list.contains(55);//false
        boolean b2 = list.contains(53);//true
        System.out.println(b1);
        System.out.println(b2);
        //找出55和53在集合中第一次出现的位置，如果不存在返回-1
        int index1 = list.indexOf(55);//-1
        int index2 = list.indexOf(53);//1
        System.out.println(index1);
        System.out.println(index2);
        //找出55和53在集合中的最后一个出现的位置，如果不存在返回-1
        int index3 = list.lastIndexOf(55);//-1
        int index4 = list.lastIndexOf(53);//3
        System.out.println(index3);
        System.out.println(index4);
    }

    public static void b(){
        List<StuInfo> list = new ArrayList<>();
        StuInfo si1 = new StuInfo(1,"张三");
        StuInfo si2 = new StuInfo(2,"李四");
        StuInfo si3 = new StuInfo(3,"王五");
        StuInfo si4 = si3;
        StuInfo si5 = new StuInfo(3,"王五");
        list.add(si1);
        list.add(si2);
        list.add(si3);
        int index1 = list.indexOf(si4);
        int index2 = list.indexOf(si5);
        System.out.println(si3.equals(si4));//true
        System.out.println(si3.equals(si5));//false 地址不相等
    }

    public static void c(){
        List<Integer> list = new ArrayList<>();
        list.add(34);
        list.add(56);
        list.add(53);
        list.add(21);
        list.add(17);
        System.out.println(list);
        Collections.sort(list);//升序排列
        System.out.println(list);
    }

    public static void  d(){
        List<StuInfo> list = new ArrayList<>();
        StuInfo si1 = new StuInfo(1,"张三");
        StuInfo si2 = new StuInfo(2,"李四");
        StuInfo si3 = new StuInfo(3,"王五");
        StuInfo si4 = new StuInfo(5,"aa");
        StuInfo si5 = new StuInfo(4,"aa");
        list.add(si1);
        list.add(si2);
        list.add(si3);
        list.add(si4);
        list.add(si5);
        System.out.println(list);
        Collections.sort(list);//报错  必须是子类  解决：实现接口
        System.out.println(list);
    }

    public static void main(String[] args) {
        d();
    }


}

/*
ArrayList：
1.线性队列式结构，里面封装的是一个Object类型的数组
2.在执行插入方法时，会自动判断容量是否够，不够进行扩容
3.再执行删除方法时，会通过位移来覆盖原来的值
4.是一个有序（每一个元素都知道它自身的位置），可重复（存放的值）的集合
5.未指定泛型时，默认类型是Object
6.集合存放的是引用，不是值
 */

package xzy0718;

public class StuInfo {
    private Integer id;
    private String name;

    public StuInfo(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "StuInfo{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
//equals方法是object 重写的
public boolean equals(Object obj) {//重写equals方法，实现值比较
    StuInfo a = (StuInfo) obj;
    String b = a.getName();
    String c = this.getName();
    return b==c;
}

//comparTo方法是实现Comparable<>接口重写的
public int compareTo(StuInfo o){
    int thisId = this.getId();
    int otherId = o.getId();
    return otherId-thisId;
}

}

LinkedList

*
区别：
ArrayList：查询快
LinkedList：插入、删除快

LinkedList：双向链表结构
1.集合中只记录第一个和最后一个
2.每一个元素只记录上一个和下一个
3.元素并不知道自身的具体位置，需要通过遍历来找出
4.插入删除时，只影响上一个和下一个
5.尽量不要使用LinkedList进行遍历和查询，速度比较慢
 */
public class DemoF {
    public static void a(){
        LinkedList<Integer> list1 = new LinkedList<>();
        LinkedList<Integer> list2 = new LinkedList<>(list1);
    }

    //LinkedList的常见方法
    public static void b(){
        LinkedList<Integer> list = new LinkedList<>();
        list.add(33);//添加到最后一个
        list.add(45);
        list.add(31);
        list.add(1,54);//插入到指定位置
        list.addFirst(87);//添加到第一个
        list.addLast(51);//添加到最后一个
        System.out.println(list.toString());
        //删除
        list.removeFirst();
        list.removeLast();
        list.remove(3);
        list.remove(new Integer(45));
        //查询
        int v1 = list.get(3);//返回第三个结点的值
        int v2 = list.getFirst();
        int v3 = list.getLast();
        //修改
        list.set(1,24);//将第一个位置的值修改为24
        int size = list.size();
    }

    public static void c(){
        LinkedList<PersonInfo> list = new LinkedList<>();
        PersonInfo pi1 = new PersonInfo(1,"张三",23);
        PersonInfo pi2 = new PersonInfo(2,"李四",26);
        PersonInfo pi3 = new PersonInfo(3,"王五",25);
        PersonInfo pi4 = pi3;
        PersonInfo pi5 = new PersonInfo(3,"王五",22);
        list.add(pi1);
        list.add(pi2);
        list.add(pi3);
        boolean b1 = list.contains(pi4);//true
        boolean b2 = list.contains(pi5);//false
        int index1 = list.indexOf(pi4);
        int index2 = list.indexOf(pi5);
        int index3 = list.lastIndexOf(pi4);
        int index4 = list.lastIndexOf(pi5);
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(index1+"\t"+index2);
        System.out.println(index3+"\t"+index4);
        System.out.println("--------------");
        System.out.println(list);
        Collections.sort(list);//重写compareTo方法  实现Comparable<PersonInfo>接口
        System.out.println(list);
    }

    public static void main(String[] args) {
        c();
    }
}

public class PersonInfo implements Comparable<PersonInfo> {
    private Integer id;
    private String name;
    private  Integer age;

    public PersonInfo(Integer id, String name,Integer age){
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public int getAge(){
        return age;
    }

    public int getId(){
        return id;
    }

    @Override
    public String toString() {
        return "StuInfo{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public boolean equals(Object obj){
        PersonInfo pi = (PersonInfo)obj;
        return this.getId()==pi.getId();
    }

    @Override
    public int compareTo(PersonInfo o) {
        return this.getAge()-o.getAge();
    }
}

Vector

//Collection--List--Vector
//Vector和ArrayList一样，里面封装了一个数组，但是加了一把同步锁
//是线程安全的
public class DemoG {
    public static void  main(String[] args){
        Vector<String> vector = new Vector<>();
        vector.add("aa");
        vector.add("bb");
        vector.add("cc");
        vector.add(1,"dd");
        String v1 = vector.get(2);
        vector.set(2,"mm");
        int size = vector.size();
        boolean b1 = vector.contains("aa");//如果是对象，必须重写equals（）方法
        int index1 = vector.indexOf("aa");
        int index2 = vector.lastIndexOf("aa");
        vector.remove("bb");
        vector.remove(2);
        Collections.sort(vector);//如果vector里面的类型是自定义类型，要重写compareTo（）方法
        System.out.println(vector);
        vector.clear();//将集合里面的所有内容清空
    }
}

Stack

//Collection--List--Stack
public class DemoH {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        //向集合中添加内容
        stack.push("aa");
        stack.push("bb");
        stack.push("cc");
        stack.add("dd");
        stack.add(2,"ee");
        System.out.println(stack);
        //取出集合中的元素
        String v1 = stack.get(3);//按照索引取
        System.out.println(stack);
        String V2 = stack.peek();//取出最后一个元素
        System.out.println(stack);
        String v3 = stack.pop();//取出最后一个元素，并删除它
        System.out.println(stack);
    }
System.out.println("---------------------------");
Stack<Integer> s = new Stack<>();
for (int i = 0; i < 10; i++) {
    s.push((int)(Math.random()*(100+1)));
}
while(s.size()!=0){
    System.out.println(s.pop());
}

}

迭代器

public class DemoI {
    public static void a(){
        List<String> list = new ArrayList<>();
        list.add("aa");
        list.add("bb");
        list.add("cc");
        list.add("dd");
        list.add("ee");
        for (int i = 0; i < list.size(); i++) {
            System.out.print("  "+list.get(i));
        }
        System.out.println();
        //迭代器模式（游标模式）
        Iterator<String> it = list.iterator();
        while(it.hasNext()){//是否有下一个
            System.out.print("  "+it.next());//获取到下一个 输出
        }
        System.out.println();
        //简写 foreach
        for (String s:list){//：前面为类型和变量名，：后面是集合
            System.out.print("  "+s);
        }
    }

    public static void main(String[] args) {
        a();
    }
}