泛型的习题巩固

泛型的习题巩固

(文章中的习题均来自梁勇的Java语言设计（进阶篇）)

19-1

修改程序清单19-1中的GenericStack类，使用数组而不是ArrayList来实现它。你应该在栈添加新元素之前检查数组的大小。如果数组满了，就创建一个新的数组，该数组是当前数组大小的两倍，然后将当前数组的元素复制到新数组中。

package Test;

public class GenericStack191<E> {
	//运用泛型类
	private E[] list=(E[])new Object[100];//将ArrayList改成数组，注意此处是上篇文章中泛型的限制里提到的不能使用new E（）
	private int size=0;
	
	public int getSize()//原始数组的长度
	{
		return size;
	}
	
	public int getArrayLength()//数组的最大长度
	{
		return list.length;
	}
	
	public E peek()
	{
		if(size==0)
		{
			System.out.println("The stack is empty");
			return null;
		}
		return list[size-1];
	}
	
	public void push(E o)//插入元素o
	{
		
		if(size>=list.length)//插满的情况下
		{
			E[] newList=(E[])new Object[2*list.length];//定义一个新数组，长度为原来的两倍
			for(int i=0;i<list.length;i++)
			{
				newList[i]=list[i];//将原始数组复制到新数组
			}
			newList[size]=o;
			list=newList;
		}
		else
		{
			list[size]=o;
		}
		size=size+1;
	}
	
	public E pop()//返回最后一个数组元素
	{
		E o=list[size-1];
		size=size-1;
		return o;
	}
	
	public static void main(String[] args) {
		GenericStack191<Integer> list1=new GenericStack191<Integer>();//泛型类，在类名之后
		for(int i=0;i<100;i++)
		{
			list1.push(i);
		}
		System.out.println(list1.getSize());//当前数组的长度（元素个数）
		System.out.println(list1.getArrayLength());//当前数组最大的长度
		list1.push(100);//插入的元素
		System.out.println(list1.getSize());//插入后元素的个数
		System.out.println(list1.getArrayLength());//插入后数组最大的长度，是原来的两倍
	}
}

19-3

编写以下方法，返回一个新的ArrayList。新的列表中包含来自原列表中的不重复元素。
public static ArrayList removeDuplicates(ArrayList list)

19-6

编写一个泛型方法，返回二维数组中的最大元素。
public static <E extends Comparable<? super E>> E max(E[][] list)

19-8

编写以下方法，打乱ArrayList。
public static void shuffle(ArrayList list)

将19-3,19-6，19-8一起编写。

```java
package Test;

import java.util.ArrayList;
import java.util.Random;

public class Generic19368 {

	public static <E> ArrayList<E> removeDuplicates(ArrayList<E> list)
	{
		ArrayList<E> newList=new ArrayList<E>();
		for(E temp:list)
		{
			if(!newList.contains(temp))newList.add(temp);
		}
			return newList;
	}//19-3

	public static <E extends Comparable<? super E>> E max(E[][] list)
	{
		E max=list[0][0];
		for(int i=0; i<list.length;i++)
		{
			for(int j=0;j<list[i].length;j++)
			{
				if(max.compareTo(list[i][j])<0)
				{
					max=list[i][j];
				}
			}
		}
		return max;
	}//19-6

	public static <E> void shuffle(ArrayList<E> list)
	{
		Random random=new Random();
		for(int i=0;i<list.size();i++)
		{
			int index=random.nextInt(list.size());
			E temp=list.get(index);
			list.remove(index);
			list.add(temp);
		}
	}//19-8

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		//测试19.3，返回新列表，包括原列表中不重复元素
		ArrayList<Integer> list=new ArrayList<Integer>();
		list.add(3);
		list.add(6);
		list.add(1);
		list.add(2);
		list.add(2);

		System.out.println(list);
		System.out.println(removeDuplicates(list));

		//测试19.6，返回二维数组中最大的元素
		Integer[][]matirx= {{2,4,5},{87,23,45},{34,1,6}};
		System.out.println(max(matirx));

       //测试19.8，打乱ArrayListd的元素顺序
		ArrayList<Integer> list1=new ArrayList<Integer>();
		list1.add(1);
		list1.add(2);
		list1.add(3);
		list1.add(4);
		list1.add(5);
		System.out.println(list1);//输出打乱前
		shuffle(list1);
		System.out.println(list1);//输出打乱后
	}
}