2. 编写程序，定义一个方法用于实现不同数据类型两数交换，要求方法参数是泛型

以下是一个使用泛型的 Java 代码，实现了两个不同数据类型的交换：

public class Swap<T> {
    public void swap(T a, T b) {
        T temp = a;
        a = b;
        b = temp;
        System.out.println("After swap: a = " + a + ", b = " + b);
    }
    
    public static void main(String[] args) {
        Swap<Integer> swapInt = new Swap<>();
        Swap<String> swapStr = new Swap<>();
        
        Integer a = 3, b = 5;
        String c = "hello", d = "world";
        
        swapInt.swap(a, b);
        swapStr.swap(c, d);
    }
}

在上面的代码中，我们定义了一个 `Swap` 类，并使用了泛型类型 `T`。`swap` 方法接收两个泛型类型的参数 `a` 和 `b`，并在方法内部进行交换。我们在 `main` 方法中创建了两个 `Swap` 对象，分别用于交换整数和字符串。最后输出了交换后的结果。

相关问题

编写程序，实现两个数的交换，并用int、float、double、char类型的数据进行测试。 提示：定义一个泛型方法实现两数的交换。

在Java中，编写一个泛型方法来实现两个数的交换需要使用泛型来定义方法参数，以便它可以适用于不同的数据类型。下面是一个使用Java泛型实现的示例代码：

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

    public static void main(String[] args) {
        // int类型数据测试
        Integer[] intArray = {1, 2};
        System.out.println("Before swap: " + intArray[0] + ", " + intArray[1]);
        swap(intArray, 0, 1);
        System.out.println("After swap: " + intArray[0] + ", " + intArray[1]);

        // float类型数据测试
        Float[] floatArray = {1.1f, 2.2f};
        System.out.println("\nBefore swap: " + floatArray[0] + ", " + floatArray[1]);
        swap(floatArray, 0, 1);
        System.out.println("After swap: " + floatArray[0] + ", " + floatArray[1]);

        // double类型数据测试
        Double[] doubleArray = {1.1, 2.2};
        System.out.println("\nBefore swap: " + doubleArray[0] + ", " + doubleArray[1]);
        swap(doubleArray, 0, 1);
        System.out.println("After swap: " + doubleArray[0] + ", " + doubleArray[1]);

        // char类型数据测试
        Character[] charArray = {'a', 'b'};
        System.out.println("\nBefore swap: " + charArray[0] + ", " + charArray[1]);
        swap(charArray, 0, 1);
        System.out.println("After swap: " + charArray[0] + ", " + charArray[1]);
    }
}

上述代码中，我们定义了一个泛型方法`swap`，它可以接受任意类型的数组和两个索引，然后交换这两个索引位置的元素。这个方法通过泛型`<T>`来实现，使其可以适用于任何数据类型。在`main`方法中，我们创建了`int`、`float`、`double`和`char`类型的数组，并分别调用`swap`方法进行测试，以展示泛型方法的通用性。

java语言编写程序，利用选择排序对n个数据从小到大排序，数据类型可以是int、float、double类型

在Java中，选择排序是一种简单直观的排序算法，其基本思想每次从未排序的数据中找到最小（或最大）的一个元素，存放到已排序序列的末尾。对于支持比较操作的不同数据类型（如int、float、double），你可以通过通用的方式来实现。以下是选择排序的基本步骤：

1. 定义一个方法`selectSort(arr[])`，它接受一个数组作为参数。
2. 使用两个嵌套循环，外部循环控制未排序部分的开始位置（i），内部循环在未排序范围内找到最小值的索引（minIndex）。
3. 如果找到的最小值不在第一个位置（即minIndex != i），交换arr[i]和arr[minIndex]的位置。
4. 内部循环结束后，将i加一，重复以上过程直到所有元素都排序完成。

public class SelectionSort {
    public void selectSort(Object[] arr) {
        for (int i = 0; i < arr.length - 1; i++) { // 遍历整个数组
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) { // 比较并找到当前未排序区间的最小值
                if ((Comparable<? super T>) arr[j].compareTo((Comparable<? super T>) arr[minIndex]) < 0) {
                    minIndex = j;
                }
            }
            // 将找到的最小值与当前位置交换
            Object temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }
}

在这里，我们假设泛型T实现了Comparable接口，这样可以对不同类型的数组进行比较。注意，Java中的原始类型不允许直接实例化`Comparable`接口，所以需要使用Object作为类型参数。