集合-进阶 - 技术栈

Collection

collection的遍历方式

迭代器遍历
- 不依赖索引

plain 复制代码

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class mycollection {
    public static void main(String[] args) {
        //1.创建集合并添加元素
        Collection<String> coll = new ArrayList();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");

        //2.获取迭代器对象
        //迭代器就好比是一个箭头，指向集合中的0索引处
        Iterator<String> it = coll.iterator();
        //3.利用循环不断的去获取集合中的每一个元素
        while(it.hasNext()) {
            //4.next方法夫人两件事情：获取元素并移动指针
            String str = it.next();
            System.out.println(str);
        }
    }
}

迭代器的细节注意点:

1.报错NoSuchElementException

2.迭代器遍历完毕,指针不会复位

3.循环中只能用一次next方法

4.迭代器遍历时,不能用集合的方法进行增加或者删除

增强for

java 复制代码

//快速生成方式：
//集合的名字+for回车
//1.创建集合并添加元素
collection<string> coll new arrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");
//2.利用增强for进行遍历
//注意点：
1/s其实就是一个第三方变量，在循环的过程中依次表示集合中的每一个数据
for(string s : coll){
     s "qqq"'
system.out.println(coll);//zhangsan lisi wangwu

List集合

删除元素

请问:此时删除的是1这个元素,还是1索引上的元素?

为什么?

因为在调用方法的时候,如果方法出现了重载现象

优先调用,实参跟形参类型一致的那个方法。

list.remove(1);

练习

java 复制代码

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;

public class mylist {
    public static void main(String[] args) {
        //1.创建列表并添加元素
        List<String> list = new ArrayList<String>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        //1.迭代器方式遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String str = it.next();
            System.out.println(str);
        }

        //2.增强for
        //下面的变量s，其实是一个第三方的变量而已
        //在循环的过程中，依次表示集合中的每一个元素
        for (String str : list) {
            System.out.println(str);
        }

        //3.Lambda表达式
        //forEach方法的底层启示就是一个循环遍历，依次得到集合的每一个元素
        //并把每一个元素传递给下面的accept方法
        //accept方法的形参s，依次表示集合的每一个元素
        list.forEach(s-> System.out.println(s));
    }
}

数据结构

栈

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

队列

队列特点：先进先出，后进后出
数据从后端进入队列模型的过程称为:入队列

数据从前端离开队列模型的过程称为:出队列

链表

链表中的结点是独立的对象,在内存中是不连续的,每个结点包含数据值和下一个结点的地址。
链表查询慢,无论查询哪个数据都要从头开始找。
链表增删相对快

ArrayList

底层源码

LinkedList集合

底层数据结构是双链表,查询慢,增删快,但是如果操作的是首尾元素,速度也是极快的。
LinkedList本身多了很多直接操作首尾元素的特有API。

泛型深入

统一数据类型。
把运行时期的问题提前到了编译期间,避免了强制类型转换可能出现的异常,因为在编译阶段类型就能确定下来。

泛型的细节

泛型中不能写基本数据类型
指定泛型的具体类型后,传递数据时,可以传入该类类型或者其子类类型

如果不写泛型,类型默认是Object

泛型可以在很多地方进行定义

泛型接口

泛型不具备继承性
此时,泛型里面写的是什么类型,那么只能传递什么类型的的数据

弊端:

利用泛型方法有一个小弊端,此时他可以接受任意的数据线类型

Ye Fu Zi Student

希望:本方法虽然不确定类型,但是以后我希望只能传递 Ye Fu Zi

此时我们就可以使用泛型的通配符:

?也表示不确定的类型

他可以进行类型的限定

?extendsE:表示可以传递E或者E所有的子类类型

?superE:表示可以传递E或者E所有的父类类型

TreeSet

java 复制代码

package TreeSetDemo;

import java.util.TreeSet;
import java.util.function.Consumer;

public class TreeSetDemo2 {
    public static void main(String[] args) {
        /*需求:创建5个学生对象
        属性:(姓名,年龄,语文成绩,数学成绩,英语成绩),
        按照总分从高到低输出到控制台
        如果总分一样,按照语文成绩排
        如果语文一样,按照数学成绩排
        如果数学成绩一样,按照英语成绩排
        如果英文成绩一样,按照年龄排
        如果年龄一样,按照姓名的字母顺序排
        如果都一样,认为是同一个学生,不存。
         */
        //默认排序

        //创建学生对象
        Student s1 = new Student("zhangsan",23,77,88,99);
        Student s2 = new Student("lisi",23,87,67,99);
        Student s3 = new Student("wangwu",23,67,85,78);
        Student s4 = new Student("zhaoliu",23,87,86,87);
        //创建集合
        TreeSet<Student> treeSet = new TreeSet<Student>();
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);

        //增强for
        for (Student t : treeSet) {
            System.out.println(t);
        }
    }
}

java 复制代码

package TreeSetDemo;

public class Student implements Comparable<Student>{
    private String name;
    private int age;
    private int chinese;
    private int math;
    private int english;

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

    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;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getEnglish() {
        return english;
    }

    public void setEnglish(int english) {
        this.english = english;
    }

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

    public Student() {
    }

    @Override
    public int compareTo(Student o) {
        int sum1 = this.getChinese() + this.getMath() + this.getEnglish();
        int sum2 = o.getChinese() + o.getMath() + o.getEnglish();

        int i = sum1 - sum2;
            i = i == 0 ? this.getChinese() - o.getChinese() : i;
            i = i == 0 ? this.getMath()- o.getMath() : i;
            i = i == 0 ? this.getEnglish()- o.getEnglish() : i;
            i = i ==0 ? this.getAge() - o.getAge() : i;
            i = i ==0 ? this.getName().compareTo(o.getName()) : i;

        return i;
    }
}