编程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
编程3
无
声明：放五一假没来的及做完，系统就给我自动提交了
编程4
无
声明：放五一假没来的及做完，系统就给我自动提交了