java 排查List中在另一个list中的对象

一.集合
集合概述
A:集合的由来
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。
B:数组和集合的区别
(1): 长度区别:
数组的长度是固定的而集合的长度是可变的
(2): 存储数据类型的区别:
数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
(3): 内容区别:
数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素
2.Collection集合的功能
（一）Collection的功能概述
a:添加功能
boolean add(Object obj):添加一个元素
boolean addAll(Collection c):添加一个集合的元素 (给一个集合添加进另一个集合中的所有元素)
b:删除功能
void clear():移除所有元素
boolean remove(Object o):移除一个元素
boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素
如果没有交集元素 则删除失败 返回false
c:判断功能
boolean contains(Object o)：判断集合中是否包含指定的元素
boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
比如：1，2，3 containsAll 12=true 1,2,3 containsAll 2,3,4=false
boolean isEmpty()：判断集合是否为空
d:获取功能
terator iterator()(重点)
e:长度功能
int size():元素的个数
面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
f:交集功能
//例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化
boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
g:把集合转换为数组
Object[] toArray()
案例演示：

public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        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 +
                '}';
    }
}
 public static void main(String[] args) {
        //创建三个学生对象
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);
        //创建集合
        Collection arrayList = new ArrayList();
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(new Student("赵六", 26));
        //迭代集合中的元素
        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            Student student = (Student) obj;
            System.out.println(student.getName() + "====" + student.getAge());
        }
    }

（二）.List集合
1.List概述
A:List概述及特点: 元素有序,并且每一个元素都存在一个索引.元素可以重复.
2.List集合的特有功能
A:List集合的特有功能概述
void add(int index,E element): 在指定索引处添加元素
E remove(int index):移除指定索引处的元素 返回的是移除的元素
E get(int index):获取指定索引处的元素
E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素
3.ListIterator的特有功能
ListIterator 继承自Iterator 可以使用Iterator中的方法
A:ListIterator的特有功能
boolean hasPrevious(): 是否存在前一个元素
E previous(): 返回列表中的前一个元素
以上两个方法可以实现反向遍历 但是注意 要完成反向遍历之前 要先进行正向遍历 这样指针才能移到最后
如果直接反向遍历是没有效果的 因为指针默认位置就在最前面 他前面没有元素

public class MyTest {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(4);
        list.add(60);
        list.add(40);
        list.add(50);
        list.add(60);
        list.add(40);
        list.add(50);
        list.add(60);
        //void sort (Comparator < ? super E > c)
        //分类列表使用提供的 Comparator比较元素。
        //
        //void forEach (Consumer < ? super E > action)
        //执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常。
        // Comparator 比较器，是一个接口，
        list.sort(new Comparator() {
            @Override
            public int compare(Object a, Object b) {
                Integer aa = (Integer) a;
                Integer bb = (Integer) b;
                return bb - aa; //根据差值 的正 负 0 就会排列集合中的元素
            }
        });

        list.sort((a, b) -> {
            Integer aa = (Integer) a;
            Integer bb = (Integer) b;
            return bb - aa;
        });

        System.out.println(list);
	}
}

4.数据结构之数组和链表
A:数组特点: 查询快 , 增删慢
B:链表特点: 查询慢 , 增删快
5.List的三个子类的特点
A:List的三个子类的特点
ArrayList:
底层数据结构是数组，查询快，增删慢。
线程不安全，效率高。
Vector:
底层数据结构是数组，查询快，增删慢。
线程安全，效率低。
LinkedList:
底层数据结构是链表，查询慢，增删快。
线程不安全，效率高。
B:List有三个儿子，我们到底使用谁呢?
得看 要安全还是要效率
是查找多还是增删多
ArrayList中的比较器

list.sort(new Comparator() {
            @Override
            public int compare(Object a, Object b) {
                Integer aa = (Integer) a;
                Integer bb = (Integer) b;
                return bb - aa; //根据差值 的正 负 0 就会排列集合中的元素
            }
        });
 // Consumer
        //JDK1.8 提供的新语法 Lmabda 表达式
        list.forEach(System.out::println);
        System.out.println("---------------");
        list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });

用forEach遍历时不能进行增删操作。

ListIterator的特有功能
ListIterator 继承自Iterator 可以使用Iterator中的方法
A:ListIterator的特有功能
boolean hasPrevious(): 是否存在前一个元素
E previous(): 返回列表中的前一个元素
以上两个方法可以实现反向遍历 但是注意 要完成反向遍历之前 要先进行正向遍历 这样指针才能移到最后
如果直接反向遍历是没有效果的 因为指针默认位置就在最前面 他前面没有元素。

//案例演示
//需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
//思路：创建新集合方式

ArrayList list = new ArrayList();
    list.add("abc");
    list.add("abc");
    list.add("abcddd");
    list.add("abc");
    list.add("abc");
    list.add("abcdd");
    list.add("abcddd");
    list.add("abc");

    //去除集合中的重复元素
    //创建一个新集合
    ArrayList newList = new ArrayList();

    for (int i = 0; i < list.size(); i++) {
       String  oldEle = (String) list.get(i);
       if(!newList.contains(oldEle)){
           newList.add(oldEle);
       }

    }
    System.out.println(newList);
}
另一种
private static ArrayList<String> qudiao(ArrayList<String> list) {
    //判断元素有没有重复
    for (int i = 0; i < list.size(); i++) {
        String obj = list.get(i);
        if (list.indexOf(obj) != list.lastIndexOf(obj)) {
            list.remove(obj);
            return qudiao(list);
        }
    }
    return list;
    另一种
     for (int i = 0; i < list.size(); i++) {
        for (int j = i + 1; j < list.size(); j++) {
            String str = (String) list.get(i);
            String str2 = (String) list.get(j);
            if (str.equals(str2)) {
                list.remove(str2);
                j--;
            }
        }

LinkedList

//LinkedList 底层数据结构是链表，查询慢，增删快，线程不安全，效率高
void addFirst (E e)
将指定元素插入此列表的开头。
void addLast (E e)
将指定元素添加到此列表的结尾 Object element = linkedList.element();。
Iterator descendingIterator ()
返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
E getFirst ()
返回此列表的第一个元素。
E getLast ()
返回此列表的最后一个元素。
E element ()
获取但不移除此列表的头（第一个元素）。
    E peek ()
    获取但不移除此列表的头（第一个元素）。
    E peekFirst ()
    获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
    E peekLast ()
    获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
    E poll ()
    获取并移除此列表的头（第一个元素）
    E pollFirst ()
    获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
    E pollLast ()
    获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
    //案例演示:
    //需求：请用LinkedList模拟栈数据结构的集合，并测试
    MyStack myStack = new MyStack();
    myStack.add(10);
    myStack.add(20);
    myStack.add(30);
    Object o = myStack.get();
    System.out.println(o);

Vector
// Vector底层数据结构是数组，查询快，增删慢，他是线程安全，效率低
//void addElement (E obj)
//将指定的组件添加到此向量的末尾，将其大小增加 1。

//E elementAt ( int index)
//返回指定索引处的组件。
//
//Enumeration<E> elements ()
//返回此向量的组件的枚举。
//E firstElement ()
//返回此向量的第一个组件（位于索引 0)处的项）。
//E lastElement ()
//返回此向量的最后一个组件。
//void removeAllElements ()
//从此向量中移除全部组件，并将其大小设置为零。
//boolean removeElement (Object obj)
//从此向量中移除变量的第一个（索引最小的）匹配项。
//void removeElementAt ( int index)
//删除指定索引处的组件
//void setElementAt (E obj,int index)
//将此向量指定 index 处的组件设置为指定的对象
Vector vector = new Vector();
vector.add("abc");
vector.addElement(123);
vector.add("abc");
vector.addElement(123);
vector.add("abc");
vector.addElement(123);
vector.add("abc");
vector.addElement(123);
vector.add("abc");
vector.addElement(123);
vector.add("abc");
vector.addElement(123);
vector.add("abc");
vector.addElement(123);
Object o = vector.elementAt(1);
System.out.println(o);
//获取一个迭起器，可以变量Vector集合中的元素
Enumeration elements = vector.elements();//vector特有的迭代器
//while (elements.hasMoreElements()){
//    Object o1 = elements.nextElement();
//    System.out.println(o1);
//}
//vector.removeAllElements();
//System.out.println(vector);

二、泛型
A:泛型概述:是一种把类型明确的工作
推迟到创建对象
或者调用方法的时候才去明确的特殊的类型。
参数化类型，把类型当作参数一样的传递。
B:泛型的格式 : <数据类型> 这里的数据类型只能是引用数据类型
C:泛型好处
(1): 把运行时期的问题提前到了编译期间
(2): 避免了强制类型转换
(3):优化了程序设计，解决了黄色警告线
注意：泛型只在编译期有效 但在运行期就擦除了
D:泛型基本使用

- 泛型的应用之泛型类: 就是把泛型定义在类上
- 格式:		public class 类名<数据类型 , ....> {}
  */
  public class ObjectTools<K> {

  private K k ;

  public K getK() {
  	return k;
  }
  public void setK(K k) {
  	this.k = k;
  }
}

A:泛型方法概述:	把泛型定义在方法上
B:定义格式:		public <泛型类型> 返回类型 方法名(泛型类型 变量名)
C:案例演示:		泛型方法的使用
public class Phone {

/**
 * 泛型方法
 */
public <E> void show(E e){
	System.out.println(e);
}
}