List集合、Collection、ArrayList、LinkedList

List集合、Collection、ArrayList、LinkedList介绍

有所不足之处，请各位大侠们指点指点。谢谢！

1、Collection的方法和迭代器Iterator

Collection的方法和概况
https://blog.csdn.net/qq_44224029/article/details/94665030

lterator方法讲解
https://blog.csdn.net/qq_44224029/article/details/94666471

package  com.deng.list;
import  java.util.ArrayList;
import  java.util.Collection;
import  java.util.Iterator;

public class CollectionDemo {
         public static void main(String[] args) {
   Collection  c=new ArrayList();
/*          c.add("q");
            c.add("w");
            c.add("e");
            c.add("r");
            c.add("t");*/
            
   c.add(23);
   c.add(24);
   c.add(25);
   c.add(26);
   c.add(55); 
   //   遍历foreach   for增强版
  /* for (Object obj : c) {    
    System.out.println(obj);
   }*/
   //迭代器是集合特有的遍历方式
   Iterator it=c.iterator();
   while(it.hasNext()) {
    /*System.out.println(it.next());*/
    int   num=(int) it.next();
    if(num%2==0) {
     /*System.out.println(it.next());*/
      /*System.out.println(num);*/
       c.remove(num);   //    直接报错   ConcurrentModificationException  当前改变异常   
    }
   }
   
  }
}

num打印出的是   24    26

it.next:是从顶部开始运行，运行一次，返回下一个元素；

假如：      第一个数是     1    
           第二个数是     2
           第三个数是     3
      int   num=(int) it.next();
      if(num%2==0) {//被2整除是2
    System.out.println(it.next());//但是这里打印出的是3。（运行一次，返回下一个元素）
     System.out.println(num);//这里打印出的是2。
    }
  

2、vector集合

数组结构 增删改查都慢 有连续下标 线程同步 增长因子2 初始长度10

3、List 集合

有序 元素可以重复 因为该集合体系有索引

4、Linkedlist 集合

链表结构 增删快，查询慢 没有连续下标
LinkedList 堆栈结构如下图所示：
LinkedList 堆栈结构代码

package  com.deng.list;

import java.util.Iterator;
import java.util.LinkedList;
/**堆栈
 * @author Administrator
 *
 */
public class LinkDemo {
      public static void main(String[] args) {
       DuiDeng dd= new DuiDeng();
    dd.push("q");
    dd.push("w");
    dd.push("e");
    dd.push("r");
    dd.push("t");
    dd.bianli();
 }
}
class DuiDeng{
 private LinkedList l= new LinkedList<>();
 
 
public void push(Object obj) {
  l.addFirst(obj);
 }
 
ublic Object pop() {
  return l.removeFirst();
 }
 
 public void bianli() {
  Iterator it = l.iterator();
  while(it.hasNext()) {
   System.out.println(it.next());
  }
 }
}

LinkedList 队列结构如下图所示：
LinkedList 对列 代码如下：

package com.deng.list;
import  java.util.Iterator;
import  java.util.LinkedList;
/**队列
 * @author Administrator
 *
 */
public class LinkDemo2 {
      public static void main(String[] args) {
       DuiLie dl= new DuiLie();
    dl.push("a");
    dl.push("b");
    dl.push("c");
    dl.push("d");
    dl.push("e");
    dl.bianli();
 }
}
class DuiLie{
 private LinkedList l= new LinkedList<>();
 
 /**放东西进去
  * @param obj
  */
 public void push(Object obj) {
  l.addFirst(obj);
 }
 
 
 /**从里面取东西
  * @return
  */
 public Object pop() {
  return l.removeFirst();
 }
 
 public void bianli() {
  Iterator it = l.iterator();
  while(it.hasNext()) {
   System.out.println(it.next());
  }
 }
}

5、Arraylist 集合

数组结构 增删慢，查询快 有连续下标 线程不同步 增长 因子为1.5 初始长度10

Arraylist 概况和实现
https://blog.csdn.net/qq_44224029/article/details/94663337

ArrarList 去重复：
判断list 集合中元素是否相同，依据的是元素的equals方法
String能够去重，是因为重写了Object的equals方法
如果自定义的对象需要去重的话，那么就需要重写Object ，equals方法。
思路：
新建一个容器，新容器和旧容器判断是否有相同的元素，如果有，那么不加新容器中，如果没有，那么加到新容器中。
代码如下：

package com.deng.list;

import java.util.ArrayList;
/**
 * 对ArrayList 中的元素去重 1.元素是字符串 2.元素是自定义对象
 * 集合collection 的contains 在调用的时候底层调用容器元素对象equals方法
 *  之前元素对象是Strng
 *  元素对象object(Person)
 * @author Administrator
 *
 */
public class ArrayDemo {
public static void main(String[] args) {
       ArrayList a= new ArrayList<>();
       a.add(new Person("qq","18"));
       a.add(new Person("ww","22"));
       a.add(new Person("ee","21"));
       a.add(new Person("rr","18"));
       a.add(new Person("tt","18"));
       
       /**遍历要去重复的数据
           * @param args
           */
       ArrayList newAl = repeatList(a);
       for (Object object : newAl) {      
        System.out.println(object);
       }
      }
private static ArrayList repeatList(ArrayList a) {
       ArrayList newAll=new ArrayList<>();
       for (Object object : a) {
        if(!newAll.contains(object)) {
         newAll.add(object);
        }
       }
       return newAll;
      }
    
}
class Person{
      private String name;
      private String age;
      public Person() {}
      public Person(String name, String age) {
       super();
       this.name = name;
       this.age = age;
      }
      public String getName() {
       return name;
      }
      public void setName(String name) {
       this.name = name;
      }
      public String getAge() {
       return age;
      }
      public void setAge(String age) {
       this.age = age;
      }
      @Override
      public String toString() {
       return "Person [name=" + name + ", age=" + age + "]";
      }
      @Override
      public boolean equals(Object obj) {
       Person p= (Person)obj;
       return p.name.equals(this.name) && p.age==this.age;
      }
      }