泛型
什么是受限泛型类型？
- 不能使用new E();
- 不能使用new e[];
- 静态方法中不允许类的参数是泛型；
- 异常类不能是泛型；
什么是原始类型？原始类型为什么是不安全的？为什么Java中允许使用原始类型？
什么是原始类型？
没有指定具体类型的泛型类和泛型接口被称为原始类型；
原始类型是不带类型参数的GenerStack和ArratList泛型类型属于原始类型
1.GenerStack stack = new GenerStack();
上语句等于
2.GenerStack stack=new GenerStack();
1就是原始类型。
为什么原始类型是不安全的？
因为原始类型的参数类型默认为object，有可能出现一个integer类型的参数输入到一个string类型的数组中，虽然编译不会报错但是这样是不对的。
为什么Java中允许使用原始类型？
因为在实际执行语句时，java在虚拟机中是没有泛型的，会将泛型转化为一个参数类型的强制转换，执行语句是原始类型。
什么是非受限通配？什么是受限通配？什么是下限通配？
非受限通配是 ？，即 ？Extends object，等级在object之下；
受限通配是 ？ Extends E，即 ？是E的子类或是E；
下限通配是 ？super E，即 ？是E的父类或者E；
什么是消除？为什么使用消除来执行Java语句？
消除就是将泛型转化为运行时可用的强制转换的原始类型。
为什么要使用消除来执行Java语句？因为泛型类型在运行时候是不可用的。
例19.1
import java.util.ArrayList;
public class GenericStack<E> {
private ArrayList<E> list = new ArrayList<>();
public int getSize() {
return list.size();
}
public E peek() {
return list.get(getSize() - 1);
}
public void push(E o) {
list.add(o);
}
public E pop() {
E o = list.get(getSize() - 1);
return o;
}
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public String toString() {
return "stack:" + list.toString();
}
}
课后题：
19.1
public class GenericStack<E> {
int n = 2;
private E list[] = (E[]) new Object[n];
// seeArray
public int see(E list[]) {
int acount = 0;
for (int i = 0; i < list.length ; i++) {
if (null != list[i]) {
acount++;
}
}
return acount;
}
// getSize
public int getSize() {
return see(list);
}
// peek
public E peek() {
return list[see(list) - 1];
}
// pop
public E pop() {
E a = list[see(list) - 1];
list[see(list) - 1] = null;
return a;
}
// isEmpty
public boolean isEmpty() {
if ((see(list) != 0))
return true;
return false;
}
// push
public void push(E o) {
if ((see(list)) == list.length) {
E newlist[] = (E[]) new Object[n<<1];
System.arraycopy(list, 0, newlist, 0, list.length);
list = newlist;
n=n<<1;
}
list[see(list) ] = o;
}
public String toString() {
return "stack" + list[0]+list[1]+list[2];
}
}
19.2
import java.util.*;
public class GenericStack1 {
public static void main(String[] args){
Genericstack<String> list = new Genericstack<>();
Scanner scan = new Scanner(System.in);
for(int i=0;i<5;i++){
String a =scan.nextLine();
list.add(a);
}
for(int i=0;i<5;i++){
System.out.println(list.get(list.size()-i-1));
}
}
}
class Genericstack<E> extends ArrayList{
}
19.3
import java.util.*;
public class test193 {
public static void main(String[] args){
ArrayList<Integer> list = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
for(int i=0;i<20;i++){
int a = scanner.nextInt();
list.add(a);
}
System.out.println(removeDuplicates(list));
}
public static <E> ArrayList<E> removeDuplicates(ArrayList<E> list){
for(int i=0;i<list.size();i++){
for(int j=i+1;j<list.size();j++){
if(list.get(i).equals(list.get(j))){
System.out.println(list.get(j));
list.remove(j);
}
}
}
return list;
}
}
19.6
public class test196 {
public static void main(String[] args) {
Integer list[][] = new Integer[4][3];
for (int i = 0; i < 4; i++)
for (int j = 0; j < 3; j++) {
list[i][j] = i + j;
System.out.println(list[i][j]);
}
System.out.println(max1(list));
}
public static <E extends Comparable<E>> E max1(E[][] list) {
E temp1 = null;
for (int i = 0; i < list[i].length; i++) {
for (int j = 0; j < list.length; j++) {
if (list[j][i].compareTo(list[0][i]) >= 0) {
list[0][i] = list[j][i];
}
if (list[0][i].compareTo(list[0][0]) >= 0) {
list[0][0] = list[0][i];
}
temp1 = list[0][0];
}
}
return temp1;
}
}
19.8
import java.util.ArrayList;
public class text198 {
public static void main(String[] args){
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
list.add(8);
list.add(9);
list.add(10);
list.add(11);
list.add(12);
list.add(13);
list.add(14);
list.add(15);
System.out.println(list.toString());
shuffle(list);
System.out.println(list.toString());
}
public static<E> void shuffle(ArrayList<E> list){
int num1,num2;
for(int i=0;i<(list.size())*2;i++){
num1 =(int )(Math.random()*list.size());
num2 =(int)(Math.random()*list.size());
E temp=list.get(num1);
list.set(num1,list.get(num2));
list.set(num2,temp);
}
}
}