Java基础编程500题——泛型

已于 2024-07-20 16:28:51 修改
阅读量1.1k 收藏 12
点赞数 9
分类专栏： Java基础编程500题 文章标签： java 开发语言 后端 spring 数据结构
于 2024-07-20 16:05:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53140426/article/details/140571727
版权

💥 该系列属于【Java基础编程500题】专栏，如您需查看Java基础的其他相关题目，请您点击左边的连接

目录

1. 定义一个泛型方法，用于交换两个元素的位置。

2. 定义一个泛型方法，用于查找数组中的最大值。

3. 定义一个泛型方法，用于打印数组中的所有元素。

4. 编写一个泛型方法，用于计算数组中所有元素的总和。

5. 编写一个泛型方法，用于复制一个泛型数组。

6. 编写一个泛型方法，打印两个泛型对象的字符串表示。

7*. 编写一个泛型方法，打印两个泛型变量的类型。

8. 定义一个泛型类Pair，包含两个泛型类型的成员变量first和second，并提供一个构造方法和一个交换两个成员变量值的方法。

9. 定义一个泛型类Box，包含一个泛型类型的字段，并实现一个方法，比较两个Box对象是否相等。

10. 定义一个泛型类MinMaxPair，该类存储一对泛型类型的数据，并提供一个方法来获取最大值和最小值。

11. 定义一个泛型类Box，包含一个泛型类型的成员变量item。创建Box类的子类GiftBox，并添加一个成员变量price。

12. 定义一个泛型接口CalcInterface，包含一个方法calculate(T a, T b)，实现该接口的类AddClass，用于计算两个整数的和，并在Main方法中输出结果。

13. 定义一个泛型接口CompareInterface，包含一个方法compare(T a, T b)，实现该接口的类StringComparator，用于比较两个字符串的大小，并在Main方法中输出比较结果。

14. 定义一个泛型接口TransformInterface，包含一个方法transform(T t)，实现该接口的类StringToIntConverter，用于将字符串转换为整数，并在Main方法中输出转换结果。,>

15. 定义一个泛型接口PairInterface，包含一个方法swap()，该方法交换泛型类型的两个实例的值。实现该接口的类ValuePair，并在Main方法中测试交换功能。

16. 定义一个泛型接口ContainerInterface，包含一个方法getSize()，实现该接口的类MyList，并在Main方法中输出列表的大小。

17. 编写一个方法，该方法接受一个Pair类型的参数，并将该对中的两个值都增加10。

18*. 编写一个方法，计算传入List的中所有元素的和。

✨✨  返回题目目录 ✨ ✨ 

Java基础编程500题

1. 定义一个泛型方法，用于交换两个元素的位置。

public class Main {
    public static void main(String[] args) {
        Integer[] intArr = {1, 2};
        swap(intArr, 0, 1);
        System.out.println("交换后的数组：[" + intArr[0] + ", " + intArr[1] + "]");
        
        Character[] charArr = {'a','b'};
        swap(charArr,0,1);
        System.out.println("交换后的数组：[" + charArr[0] + ", " + charArr[1] + "]");

    }

    public static <T> void swap(T[] arr, int i, int j) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

2. 定义一个泛型方法，用于查找数组中的最大值。

public class Main {
    public static void main(String[] args) {
        Integer[] intArr = {1, 3, 5, 2, 4};
        System.out.println("数组中的最大值为：" + findMax(intArr));      //数组中的最大值为：5

        Double[] doubleArr = {1.0, 3.0, 5.0, 2.0, 4.0};
        System.out.println("数组中的最大值为：" + findMax(doubleArr));   //数组中的最大值为：5.0
    }

    public static <T extends Comparable<T>> T findMax(T[] arr) { //Comparable的儿子们都可以使用findMax这个方法，返回值也是T类型的
        T max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i].compareTo(max) > 0) {
                max = arr[i];
            }
        }
        return max;
    }
}

3. 定义一个泛型方法，用于打印数组中的所有元素。

public class Main {
    public static void main(String[] args) {
        Character[] arr = {'A', 'B', 'C', 'D'};
        printArray(arr);
    }

    public static <T> void printArray(T[] arr) {
        for (T element : arr) {
            System.out.println("元素：" + element);
        }
    }
}

4. 编写一个泛型方法，用于计算数组中所有元素的总和。

public class Main {
    public static void main(String[] args) {
        Integer[] arr = {1, 2, 3, 4, 5};
        System.out.println("数组元素之和：" + sum(arr));
    }

    public static <T extends Number> double sum(T[] arr) {
        double sum = 0;
        for (T num : arr) {
            sum += num.doubleValue();
        }
        return sum;
    }
}

5. 编写一个泛型方法，用于复制一个泛型数组。

public class Main {
    public static void main(String[] args) {
        Integer[] arr = {1, 2, 3, 4, 5};
        Integer[] copiedArr = copyArray(arr);
        System.out.print("复制后的数组：");
        for (Integer num : copiedArr) {
            System.out.print(num + " ");
        }
    }

    public static <T> T[] copyArray(T[] arr) {
        return arr.clone();
    }
}

6. 编写一个泛型方法，打印两个泛型对象的字符串表示。

public class Main {
    public static void main(String[] args) {
        printObjects("Hello", 123);
    }

    public static <T, K> void printObjects(T t, K k) {
        System.out.println("对象t的字符串表示：" + t);
        System.out.println("对象k的字符串表示：" + k);
    }
}

7*. 编写一个泛型方法，打印两个泛型变量的类型。

（需要掌握反射的知识点）

public class Main {
    public static void main(String[] args) {
        printType("字符串", 100);
    }

    public static <T, K> void printType(T t, K k) {
        // 必须使用getClass()方法，因为泛型参数在运行时会被擦除，无法直接使用.class来获取类型信息
        // 通过反射获取类型
        System.out.println("变量t的类型为：" + t.getClass().getSimpleName()); //变量t的类型为：String
        System.out.println("变量k的类型为：" + k.getClass().getSimpleName()); //变量k的类型为：Integer
    }
}

8. 定义一个泛型类Pair，包含两个泛型类型的成员变量first和second，并提供一个构造方法和一个交换两个成员变量值的方法。

class Pair<T> {
    private T first;
    private T second;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public void swap() {
        T temp = first;
        first = second;
        second = temp;
    }

    public void printPair() {
        System.out.println("first: " + first + ", second: " + second);
    }
}

public class Main {
    public static void main(String[] args) {
        Pair<String> pair = new Pair<>("你好", "世界");
        pair.printPair(); //first: 你好, second: 世界
        pair.swap();
        pair.printPair(); //first: 世界, second: 你好
    }
}

9. 定义一个泛型类Box，包含一个泛型类型的字段，并实现一个方法，比较两个Box对象是否相等。

class Box<T> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public boolean equals(Box<T> other) {
        return this.value.equals(other.value);
    }
}

public class Main {
    public static void main(String[] args) {
        Box<String> box1 = new Box<>("Java");
        Box<String> box2 = new Box<>("Java");
        System.out.println("两个Box对象是否相等：" + box1.equals(box2));
    }
}

10. 定义一个泛型类MinMaxPair，该类存储一对泛型类型的数据，并提供一个方法来获取最大值和最小值。

class MinMaxPair<T extends Comparable<T>> {
    private T min;
    private T max;

    public MinMaxPair(T first, T second) {
        if (first.compareTo(second) <= 0) {
            this.min = first;
            this.max = second;
        } else {
            this.min = second;
            this.max = first;
        }
    }

    public T getMin() {
        return min;
    }

    public T getMax() {
        return max;
    }
}

public class Main {
    public static void main(String[] args) {
        MinMaxPair<Integer> pair = new MinMaxPair<>(10, 20);
        System.out.println("最小值：" + pair.getMin());
        System.out.println("最大值：" + pair.getMax());
    }
}

11. 定义一个泛型类Box，包含一个泛型类型的成员变量item。创建Box类的子类GiftBox，并添加一个成员变量price。

class Box<T> {
    private T item;

    public Box(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

class GiftBox<T> extends Box<T> {
    private double price;

    public GiftBox(T item, double price) {
        super(item);
        this.price = price;
    }

    public void printInfo() {
        System.out.println("物品：" + getItem() + ", 价格：" + price);
    }
}

public class Main {
    public static void main(String[] args) {
        GiftBox<String> giftBox = new GiftBox<>("礼物", 99.9);
        giftBox.printInfo(); //物品：礼物, 价格：99.9
    }
}

12. 定义一个泛型接口CalcInterface<T>，包含一个方法calculate(T a, T b)，实现该接口的类AddClass，用于计算两个整数的和，并在Main方法中输出结果。

// 定义泛型接口
interface CalcInterface<T> {
    T calculate(T a, T b);
}

// 实现泛型接口的类
class AddClass implements CalcInterface<Integer> {
    @Override
    public Integer calculate(Integer a, Integer b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        AddClass addClass = new AddClass();
        System.out.println("计算结果为：" + addClass.calculate(5, 3));
    }
}

13. 定义一个泛型接口CompareInterface<T>，包含一个方法compare(T a, T b)，实现该接口的类StringComparator，用于比较两个字符串的大小，并在Main方法中输出比较结果。

// 定义泛型接口
interface CompareInterface<T> {
    int compare(T a, T b);
}

// 实现泛型接口的类
class StringComparator implements CompareInterface<String> {
    @Override
    public int compare(String a, String b) {
        return a.compareTo(b);
    }
}

public class Main {
    public static void main(String[] args) {
        StringComparator comparator = new StringComparator();
        int result = comparator.compare("Java", "C++");
        if (result > 0) {
            System.out.println("第一个字符串大于第二个字符串");
        } else if (result < 0) {
            System.out.println("第一个字符串小于第二个字符串");
        } else {
            System.out.println("两个字符串相等");
        }
    }
}

14. 定义一个泛型接口TransformInterface<T, R>，包含一个方法transform(T t)，实现该接口的类StringToIntConverter，用于将字符串转换为整数，并在Main方法中输出转换结果。

// 定义泛型接口
interface TransformInterface<T, R> {
    R transform(T t);
}

// 实现泛型接口的类
class StringToIntConverter implements TransformInterface<String, Integer> {
    @Override
    public Integer transform(String t) {
        return Integer.parseInt(t);
    }
}

public class Main {
    public static void main(String[] args) {
        StringToIntConverter converter = new StringToIntConverter();
        int result = converter.transform("123");
        System.out.println("字符串转换为整数：" + result);
    }
}

15. 定义一个泛型接口PairInterface<T>，包含一个方法swap()，该方法交换泛型类型的两个实例的值。实现该接口的类ValuePair<T>，并在Main方法中测试交换功能。

interface PairInterface<T> {
    void swap();
}

class ValuePair<T> implements PairInterface<T> {
    private T first;
    private T second;

    public ValuePair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    @Override
    public void swap() {
        T temp = first;
        first = second;
        second = temp;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }
}

public class Main {
    public static void main(String[] args) {
        ValuePair<Integer> pair = new ValuePair<>(1, 2);
        System.out.println("交换前：first = " + pair.getFirst() + ", second = " + pair.getSecond());
        pair.swap();
        System.out.println("交换后：first = " + pair.getFirst() + ", second = " + pair.getSecond());
    }
}

16. 定义一个泛型接口ContainerInterface<T>，包含一个方法getSize()，实现该接口的类MyList<T>，并在Main方法中输出列表的大小。

import java.util.Arrays;

// 定义泛型接口
interface ContainerInterface<T> {
    int getSize();
}

// 实现泛型接口的类
class MyList<T> implements ContainerInterface<T> {
    private Object[] array; // 使用Object数组以支持泛型
    private int size = 0; // 用于追踪数组中元素的数量

    public MyList() {
        array = new Object[10]; // 初始化数组，假设初始容量为10
    }

    public void add(T element) {
        if (size == array.length) {
            // 扩容数组
            array = Arrays.copyOf(array, array.length * 2);
        }
        array[size++] = element;
    }

    @Override
    public int getSize() {
        return size;
    }
}

public class Main {
    public static void main(String[] args) {
        MyList<String> myList = new MyList<>();
        myList.add("Java");
        myList.add("泛型");
        System.out.println("列表大小为：" + myList.getSize());
    }
}

17. 编写一个方法，该方法接受一个Pair<? super Integer>类型的参数，并将该对中的两个值都增加10。

class Pair<T> {
    private T first;
    private T last;

    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }

    public T getFirst() {
        return first;
    }

    public T getLast() {
        return last;
    }

    public void setFirst(T first) {
        this.first = first;
    }

    public void setLast(T last) {
        this.last = last;
    }
}

public class Main {
    public static void main(String[] args) {
        Pair<Number> pair = new Pair<>(5, 10);
        increasePairValues(pair);
        System.out.println("第一个值：" + pair.getFirst() + "，第二个值：" + pair.getLast());
    }

    static void increasePairValues(Pair<? super Integer> pair) {
        if (pair.getFirst() instanceof Integer) {
            pair.setFirst((Integer) pair.getFirst() + 10);
        }
        if (pair.getLast() instanceof Integer) {
            pair.setLast((Integer) pair.getLast() + 10);
        }
    }
}

18*. 编写一个方法，计算传入List<? extends Number>的中所有元素的和。

（需要掌握集合ArrayList的知识点）

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = List.of(1, 2, 3, 4, 5);
        System.out.println("列表元素之和为：" + sumOfList(list));
    }

    static double sumOfList(List<? extends Number> list) {
        double sum = 0;
        for (Number n : list) {
            sum += n.doubleValue();
        }
        return sum;
    }
}

安晴晚风
关注
专栏目录
java 关于泛型知识点的两题
weixin_44193337的博客
01-19 899
第一题：开发一个泛型Apple类，要求有一个重量属性weight在测试类中实例化不同的泛型对象，要求对象a1的这一属性是String类型，对象a2的这一属性是Integer型，a3的这一属性是Double型。分别为a1，a2，a3的重量属性赋值为：”500克”，500,500.0，在测试类中通过对象调用访问器得到属性值并输出。 public class Apple<T> { private T weight; public T getWeight() { ret
Java面向对象编程——泛型
qq_25036849的博客
12-29 361
目录 一、定义一个Point泛型，如以下程序： 实例化Point类，如以下程序： 关于默认的泛型类型：由于泛型是JDK1.5之后的产物，但是在此之前有不少的内置程序类或者是接口广泛应用在项目开发之中，为保证这些类或接口在追加了泛型之后，原始的类依然可以使用，所以如果没有设置泛型的类型，自动将使用Object作为类型以保证程序的正常执行，但是在编译中会出现警告。 泛型的使用注意点：1.泛型之中只允许设置引用类型，如果现在要操作的基本类型，必须使用包装类；2.从JDK1.7开始，泛型对象实例化可以简化为
Java泛型单元试题.html
03-17
精选java关于泛型的原理，应用和面试题，包含所有泛型考点。例如，泛型的概念，类型，实例化，容易混淆的用法。每一道题附上答案，方便理解考试要点。
java面试
qq_33334482的博客
08-11 902
赢在面试之Java泛型篇（14） 2017-08-10 阿木侠 Java知音 Java知音 Java知音 微信号 Java_friends 功能介绍 推送Java开发中的一些必备技能，包括但不限于数据库、Java核心、流行框架、管理工具以及服务器相关，同时为您精选流行的开源项目，必会的面试选题，练手项目，优质视频资源等。让您闲暇之余巩固一下自己的知识，不知不觉中
JAVA泛型编程全面总结
__七把刀__
05-14 3661
JAVA泛型编程总结                                                                                                                                                                ——by书生 1介绍 Java泛型编程是JDK1.5版
Java_泛型练习题
战士小小白的博客
11-19 2749
泛型课堂练习题(韩顺平老师) 定义Employee类 （1）该类包含：private成员变量name，sal，birthday，其中birthday为MyDate类的对象； （2）为每一个属性定义getter，setter方法； （3）重写toString方法输出name，sal，birthday （4）MyDate类包含：private成员变量year，month，year；并为每一个属性定义getter，setter方法； （5）创建该类的3个对象，并把这些对象放入ArrayList集合中（
Day53.泛型练习 -Java泛型
阿昌爱Java
09-26 458
泛型练习 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mx0zgFoF-1601109935453)(C:\Users\PePe\AppData\Roaming\Typora\typora-user-images\image-20200926164408959.png)] //DAOTest测试窗口 /* 定义个泛型类 DAO<T>，在其中定义一个 Map 成员变量，Map 的键 为 String 类型，值为 T 类型。 分别创建以下方法： public v
Java学废之路06——泛型与集合
我姓弓长那个张的博客
10-27 322
六、泛型与集合 6.1 泛型 为了能够更好的学习容器，我们首先要先来学习一个概念：泛型。 泛型是JDK1.5以后增加的，它可以帮助我们建立类型安全的集合。在使用了泛型的集合中，遍历时不必进行强制类型转换。JDK提供了支持泛型的编译器，将运行时的类型检查提前到了编译时执行，提高了代码可读性和安全性。 泛型的本质就是“数据类型的参数化”。泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用。使用泛型编写的代码要比那些杂乱的使用Object变量，然后再进行强制类型转换的代码具有更好的安全性，可读性。 6.
java的面向对象基础（6）——高级泛型
weixin_50546241的博客
09-17 732
java的面向对象基础（6）——高级泛型
115个Java面试题和答案——终极列表
09-14
1. **Java基础** - **数据类型**：Java分为基本数据类型（如int, double, boolean等）和引用数据类型（类、接口、数组）。理解它们的区别和用法至关重要。 - **变量**：变量是存储数据的容器，分为实例变量、类...
Java泛型实例
06-06
Java泛型，泛型接口、泛型方法实例
Java泛型应用实例
01-04
网上很多讲泛型原理的文章, 很少有提到我们什么时候使用泛型有优势, 我就泛型类和方法搞了两个实例,算是探索下泛型使用的冰山一角吧,在我博客里面有配套的文章,可以配套看.
夯实JAVA基本之一——泛型详解(2)：高级进阶
热门推荐
启舰
11-17 2万+
前言：被温水煮惯了，梦想的东西总是不敢于尝试，失败了又怎样，最多从头来过。 相关文章： 1、《夯实JAVA基本之一 —— 泛型详解(1):基本使用》 2、《夯实JAVA基本之一——泛型详解(2)：高级进阶》 3、《夯实JAVA基本之二 —— 反射（1）：基本类周边信息获取》 4、《夯实JAVA基本之二 —— 反射（2）：泛型相关周边信息获取》 5、《夯实JAVA基本之二 —— ...
Java泛型 练习
gegejiawei的博客
08-01 1695
选择 1、以下语句正确的是：（多选） AB 编程 1、通过练习，掌握泛型作为方法参数的应用，具体内容见任务要求。运行效果如下： package project0801.demo1; public abstract class Animal { // 成员属性 private String name; // get/set方法 public String getName() { return name; } public void setName(String name) {
Java泛型深入题目
weixin_34167819的博客
02-06 153
//Java泛型. 程序是从网上看到的，很具有代表性。 //已知 Apple extends Fruit extends Object //指出下列语句的正确性，并解释。 import java.util.ArrayList; import java.util.List; public class GenericTest { public static...
Java泛型习题
hgfhjtff的博客
06-01 818
泛型习题练习
weixin_44922515的博客
02-23 874
功能 定义一个操作数据库的库， 支持MySql MsSql MongDb 要求1：MySql MsSql Mongdb功能一样，都有add updata delete get 注意：约束统一规范、以及代码重 解决方案：需要约束规范所以走定义接口，需要代码重用用泛型 1：接口:在面向对象的编程中，接口是一种规范的定义，它定义了行为和动作的规范 2：泛型：通俗理解：泛型就是解决 类接口 方法的复用性 思路： 1、定义一个泛型接口22 interface configApi<T&g..
java 泛型小练习
yd小晨的专栏
10-21 2741
/* * 程序头部注释开始 * 程序的版权和版本声明部分 * Copyright (c) 2011, 烟台大学计算机学院学生 * All rights reserved. * 文件名称：泛型小练习 * 作 者：薛广晨 * 完成日期：2012 年 10
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值