JAVASE(13)List集合接口的三个子类

Keyword：

• List集合
  • Arraylist
  • Vector
  • Linklist
• 泛型(Generic)
• 增强for循环
• 可变参数

Arraylist

ArrayList存储字符串并遍历

​ JDK1.8新增的一个方法也能遍历集合
​ void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable直到所有元素都被处理或操作抛出异常

案例演示:ArrayList存储字符串并遍历
迭代器
普通for

public class Demo {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //迭代器
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            Object next = listIterator.next();
            System.out.println(next);
        }
        //普通for
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }
    }
}

ArrayList存储自定义对象并遍历

案例演示:ArrayList存储自定义对象并遍历
迭代器
普通for

public class Student {
    int age;
    String name;
    public Student() {
    }
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
public class Demo {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Student(20,"学生一"));
        list.add(new Student(22,"学生二"));
        list.add(new Student(24,"学生三"));
        //迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
        //普通for
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.println(o);
        }
    }
}

Vector类

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

Vector的特有功能

​ public void addElement(E obj)添加对象
​ public E elementAt(int index)根据索引提取对象
​ public Enumeration elements()Vector特有的迭代器

LinkedList类

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

LinkedList类特有功能
public void addFirst(E e)及addLast(E e)在集合的最开始/后添加对象
public E getFirst()及getLast()获取集合中最开始/最后的对象
public E removeFirst()及public E removeLast()删除集合中最开始/最后的对象

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

代码：

//分析：栈数据结构的特点是先进后出
public class Myclass {
    LinkedList list = null;//将集合制空
    public Myclass() {
        list = new LinkedList();
    }//在空参构造里面对Linklist类指向
    public <T> void setList(T ele) {
        list.addFirst(ele);
    }//获取将每一个进入集合的元素，放在最前面
    public Object getlist() {
        Object pop = list.pop();
        //获取集合中最前面的元素并删除
        list.addLast(pop);
        //将最前面的元素放在集合的最后
        return pop;
    }
}
public class test {
    public static void main(String[] args) {
        Myclass myclass = new Myclass();
        myclass.setList("aaa");
        myclass.setList("bbb");
        myclass.setList("ccc");
        System.out.println(myclass.getlist());
        System.out.println(myclass.getlist());
        System.out.println(myclass.getlist());
        System.out.println(myclass.getlist());
    }
}
ccc
bbb
aaa
ccc

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

public class MyTest3 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(30);
        list.add(10);
        list.add(109);
        list.add(30);
        //去除掉集合中的重复元素，要求是不能创建新的容器，就在list集合中操作，去掉重复元素
        //选择排序
        deleteEle(list);
        System.out.println(list);
    }
    private static void deleteEle(ArrayList list) {
        for (int i = 0; i < list.size(); i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(i).equals(list.get(j))) {
                    list.remove(j);//根据索引删除掉这个元素
                    j--; //注意 j--
                }
            }
        }
    }
    //利用对象的从前往后查找的索引值与从后往前的索引值进行对比，利用递归的方法
 ArrayList list2 = removeEle(list);
        System.out.println(list2);
    }
    private static ArrayList removeEle(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);
                removeEle(list);
            }
        }
        return list;
    }
}

去除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 +
                '}';
    }

    @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);
    }
}
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("王五", 25));
        list.add(new Student("王五", 26));
        list.add(new Student("王五", 25));
        list.add(new Student("赵六", 26));
        ArrayList newList = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
           Student stu = (Student) list.get(i);
           if(!newList.contains(stu)){
               newList.add(stu);
           }
        }
        //遍历新集合
        for (int i = 0; i < newList.size(); i++) {
            System.out.println(newList.get(i));
        }
    }
}
//注意事项：重写equals()方法

泛型

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

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

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

  例如：LinkedList<E> list = new LinkedList<E>();     <E>就是泛型
  

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

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

public class Demo1 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
        }
    }
}

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

泛型的由来:

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

泛型类、变量、接口和方法

• 泛型类例如：public class A{ }
• 泛型变量例如：private 变量名
• 泛型接口：interface { }
• 泛型方法：public void function(T t){}
  使用泛型，可以提高代码的灵活性，类型未写死，可让客户定义

泛型高级之通配符

泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E: 向下限定，E及其子类
? super E: 向上限定，E及其父类

增强for

简化数组和Collection集合的遍历

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

idea的快捷键：arr . for

注意事项：增强for的目标要判断是否为null

案例演示:

public class Demo2 {
    public static void main(String[] args) {
        int arr[]={1,2,3,4,5,6};
        for (int i : arr) {
            System.out.println(arr[i]);
        }
    }
}

ArrayList存储字符串并遍历增强for版

public class Test1 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList();
        list.add("学生1");
        list.add("学生2");
        list.add("学生3");
        for (String s : list) {
            System.out.println(s);
        }
    }
}

ArrayList存储自定义对象并遍历增强for版

代码：

public class Student {
    private int age;
    private String name;

    public Student() {
    }

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    @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(age, name);
    }
}
public class Test1 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList();
        list.add(new Student(20,"学生一"));
        list.add(new Student(22,"学生二"));
        list.add(new Student(24,"学生三"));
        for (Student student : list) {
            System.out.println(student);
        }
    }
}

集合嵌套之ArrayList嵌套ArrayList

可以将Arraylist想象成一个二维的集合，对集合的遍历，可以想象成一个二维数组的遍历

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

代码如下：

public class Student {
    private int age;
    private String name;

    public Student() {
    }

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    @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(age, name);
    }
}


public class Test1 {
    public static void main(String[] args) {
        ArrayList<Student> list1 = new ArrayList();
        list1.add(new Student(20,"学生一"));
        list1.add(new Student(22,"学生二"));
        ArrayList<Student> list2 = new ArrayList<>();
        list2.add(new Student(24,"学生三"));
        list2.add(new Student(24,"学生四"));
        ArrayList<Student> list3 = new ArrayList<>();
        list3.add(new Student(24,"学生五"));
        list3.add(new Student(24,"学生六"));

        ArrayList<ArrayList<Student>> max = new ArrayList<>();
        //创建的泛型为<ArrayList<Student>>为集合的嵌套
        //<对象的类型>这时，类似于{{list1}，{list2}，{list3}}
        max.add(list1);
        max.add(list2);
        max.add(list3);
/*        普通for循环遍历
            for (int i = 0; i < max.size(); i++) {
            ArrayList<Student> students = max.get(i);
            for (int j = 0; j < students.size(); j++) {
                Student student = students.get(j);
                System.out.println(student.getAge() + "   " + student.getName());
            }
        }*/
        //增强for循环遍历
        for (ArrayList<Student> i:max){
            for (Student j:i){
                System.out.println(j.getAge()+"  "+j.getName());
            }
        }
    }
}

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

Arrays工具类的asList(T… t)方法的使用:将数组转换成集合

注意事项:得到的集合长度是不可变的 你不能往这个转换后的集合中 添加元素（add） 和 删除元素(remove)，只能获取元素(get)。

可变参数

可变参数概述:定义方法的时候不知道该定义多少个参数

格式: 修饰符 返回值类型 方法名(数据类型… 变量名){}
注意事项：
a:这里的变量其实是一个数组
b:如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

public static int add(int... a){
	// 定义一个累加变量
	int sum = 0 ;
	for(int s : a ){
		sum += s ;
	}
	return sum;
}