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