Day10-Java进阶-泛型&数据结构(树)&TreeSet 集合

码里码理~

于 2024-04-21 19:45:44 发布

阅读量372

点赞数 4

分类专栏： JavaEE 文章标签： java 数据结构开发语言

本文链接：https://blog.csdn.net/weixin_68063226/article/details/137374680

版权

JavaEE 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1. 泛型

1.1 泛型介绍

package com.itheima.generics;

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

public class GenericsDemo1 {
    /*
        泛型介绍 : JDK5引入的, 可以在编译阶段约束操作的数据类型, 并进行检查

        注意 : 泛型默认的类型是Object, 且只能接引用数据类型

        泛型的好处:
                    1. 统一数据类型
                    2. 将运行期的错误提升到了编译期

        泛型的学习路径:
                    1. 泛型类
                    2. 泛型方法
                    3. 泛型接口
                    4. 泛型通配符
                    5. 泛型的限定
     */
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");

        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object o = it.next();
            String s = (String) o;
            System.out.println(s.length());
        }
    }
}

1.2 泛型类

package com.itheima.generics;

import java.util.ArrayList;

public class GenericsDemo2 {
    /*
        常见的泛型标识符 : E V K T

            E : Element
            T : Type
            K : Key(键)
            V : Value(值)

        清楚不同的泛型, 在什么时机能确定到具体的类型

        泛型类 : 创建对象的时候
     */
    public static void main(String[] args) {
        Student<Integer> stu = new Student<>();

    }
}

class Student<E> {

    private E e;

    public E getE() {
        return e;
    }

    public void setE(E e) {
        this.e = e;
    }
}

1.3 泛型方法

package com.itheima.generics;

public class GenericsDemo3 {
    /*
        泛型方法
                1. 非静态的方法 : 内部的泛型, 会根据类的泛型去匹配
                2. 静态的方法 : 静态方法中如果加入了泛型, 必须声明出自己独立的泛型
                                    - 时机: 在调用方法, 传入实际参数的时候, 确定到具体的类型
     */
    public static void main(String[] args) {

        String[] arr1 = {"张三", "李四", "王五"};
        Integer[] arr2 = {11, 22, 33};
        Double[] arr3 = {11.1, 22.2, 33.3};

        printArray(arr1);
        printArray(arr2);
        printArray(arr3);

    }

    public static <T> void printArray(T[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length - 1; i++) {
            System.out.print(arr[i] + ", ");
        }
        System.out.println(arr[arr.length - 1] + "]");
    }
}

1.4 泛型接口

package com.itheima.generics;

import java.util.ArrayList;
import java.util.List;

public class GenericsDemo4 {
    /*
        泛型接口
            1. 实现类, 实现接口的时候确定到具体的泛型
            2. 实现类实现接口, 没有指定具体类型, 就让接口的泛型, 跟着类的泛型去匹配
     */
    public static void main(String[] args) {
        InterBIml<String> i = new InterBIml<>();
    }
}

interface Inter<E> {
    void show(E s);
}

class InterAIml implements Inter<String>{

    @Override
    public void show(String s) {

    }
}

class InterBIml<E> implements Inter<E>{

    @Override
    public void show(E e) {

    }
}

1.5 泛型通配符

package com.itheima.generics;

import java.util.ArrayList;

public class GenericsDemo5 {
    /*
        泛型通配符

                ? : 任意类型

                ? extends E : 可以传入的是E, 或者是E的子类

                ? super E : 可以传入的是E, 或者是E的父类
     */
    public static void main(String[] args) {

        ArrayList<Coder> list1 = new ArrayList<>();
        list1.add(new Coder());

        ArrayList<Manager> list2 = new ArrayList<>();
        list2.add(new Manager());

        ArrayList<String> list3 = new ArrayList<>();
        list3.add("abc");

        ArrayList<Object> list4 = new ArrayList<>();
        list4.add("aaa");

        //method(list1);    // 编译错误
        //method(list2);    // 编译错误
        //method(list3);    // 编译错误
        method(list4);      // 编译正常

    }

    // 可以传入Employee及其子类
    public static void method(ArrayList<? super Employee> list){
        for (Object o : list) {
            Employee e = (Employee) o;
            e.work();
        }
    }

}

abstract class Employee{
    private String name;
    private double salary;


    public Employee() {
    }

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    public abstract void work();

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return salary
     */
    public double getSalary() {
        return salary;
    }

    /**
     * 设置
     * @param salary
     */
    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String toString() {
        return "Employee{name = " + name + ", salary = " + salary + "}";
    }
}

class Coder extends Employee{

    @Override
    public void work() {
        System.out.println("程序员写代码...");
    }
}

class Manager extends Employee{

    @Override
    public void work() {
        System.out.println("项目经理分配任务...");
    }
}

2. 数据结构(树)

2.1 树的介绍

2.1 平衡二叉树

2.1.1 左旋

2.1.2 右旋

2.1.3 左左旋

2.1.4 左右旋

2.1.5 右右旋

2.1.6 右左旋

2.2 红黑树

当每次添加节点的颜色是黑色

当每次添加节点的颜色是红色

3. TreeSet 集合

3.1 TreeSet 集合元素排序介绍

package com.itheima.set;

import java.util.TreeSet;

public class TreeSetDemo1 {
    /*
        TreeSet集合的特点体验 : 排序, 去重
     */
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<>();
        ts.add("a");
        ts.add("d");
        ts.add("e");
        ts.add("c");
        ts.add("b");
        ts.add("b");
        ts.add("b");

        System.out.println(ts);

    }
}

以下以返回值全为 -1 (倒序排序为例)

3.2 TreeSet 排序 (自然排序)

package com.itheima.domain;

public class Student implements Comparable<Student>{

    // this.xxx - o.xxx 正序
    // o.xxx - this.xxx 降序
    @Override
    public int compareTo(Student o) {
        // 根据年龄做主要排序条件
        int ageResult = this.age - o.age;
        // 根据姓名做次要排序条件
        int nameResult = ageResult == 0 ? o.name.compareTo(this.name) : ageResult;
        // 判断姓名是否相同
        int result = nameResult == 0 ? 1 : nameResult;
        return result;
    }

    private String name;
    private int age;

    public Student() {
    }

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

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


}

package com.itheima.set;

import com.itheima.domain.Student;

import java.util.TreeSet;

public class TreeSetDemo2 {
    /*
        TreeSet集合存储Student学生对象

                compareTo 方法的返回值 :

                0 : 只有王五,25
                1 : 正序排列
                -1 : 倒序排序
     */
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>();

        ts.add(new Student("王五", 25));
        ts.add(new Student("王五", 25));
        ts.add(new Student("王五", 25));
        ts.add(new Student("王五", 25));

        System.out.println(ts);
    }
}

3.3 TreeSet 排序 (比较器排序)

package com.itheima.set;

import com.itheima.domain.Student;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo3 {
    /*
        如果同时具备比较器和自然排序, 会优先按照比较器的规则, 进行排序操作.
     */
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int ageResult = o1.getAge() - o2.getAge();
                return ageResult == 0 ? o1.getName().compareTo(o2.getName()) : ageResult;
            }
        });

        ts.add(new Student("赵六", 26));
        ts.add(new Student("李四", 24));
        ts.add(new Student("张三", 23));
        ts.add(new Student("王五", 25));

        System.out.println(ts);
    }
}

package com.itheima.set;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo4 {
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.length() - o1.length();
            }
        });

        ts.add("aa");
        ts.add("aaaaaaaa");
        ts.add("aaa");
        ts.add("a");

        System.out.println(ts);
    }
}