Java作业8-泛型和模板类

编程1

题目

自定义堆栈类

用泛型数组实现自定义堆栈类GenericStack，可处理任意类型数据。

堆栈类中包含三个成员，一为泛型类型数组list，保存栈中元素，一为整型成员length表示数组的长度，一为整型成员count表示当前栈中元素个数。

其中堆栈类功能中要求至少包含以下几点：

不带参数构造方法和带一个长度参数构造方法，堆栈的初始长度为10
入栈push操作和出栈pop操作
访问栈顶元素peek方法
获得栈中当前保存元素数size方法
判断当前栈是否为空isEmpty方法
printStack方法，显示堆栈中保存的所有元素，元素之间以空格分割，最后一个元素后无空格

定义一测试方法，可分别构建整数类型、浮点类型、字符串类型堆栈进行测试，对每个栈自行调用上述至少三种方法实现操作，并显示堆栈中元素

代码

import java.util.*;
public class GenericStack<E>{
	//数据
	private E[] list;
	private int length;//数组长度
	private int count;//栈中元素个数
	//构造
	public GenericStack(){
		length = 10;
		list = (E[])(new Object[ length ]);
	}
	
	public GenericStack( int length ){
		this.length = length;
		list = (E[])(new Object[ length ]);
	}
	//方法
	public void push( E num ){
		list[count++] = num;
	}
	
	public E pop(){
		E num = list[ --count ];
		return num;
	}
	
	public E peek(){
		return list[count-1];
	}
	
	public boolean isEmpty(){
		return count==0;
	}
	
	public void printStack() {
		for(int i = 0;  i < count - 1; i++) {
			System.out.print(this.list[i] + " ");
		}
		System.out.print(this.list[this.count-1]);
		System.out.println();
	}
	
	public static void main( String[] args ){
		GenericStack<Integer> stack = new GenericStack<Integer>( );
		for(int i = 0; i < 10; i++) {
			stack.push(i);
		}
		System.out.println("stack栈：");
		stack.printStack();
		System.out.println("stack是否为空："+ stack.isEmpty());
		System.out.println("stack栈顶元素是：" + stack.peek());
		
		GenericStack<Float> stack1 = new GenericStack<Float>(11);
		stack1.push(1.1F);
		stack1.push(2.2F);
		stack1.push(3.3F);
		System.out.println("stack1栈：");
		stack1.printStack();
		System.out.println("出栈元素是：" + stack1.pop());
		stack1.peek();
		System.out.println("出栈后的栈顶元素是：" + stack1.peek());
		
		GenericStack<String> stack2 = new GenericStack<String>(12);
		stack2.push("好好学习，");
		stack2.push("天天向向上。");
		stack2.push("你们就像是早晨八九点钟的太阳。");
		System.out.println("stack2栈：");
		stack2.printStack();
		System.out.println("出栈元素是：" + stack2.pop());
		System.out.println("stack2栈出栈后：");
		stack2.printStack();
	}
}

stack栈：
0 1 2 3 4 5 6 7 8 9
stack是否为空：false
stack栈顶元素是：9
stack1栈：
1.1 2.2 3.3
出栈元素是：3.3
出栈后的栈顶元素是：2.2
stack2栈：
好好学习， 天天向向上。 你们就像是早晨八九点钟的太阳。
出栈元素是：你们就像是早晨八九点钟的太阳。
stack2栈出栈后：
好好学习， 天天向向上。

编程2

题目

泛型数组操作

利用泛型定义一数组操作类GenericOperator，操作对象为数值类型数组，其中数值类型包括Integer, Short, Byte, Double, Float等。

在操作类中提供若干静态方法，实现对任意数值类型数组的下述操作，

1. 求平均值 averageValue(T[] t)

2. 求数组最大元素 maxElement(T[] t)

3. 对数组元素采用冒泡方法进行排序 bubbleSort(T[] t)

4. 对数组元素利用选择排序方法进行排序 selectionSort(T[] t)

5. 求两长度相同数组的和(对应元素的和) arraySum(T[] ta, T[] tb)

6. 输出数组元素 print(T[] list)

在此基础上定义测试类，测试各方法功能是否正常

代码

class GenericOperator <T extends Number> {

	public static <T extends Number> double averageValue(T[] array) {
        double sum = 0;
        for (T item : array) {
            sum += item.doubleValue(); //xxxValue() 方法用于将 Number 对象转换为 xxx 数据类型的值并返回
        }
        return sum / array.length;
    }
	
	public static <T extends Comparable<T>> T maxElement(T[] array) { //Comparable是个接口
        T max = array[0];
        for (T item : array) {
            if (item.compareTo(max) > 0) { //compareTo()方法
                max = item;
            }
        }
        return max;
    }
	
	public static <T extends Comparable<T>> void bubbleSort(T[] array) { //从小到大
		boolean flag;
		for( int i = 0; i < array.length -1; i++ ) {循环n-1轮
			flag = false; //元素是否发生交换的标志
			for( int j = array.length - 1; j > i; j-- ) {
				if(array[j].compareTo(array[j-1]) < 0 ) { //等价于：if(array[j] < array[j-1]);
					T temp = array[j-1];
					array[j-1] = array[j];
					array[j] = temp;
					flag = true;
				}	
			}
			if(false == flag) //如果一趟比较没有发生任何交换，说明有序，提前结束排序
				return;
		}
	}
	
	public static <T extends Comparable<T>> void selectionSort(T[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j].compareTo(array[minIndex]) < 0) {
                    minIndex = j;
                }
            }
            T temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
    }
	
	public static <T extends Number> Number[] arraySum(T[] a, T[] b) {
        Number[] arraysum = new Number[a.length];
		for( int i = 0; i < a.length; i++ ){
            arraysum[i] = a[i].doubleValue() + b[i].doubleValue();
        }
		return arraysum;
    }
	
	public static <T> void print(T[] array) {
        for (T item : array) {
            System.out.print(item + " ");
        }
		System.out.println();
    }
}
public class Test {
	
	public static void main( String[] args ) {
		Integer[] integer = {5, 4, 3, 2, 1};
		System.out.println("integer的平均值为：" + GenericOperator.averageValue(integer));
		System.out.println("integer的最大值为：" + GenericOperator.maxElement(integer));
		GenericOperator.bubbleSort(integer);
		System.out.print("integer冒泡排序从小到大排：");
		GenericOperator.print(integer);
		
		System.out.println();
		
		Double[] Double = {9.9, 8.8, 7.7, 6.6, 5.5};
		System.out.println("Double的平均值为：" + GenericOperator.averageValue(Double));
		System.out.println("Double的最大值为：" + GenericOperator.maxElement(Double));
		GenericOperator.selectionSort(Double);
		System.out.print("double选择排序从小到大排：");
		GenericOperator.print(Double);
				
		System.out.println();
				
	    Number[] arraysum = GenericOperator.arraySum(integer,Double);
		System.out.print("integer + Double：");
		GenericOperator.print(arraysum);
	}
}

integer的平均值为：3.0
integer的最大值为：5
integer冒泡排序从小到大排：1 2 3 4 5

Double的平均值为：7.7
Double的最大值为：9.9
double选择排序从小到大排：5.5 6.6 7.7 8.8 9.9

integer + Double：6.5 8.6 10.7 12.8 14.9