泛型 Java语言程序设计 第十九章（19.10、19.11）

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

19.10

//找到ArrayList中的最大元素
import java.util.ArrayList;
import java.util.Scanner;

public class GetMaxInArrayList
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        ArrayList<Integer> list = new ArrayList<>();

        System.out.println("创建一个整型列表，输入-1表示结束：");
        boolean in = true;
        while (in)
        {
            Integer num = input.nextInt();
            if (num == -1)
            {
                break;
            }
            else
            {
                list.add(num);
            }
        }

        Integer max = max(list);
        System.out.println("此列表最大值是：" + max);
    }

    public static <E extends Comparable<E>>
        E max(ArrayList<E> list)
    {
        //没有说list是已排序的，所以使用线性查找
        E max = list.get(0);
        int size = list.size();
        for (int i = 0; i < size; i++)
        {
            if (list.get(i).compareTo(max) > 0)
            {
                max = list.get(i);
            }
        }

        return max;
    }
}

19.11

public abstract class NewGenericMatrix<E>
{
    //非泛型类方法。不是静态方法，那么参数可以使用泛型类型
    protected abstract E add(E o1, E o2);
    protected abstract E multiply(E o1, E o2);
    protected abstract E zero();

    public E[][] addMatrix(E[][] matrix1, E[][] matrix2)
    {
        if ((matrix1.length != matrix2.length) ||
            (matrix1[0].length != matrix2[0].length))
        {
            throw new RuntimeException("The matrix do not have the same size");
        }

        E[][] result = 
            (E[][])new Number[matrix1.length][matrix1[0].length];

        for (int i = 0; i < matrix1.length; i++)
        {
            for (int j = 0; j < matrix1[0].length; j++)
            {
                result[i][j] = add(matrix1[i][j], matrix2[i][j]);
            }
        }

        return result;
    }

    public E[][] multiplyMatrix(E[][] matrix1, E[][] matrix2)
    {
        if (matrix1[0].length != matrix2.length)
        {
            throw new RuntimeException("The matrix do not have compatible size");
        }

        E[][] result = (E[][])new Number[matrix1.length][matrix2[0].length];

        for (int i = 0; i < result.length; i++)
        {
            for (int j = 0; j < result[0].length; j++)
            {
                result[i][j] = zero();

                for (int k = 0; k < matrix1[0].length; k++)
                {
                    result[i][j] = add(result[i][j], multiply(matrix1[i][k], matrix2[k][j]));
                }
            }
        }
        return result;
    }

    public static void printResult(Object[][] m1, Object[][] m2, Object[][] m3, char op)
    {
        for (int i = 0; i < m1.length; i++)
        {
            for (int j = 0; j < m1[0].length; j++)
            {
                System.out.print(" " + m1[i][j]);
            }

            if (i == m1.length / 2)
            {
                System.out.print(" " + op + " ");
            }
            else
                System.out.print("   ");

            for (int j = 0; j < m2.length; j++)
            {
                System.out.print(" " + m2[i][j]);
            }

            if (i == m1.length / 2)
            {
                System.out.print(" = ");
            }
            else
                System.out.print("   ");

            for (int j = 0; j < m3[0].length; j++)
            {
                System.out.print(m3[i][j] + " ");
            }

            System.out.println();
        }
    }
}

public class Complex
{
    private double realPart;
    private double imaginaryPart;

    public Complex(double a)
    {
        this(a, 0);
    }

    public Complex(double a, double b)
    {
        this.realPart = a;
        this.imaginaryPart = b;
    }

    public double getRealPart()
    {
        return realPart;
    }

    public double getImaginaryPart()
    {
        return imaginaryPart;
    }

    public Complex add(Complex c)
    {
        double r = realPart + c.getRealPart();
        double i = imaginaryPart + c.getImaginaryPart();
        return new Complex(r, i);
    }

    public Complex subtract(Complex c)
    {
        double r = realPart - c.getRealPart();
        double i = imaginaryPart - c.getImaginaryPart();
        return new Complex(r, i);
    }

    public Complex multiply(Complex c)
    {
        double r = realPart * c.getRealPart() - imaginaryPart * c.getImaginaryPart();
        double i = realPart * c.getImaginaryPart() + imaginaryPart * c.getRealPart();

        return new Complex(r, i);
    }

    public Complex divide(Complex c)
    {
        double r = (realPart * c.getRealPart() + imaginaryPart * c.getImaginaryPart()) / 
            (c.getRealPart() * c.getRealPart() + c.getImaginaryPart() * c.getImaginaryPart());
        double i = (realPart * c.getImaginaryPart() - imaginaryPart * c.getRealPart()) /
            (c.getRealPart() * c.getRealPart() + c.getImaginaryPart() * c.getImaginaryPart());

        return new Complex(r, i);
    }

    public double abs()
    {
        return Math.sqrt(realPart * realPart + imaginaryPart * imaginaryPart);
    }

    @Override
    public String toString()
    {
        if (realPart == 0)
        {
            return imaginaryPart + "i";
        }
        else if (imaginaryPart == 0)
        {
            return realPart + "";
        }
        else
            return realPart + " + " + imaginaryPart + "i";
    }
}

public class ComplexMatrix extends NewGenericMatrix<Complex>
{
    @Override
    protected Complex add(Complex r1, Complex r2)
    {
        return r1.add(r2);
    }

    @Override
    protected Complex multiply(Complex r1, Complex r2)
    {
        return r1.multiply(r2);
    }

    @Override
    protected Complex zero()
    {
        return new Complex(0, 0);
    }
}

//测试复数矩阵
public class TestComplexMatrix
{
    public static void main(String[] args)
    {
        Complex[][] m1 = new Complex[3][3];
        Complex[][] m2 = new Complex[3][3];

        for (int i = 0; i < m1.length; i++)
        {
            for (int j = 0; j < m1[0].length; j++)
            {
                m1[i][j] = new Complex(i + 1, j + 5);
                m2[i][j] = new Complex(i + 1, j + 6);
            }
        }

        ComplexMatrix complexMatrix = new ComplexMatrix();
        System.out.println("\nm1 + m2 is "
        + NewGenericMatrix.printResult(m1, m2, complexMatrix.addMatrix(m1, m2), '+'));

        System.out.println("\nm1 + m2 is "
        + NewGenericMatrix.printResult(m1, m2, complexMatrix.multiplyMatrix(m1, m2), '+'));
    }
}