Java实现输入一个正整数n，再输入n个整数，将它们从大到小排序后输出。

可以使用Java中的Arrays.sort()方法来实现从大到小排序，具体代码如下：

import java.util.Arrays;
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = scanner.nextInt();
}
Arrays.sort(nums);
for (int i = n - 1; i >= 0; i--) {
System.out.print(nums[i] + " ");
}
}
}

输入样例：
5
3 1 4 1 5

输出样例：
5 4 3 1 1

相关问题

java输入正整数n，再输入n个整数，将n个整数按从小到大排序输出。

下面是Java代码实现：

import java.util.Scanner;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = input.nextInt();
        }
        Arrays.sort(nums);
        for (int i = 0; i < n; i++) {
            System.out.print(nums[i] + " ");
        }
    }
}

首先使用`Scanner`类获取输入的正整数`n`，然后创建一个长度为`n`的整型数组`nums`，使用循环将输入的`n`个整数存储到数组中。接着使用`Arrays.sort`方法对数组进行排序，最后再次使用循环输出排序后的整数序列。

java 输入一个正整数 n，再输入没有重复数的 a1,a2.....an 个整数，先用冒泡排序将这n个数从大到小排序，再用二分查找法，查找原输入的最后一个数an，在排序后是第几个，输出该下标(下标从0计算)。

在Java中，你可以通过以下几个步骤来实现这个功能：

1. **用户输入**：首先，创建一个`Scanner`对象获取用户的输入，包括正整数`n`以及没有重复的`n`个整数`a1, a2, ..., an`。

import java.util.Scanner;

public int[] inputArray() {
    Scanner scanner = new Scanner(System.in);
    System.out.print("请输入正整数n：");
    int n = scanner.nextInt();
    
    int[] arr = new int[n];
    for (int i = 0; i < n; i++) {
        System.out.print("请输入第" + (i+1) + "个数：");
        arr[i] = scanner.nextInt();
    }
    scanner.close(); // 关闭扫描器防止内存泄漏

    return arr;
}

2. **冒泡排序**：使用冒泡排序算法对数组进行降序排列。从第一个元素开始，每次比较相邻两个元素并交换位置，直到数组完全排序。

void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - i - 1; j++) {
            if (arr[j] < arr[j + 1]) {
                // 交换元素
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

3. **二分查找**：遍历已排序的数组找到目标值`an`的位置。因为数组已经按照降序排列，所以可以直接进行二分查找，而不需要修改二分查找的常规过程。

int binarySearch(int[] sortedArr, int target) {
    int low = 0;
    int high = sortedArr.length - 1;

    while (low <= high) {
        int mid = (low + high) / 2;
        if (sortedArr[mid] == target) {
            return mid;
        } else if (sortedArr[mid] > target) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }

    // 如果没找到，则返回目标应该插入的位置（如果数组有序，这将是它在有序数组中的位置）
    return low;
}

// 调用函数
int index = binarySearch(bubbleSort(inputArray()), arr[n-1]);
System.out.println("在排序后，数" + arr[n-1] + "的位置是：" + index);

4. **处理未找到的情况**：如果在排序后的数组中找不到`an`，则说明原数组有重复数字，这时返回的是`an`应当插入的位置，以便保持降序排列。