2020-08-06

集合框架

ArrayList

ArrayList存储字符串并遍历

JDK1.8新增的一个方法也能遍历集合

• void forEach（Consumer<? super E> action）：执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常

import java.util.ArrayList;
import java.util.function.Consumer;
public class MyTest {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("AAA");
        arrayList.add("BBB");
        arrayList.add("CCC");
        //执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常 
        arrayList.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });
        //Alt+Enter 变缩写
        //arrayList.forEach(o -> System.out.println(o));
    }
}

Vector的特有功能

Vector类概述：Vector 类可以实现可增长的对象数组 , Vector是同步的

Vector类特有功能

• public void addElement（E obj）

import java.util.Vector;
public class MyTest {
    public static void main(String[] args) {
        //和add（）一样，都是添加元素，区别是add（）会有返回值，addElement（）没有返回值
        Vector vector = new Vector();
        boolean a = vector.add("AAA");
        System.out.println(a);//true
        vector.addElement("BBB");
        System.out.println(vector.toString());//[AAA, BBB]
    }
}

• public E elementAt（int index）

import java.util.Vector;
public class MyTest {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement("AAA");
        vector.addElement("BBB");
        vector.addElement("CCC");
        vector.addElement("DDD");
        //根据索引找元素
        Object o1 = vector.elementAt(0);
        Object o2 = vector.elementAt(2);
        System.out.println(o1);//AAA
        System.out.println(o2);//CCC
    }
}

• public Enumeration elements（）

import java.util.Enumeration;
import java.util.Vector;
public class MyTest {
    public static void main(String[] args) {
        Vector vector = new Vector();
        vector.addElement("AAA");
        vector.addElement("BBB");
        vector.addElement("CCC");
        vector.addElement("DDD");
        //elements  是一个枚举
        Enumeration elements = vector.elements();
        System.out.println(elements);
        while (elements.hasMoreElements()){
            Object o = elements.nextElement();
            System.out.println(o);
        }
    }
}

LinkedList的特有功能

LinkedList类概述：List 接口的链接列表实现，此实现不是同步的

LinkedList类特有功能

• public void addFirst（E e）及addLast（E e）

import java.util.LinkedList;
public class MyTest {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add("鹿秀儿");
        //插入元素到末尾
        linkedList.addLast("我在最后面");
        //插入元素到首位
        linkedList.addFirst("我可以排在最前面");
        System.out.println(linkedList);//[我可以排在最前面, 鹿秀儿, 我在最后面]
    }
}

• public E getFirst（）及getLast（）

import java.util.LinkedList;
public class MyTest {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add("鹿秀儿");
        linkedList.addLast("我在最后面");
        linkedList.addFirst("我可以排在最前面");
        //获取第一个元素
        Object first = linkedList.getFirst();
        //获取最后一个元素
        Object last = linkedList.getLast();
        System.out.println(first);//我可以排在最前面
        System.out.println(last);//我在最后面
        System.out.println(linkedList);//[我可以排在最前面, 鹿秀儿, 我在最后面]
    }
}

• public E removeFirst（）及public E removeLast（）

import java.util.LinkedList;
public class MyTest {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add("鹿秀儿");
        linkedList.addLast("我在最后面");
        linkedList.addFirst("我可以排在最前面");
        //移除第一个元素，返回值是被移除的元素
        Object first = linkedList.removeFirst();
        //移除最后一个元素，返回值是被移除的元素
        Object last = linkedList.removeLast();
        System.out.println(first);//我可以排在最前面
        System.out.println(last);//我在最后面
        System.out.println(linkedList);//[ 鹿秀儿]
    }
}

用LinkedList模拟栈数据结构的集合并测试

栈的特点：先进的后出，后进的先出

import java.util.LinkedList;
public class MyList {

    private  LinkedList linkedList;

    public MyList() {
        //创建Lin
        linkedList = new LinkedList();
    }

    public void add(Object obj) {
        linkedList.addFirst(obj);
    }

    public Object get() {
        Object first = linkedList.pop();
        linkedList.addLast(first);
        return first;
    }
}

public class MyTest {
    public static void main(String[] args) {
        MyList myList = new MyList();
        myList.add(100);
        myList.add(200);
        myList.add(300);

       Object obj= myList.get();
        System.out.println(obj);
        obj = myList.get();
        System.out.println(obj);
        obj = myList.get();
        System.out.println(obj);

        obj = myList.get();
        System.out.println(obj);
        obj = myList.get();
        System.out.println(obj);
        obj = myList.get();
        System.out.println(obj);
    }
}

去除ArrayList中重复字符串元素方式

需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)

import java.util.ArrayList;
public class MyTest {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(20);
        list.add(20);
        list.add(20);
        list.add(20);
        list.add(120);
        list.add(320);
        list.add(320);
        list.add(120);
        list.add(20);
        list.add(230);
        list.add(204);
        list.add(203);
        list.add(20);
        list.add(120);
        list.add(320);
        list.add(320);
        list.add(120);
        list.add(20);
        list.add(230);
        list.add(204);
        list.add(203);

        //选择排序：拿一个元素跟后面的每一个元素去比较，遇到相同的删掉。

        for (int i = 0; i < list.size()-1; i++) {
            for(int j=i+1;j<list.size();j++){
                if(list.get(i).equals(list.get(j))){
                    list.remove(j);
                    j--;
                }
            }
        }
        System.out.println(list);
    }
}

import java.util.ArrayList;
public class MyTest2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(20);
        list.add(20);
        list.add(20);
        list.add(20);
        list.add(120);
        list.add(320);
        list.add(320);
        list.add(120);
        list.add(20);
        list.add(230);
        list.add(204);
        list.add(203);
        list.add(20);
        list.add(120);
        list.add(320);
        list.add(320);
        list.add(120);
        list.add(20);
        list.add(230);
        list.add(204);
        list.add(203);

        deleteObj(list);

        System.out.println(list);
    }
    private static void deleteObj(ArrayList list) {
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            if(list.indexOf(o)!=list.lastIndexOf(o)){
                list.remove(o);
                deleteObj(list); //递归
            }else{
                return;
            }
        }
    }
}

import java.util.ArrayList;
public class MyTest {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("aaa");
        list.add("bbb");
        list.add("bbb");
        list.add("ccc");
        list.add("ccc");

        ArrayList newList = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            if(!newList.contains(o)){
                newList.add(o);
            }
        }
        System.out.println(newList);
    }
}

去除ArrayList中重复自定义对象元素

需求：ArrayList去除集合中自定义对象元素的重复值(对象的成员变量值相同)

注意：重写equals（）方法

import java.util.Objects;
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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +

                '}';
    }
}

import java.util.ArrayList;
public class MyTest {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Student("张三",23));
        list.add(new Student("张三", 23));
        list.add(new Student("张学友", 24));
        list.add(new Student("张学友", 24));
        list.add(new Student("刘德华", 25));
        list.add(new Student("张国荣", 24));

        ArrayList newList = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            if (!newList.contains(o)) {
                newList.add(o);
            }
        }
        System.out.println(newList);
    }
}

泛型

泛型概述和基本使用

泛型概述:是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型

参数化类型，把类型当作参数一样的传递

泛型的格式：<数据类型>，这里的数据类型只能是引用数据类型

泛型好处

• 把运行时期的问题提前到了编译期间
• 避免了强制类型转换
• 优化了程序设计，解决了黄色警告线
• 注意：泛型只在编译期有效 但在运行期就擦除了

import java.util.ArrayList;
public class MyTest {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(100);
        System.out.println(integers);//[100]
    }
}

ArrayList存储字符串并遍历泛型版

import java.util.ArrayList;
public class MyTest {
    public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(100);
        Integer integer = integers.get(0);
        System.out.println(integer);//100
    }
}

ArrayList存储自定义对象并遍历泛型版

import java.util.ArrayList;
import java.util.Iterator;
public class MyTest {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("鹿秀儿",23));
        list.add(new Student("秀儿", 23));
        list.add(new Student("鹿鹿", 23));
        Iterator<Student> iterator = list.iterator();
        while (iterator.hasNext()){
            Student student = iterator.next();
            System.out.println(student);
            //Student{name='鹿秀儿', age=23}
            //Student{name='秀儿', age=23}
            //Student{name='鹿鹿', age=23}
        }
    }
}

泛型的由来

早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题

泛型类的概述及使用

泛型类概述：把泛型定义在类上

定义格式：public class 类名<泛型类型1，…>

注意事项：泛型类型必须是引用类型

//泛型类，在类上可以加上泛型。
public class MyClass<T> {
    private T t;
    private Integer num;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

泛型方法的概述和使用

泛型方法概述：把泛型定义在方法上

定义格式：public <泛型类型> 返回类型 方法名（泛型类型 变量名）

泛型接口的概述和使用

泛型接口概述：把泛型定义在接口上

定义格式：public interface 接口名<泛型类型>

public interface MyInterface<A> {
    public abstract void test(A a);
}

public class MyB<A> implements MyInterface<A>{
    @Override
    public void test(A a) {

    }
}
//子类实现接口时，可以明确接口上的泛型具体是什么类型

泛型高级之通配符

• 泛型通配符<?>：任意类型，如果没有明确，那么就是Object以及任意的Java类了
• ? extends E：向下限定，E及其子类
• ? super E：向上限定，E及其父类
• 泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致

增强for的概述和使用

增强for概述

简化数组和Collection集合的遍历

格式

for(元素数据类型 变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}

import java.util.ArrayList;
public class MyTest {
    public static void main(String[] args) {
        int[] ints = new int[3];
        ints[0]=111;
        ints[1]=222;
        ints[2]=333;
        //增强for遍历数组
        for (int anInt : ints) {
            System.out.println(anInt);
            //111
            //222
            //333
        }
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("鹿秀儿",23));
        list.add(new Student("秀儿", 23));
        list.add(new Student("鹿鹿", 23));
        //增强for遍历集合
        for (Student student : list) {
            System.out.println(student);
            //Student{name='鹿秀儿', age=23}
            //Student{name='秀儿', age=23}
            //Student{name='鹿鹿', age=23}
        }
    }
}
//ConcurrentModificationException 并发修改异常

好处及注意事项

• 简化遍历
• 注意事项：增强for的目标要判断是否为null
• 注意新式for循环，你在迭代集合的途中，不能增删元素，会报并发修改异常

可变参数的概述和使用

可变参数概述

定义方法的时候不知道该定义多少个参数

格式 ：修饰符 返回值类型 方法名(数据类型… 变量名){}

注意事项

• 这里的变量其实是一个数组
• 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

public class MyTest {
    public static void main(String[] args) {
        int a=sum(1,2,3,4,5,6,7,8,9);
        System.out.println(a);
    }
    //可变参数，一次可以接收多个同类型的参数
    //可变参数 本质是是个数组
    //如果一个方法的形参有多个参数，那么可变参数，应该是最后一个
    public static int sum(int...a){
        int t=0;
        for (int i : a) {
            t+=i;
        }
        return t;
    }
}

Arrays工具类的asList()方法的使用

• asList（T…t）：将数组转换成集合
• 注意事项：得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)，只能获取元素(get)

public class MyTest {
    public static void main(String[] args) {
        int[] ints = new int[3];
        ints[0] = 1;
        ints[1] = 2;
        ints[2] = 3;
        //集合长度不可变，不能add（）和remove（），只能get（）
        List<int[]> i = Arrays.asList(ints);
    }
}

集合嵌套之ArrayList嵌套ArrayList

需求：我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生

• 集合嵌套之ArrayList嵌套ArrayList

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 +

                '}';
    }
}

import java.util.ArrayList;
import java.util.Iterator;
public class MyTest {
    public static void main(String[] args) {
        //创建java班集合
        ArrayList<Student> javaClass = new ArrayList<>();
        javaClass.add(new Student("鹿秀儿", 22));
        javaClass.add(new Student("王秀儿", 25));
        javaClass.add(new Student("李秀儿", 18));
        //创建web班集合
        ArrayList<Student> webClass = new ArrayList<>();
        webClass.add(new Student("钱秀秀", 19));
        webClass.add(new Student("赵秀秀", 24));
        webClass.add(new Student("段秀秀", 23));
        //定义大的集合
        ArrayList<ArrayList<Student>> maxClass = new ArrayList<>();
        maxClass.add(javaClass);
        maxClass.add(webClass);
        //使用迭代器进行遍历
        //遍历大的集合
        Iterator<ArrayList<Student>> iterator = maxClass.iterator();
        while (iterator.hasNext()){
            ArrayList<Student> next = iterator.next();
            //遍历小集合
            Iterator<Student> studentIterator = next.iterator();
            while (studentIterator.hasNext()){
                Student next1 = studentIterator.next();
                System.out.println(next1);
                //Student{name='鹿秀儿', age=22}
                //Student{name='王秀儿', age=25}
                //Student{name='李秀儿', age=18}
                //Student{name='钱秀秀', age=19}
                //Student{name='赵秀秀', age=24}
                //Student{name='段秀秀', age=23}
            }
        }
    }
}

完