泛型 Java语言程序设计 第十九章（19.1、19.2、19.3、19.4、19.5）

程序小白，希望和大家多交流，共同学习

19.1

//使用数组实现栈，当数组满的时候，自动创建一个更大的数组
import java.util.Arrays;
public class ArrayGenericStack<E>
{
    private int max = 10;
    private int last = 0;
    private E[] array;

    public ArrayGenericStack()
    {
        array = (E[])new Object[max];
    }

    public void push(E o)
    {
        if (isFull())
        {
            //System.out.println("full");
            max *= 2;
            E[] newArray = (E[])new Object[max];
            int length = array.length;
            for (int i = 0; i < length; i++)
            {
                newArray[i] = array[i];
            }
            array = newArray;
        }
        array[last] = o;
        last++;
    }

    public E pop()
    {
        if (isEmpty())
        {
            return null;
        }

        E o = array[last--];
        return o;
    }

    public E peek()
    {
        return array[last - 1];
    }

    public boolean isEmpty()
    {
        return last == 0;
    }

    public boolean isFull()
    {
        return last == max;
    }

    @Override
    public String toString()
    {
        String info = "";
        for (int i = 0; i < last; i++)
        {
            info += " " + array[i];
        }

        return info;
    }
}

19.2

import java.util.ArrayList; 
//注意这里包的引入不是ArrayList<E>

public class ArrayListStack<E> extends ArrayList<E>
{
    public ArrayListStack()
    {
        super();
    }

    public int getSize()
    {
        return super.size();
    }

    public E peek()
    {
        return super.get(0);
    }

    public E pop()
    {
        E o = super.get(getSize() - 1);
        super.remove(getSize() - 1);
        return o;
    }

    public void push(E o)
    {
        add(o);
    }

    public boolean isEmpty()
    {
        return super.isEmpty();
    }

    @Override
    public String toString()
    {
        return "ArrayListStack: " + super.toString();
    }
}

//测试继承自ArrayList的栈
import java.util.Scanner;

public class TestArrayListStack
{
    public static void main(String[] args)
    {
        System.out.println("清输入五个字符串：");
        Scanner input = new Scanner(System.in);

        ArrayListStack<String> stack = new ArrayListStack<>();
        String str = "";
        for (int i = 0; i < 5; i++)
        {
            str = input.nextLine();
            stack.push(str);
        }

        while (!stack.isEmpty())
        {
            System.out.println(stack.pop());
        }
    }
}

19.3

//队列去重

import java.util.ArrayList;
import java.util.Scanner;

public class DuplicateRemoval
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        ArrayList<Integer> list = new ArrayList<>();
        int num = 0;
        boolean in = true;
        System.out.println("创建一个整型列表（-1表示结束）：");
        while (in)
        {
            num = input.nextInt();
            if (num == -1)
            {
                break;
            }
            list.add(new Integer(num));
        }

        ArrayList<Integer> finalList = removeDulicates(list);
        int size = finalList.size();
        for (int i = 0; i  < size; i++)
        {
            System.out.print(finalList.get(i) + " ");
        }
        System.out.println();
    }
    //队列内容去重
    public static <E> ArrayList<E> removeDulicates(ArrayList<E> list)
    {
        ArrayList<E> finalList = new ArrayList<>();
        int size = list.size();
        for (int i = 0; i < size; i++)
        {
            if (finalList.indexOf(list.get(i)) == -1)
            {
                finalList.add(list.get(i));
            }
        }

        return finalList;
    }
}

19.4

//实现对泛型类型的线性搜索
import java.util.Scanner;

public class LinearSearchGeneric
{
    public static void main(String[] args)
    {
            Integer[] list = new Integer[10];
            Scanner input = new Scanner(System.in);
            System.out.println("请输入10个整型元素：");
            for (int i = 0; i < 10; i++)
            {
                list[i] = input.nextInt();
            }

            System.out.println("请输入需要查找的数：");
            Integer key = input.nextInt();
            System.out.println(key + " 的下表是：" + (linearSearch(list, key) + 1));
    }
    //线性查找元素
    public static <E extends Comparable<E>> int linearSearch(E[] list, E key)
    {
        int length = list.length;
        for (int i = 0; i < length; i++)
        {
            if (list[i].compareTo(key) == 0)
            {
                return i;
            }
        }

        return -1;
    }
}

19.5

//使用泛型查找最大值
import java.util.Scanner;

public class GenericMax
{
    public static void main(String[] args)
    {
        Integer[] list = new Integer[10];
        Scanner input = new Scanner(System.in);
        System.out.println("请输入10个整型：");
        for (int i = 0; i < 10; i++)
        {
            list[i] = input.nextInt();
        }

        Integer max = max(list);
        System.out.println("最大值是：" + max);
    }
    //返回数组中最大值
    public static <E extends Comparable<E>> E max(E[] list)
    {
        E max = list[0];
        int length = list.length;
        for (int i = 1; i < length; i++)
        {
            if (list[i].compareTo(max) > 0)
            {
                max = list[i];
            }
        }

        return max;
    }
}