list接口以及其实现类Arraaaylist 以及Linkedlist解析

private static void fun(){
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
//使用List添加元素 list.add( int index Object obj)
//添加的角标就是后面添加的元素的角标，所以不能越界 
list.add(4,"x");
//通过角标获取元素 list.get( int index )
Object object = list.get(1)
System.out.println(object);
//通过get方法来遍历
for(int i =0;i<list.size():i++){
    System.out.println(list.get(i));
}
//set()方法进行替换
//注意不要越界
list.set(3,"a");
//remove() 方法根据角标删除元素（返回的是被删除的元素）
Object remove = list.remove(3);
} 
//删除时要注意的
private static void fun2() {
List list = new ArrayList();
list.add(111);//进行了自动装箱
list.add(222);
list.add(333);
//删除111元素
//Object remove = list.remove(0);
//System.out.println(remove);
//System.out.println(list);
//这里删除的时候系统没给你自动装箱，就按数字传入的
//所以调用的时按角标删除的方法调用的 所以越界
//Object remove = list.remove(111);
//System.out.println(remove);
//System.out.println(list);
Object remove = list.remove(Integer.valueOf(111));
System.out.println(remove);
System.out.println(lis////集合中添加abcd，如果有b 添加一个say yes
private static void fun3() {
    List list = new Arraylist();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    //声明一个迭代器
    Iterator iterator=list.Iterator();
    //遍历 
    while(iterator.hasNext()){
    //这个时候发生了并发异常
    //因为添加了一个数据相当于增加了集合的长度。在迭代器遍历的时候不能直接在集合区操作，即不能改变集合长度


        if(iterator.next().equals("b")){
        list.add("say yes")
        }
    }
    System.out.println(list);
//如何private static void fun4() {
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
//解决并发修改异常，思路让迭代器完成添加元素
//取出迭代器 list 特有的迭代器
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()) {
if(listIterator.next().equals("b")) {
listIterator.add("say hi");

}
}
System.out.println(list);
//注意在 迭代器中进行堆集合 的 添加删除操作，要使用迭代器中的方法
//不能直接使用集合区操作
}


//Vector 浅析

private static void fun5() {
//vector 利用数组来实现并且已经被ArrayList替代
//创建一个vector 集合，迭代器遍历
Vector vector = new Vector();
vector.add("a");
vector.add("b");
vector.add("c");
vector.add("d");
System.out.println(vector);
//使用迭代器遍历
//获取vector中的迭代器
Enumeration elements = vector.elements();
while(elements.hasMoreElements()) {
System.out.println(elements.nextElement());
}
}ivate static void fun6() {
        //使用List中的特有迭代器遍历 
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        ListIterator listIterator = list.listIterator();
        //正向
        while(listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
        //逆向
        //hasPrevious()判断前一个元素有么有
        while(listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
    }


private static void fun7() {
        LinkedList linkedList = new LinkedList();
        // 使用addfirst添加

        /*linkedList.addFirst("a");
        linkedList.addFirst("b");
        linkedList.addFirst("c");
        linkedList.addFirst("d");*/
        linkedList.addLast("a");
        linkedList.addLast("b");
        linkedList.addLast("c");
        System.out.println(linkedList);
        //获取头尾元素 
        System.out.println(linkedList.getFirst());
        System.out.println(linkedList.getLast());
    }

arraylist 和linkedlist区别
*  arrayList特点 ；查询快，增删慢 （）
*  linkedlist  ;是链表实现 
*  链表实现特点  ； 是查询慢 增删块


队列结构 和 栈结构 
*  栈结构的特点，先入的后出去
*  队列结构的特点 ：先进先出
*  使用linkedList模拟栈结构


private static void fun1() {
        // 使用linkedList模拟栈结构
        // 使用类模拟类结构
        LinkedList linkedList = new LinkedList();
        linkedList.addFirst("a");
        linkedList.addFirst("b");
        linkedList.addFirst("c");
        linkedList.addFirst("d");

        while(!linkedList.isEmpty()) {
            Object removeLast = linkedList.removeLast();
            System.out.println(removeLast);
        }
    }


private static void fun2() {
        // 创建一个集合 添加a,a,a b,b,b c,c,c
        //输出不重复的
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        arrayList.add("a");
        arrayList.add("a");
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("b");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("c");
        arrayList.add("c");
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            // 判断 老数组中的元素是否存在于新数组中 如果不存在就添加
            // 不能调用两次next方法
            if (!arrayList2.contains(next)) {
                // 将元素添加到新数组中
                arrayList2.add(next);
            }
        }
        System.out.println(arrayList2);
    }


//student 类
public class Student {
    private String name;
    private int age;
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
    //重写equals方法
    @Override
    public boolean equals(Object obj) {
    //原来比较地址，现在需求改变，只看姓名和年龄
        //姓名和年龄相同就表示是同一个
        //把转进来的obj转换为Student类型
        Student student = (Student)obj;
        //然后判断姓名和年龄同时相同
        return this.name.equals(student.getName())&& this.age ==student.getAge();
    }


}


    private static void fun3() {
        // 创建一个arraylist 保存六个学生 去除重复的学生
        ArrayList list = new ArrayList();
        ArrayList list2 = new ArrayList();
        // 这六个学生地址都不一样 所以就不是同一个对象
        // 想去重根据对象的名字和年龄去重
        // 如果年龄和名字一样 咱们就认为两个对象重复了就保存一个
        list.add(new Student("鹏鹏", 10));
        list.add(new Student("鹏鹏", 10));
        list.add(new Student("水水", 10));
        list.add(new Student("丁丁", 15));
        list.add(new Student("倩倩", 16));
        list.add(new Student("倩倩", 16));
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            // Object类型 所以要强转
            Student student = (Student) next;
            if (!list2.contains(student)) {
                list2.add(student);
            }
        }
        // 去重的这个思路依赖contains这个方法
        for (Object object : list2) {
            Student student = (Student) object;
            System.out.println(list2);
        }
    }

“`