Java中list接口的方法和list接口的实现类LinkedList，Vecotr以及队列和栈结构

一、List接口中的常用方法

1.添加方法
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
添加角标插入对应的元素
list.add(3,"x");
System.out.print(list)----[a,b,c,x,d];
2.通过get方法进行遍历
Object object = list.get(0);
System.out.println(object);----0
for(int i= 0;i<list<size();i++){
    Object object2 = list.get(i);
    System.out.print(object2);---abcd
}
3.set方法，按指定角标替换填入的元素
  所替换的角标不要越界
  list.set(0,"c");
  System.out.prrintln(list);----[c,b,c,d];
4.删除，根据角标删除，返回的是被删除的元素
Object remove = list.remove(3);
System.out.println(remove);------d
System.out.println(list);[a,b,c]
5.删除时要注意，是按角标还是按元素删除的
List list = new ArrayList();
//自动装箱
list.add(111);
list.add(222);
list.add(333);
//删除111
//remove删除
//调用remove（角标删除）
int indexOf = list.indexOf(111);
list.remove(indexOf);
System.out.println(list);---[222,333]
//调用 remove(按元素删除)
list.remove(111);
System.out.println(list);---报错数组越界
//这里删除的时候系统没有给你自动装箱
//就按数字传入的方法，调用角标删除的方法，所以越界
要想按元素删除，需要手动删除（就是手动进行装箱）
    Object object =  list.remove(Integer.valueOf(111));
    System.out.println(list);----[222,333];
6.发生修改异常
  List list = new ArrayList();
  list.add("a");
  list.add("b");
  list.add("c");
  list.add("d");
  //添加完四个元素，这时集合长度是4
  //如果使用迭代器遍历，那么长度是固定的
  Iterator iterator = list iterator();
  while(iterator.hasNext()){
        Object next =  iterator.next();
        if(next.equals("b")){
            list.add("on");
//这里相当于修改了集合的长度，迭代器并不知道
//在迭代器遍历的时候，不要直接使用集合做操作（添加或删除）
//如果想添加或修改，可以让迭代器自己去添加或者删除元素，这就让迭代器知道了
        }
  }
  System.out.println(list)---报错，修改异常
//ConcurrentModificationException并发修改异常

  }
7.解决上面的并发修改异常
Lsit list = new ArrayList();
list.add("a");
list.add("b");
list.add("c")
list.add("d");
//采用List中特有的迭代器
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()){
    Object object = listIterator.next();
    if(next.equals("b"){
        listIterator.add("on");
    }
}
System.out.println(list);--[a,b,c,d,on]
//注：在迭代器中进行对集合添加或删除，要使用迭代器中的方法，不能直接使用集合去操作
8.利用list中的特有迭代器，逆向遍历集合
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
ListIterator listIterator = list.listIterator();
while(listIteratro.hasNext()){
    //正向遍历
    System.out.println(listIterator.next());
    ---[a,b,c,d]
}
//逆向遍历，hasPrevious判断前一个元素没有
while(listIterator.hasPrevious()){
    //获取前一个元素
    System.out.println(listInterator.previous());---[d,c,b,a]
    //注：这里逆向遍历的原因是因为，上面正向遍历后，指针指向了，最后一个元素，然后逆向排序才能执行成功，
    }
}

二、Vecotr实现类

/*
 *Vector 1.2(使用数组来实现的，已经被ArrayList代替)
 创建一个Vector集合，迭代遍历
/*
Vector vector = new Vector();
vector.addElement("a");
vector.addElement("b");
vector.addElement("c");
vector.addElement("d");
//使用迭代器遍历
//获取elements中的迭代器
Enumeration elements = vector.elements();
while(elements.hasMoreElements()){
  System.out.println(elements.nextElement());
}
System.out.println(vector);--[a,b,c,d]
}

三、LinkedList

LinkedList linkedList = new linkedList();
1.//使用addFirst方法添加
linkedList.addFirst("a");
linkedList.addFirst("b");
linkedList.addFirst("c");
linkedList.addFirst("d");
System.out.println(linkedList);--[d,c,b,a];
2.//使用addLirst方法添加
linkdeList.addLast("a");
linkedList.addLast("b");
linkedList.addLast("c");
linkedList.addLast("d");
System.out.println(linkedList);--[a,b,c,d]
3.获取头尾元素
LinkedList linkedlist = new LinkedList();
linkedList.add("a");
linkedList.add("b");
linkedList.add("c");
System.out.println(linkedList.getFirst());--a
System.out.println(linkdeList.getLast());--c

四、队列结构和栈结构

栈结构特点：先入后出去
队列结构特点：先进先出
使用LinkedList模拟栈结构

栈结构特点：先入后出去
//模拟进栈
LinkedList linkedList = new LinkedList();
linkedList.addLast("a");
linkedList.addLast("b");
linkedList.addLast("c");
linkedList.addLast("d");
System.out.println(linkedList);--[a,b,c,d]

//模拟出栈
while1(!linkedList.isEmpty()){
    Object removeLast = linkedList.removeLast();
    System.out.print(removeLast);--dcba
}

五、ArrayList去重

1.要求：创建一个集合，添加a,a,a,b,b,b,c,c,c取出重复

 ArrayList arrayList = new ArrayList();
 ArrayList newList = 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()){
    //不能调用两次next方法
    Object next = iterator.next();
//判断老数组中的元素，是否存在于新数组中
//如果存在，就不添加进新集合
//不存在，就添加进新集合
if( !newList.contains(next)){
    newList.add(next);
}
}
System.out.println(newList);--[a,b,c]
2.创建一个Array，保存6个学生，去除重复学生
ArrayList list = new ArrayList();
//这6个学生地址都不一样， 所以不是同一个对象
//想去去重，可以根据对象名字和年龄，
//如果名字和年龄一样，就认为，两个对象重复，这时就会让其只保留一个
ArrayList list = new ArrayList();
list.add(new Student("鹏鹏",18));
list.add(new Student("鹏鹏",18));
list.add(new Student("水水",17));
lsit.add(new Student("水水",17));
 list.add(new Student("茜茜",16));  
list.add(new Student("茜茜",16));
ArrayList newList = new ArrayList();

    Iterator iterator = list.iterator();
    while(iterator.hasNext()) {
        Object next = iterator.next();
        Student student = (Student)next;
        if(!newList.contains(student)) {
        //写的去重这个思路，都依赖contains这个方法
    //所以这点要重写equals()方法，在Student里面
        newList.add(student);
    }
    }

    //打印新数组
    for (Object object : newList) {
        Student student =(Student)object;
        System.out.println(student);
    }


}

package com.lanou3g;
/*
 * 
 */
public class Student {
   private String namle;
   private int age;
   public Student() {
    // TODO Auto-generated constructor stub
}
public Student(String namle, int age) {
    super();
    this.namle = namle;
    this.age = age;
}
public String getNamle() {
    return namle;
}
public void setNamle(String namle) {
    this.namle = namle;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
@Override
public String toString() {
    return "Student [namle=" + namle + ", age=" + age + "]";
}
 //在studen里重写equals方法
@Override
    public boolean equals(Object obj) {
    //原来系统比较的是地址，
    //而现在我们需要看姓名和年龄 相同，就认为是同一个对象
    //把传进来的转换成Student类型

    Student s =(Student)obj;
    //判断姓名和年龄相同
        return this.namle.equals(s.getNamle()) && this.age ==s.getAge() ;   
    }
}