Java数组随机产生100个大于等于1，小于10000的随机整数存入整数数组intArr[]中，用冒泡升序排序和二分法逆序排序算法进行排序

### 回答1：
可以使用Java的`Random`类来产生随机数，例如：

import java.util.Random;

int[] intArr = new int[100];
Random rand = new Random();
for (int i = 0; i < intArr.length; i++) {
  intArr[i] = rand.nextInt(9999) + 1;
}

要使用冒泡升序排序算法对数组进行排序，可以使用以下代码：

for (int i = 0; i < intArr.length - 1; i++) {
  for (int j = 0; j < intArr.length - i - 1; j++) {
    if (intArr[j] > intArr[j + 1]) {
      int temp = intArr[j];
      intArr[j] = intArr[j + 1];
      intArr[j + 1] = temp;
    }
  }
}

要使用二分法逆序排序算法对数组进行排序，可以使用以下代码：

import java.util.Arrays;

int[] intArr = new int[100];
Random rand = new Random();
for (int i = 0; i < intArr.length; i++) {
  intArr[i] = rand.nextInt(9999) + 1;
}
Arrays.sort(intArr, Collections.reverseOrder());

请注意，上述代码使用了Java的`Arrays.sort`方法和`Collections.reverseOrder`方法来实现逆序排序。

### 回答2：
首先，我们可以使用Java的Random类来生成100个大于等于1，小于10000的随机整数，然后将它们存入整数数组intArr[]中。

下面是实现该过程的代码：

import java.util.Arrays;
import java.util.Random;

public class ArraySort {
    public static void main(String[] args) {
        int[] intArr = new int[100];
        
        Random random = new Random();
        for (int i = 0; i < intArr.length; i++) {
            intArr[i] = random.nextInt(9999) + 1;
        }
        
        // 冒泡升序排序
        bubbleSort(intArr);
        
        // 二分法逆序排序
        binarySort(intArr);
    }
    
    // 冒泡升序排序算法
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("冒泡升序排序结果：" + Arrays.toString(arr));
    }
    
    // 二分法逆序排序算法
    public static void binarySort(int[] arr) {
        // 先进行升序排序
        bubbleSort(arr);
        
        // 再逆序排列
        for (int i = 0; i < arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - 1 - i];
            arr[arr.length - 1 - i] = temp;
        }
        System.out.println("二分法逆序排序结果：" + Arrays.toString(arr));
    }
}

以上代码中，我们使用冒泡排序算法对数组进行升序排序，然后将排序后的数组传给二分法逆序排序算法，先进行升序排序，再将结果逆序排列。最后打印出排序结果。

要注意的是，在二分法逆序排序算法中，我们调用了冒泡排序算法来进行升序排序。这是因为在二分法逆序排序中，我们需要先进行升序排序，然后再将结果逆序排列。

### 回答3：
为了解决这个问题，我们可以用Java编写代码来实现。

首先,我们可以使用Math类的random()方法来生成随机整数。我们需要循环100次，每次生成一个介于1到9999之间的随机整数，并将其存储在intArr[]数组中。

int[] intArr = new int[100];
for (int i = 0; i < 100; i++) {
    intArr[i] = (int) (Math.random() * 9999) + 1;
}

接下来，我们使用冒泡排序算法对intArr[]数组进行升序排序。冒泡排序算法每次从头开始比较相邻的两个元素，并将较大的元素交换到后面。重复多次比较和交换的过程，直到所有元素都按照升序排列。

for (int i = 0; i < intArr.length - 1; i++) {
    for (int j = 0; j < intArr.length - i - 1; j++) {
        if (intArr[j] > intArr[j + 1]) {
            int temp = intArr[j];
            intArr[j] = intArr[j + 1];
            intArr[j + 1] = temp;
        }
    }
}

最后，我们使用二分法逆序排序算法对intArr[]数组进行逆序排序。二分法逆序排序算法是一种基于比较的排序方法，它通过不断地将待排序序列二分，然后将较大的元素交换到较小的元素前面，从而实现逆序排序。

for (int i = 1; i < intArr.length; i++) {
    int key = intArr[i];
    int low = 0;
    int high = i - 1;
    while (low <= high) {
        int mid = (low + high) / 2;
        if (key > intArr[mid]) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    for (int j = i; j > low; j--) {
        intArr[j] = intArr[j - 1];
    }
    intArr[low] = key;
}

通过以上代码，我们可以生成100个大于等于1、小于10000的随机整数，并使用冒泡排序和二分法逆序排序算法对其进行排序。