List

ArrayList和LinkedList可以在LIst中实现了一些通用的方法
List接口（DRY原则）
接口可以看做是一种特殊的抽象父类
接口同样支持多态--接口可以接受一个实现类的引用
面向接口编程
同理为了达到通用性，在设计方法时，方法的参数需要时一个集合，使用接口类型作为参数的数据类型
这样一来就可以在方法中使用不同的集合了
public static void show（List list）
当调用哪个show方法时可以传入的参数有哪些：ArrayList或者LinkedList或者Vector
可以限制当前方法的集合的类型
若以后在使用LIst接口集合的建议：
List list = new 当前实现类即可（）--对象向上转型-list

public class ListDome {
    public static void main(String[] args){
        List list1 = new ArrayList();
        List list2=new ArrayList();
        list1.add("1");
        list1.add("2");
        list1.add("3");
        list1.add("4");
        
        list2.add("2");
        list2.add("3");
        //判断当前集合中制定集合中的元素
        boolean res=list1.containsAll(list2);
        System.out.println(res);
        List list3 = new ArrayList();
        //空集是任何集合的子集
        System.out.println(list1.containsAll(list3));
        //保留参数集合中的元素，删除其他元素
       // list1.retainAll(list2);
        //删除参数集合中的元素在当前集合
      //  list1.removeAll(list2);
        System.out.println(list1);
        //截取当前包括开始的位置，不包括结束的位置
        List list4 = list1.subList(1,3);
        //当前list4 获取的不是新的堆空间
        //list4 获取的是截取之后的空间
        System.out.println(list4);


    }

}

LinkedList

LinkedList方法的演示

public class LinkedListDemo {

	
	@SuppressWarnings("rawtypes")
	public static void main(String[] args) {
		//创建LinkedList集合对象
		LinkedList list = new LinkedList();
		//将集合中的元素存到当前集合中
		//将参数中集合对象的元素存到新的集合中
		LinkedList list1 = new LinkedList(list);
		
		//常用方法:
		//向集合中存储元素-->(包括任何数据类型)
		list.add("第一个元素");
		LinkedList list2 = new LinkedList();
		list2.add("1");
		list2.add("2");
		list2.add("3");
		//这样添加对象是将集合添加到了当前集合对象中
		//list.add(list2);
		//这样添加对象是将当前参数集合中的元素存到了集合对象
		list.addAll(list2);
		/*
		 * add(int index, E element) 
                      在此列表中指定的位置插入指定的元素。
          addAll(int index, Collection<? extends E> c) 
                     将指定 collection 中的所有元素从指定位置开始插入此列表。
                     支持下标 -->0开始 size()-1
		 */
		System.out.println(list);
		
		//将元素添加到集合的开头
		list.addFirst("第0个元素");
		System.out.println(list);
		//将元素添加到集合的末尾
		list.addLast("最后一个元素");
		System.out.println(list);
		//clear() 清空集合中的元素 --> 集合依旧存在
		//判断集合中是否存在指定元素 存在即true  即false
		list.add("1");
		System.out.println(list);
		boolean result = list.contains("1");
		System.out.println(result);
		
		//获取集合中的第一个元素但是不删除该元素
		Object obj = list.element();
		System.out.println(obj);
		System.out.println(list);
		//get(int index) 返回此列表中指定位置处的元素 下标
		
		//获取第一个或最后一个元素
		System.out.println(list.getFirst());
		System.out.println(list.getLast());
		/*
 int indexOf(Object o) 
          返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。 
 int lastIndexOf(Object o) 
          返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。 
      返回值的是第一次出现的下标,找不到返回-1
		 */
		//将指定元素添加到末尾
		boolean res = list.offer("ppp");//添加成功返回true
		System.out.println(list);
		System.out.println(res);
		/*
		 * boolean offerFirst(E e) 
          		在此列表的开头插入指定的元素。 
 			boolean offerLast(E e) 
          		在此列表末尾插入指定的元素。 
          	添加成功是不返回true	

		 */
		//获取集合中的第一个元素但是不删除
		Object obj2 = list.peek();
		System.out.println(obj2);
		System.out.println(list);
		/*
		 *  E peekFirst() 
          获取但不移除此列表的第一个元素；如果此列表为空(集合中没有元素)，则返回 null。 
 			E peekLast() 
          获取但不移除此列表的最后一个元素；如果此列表为空(集合中没有元素)，则返回 null。 

		 */
		
		//获取集合中第一个元素并删除
		Object obj3 = list.poll();
		System.out.println(obj3);
		System.out.println(list);
		/*
			E pollFirst() 
          获取并移除此列表的第一个元素；如果此列表为空(集合中没有元素)，则返回 null。 
 			E pollLast() 
          获取并移除此列表的最后一个元素；如果此列表为空(集合中没有元素)，则返回 null。 

		 */
		 //获取集合中第一个元素并删除
		Object obj4 = list.pop();
		System.out.println(obj4);
		System.out.println(list);
		//向集合添加元素
		list.push("0"); //--> addfist
		System.out.println(list);
		
		//集合中删除元素
		//1.删除集合中的第一个元素并获取
		Object obj5 = list.remove();
		System.out.println(obj5);
		System.out.println(list);
		//2.根据下标删除指定元素并获取
		Object obj6 = list.remove(2);
		System.out.println(obj6);
		System.out.println(list);
		//3.删除集合中的指定元素
		//若删除成功返回 true 失败 返回false
		boolean res1 = list.remove("1");
		System.out.println(list);
		 System.out.println(res1);
		 /*
		  * E removeFirst() 
          	移除并返回此列表的第一个元素。 
           E removeLast() 
          	移除并返回此列表的最后一个元素。 
          	会得到删除的元素
		  * 
		  */
		//传入下标替换指定元素,并获取原有值
		 Object obj7 = list.set(0, "yui");
		 System.out.println(obj7);
		 System.out.println(list);
		//将LinkedList集合集合对象转换为数组
		 Object[] objs = list.toArray();
		 System.out.println(Arrays.toString(objs));
		

链表、节点Node

public class MyLinkedList {
     //存在节点 连接链表使用的(链表的组成)
	 private Node first; // 第一个节点
	 private Node last; // 最后一个节点
	 private int size; //节点的数量
	 
	  //对链表中的节点进行描述
	 class Node{
		  //定义上一个节点 和 下一个节点
		  Node  prev;
		  Node  next;
		  Object  ele; //当前节点中存储的数据
		  //构造方法 方便给基点中的数据进行赋值
		  public Node(Object ele) {
			  this.ele = ele;
		  }
	 }
	 //第一个方法 向头节点添加元素
	 public void addFirst(Object ele) {
		 //1. 创建节点对象
		 Node node = new Node(ele);
		 if(size == 0) {
			 this.first = node;
			 this.last = node;
		 }else {
			 //把之前的第一个基点作为新增基点的下一个节点
			 node.next = this.first; 
			 //把新增的基点作为原有节点的上一个基点
			 this.first.prev = node;
			 //重置开始节点
			 this.first = node;
		 }
		 size ++;
		 
	 }

	 //第二个方法 向头节点添加元素
	 public void addLast(Object ele) {
		//1. 创建节点对象
		 Node node = new Node(ele);
		 if(size == 0 ) {
			 this.first = node;
			 this.last = node;
			 
		 }else {
			 //把新增的节点作为原有节点的下一个节点
			 this.last.next = node;
			 //把之前最后一个节点作为当前节点的上一个节点
			 node.prev = this.last;
			 //重置最后一个基点
			 this.last = node;
		 }
		 size++;
	 }
	 
	 //删除元素
	 public void remove(Object ele) {
		 //先获取第一个节点
		 Node current = this.first;
		 //寻找节点
		 for(int i = 0; i < size; i++) {
			 if(!current.ele.equals(ele)){
			   if(current.next == null) {
				   return;
			   }
			   current = current.next;
			 }
		 }
		 //删除
		 if(current == first) {
			 this.first = current.next;
			 this.first.prev = null;
		 }else if(current == last) {
			 this.last = current.prev;
			 this.last.next = null;
		 }else {
			 //当前对象的上一个节点对象的下一个节点 得到 当前对象的下一个节点
			 current.prev.next = current.next;
			 //当前对象的下一个基点对象的上一个节点 的带 当前对象的上一个节点
			 current.next.prev = current.prev;
		 }
		 size--;
	 }

	 //打印当前链表中存储的元素
	 @Override
	public String toString() {
		if (size == 0) {
			return "[]";
		}
		StringBuilder sbr = new StringBuilder();
		// 获取节点对象
		Node node = this.first;
		sbr.append("[");
		for (int i = 0; i < size; i++) {
			sbr.append(node.ele);
			if (i != size - 1) {
				sbr.append(",");
			} else {
				sbr.append("]");
			}
			node = node.next; // 取自己的下一个节点
		}
		return sbr.toString();
	}	 

}

集合对的遍历方法

public class ForListDemo {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("A");
		list.add("B");
		list.add("C");
		list.add("D");
		list.add("E");
		System.out.println("普通for循环遍历打印的结果:");
		//1.普通for循环
		for(int  i = 0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
		System.out.println("增强for循环遍历打印的结果:");
		//2.增强for循环
		//ps:对于集合来说就是一个迭代器
		/*
		 * 通过反编译.class文件的到的结果
		 * Object obj;
		 * for (Iterator iterator = list.iterator(); iterator.hasNext();){
						obj = iterator.next();
			 			System.out.println(obj)
			 }
		 */
		for(Object obj : list) {
			System.out.println(obj);
		}
		System.out.println("迭代器遍历打印的结果:");
		//3.迭代器 
		//3.1需要先获取迭代器对象
		Iterator it = list.iterator();
		//3.2通过迭代器对象的hasNext方法获取是否还有下一个元素
		while(it.hasNext()) {
			System.out.println(it.next());
			
		}
		System.out.println("for循环迭代器版本");
		//for循环版本:
		for(Iterator itr = list.iterator();itr.hasNext();) {
			System.out.println(itr.next());
			
		}
		//ps:以上三种的效果都是一样,但实际迭代器是不同
		
		//4.枚举迭代器:
		//这个只是用来掩饰无需记住,不会再使用这种方式
		Vector v = new Vector();
		v.addAll(list);
		//4.1获取枚举迭代器的对象
		 Enumeration en =  v.elements();
		 //判断枚举迭代器中是否存在下一个元素
		 while(en.hasMoreElements()) {
			 //获取迭代器中的对象
			 System.out.println(en.nextElement());
		 }
		 System.out.println("-----------------------------以下是listIterator的结果---------------------------");
		//这个是listIterator的对象
	    ListIterator lit =   list.listIterator();
	    while(lit.hasNext()) {
	    	System.out.println(lit.next());
	    }
	    while(lit.hasPrevious()) {//上一个元素 指针必须在后面
	    	System.out.println(lit.previous());
	    }

	}

}