泛型编程
Java的泛型编程:
1.所写的代码可以处理任何的类型
2.Java1~Java4时期Java并不支持泛型编程 ————直到Java5开始才支持泛型编程
泛型编程的本质意义:
1.能够检测参数的类型是否正确,合法
2.自动类型转换,避免用户手动类型转换
Java泛型的类型擦除机制
在编译阶段,Java编译器通过泛型类型进行类型检查和自动类型转换,处理完成后,就会把T类型一直往上擦除,直到上届(Object)
实例1:
public class GenericTest<T> {
// 定义数组
private T[] array;
// 定义有效元素的大小
private int size;
public GenericTest(int size){
this.array = (T[])new Object[size];
this.size = 0;
}
public GenericTest(){
this(10);
}
public void add(T data){
if(this.size == this.array.length){
this.array = Arrays.copyOf(this.array, this.array.length*2);
}
this.array[this.size++] = data;
}
public T get(){
if(this.size == 0){
return null;
}
return this.array[this.size-1];
}
public static void main(String[] args) {
GenericTest<Integer> test = new GenericTest<Integer>();
test.add(10);
test.add(30); // Java的泛型可以进行类型的检查
System.out.println(test);
int data = test.get(); // Java的泛型可以做类型自动转换
System.out.println(data);
}
}
实例2:
描述: 输出一个泛型的顺序栈实现 构造函数,入栈push,出栈pop,获取栈顶元素peek栈空empty,栈满full
public class GenericStack<T> {
// 定义存储顺序栈元素的数组
private T[] stack;
// 标识栈顶位置的下标
private int top;
/**
* 按传入的参数size初始化数组大小
*
* @param size
*/
public GenericStack(int size) {
this.stack = (T[]) new Object[size];
this.top = -1;
}
public GenericStack() {
this(10);
}
/**
* 入栈操作
*
* @param val
*/
public void push(T val) {
if (full()) {
this.stack = Arrays.copyOf(this.stack, this.stack.length * 2);
}
this.stack[++this.top] = val;
}
/**
* 出栈操作,并返回出栈的元素
*
* @return
*/
public T pop() {
if (empty()) {
return null;
}
T oldVal = this.stack[this.top];
this.stack[this.top] = null; // GC能够回收出栈的对象!!!
--this.top;
return oldVal;
}
/**
* 查看栈顶元素
*
* @return
*/
public T peek() {
if (empty()) {
return null;
}
return this.stack[this.top];
}
/**
* 返回栈元素的个数
*
* @return
*/
public int size() {
return this.top + 1;
}
/**
* 判断栈满
*
* @return
*/
public boolean full() {
return this.top == this.stack.length - 1;
}
/**
* 判断栈空
*
* @return
*/
public boolean empty() {
return this.top == -1;
}
在泛型顺序栈中定义一个class类Student定义一个学生类,提供相应的构造函数重写toString方法 id,name,age信息打印出来成员变量提供get和set的标准方法
class Student implements Comparable<Student> {
private Integer id;
private String name;
private Integer age;
public Student(Integer id, String name, Integer age) {
this.id = id;
this.name = name;
this.age = age;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student o) {
return this.name.compareTo(o.name);
}
}
通过Comparator接口实现学生信息的不同顺序输出
public static void main(String[] args) throws InterruptedException {
GenericStack<Student> s = new GenericStack<>();
s.push(new Student(1000, "zhang san", 26));
s.push(new Student(3030, "liu bai", 28));
s.push(new Student(2020, "du fu", 25));
Student[] stus = new Student[s.size()];
for (int i = 0; !s.empty(); ++i) {
stus[i] = s.pop();
}
Arrays.sort(stus);
System.out.println(Arrays.toString(stus));
Arrays.sort(stus, (a, b)->{return a.getName().compareTo(b.getName());}); // Comparator接口
System.out.println(Arrays.toString(stus));
Arrays.sort(stus, (a, b)->{return -a.getAge().compareTo(b.getAge());}); // Comparator接口 int compare(T a, T b)
System.out.println(Arrays.toString(stus));
Arrays.sort(stus, (a, b)->{return -a.getId().compareTo(b.getId());}); // Comparator接口 int compare(T a, T b)
System.out.println(Arrays.toString(stus));
}