devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：羊村懒王 | 2024-04-25 17:30:07

赞

踩

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

1. 泛型

1.1 泛型介绍

  1. package com.itheima.generics;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5.  
  6. public class GenericsDemo1 {
  7.     /*
  8.         泛型介绍 : JDK5引入的, 可以在编译阶段约束操作的数据类型, 并进行检查
  10.         注意 : 泛型默认的类型是Object, 且只能接引用数据类型
  12.         泛型的好处:
  13.                     1. 统一数据类型
  14.                     2. 将运行期的错误提升到了编译期
  16.         泛型的学习路径:
  17.                     1. 泛型类
  18.                     2. 泛型方法
  19.                     3. 泛型接口
  20.                     4. 泛型通配符
  21.                     5. 泛型的限定
  22.      */
  23.     public static void main(String[] args) {
  24.         ArrayList<String> list = new ArrayList<>();
  25.         list.add("张三");
  26.         list.add("李四");
  27.         list.add("王五");
  28.  
  29.         Iterator it = list.iterator();
  30.         while (it.hasNext()) {
  31.             Object o = it.next();
  32.             String s = (String) o;
  33.             System.out.println(s.length());
  34.         }
  35.     }
  36. }

1.2 泛型类

  1. package com.itheima.generics;
  2.  
  3. import java.util.ArrayList;
  4.  
  5. public class GenericsDemo2 {
  6.     /*
  7.         常见的泛型标识符 : E V K T
  9.             E : Element
  10.             T : Type
  11.             K : Key(键)
  12.             V : Value(值)
  14.         清楚不同的泛型, 在什么时机能确定到具体的类型
  16.         泛型类 : 创建对象的时候
  17.      */
  18.     public static void main(String[] args) {
  19.         Student<Integer> stu = new Student<>();
  20.  
  21.     }
  22. }
  23.  
  24. class Student<E> {
  25.  
  26.     private E e;
  27.  
  28.     public E getE() {
  29.         return e;
  30.     }
  31.  
  32.     public void setE(E e) {
  33.         this.e = e;
  34.     }
  35. }

1.3 泛型方法

  1. package com.itheima.generics;
  2.  
  3. public class GenericsDemo3 {
  4.     /*
  5.         泛型方法
  6.                 1. 非静态的方法 : 内部的泛型, 会根据类的泛型去匹配
  7.                 2. 静态的方法 : 静态方法中如果加入了泛型, 必须声明出自己独立的泛型
  8.                                     - 时机: 在调用方法, 传入实际参数的时候, 确定到具体的类型
  9.      */
  10.     public static void main(String[] args) {
  11.  
  12.         String[] arr1 = {"张三", "李四", "王五"};
  13.         Integer[] arr2 = {11, 22, 33};
  14.         Double[] arr3 = {11.1, 22.2, 33.3};
  15.  
  16.         printArray(arr1);
  17.         printArray(arr2);
  18.         printArray(arr3);
  19.  
  20.     }
  21.  
  22.     public static <T> void printArray(T[] arr) {
  23.         System.out.print("[");
  24.         for (int i = 0; i < arr.length - 1; i++) {
  25.             System.out.print(arr[i] + ", ");
  26.         }
  27.         System.out.println(arr[arr.length - 1] + "]");
  28.     }
  29. }

1.4 泛型接口

  1. package com.itheima.generics;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. public class GenericsDemo4 {
  7.     /*
  8.         泛型接口
  9.             1. 实现类, 实现接口的时候确定到具体的泛型
  10.             2. 实现类实现接口, 没有指定具体类型, 就让接口的泛型, 跟着类的泛型去匹配
  11.      */
  12.     public static void main(String[] args) {
  13.         InterBIml<String> i = new InterBIml<>();
  14.     }
  15. }
  16.  
  17. interface Inter<E> {
  18.     void show(E s);
  19. }
  20.  
  21. class InterAIml implements Inter<String>{
  22.  
  23.     @Override
  24.     public void show(String s) {
  25.  
  26.     }
  27. }
  28.  
  29. class InterBIml<E> implements Inter<E>{
  30.  
  31.     @Override
  32.     public void show(E e) {
  33.  
  34.     }
  35. }

1.5 泛型通配符

  1. package com.itheima.generics;
  2.  
  3. import java.util.ArrayList;
  4.  
  5. public class GenericsDemo5 {
  6.     /*
  7.         泛型通配符
  9.                 ? : 任意类型
  11.                 ? extends E : 可以传入的是E, 或者是E的子类
  13.                 ? super E : 可以传入的是E, 或者是E的父类
  14.      */
  15.     public static void main(String[] args) {
  16.  
  17.         ArrayList<Coder> list1 = new ArrayList<>();
  18.         list1.add(new Coder());
  19.  
  20.         ArrayList<Manager> list2 = new ArrayList<>();
  21.         list2.add(new Manager());
  22.  
  23.         ArrayList<String> list3 = new ArrayList<>();
  24.         list3.add("abc");
  25.  
  26.         ArrayList<Object> list4 = new ArrayList<>();
  27.         list4.add("aaa");
  28.  
  29.         //method(list1);    // 编译错误
  30.         //method(list2);    // 编译错误
  31.         //method(list3);    // 编译错误
  32.         method(list4);      // 编译正常
  33.  
  34.     }
  35.  
  36.     // 可以传入Employee及其子类
  37.     public static void method(ArrayList<? super Employee> list){
  38.         for (Object o : list) {
  39.             Employee e = (Employee) o;
  40.             e.work();
  41.         }
  42.     }
  43.  
  44. }
  45.  
  46. abstract class Employee{
  47.     private String name;
  48.     private double salary;
  49.  
  50.  
  51.     public Employee() {
  52.     }
  53.  
  54.     public Employee(String name, double salary) {
  55.         this.name = name;
  56.         this.salary = salary;
  57.     }
  58.  
  59.     public abstract void work();
  60.  
  61.     /**
  62.      * 获取
  63.      * @return name
  64.      */
  65.     public String getName() {
  66.         return name;
  67.     }
  68.  
  69.     /**
  70.      * 设置
  71.      * @param name
  72.      */
  73.     public void setName(String name) {
  74.         this.name = name;
  75.     }
  76.  
  77.     /**
  78.      * 获取
  79.      * @return salary
  80.      */
  81.     public double getSalary() {
  82.         return salary;
  83.     }
  84.  
  85.     /**
  86.      * 设置
  87.      * @param salary
  88.      */
  89.     public void setSalary(double salary) {
  90.         this.salary = salary;
  91.     }
  92.  
  93.     public String toString() {
  94.         return "Employee{name = " + name + ", salary = " + salary + "}";
  95.     }
  96. }
  97.  
  98. class Coder extends Employee{
  99.  
  100.     @Override
  101.     public void work() {
  102.         System.out.println("程序员写代码...");
  103.     }
  104. }
  105.  
  106. class Manager extends Employee{
  107.  
  108.     @Override
  109.     public void work() {
  110.         System.out.println("项目经理分配任务...");
  111.     }
  112. }

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 集合元素排序介绍

  1. package com.itheima.set;
  2.  
  3. import java.util.TreeSet;
  4.  
  5. public class TreeSetDemo1 {
  6.     /*
  7.         TreeSet集合的特点体验 : 排序, 去重
  8.      */
  9.     public static void main(String[] args) {
  10.         TreeSet<String> ts = new TreeSet<>();
  11.         ts.add("a");
  12.         ts.add("d");
  13.         ts.add("e");
  14.         ts.add("c");
  15.         ts.add("b");
  16.         ts.add("b");
  17.         ts.add("b");
  18.  
  19.         System.out.println(ts);
  20.  
  21.     }
  22. }

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

3.2 TreeSet 排序 (自然排序)

  1. package com.itheima.domain;
  2.  
  3. public class Student implements Comparable<Student>{
  4.  
  5.     // this.xxx - o.xxx 正序
  6.     // o.xxx - this.xxx 降序
  7.     @Override
  8.     public int compareTo(Student o) {
  9.         // 根据年龄做主要排序条件
  10.         int ageResult = this.age - o.age;
  11.         // 根据姓名做次要排序条件
  12.         int nameResult = ageResult == 0 ? o.name.compareTo(this.name) : ageResult;
  13.         // 判断姓名是否相同
  14.         int result = nameResult == 0 ? 1 : nameResult;
  15.         return result;
  16.     }
  17.  
  18.     private String name;
  19.     private int age;
  20.  
  21.     public Student() {
  22.     }
  23.  
  24.     public Student(String name, int age) {
  25.         this.name = name;
  26.         this.age = age;
  27.     }
  28.  
  29.     /**
  30.      * 获取
  31.      * @return name
  32.      */
  33.     public String getName() {
  34.         return name;
  35.     }
  36.  
  37.     /**
  38.      * 设置
  39.      * @param name
  40.      */
  41.     public void setName(String name) {
  42.         this.name = name;
  43.     }
  44.  
  45.     /**
  46.      * 获取
  47.      * @return age
  48.      */
  49.     public int getAge() {
  50.         return age;
  51.     }
  52.  
  53.     /**
  54.      * 设置
  55.      * @param age
  56.      */
  57.     public void setAge(int age) {
  58.         this.age = age;
  59.     }
  60.  
  61.     public String toString() {
  62.         return "Student{name = " + name + ", age = " + age + "}";
  63.     }
  64.  
  65.  
  66. }
  1. package com.itheima.set;
  2.  
  3. import com.itheima.domain.Student;
  4.  
  5. import java.util.TreeSet;
  6.  
  7. public class TreeSetDemo2 {
  8.     /*
  9.         TreeSet集合存储Student学生对象
  11.                 compareTo 方法的返回值 :
  13.                 0 : 只有王五,25
  14.                 1 : 正序排列
  15.                 -1 : 倒序排序
  16.      */
  17.     public static void main(String[] args) {
  18.         TreeSet<Student> ts = new TreeSet<Student>();
  19.  
  20.         ts.add(new Student("王五", 25));
  21.         ts.add(new Student("王五", 25));
  22.         ts.add(new Student("王五", 25));
  23.         ts.add(new Student("王五", 25));
  24.  
  25.         System.out.println(ts);
  26.     }
  27. }

3.3 TreeSet 排序 (比较器排序)

  1. package com.itheima.set;
  2.  
  3. import com.itheima.domain.Student;
  4.  
  5. import java.util.Comparator;
  6. import java.util.TreeSet;
  7.  
  8. public class TreeSetDemo3 {
  9.     /*
  10.         如果同时具备比较器和自然排序, 会优先按照比较器的规则, 进行排序操作.
  11.      */
  12.     public static void main(String[] args) {
  13.         TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
  14.             @Override
  15.             public int compare(Student o1, Student o2) {
  16.                 int ageResult = o1.getAge() - o2.getAge();
  17.                 return ageResult == 0 ? o1.getName().compareTo(o2.getName()) : ageResult;
  18.             }
  19.         });
  20.  
  21.         ts.add(new Student("赵六", 26));
  22.         ts.add(new Student("李四", 24));
  23.         ts.add(new Student("张三", 23));
  24.         ts.add(new Student("王五", 25));
  25.  
  26.         System.out.println(ts);
  27.     }
  28. }

  1. package com.itheima.set;
  2.  
  3. import java.util.Comparator;
  4. import java.util.TreeSet;
  5.  
  6. public class TreeSetDemo4 {
  7.     public static void main(String[] args) {
  8.         TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
  9.             @Override
  10.             public int compare(String o1, String o2) {
  11.                 return o2.length() - o1.length();
  12.             }
  13.         });
  14.  
  15.         ts.add("aa");
  16.         ts.add("aaaaaaaa");
  17.         ts.add("aaa");
  18.         ts.add("a");
  19.  
  20.         System.out.println(ts);
  21.     }
  22. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/486460
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号