Java数据结构-基于数组的栈和泛型
泛型可以参数化变量的类型
当你需要用不同类型的基本类型变量来调用构造方法时你需要泛型
public class Test {
public static void main(String[] args) {
A a=new A("a");
System.out.println(a.e);
A a1=new A(10);
System.out.println(a1.e);
}
}
class A<E>{
E e;
public A(E e){
this.e=e;
}
public E getE(){
return e;
}
}
输出结果：
a
10
如果不满意 你可以使用两个泛型 你甚至可以使用一个数组或者自定义的类
/**
* Created by root on 16-2-23.
*/
public class Test {
public static void main(String[] args) {
A a=new A("a");
System.out.println(a.e);
a.setT(new int[]{1,2,3});//你可以在这里赋给t一个数组或者以个自定义类
A a1=new A();
a1.setT(new B());//赋给a2的成员t一个B类对象
}
}
class A<E,T>{
E e;
T t;
public A(){
}
public A(E e){
this.e=e;
}
public E getE(){
return e;
}
public void setT(T t){
this.t=t;
}
public T getT(){
return t;
}
}
class B{
int b=10;
}
debug结果
有时你需要对泛型作出一些约束以免发生错误溢出
public class Test {
public static void main(String[] args) {
A<String,String> a=new A();//对泛型作出一些约束 让它只能接受String类型
A a2=new A<String,String>();//同样的约束 但是要约束的参数要紧跟类名
a.setT("a");//正确的方法
//a.setT(10); 出现报错
}
}
class A<E,T>{
E e;
T t;
public A(){
}
public A(E e){
this.e=e;
}
public E getE(){
return e;
}
public void setT(T t){
this.t=t;
}
public T getT(){
return t;
}
}
class B{
int b=10;
}
虽然java不能直接声明泛型数组 但是可以利用泛型自己写一个泛型数组类
public class ArrayType<T> {
private int index;
private int length;
T[] data;
private T el;
public ArrayType(int length){//根据长度初始化数组
this.length=length;
data=(T[])(new Object[length]);
}
public void setEl(int thatIndex,Object el){//根据索引赋值 变量的类型可以使任意的
if(thatIndex<length){
data[thatIndex]=(T)el;
}
}
public T getEl(int thatIndex){//根据索引获取元素的值
if(thatIndex<length){
return data[thatIndex];
}
else {
return data[0];
}
}
}
test class
public class Test {
public static void main(String[] args){
ArrayType a=new ArrayType(3);
a.setEl(0,23);
a.setEl(1,"dd");
a.setEl(2,true);
}
}
debug结果：
加入一些变长的功能
public class ArrayType<T> {
private int index;
private int length;
T[] data;
private T el;
public ArrayType(int length){
this.length=length;
data=(T[])(new Object[length]);
}
public void setEl(int thatIndex,Object el){
if(thatIndex<length){
data[thatIndex]=(T)el;
}
else {
stretch(thatIndex+1);//如果数组越界 执行复制
data[thatIndex]=(T)el;
}
}
public T getEl(int thatIndex){
if(thatIndex<length){
return data[thatIndex];
}
else {
stretch(thatIndex+1);//如果数组越界 执行赋值 并返回null
return data[thatIndex];
}
}
protected void stretch(int thatLength){
T[] newdata=(T[])(new Object[thatLength]);//定义一个thatLength的数组
for(int i=0;i<this.length;i++){ //把data内所有元素复制到data里
newdata[i]=data[i]; //
}
data=newdata;
}
}
有了以上基础 可以实现一个简单的数组栈
public interface Stack<E> {
public boolean isEmpty();
public E peek();
public E pop();
public void push(E target);
}
import java.util.EmptyStackException;
import java.util.Objects;
/**
* Created by root on 16-2-24.
*/
public class ArrayStack<E> implements Stack {//实现栈的interface
private E[] data; //可以获得数组长度
private int size; //用于判断栈顶的索引
public ArrayStack(){
data=(E[])(new Object[1]);//初始化的栈具有一个null类型 size的值为0 size-1是栈顶的索引
size=0;
}
public boolean isEmpty(){
return size==0; //判断栈是否为空
}
public Object pop(){
if (isEmpty()){
throw new EmptyStackException();//如果栈为空 那就报错
}
size--; //如果栈不为空
return data[size]; //弹出栈顶
}
public Object peek(){
if(isEmpty()){
throw new EmptyStackException();//如果栈为空 报错
}
return data[size-1];//返回栈顶
}
protected boolean isFull(){//栈满了？
return size ==data.length;
}
public void push(Object target){
if (isFull()){//如果栈满了 执行扩栈
stretch();
}
data[size]= (E) target;//如果栈没有满 把target压入栈顶
size++;
}
protected void stretch(){//将原数组的长度扩大两倍 扩大栈的长度
E[] newData=(E[])(new Object[data.length*2]);
for(int i=0;i<data.length;i++){
newData[i]=data[i];
}
data=newData;
}
}
