1 题目重述
题目描述：输入n个字符串，降序排列后，按照{x，y，z}格式输出
例如：
输入：3
输入：AK,AS,AC
输出：{AC,AK,AS}
2 题目分析
2.1题目梳理
题目中的关键字：输入，字符串，降序排列，格式输出
今天的题目需要我们获取两个类型内容，一个是整型，一个是字符串。
于是我们分别采用 Scanner 类的 nextInt() 方法和 next() 方法对两个内容进行获取，并分别保存在整型 n 和字符串 str 中。
下面我们就要思考如何实现数组的降序排列。我们需要将数组中的每一个元素两两进行比较，谁大谁就排在前面。我们可以采用**冒泡排序**算法对字符串数组进行排序。
最后，我们需要思考如何按照指定格式输出字符串。我们可以采用System.out.print() 方法对字符串进行字符串首尾指定字符的拼接工作，同时通过 for 循环遍历每一个元素，并在元素后加上指定的字符。
这个过程听起来十分复杂，那么有没有更好的实现方法呢？有的。Java 为我们提供了 StringJoiner 类的 joiner.add() 方法，可以对字符串按照一定格式进行拼接。我们可以通过创建 StringJoiner 类的对象来调用 StringJoiner 类的有参构造方法，以此来达到我们的需要。
2.2 实现思路
2.2.1 输入
采用 Scanner 类的 nextInt() 方法，获取一个整数 n 。
采用 Scanner 类的 next() 方法，获取一个字符串 str 。
2.2.2 对原字符串按照指定字符串“,”进行分割
采用 String 类的split()方法，将原字符串按照指定字符串进行分割，返回切割后的字符串数组。
2.2.3 判断字符串元素个数与输入个数 n 是否一致
先采用 if 语句进行字符串元素个数的判断，如果小于输入个数 n ，那么我们题目的条件就无法达成，为了避免这种情况，我们就需要对字符串元素个数与输入个数 n 是否一致这一问题进行判断。
此时，在字符串元素个数小于输入个数 n 的情况下，我们就需要返回 “输入有误！” ，同时退出JVM虚拟机，使得程序结束。
同样，为了避免输入字符串元素个数大于输入个数 n 。同时有效地保证，输入的字符串个数与输入个数 n 的一致性。我们采用 System.arraycopy() 方法，将数组按照指定要求进行复制。这样做的目的是，保证字符串元素个数与输入个数 n 一致。
2.2.4 倒序排列
思路：采用冒泡排序法的倒序排列方式对原字符串数组进行倒序排列。
冒泡排序算法是一种非常常用的算法，在这里和大家针对本题进行叙述。
冒泡排序算法：
```handlebars
BUBBLE-SORT(A)
1. for i <--- 1
2. do for j <--- length[A] downto i+1
3. do if A[j] < A[j+1]
4. then exchange A[j] <---> A[j+1]
```
分析：
本题中，我们首先要知道比几轮，其次要知道每轮比较多少次。
第一个元素和第二个元素比较，再和第三个元素比较，以此类推... ...，直到第一个元素和第 n 个元素比较；
第二个元素和第三个元素比较，再和第四个元素比较，以此类推... ...，直到第二个元素和第 n 个元素比较；
以此类推 ... ...
直到，第 n-1 个元素和第 n 个元素进行比较。
我们用 n 代表元素个数，用 i 代表比较的轮数，用 k 代表每轮比较的次数。
我们发现共需要比较 n-1 轮，同时每轮比较 n-1-i 次。
由此，我们需要进行双重循环，外层循环控制比较的轮数，内层循环控制每轮比较的次数。同时，我们需要采用 String 类的 compareTo() 方法进行相邻元素大小的判断，满足要求保持位置不变，否则交换两个元素位置。
2.2.5 按指定格式输出
这里为大家提供了两种思路，供大家参考。
思路1：通过 for(){...} 循环遍历，直接拼接。
这种输出方式不需要我们多想，就你需要什么形式，我输出什么形式。但是在拼接的时候需要采用 for 循环对字符串进行遍历，同时我们发现输出格式中最后一个元素的后面没有 “,” ，因而，我们需要采用 if判断语句判断元素是否为最后一个元素，如果不是，拼接 “,” ，否则不拼接。
值得注意的是这里的输出采用的是 System.out.print("") 输出形式，只输出不换行。
思路2：采用 StringJoiner 类的 joiner.add() 方法，对字符串按照一定格式进行拼接。
我们思考，如果元素少采用第一种思路也没有什么问题，但是如果元素多了呢？或者元素要求复杂了呢？有没有一种更好的实现思路？
幸运的是，java 为我们提供了一个这样的类型 StringJoiner 类。我们可以通过创建 StringJoiner 类的对象来调用 StringJoiner 类的有参构造方法。
采用 StringJoiner joiner=new StringJoiner(delimiter, prefix, suffix) ;的形式。
功能：对字符串按一定要求进行连接。
传入：字符串之间的间隔符，字符串最前面字符，字符串最后面字符
返回：连接后的字符串
3 代码实现
3.1 方式1：
按指定格式输出：通过 System.out.print("") 和 for(){...} 循环遍历，直接拼接。
3.1.1 代码语句：
```bash
public static void main(String[] args) {
// 1 获取输入的元素个数和输入的字符串
Scanner input = new Scanner(System.in);
// 1.1 获取输入的字符串的元素个数
System.out.println("请输入字符串元素个数：");
int n = input.nextInt();
// 1.2 获取输入的字符串
System.out.println("请输入字符串：");
String str = input.next();
System.out.println("输入为：" + str);
// 2 对输入的字符串进行切割
// String 类的split()方法
// 功能：按照指定字符串对原字符串进行切割
// 传入：原字符串
// 返回：切割后的字符串数组
String[] strArray = str.split(",");
// 3 判断实际输入的字符串元素个数与输入的元素个数n是否一致
int len = strArray.length;
// 3.1 若实际输入字符串元素个数小于输入元素个数n
if (len < n) {
System.out.println("输入有误！");
System.exit(0);// 退出JVM虚拟机
}
// 3.2 若实际输入字符串元素个数大于等于输入元素个数n
// 复制数组，使得实际输入字符串元素个数等于输入元素个数n
// 方法：System.arraycopy()
// 功能：将数组按照指定要求进行复制
// 返回：复制后的新数组
// 传入：原数组名，原数组复制起始位置的下标，新数组名，新数组复制起始位置的下标，复制元素的个数
String[] array = new String[n];
System.arraycopy(strArray, 0, array, 0, len);
// 4 对字符串中元素进行降序排列
// 冒泡排序
// 比较：strNumber1.compareTo(strNumber2)方法
// 功能：用于进行字符串间的比较
// 形式：(字符串1).compareTo(字符串2)
// 传入：待比较的两个字符串
// 返回：int类型
// 返回值>0,字符串1>字符串2
// 返回值=0,字符串1=字符串2
// 返回值<0,字符串1<字符串2
for (int i = 0; i < n - 1; i++) {
for (int k = 0; k < n - 1 - i; k++) {
if (array[k].compareTo(array[k + 1]) < 0) {
String temp = array[k];
array[k] = array[k + 1];
array[k + 1] = temp;
}
}
}
// 5 按指定格式输出
// 方法1：通过 for 循环进行遍历，直接拼接
System.out.println("输出为：");
System.out.print("{");
for (int i = 0; i < n; i++) {
System.out.print(array[i]);
if (i != n - 1) {
System.out.print(",");
}
}
System.out.print("}");
System.out.println();
}
```
3.1.2 代码结果：
```bash
请输入字符串元素个数：
3
请输入字符串：
AK,AS,AC
输入为：AK,AS,AC
输出为：
{AS,AK,AC}
```
3.2 方式2：
按指定格式输出：采用 StringJoiner 类的 joiner.add() 方法，对字符串按照一定格式进行拼接。
3.2.1 代码语句：
```bash
public static void main(String[] args) {
// 1 获取输入的元素个数和输入的字符串
Scanner input = new Scanner(System.in);
// 1.1 获取输入的字符串的元素个数
System.out.println("请输入字符串元素个数：");
int n = input.nextInt();
// 1.2 获取输入的字符串
System.out.println("请输入字符串：");
String str = input.next();
System.out.println("输入为：" + str);
// 2 对输入的字符串进行切割
// String 类的split()方法
// 功能：按照指定字符串对原字符串进行切割
// 传入：原字符串
// 返回：切割后的字符串数组
String[] strArray = str.split(",");
// 3 判断实际输入的字符串元素个数与输入的元素个数n是否一致
int len = strArray.length;
// 3.1 若实际输入字符串元素个数小于输入元素个数n
if (len < n) {
System.out.println("输入有误！");
System.exit(0);// 退出JVM虚拟机
}
// 3.2 若实际输入字符串元素个数大于等于输入元素个数n
// 复制数组，使得实际输入字符串元素个数等于输入元素个数n
// 方法：System.arraycopy()
// 功能：将数组按照指定要求进行复制
// 返回：复制后的新数组
// 传入：原数组名，原数组复制起始位置的下标，新数组名，新数组复制起始位置的下标，复制元素的个数
String[] array = new String[n];
System.arraycopy(strArray, 0, array, 0, len);
// 4 对字符串中元素进行降序排列
// 冒泡排序
// 比较：strNumber1.compareTo(strNumber2)方法
// 功能：用于进行字符串间的比较
// 形式：(字符串1).compareTo(字符串2)
// 传入：待比较的两个字符串
// 返回：int类型
// 返回值>0,字符串1>字符串2
// 返回值=0,字符串1=字符串2
// 返回值<0,字符串1<字符串2
for (int i = 0; i < n - 1; i++) {
for (int k = 0; k < n - 1 - i; k++) {
if (array[k].compareTo(array[k + 1]) < 0) {
String temp = array[k];
array[k] = array[k + 1];
array[k + 1] = temp;
}
}
}
// 5 按指定格式输出
// 方法2：StringJoiner
// 格式：StringJoiner joiner=new StringJoiner(delimiter, prefix, suffix) ;
// 功能：对字符串按一定要求进行连接
// 传入：字符串之间的间隔符，字符串最前面字符，字符串最后面字符
// 返回：连接后的字符串
StringJoiner joiner = new StringJoiner(",", "{", "}");// 分别传入：分隔符，前缀，后缀
for (String temp : array) {
joiner.add(temp);
}
System.out.println("输出为：" + joiner.toString());
}
```
3.2.2 代码结果：
```bash
请输入字符串元素个数：
3
请输入字符串：
AK,AS,AC
输入为：AK,AS,AC
输出为：{AS,AK,AC}
```
3.3 方式3：
如果你的程序中需要多次进行进行降序排列或者是需要按照指定格式输出，那么我们就可以将冒泡排序和按照指定格式进行输出写成两个方法，在主函数中调用即可。本题中，我将冒泡排序（倒序排列）和按照指定格式输出分别写成了两个方法 bubbleSort() 和 format() 供大家参考。
3.3.1 代码语句：
```bash
public static void main(String[] args) {
// 1.输入n
Scanner input = new Scanner(System.in);
System.out.println("请输入字符串个数：");
int n = input.nextInt();
// 2.输入字符串
System.out.println("请输入字符串：");
String str = input.next();
// 3.分割字符串，转为数组
String[] temp = str.split(",");
// 4.判断输入个数是否有误
// 4.1 输入个数小于n
if (temp.length < n) {
System.out.println("输入有误！");
System.exit(0);
}
// 5.复制数组（输入个数≥n）
String[] array = new String[n];
System.arraycopy(temp, 0, array, 0, n);
System.out.println("排序前：" + Arrays.toString(array));
// 6.调用冒泡排序方法
array = bubbleSort(array, n);
// 7.调用方法并输出
System.out.println("排序后：" + format(array));
}
/*
* 冒泡排序(降序)
*/
public static String[] bubbleSort(String[] array, int n) {
for (int i = 0; i < n - 1; i++) {
for (int k = 0; k < n - i - 1; k++) {
if (array[k].compareTo(array[k + 1]) < 0) {
String temp = array[k];
array[k] = array[k + 1];
array[k + 1] = temp;
}
}
}
return array;
}
/*
* 参数array: 需要转换的原数组
* 返回：指定格式的String类型的字符串
*/
public static String format(String[] array) {
// 输出指定格式
StringJoiner joiner = new StringJoiner(",", "{", "}"); // 分隔符，前缀，后缀
for (String str : array) {
joiner.add(str); // 添加字符串
}
return String.valueOf(joiner);
}
```
3.3.2 代码结果：
```bash
请输入字符串个数：
3
请输入字符串：
AK,AS,AC
排序前：[AK, AS, AC]
排序后：{AS,AK,AC}
```