6.3_[Java 数组]-经典的 Java 算法

燃吹

已于 2022-07-27 22:12:36 修改

阅读量368

点赞数 2

分类专栏： CentOS 在左 Java 在右文章标签： java 算法 Java 算法 Java 排序蓝桥杯

于 2022-06-06 03:02:07 首次发布

本文链接：https://blog.csdn.net/m0_67268286/article/details/125139783

版权

CentOS 在左 Java 在右专栏收录该内容

40 篇文章 3 订阅

订阅专栏

##################################################

Java 算法

遍历数组

倒历数组

利用 foreach 增强型 for 循环遍历输出数组

##################################################

Java 算法

——————————

遍历数组

什么是遍历数组？

就是把数组按照一定顺序输出/输入遍历一遍
或者说逐一处理？

需求：

遍历输出一遍数组

code：

public class test {

	public static void main(String[] args) {

		String[] goods = new String[] { "哇哈哈", "阔落", "口香糖", "香蕉", "草莓", };    /* String 数组 goods[] */

		System.out.println ( "我看到了 >>> " );    /* 交互信息 */

		for ( int i = 0; i < goods.length; i ++ )
		/* 使用 for 循环遍历数组 条件不超过数组的长度 */
			System.out.println("\t"+ goods[i]);    /* 遍历输出数组元素 */
	}
}

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
我看到了 >>>
        哇哈哈
        阔落
        口香糖
        香蕉
        草莓

C:\Users\byme\javaTest>

——————————

倒历数组

即倒着遍历数组

code：

import java.util.*;

public class test {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);

		String str[] = new String[5];

		for ( int i = 0; i < str.length; str[i] = input.next(), i ++ )
			System.out.print ( "请输入第 " + (i + 1) + " 句话 <<< " );

		System.out.println ( "\n倒序输出为 >>> " );
		for ( int i = str.length - 1; i >= 0; i -- )
			System.out.println ( str[i] );
	}
}

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入第 1 句话 <<< 我爱
请输入第 2 句话 <<< 打
请输入第 3 句话 <<< 崽崽
请输入第 4 句话 <<< 的脑袋瓜
请输入第 5 句话 <<< ！！！

倒序输出为 >>>
！！！
的脑袋瓜
崽崽
打
我爱

C:\Users\byme\javaTest>

——————————

利用 foreach 增强型 for 循环遍历输出数组

如果只是操作里面的元素而不使用下标索引的话推荐：

for ( 数据类型 变量名 : 目标数组)
	System.out.println ( 变量名 );

这是什么：

数据类型变量名

不是声明变量吗：

String A;
int A;
Char A;

那冒号后面是干什么的。。想一想，接收

目标数组

的值？

for ( String Str : str ) {
/* 假如 str[] 为字符串数组 长度为 5 个字符串 */

	System.out.println ( Str );
}

懂了！让我们临时声明一个变量来接收目标数组的值！
那么放入 for 循环就是说：

临时声明的变量循环接收目标数组的值！

    等同于我们熟悉的：
for ( 数据类型 变量名 = 变量值; 变量名 < 目标数组长度; 变量自增 )
    System.out.println ( 目标数组[变量名] );

	示例：
for ( int i = 0; i < str.length; i ++ )
    System.out.printf ( "%d\n", Str[i] );

        其实本质上没啥区别。。
        只是目标数组一定是数组
        然后循环。。遍历。。直到数组长度为 -1 才结束

    第一次执行时 临时声明字符串变量 Str 把 str[] 的一个数组元素 赋值给 Str
	for 循环一次 就把 str[] 的一个数组元素 赋值给 Str
	然后再循环 再 Str
	当遍历完 str[] 后 代码段结束

	其实一句话：
循环遍历 str[] 复制值给 Str
	其实就十个字：
依次 + 取出 + 赋值 + 取完为止!

    免去了我们苦比的赋值：
String Str = "";
Str = str[0];
Str = str[1];
Str = str[2];
Str = str[3];
/* ... ... */

        这就是增强 for
        增强 for 不仅可以遍历数组，还可以遍历集合
        集合先不说。

只是必须有被遍历的目标数组或集合

        普通的 for 遍历数组的时候需要下标

而增强 for 不需要也不能获取下标所以只能输出元素

	jdk 1.5 一般是：
for ( int a : arr ) { }
	而到了 1.6 就成了：
foreach ( int a : arr ) { }

示例 code：

public class test {

	public static void main(String[] args) {

		String[] arr_1 = { "abc", "ABc", "abC" };
		int[] arr_2 = { 1, 11, 111, 1111, 11111 };

		System.out.println ( "遍历字符串 >>> " );
		for ( String str : arr_1 )
			  System.out.println ( "    " + str );

		System.out.println ( "遍历 int >>> " );
		for ( int i : arr_2 )
			  System.out.println ( "    " + i );
	}
}

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
遍历字符串 >>>
    abc
    ABc
    abC
遍历 int >>>
    1
    11
    111
    1111
    11111

C:\Users\byme\javaTest>

——————————

输入求和

这个。。似乎只在小卖部才有用？

需求：

任意接收指定数量的整数输出她们的和

code：

import java.util.*;

public class test {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);    /* Scanner 输入方法 */
		int intArray[] = new int[5];    /* 声明 int 数组 intArray[] 长度为 5 */
		long total = 0;    /* 得到 intArray[] 数组元素的和 */
		int len = intArray.length;    /* 得到 intArray[] 数组的长度 */

		/* 给数组元素赋值 */
		System.out.print ( "请输入" + len + "个整数，以空格为分隔 <<< " );    /* 交互信息 */
		for ( int i = 0; i < len; i ++ )
		/* for 循环 条件：循环次数等于数组长度 */
			 intArray[i] = input.nextInt();    /* 循环录入数据 存入 intArray[] 数组 */

		for ( int i = 0; i < len; i++ )
		/* 计算数组元素的和 for 循环 条件：循环次数等于数组长度 */
			total = total + intArray[i];    /* 计算 intArray[] 数组的和 */

		/*	完全可以这样：
		 * for(int i = 0; i < len; i++)
		 *	total += intArray[i];
		 *
		 * 至于 += 是什么意思 难道还不明显吗？！！
		 */

		 System.out.println ( "所有数组元素的和为：" + total );    /* 回显信息 */
	}
}

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入5个整数，以空格为分隔 <<< 10 20 30 40 50
所有数组元素的和为：150

C:\Users\byme\javaTest>java test
请输入5个整数，以空格为分隔 <<< 50
40
30
20
10
所有数组元素的和为：150

C:\Users\byme\javaTest>

——————————

求平均数

求平均数这种操作可能也很常用？

需求：

任意接收指定数量的整数输出她们的平均数

code：

import java.util.Scanner;

public class test {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);    /* Scanner 输入方法 */

		int[] scores = new int[5];    /* 声明int数组 scores[] 长度 5 */
		int sum = 0;    /* 相加和 */

		System.out.println ( "请输入 5 个数据 输入一个数据后回车即可输入下一个数据 <<< " );    /* 交互信息 */
		for ( int i = 0; i < scores.length; i ++ ) {
		/* for 循环 条件为不超出 scores[] 数组的长度 */

			scores[i] = input.nextInt();    /* 循环录入 */
			sum = sum + scores[i];    /* 数据累加 */
		}

		System.out.println ( "5 个数据的平均分是 >>> " + (double) sum / scores.length );    /* 回显信息 计算并输出平均分 */
	}
}

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入 5 个数据 输入一个数据后回车即可输入下一个数据 <<<
10
20
30
40
50
5 个数据的平均分是 >>> 30.0

C:\Users\byme\javaTest>java test
请输入 5 个数据 输入一个数据后回车即可输入下一个数据 <<<
50 40 30 20 10
5 个数据的平均分是 >>> 30.0

C:\Users\byme\javaTest>

——————————

升序降序

        数组排序在实际开发中很常用！
        例如循环输入 5 个数据将数据从低到高排序
        该怎么办？这就是升序排列操作！

在 Java 中我们可以通过内置的一个工具来完成这种操作
这个工具就是 Java 内部提供的一个类：

java.util.Arrays

        Arrays 类就是专门针对这种数据处理而提供的一个类
        就像 Scanner 类一样我们想接收输入也要使用 Scanner
        她们都在 java 下的 util 中

我们可以挨个导入这些包：

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

也可以一次性的导入 util 下的所有包：

import java.util.*;

        sort() 是 Arrays 类提供的一个方法
        Arrays 类就像我们声明的 test 类
        Arrays.sort 方法就像我们的 test.main() 一样不同的是 main() 方法是自动执行而别的方法只能被调用才能执行
        我们调用 Arrays类中的 sort 方法来完成对数组的排序！

    用法：
Arrays.sort(数组);

        然后指定数组经过 Arrays.sort() 处理后这个数组中的元素就已经有序了！
        当然是升序
        可是我们想降序显示啊怎么办？
        现在数组不是吗？你 tm 反着输出不就是降序输出吗？

只要能达到结果过程什么的。。真的不重要。。不是吗？

需求：

请将数组按升序排列
再将数组按降序排列

code：

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

public class test {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);    /* Scanner 输入方法 */

		/* 循环录入数据 */
		int[] A = new int[5];    /* 声明 int 数组 A[] */
		System.out.println ( "请输入 5 个数据" );    /* 交互信息 */
		for ( int i = 0; i < A.length; A[i] = input.nextInt(), i ++ )
		/* for 循环条件 不超过 A[] 的长度 循环录入数据 */
			System.out.printf ( "<<< " );

		/* 循环遍历数组 升序输出 */
		Arrays.sort(A);    /* 对数组进行升序排序 */
		System.out.print ( "升序 >>> \n\t" );    /* 交互信息 */
		for ( int i = 0; i < A.length; i ++ )
		/* for 循环条件 不超过 A[] 的长度 */
			System.out.print ( A[i] + " " );    /* 遍历输出 */

		/* 循环遍历数组 降序输出 即逆向输出数组 */
		System.out.print ( "\n降序 >>> \n\t" );    /* 交互信息 */
		for( int i = A.length - 1; i >= 0; i-- )
		/* for 循环条件 元素下标到达 0 便停止 */
			System.out.print ( A[i]+ " " );    /* 遍历输出 */
	}
}

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入 5 个数据
<<< 10
<<< 20
<<< 30
<<< 40
<<< 50
升序 >>>
        10 20 30 40 50
降序 >>>
        50 40 30 20 10
C:\Users\byme\javaTest>

——————————

字符排序

数据排序就已经很 nb 了已经足够惊艳了吧？
可是我还要告诉你：

数组也可以对字符进行排序

当然是字母！！别想着排序汉字。。
字母就那么几个而汉字。。你见过一本字典不。。。。。。

code：

import java.util.*;

public class test {

	public static void main(String[] args) {

		/*	本来 我是想直接声明一个算了
		 *	声明数组 str[] 数组中是一组乱序字母 
		 * String[] str = { "a", "c", "b", "d", "f", "e" };
		 */

		/* 后来想了想 还是调用Scanner输入吧 毕竟。。高大上！ */
		Scanner input = new Scanner(System.in);
		System.out.print ( "请输入 5 个字符\n" );
		char str[] = new char[5];
		for( int i = 0; i < str.length; str[i] = input.next().charAt(0), i ++ )
			System.out.print ( "\t<<< " );

		/* 遍历 */
		System.out.print ( "这是原字母元素 >>>\n\t" );
		for ( int i = 0; i < str.length; i ++ )
			System.out.print ( str[i] + " " );

		/* 给字母排序 */
		Arrays.sort ( str );
		System.out.print ( "\n这是排序好的字母元素 >>> \n\t" );
		for ( int i = 0; i < str.length; i ++ )
			System.out.print ( str[i] + " " );

		/* 逆向遍历 */
		System.out.print ( "\n这是逆向排序的字母元素 >>> \n\t" );
		for ( int i = str.length - 1; i >= 0; i -- )
			System.out.print ( str[i] + " " );
	}
}

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入 5 个字符
        <<< a
        <<< b
        <<< d
        <<< c
        <<< z
这是原字母元素 >>>
        a b d c z
这是排序好的字母元素 >>>
        a b c d z
这是逆向排序的字母元素 >>>
        z d c b a
C:\Users\byme\javaTest>

——————————

求最大值

怎么样现在有没有对 Arrays.sort() 方法产生崇拜感呢？

接下来我们使用 for 计算最大最小值

思路：

获取最大/小值需要进行比较

每一次比较都会有一个较大的值

因为该值不确定所以需要一个变量进行临时储存
让数组中的每一个元素都和这个临储值进行比较

如果大于了临时变量中的值则临储替换记录为较大值
当所有的元素都比较完成那么临量中存储的就是数组中的最大值！
最小值思路同上

    见没见过 古代的打擂台？ 没错 就像 比武打擂
    无名小卒 挑战 当前擂主
    赢了 地位保住 擂主还是擂主
    然后还要继续 一个个无名小卒挨个挑战。。
    血雨腥风！
    只要有一次失败了！ ta 就嗝屁了。。死求了。。
    胜利者站在擂台上 踩在上一个擂主的身子上 成为新的老大 呸 新的擂主
    然后 得到上天的诅咒 上天赐予你诅咒光环：一次次被挑战 等着被干掉！
    不是身败名裂 就是。。一将功成 万骨枯！

    woc。。太 tm 感人了。。我是不是有写小说的潜质。。。。。笑哭。。嘤嘤嘤 太感人了。。

    当然 残酷的是 最小值。。
    最小值也是被一群人轮 轮不死的话 就是最后的最小值了……

现在能不能看懂：

/* 假设 max 保存最大值 而 number 是一个 int 数组 长度为 5 */
int max = number[0];

if ( number[1] > max )
    max = number[1];
if ( number[2] > max )
    max = number[2];
if ( number[3] > max )
    max = number[3];
if ( number[4] > max )
    max = number[4];

System.out.printf ( "最大值为 >>> [%d}\n", max );

code：

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

public class test {

	public static void main(String[] args) {

		/* 为程序做准备 */
		Scanner input = new Scanner(System.in);    /* 一种输入方法 */
		int number[] = new int[5];    /* int 数组 number[] 长度为 5 */
		int max = 0, min = 0;    /* 记录最大值, 记录最小值 */

		/* 录入数据 */
		System.out.printf ( "请输入任意五个数字\n" );
		for ( int i = 0; i < number.length; number[i] = input.nextInt(), i ++ )
			System.out.printf ( "<<< " );

		/* 这次不遍历了 单个输出 */
		System.out.println ( "原数组为 >>> " +
			number[0] + " " +
			number[1] + " " +
			number[2] + " " +
			number[3] + " " +
			number[4] );

		/* 计算最大值 */
		max = number[0];    /* 初始化最大值为第一个元素 */
		for ( int i = 1; i < number.length; i ++ )
		/* 挨个比较四个元素的值 谁大 max 就变成谁 注意 i = 1 而不是 0 这是因为 刚刚 max = unmber[0] 所以只需要比较 [1]、[2]、[3]、[4] 四个元素即可！ */
			if ( number[i] > max )
				max = number[i];
		System.out.println ( "最大值为 >>> " + max );
		
		/* 计算最小值 */
		min = number[0];    /* 初始化最小值 */
		for ( int i = 1; i < number.length; i ++ )
		/* 遍历四个元素 谁小就赋给 min */
			if ( number[i] < min )
				min = number[i];
		System.out.println ( "最小值为 >>> " + min );
	}
}

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入任意五个数字
<<< 100
<<< 50
<<< 70
<<< 80
<<< 200
原数组为 >>> 100 50 70 80 200
最大值为 >>> 200
最小值为 >>> 50

C:\Users\byme\javaTest>

——————————

插入元素

向数组中插入元素

        一组升序数组
        现在要加入一个新数据元素
        要将她插入数组并保持数组升序排列

思路：

假如 int 数组 number[] 长度为 6
数组中有 5 个数据 还剩一个位置
然后 我们需要找到 插入位置
同时 还要保证数组中的数据有序排列 。。我的天？
我们需要利用 for 从 number[0] 开始与 新数据 进行比较
找到插入位置后 当前位置的元素后移 新数据插入当前位置
ok 完美高大上！

code：

import java.util.Scanner;

public class test {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);    /* Scanner 输入方法 */

		int[] number = new int[6];    /* 长度为 6 的 int 数组 number[] */
		int index = number.length;    /* 保存新增元素插入位置 */
		int num = 0;    /* 新元素 */
		int j = 0, k = 0;    /* for 循环需要变量 这次在外声明 */

		/* 为 number[] 前五个赋值 可以看到 我这是降序 从大到小 不需要调用 Arrays.sort() 排列 */
		number[0] = 99;
		number[1] = 89;
		number[2] = 79;
		number[3] = 69;
		number[4] = 59;

		/* 遍历原数组 */
		System.out.print ( "插入前的数组信息是 >>> \n\t" );
		for ( int i : number ) {

			if ( i == 0 ) {
			/* 如果值为 0 则显示空值 */

				System.out.print ( "NULL" );

				continue;
			}

			System.out.print ( i + " " );
		}

		/*	当然 也可以：
		 * System.out.println("原数组：" + number[0] + " " +
		 *	number[1] + " " +
		 *	number[2] + " " +
		 *	number[3] + " " +
		 *	number[4] + " " +
		 *	"NULL");
		 */

		/* 获得元素 然后找到新元素的插入位置 */
		System.out.print ( "\n请输入新元素 <<< \n\t" );
		num = input.nextInt();
		for ( ; j < number.length; j ++ )
			if ( num > number[j] ) {
			/* 因为已经排序好了 所以只要大于 就是最合适的位置！ */
				index = j;	/* 记录下插入位置 */
				break;	/* 找到了位置就退出 不再循环比较！ */
			}


		for ( k = number.length - 1; k > index ; k --)
		/* for 条件 初始控制值 为最后一个元素 到达合适位置就停下 迭代为自减 1 */
			number[k] = number[k-1];	/* 下标开始的元素后移一个位置 */
		/* 原数据元素后移然后插入新数据 就是 合适位置之后的 所有的 后一个元素 替换为 上一个元素 即 倒着来遍历替换 遇到合适的位置就停止 */
		number[index] = num;	/* 插入数据 */

		/* 回显信息 遍历输出新数组 */
		System.out.println ( "插入元素的下标是 >>> \n\t" + index );
		System.out.print ( "插入后的新数组元素是 >>> \n\t" );
		for ( int l : number ) {

			if ( l == 0 ) {

				/* 如果值为 0 则显示空值 */
				System.out.print ( "NULL" );

				continue;
			}

			System.out.print ( l + " " );
		}
		
		System.out.println ();	/* 程序美观 */
	}
}

demo 这边把各种数据都测试一遍：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
插入前的数组信息是 >>>
        99 89 79 69 59 NULL
请输入新元素 <<<
        100
插入元素的下标是 >>>
        0
插入后的新数组元素是 >>>
        100 99 89 79 69 59

C:\Users\byme\javaTest>java test
插入前的数组信息是 >>>
        99 89 79 69 59 NULL
请输入新元素 <<<
        200
插入元素的下标是 >>>
        0
插入后的新数组元素是 >>>
        200 99 89 79 69 59

C:\Users\byme\javaTest>java test
插入前的数组信息是 >>>
        99 89 79 69 59 NULL
请输入新元素 <<<
        85
插入元素的下标是 >>>
        2
插入后的新数组元素是 >>>
        99 89 85 79 69 59

C:\Users\byme\javaTest>java test
插入前的数组信息是 >>>
        99 89 79 69 59 NULL
请输入新元素 <<<
        75
插入元素的下标是 >>>
        3
插入后的新数组元素是 >>>
        99 89 79 75 69 59

C:\Users\byme\javaTest>java test
插入前的数组信息是 >>>
        99 89 79 69 59 NULL
请输入新元素 <<<
        65
插入元素的下标是 >>>
        4
插入后的新数组元素是 >>>
        99 89 79 69 65 59

C:\Users\byme\javaTest>java test
插入前的数组信息是 >>>
        99 89 79 69 59 NULL
请输入新元素 <<<
        55
插入元素的下标是 >>>
        5
插入后的新数组元素是 >>>
        99 89 79 69 59 55

C:\Users\byme\javaTest>java test
插入前的数组信息是 >>>
        99 89 79 69 59 NULL
请输入新元素 <<<
        5
插入元素的下标是 >>>
        5
插入后的新数组元素是 >>>
        99 89 79 69 59 5

C:\Users\byme\javaTest>java test
插入前的数组信息是 >>>
        99 89 79 69 59 NULL
请输入新元素 <<<
        0
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 6
        at test.main(test.java:60)

C:\Users\byme\javaTest>java test
插入前的数组信息是 >>>
        99 89 79 69 59 NULL
请输入新元素 <<<
        -1
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 6
        at test.main(test.java:60)

C:\Users\byme\javaTest>java test
插入前的数组信息是 >>>
        99 89 79 69 59 NULL
请输入新元素 <<<
        1
插入元素的下标是 >>>
        5
插入后的新数组元素是 >>>
        99 89 79 69 59 1

C:\Users\byme\javaTest>

——————————

插入字符

        这里是说向有序/无序序列中插入字符
        为什么说有序或者无序因为不管是不是乱序总要排序的。。
        然后插入后保持有序输出
        不过呢我人好还示例了逆序输出

思路：

假如 char 数组 chr[] 长度为 10
得到一组字符
有序处理
找到插入位置
从插入位置开始后面的元素全部后移
输出插入位置插入新字符
遍历输出

code：

import java.util.*;

public class test {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);

		char[] chr = new char[10];

		for ( int i = 0; i < chr.length; i ++ ) {

			if ( i == chr.length - 2 )
				break;

			System.out.print ( "请输入第 " + (i + 1) + " 个字符 <<< " );
			chr[i] = input.next().charAt(0);
		}

		System.out.print ( "\n原字符序列为 >>> " );
		for ( int i : chr )
			System.out.print ( i + " " );

		Arrays.sort ( chr );
		System.out.print ( "\n升序处理后的字符序列为 >>> " );
		for ( int i : chr )
			System.out.print ( i + " " );

		System.out.print ( "\n\n请输入新字符 <<< " );
		char New = input.next().charAt(0);
		for ( int i = 0; i < chr.length; i ++ ) {

			if ( New < chr[i] ) {

				System.out.print ( "待插入字符的下标为 >>> " + i );
				chr[i] = New;

				break;
			}
		}

		System.out.print ( "\n插入后的字符序列为 >>> " );
		for ( int i : chr )
			System.out.print ( i + " " );

		System.out.println ( "" );
	}
}

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入第 1 个字符 <<< q
请输入第 2 个字符 <<< s
请输入第 3 个字符 <<< a
请输入第 4 个字符 <<< c
请输入第 5 个字符 <<< v
请输入第 6 个字符 <<< g
请输入第 7 个字符 <<< z
请输入第 8 个字符 <<< t

原字符序列为 >>> 113 115 97 99 118 103 122 116 0 0
升序处理后的字符序列为 >>> 0 0 97 99 103 113 115 116 118 122

请输入新字符 <<< a
待插入字符的下标为 >>> 3
插入后的字符序列为 >>> 0 0 97 97 103 113 115 116 118 122

C:\Users\byme\javaTest>

        恩？哪里不对？？。。woc 怎么输出数字？？
        其实每一个字母都对应 ASCII 码即美国信息交换码
        字母分别对应编码为：

一个 ASCII 码对应一个字母对。。计算机内部就是这么认的还记得吗？人鬼殊途哇
可是也不该打印 ASCII 码啊。。。。这样验证太麻烦了

值需要修改增强 for 取出的变量类型即可：

/*    demo：
C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入第 1 个字符 <<< q
请输入第 2 个字符 <<< s
请输入第 3 个字符 <<< a
请输入第 4 个字符 <<< c
请输入第 5 个字符 <<< v
请输入第 6 个字符 <<< g
请输入第 7 个字符 <<< z
请输入第 8 个字符 <<< t

原字符序列为 >>> q s a c v g z t 
升序处理后的字符序列为 >>> a c g q s t v z

请输入新字符 <<< a
待插入字符的下标为 >>> 3
插入后的字符序列为 >>> a a g q s t v z
 */

import java.util.*;

public class test {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);

		char[] chr = new char[10];

		for ( int i = 0; i < chr.length; i ++ ) {

			if ( i == chr.length - 2 )
				break;

			System.out.print ( "请输入第 " + (i + 1) + " 个字符 <<< " );
			chr[i] = input.next().charAt(0);
		}

		System.out.print ( "\n原字符序列为 >>> " );
		for ( char i : chr )
			System.out.print ( i + " " );

		Arrays.sort ( chr );
		System.out.print ( "\n升序处理后的字符序列为 >>> " );
		for ( char i : chr )
			System.out.print ( i + " " );

		System.out.print ( "\n\n请输入新字符 <<< " );
		char New = input.next().charAt(0);
		for ( int i = 0; i < chr.length; i ++ ) {

			if ( New < chr[i] ) {

				System.out.print ( "待插入字符的下标为 >>> " + i );
				chr[i] = New;

				break;
			}
		}

		System.out.print ( "\n插入后的字符序列为 >>> " );
		for ( char i : chr )
			System.out.print ( i + " " );

		System.out.println ( "" );
	}
}

不使用增强 for 使用数组配合循环：

import java.util.*;

public class test {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);

		char[] chr = new char[10];

		for ( int i = 0; i < chr.length; i ++ ) {

			if ( i == chr.length - 2 )
				break;

			System.out.print ( "请输入第 " + (i + 1) + " 个字符 <<< " );
			chr[i] = input.next().charAt(0);
		}

		System.out.print ( "原字符序列为 >>> " );
		for ( int i = 0; i < chr.length - 2; i ++ )
			System.out.print ( chr[i] + " " );

		Arrays.sort ( chr );
		System.out.print ( "\n升序处理后的字符序列为 >>> " );
		for ( int i = 2; i < chr.length; i ++ )
			System.out.print ( chr[i] + " " );

		System.out.print ( "\n请输入新字符 <<< " );
		chr[0] = input.next().charAt(0);
		for ( int i = 1; i < chr.length; i ++ ) {

			if ( chr[0] < chr[i] ) {

				System.out.print ( "待插入字符的下标为 >>> " + i );
				chr[1] = chr[0];
				break;
			}
		}

		chr[0] = ' ';
		Arrays.sort ( chr );

		System.out.print ( "\n插入后的字符升序为 >>> " );
		for ( int i = 1; i < chr.length; i ++ )
			System.out.print ( chr[i] + " " );

		System.out.print ( "\n插入后的字符降序为 >>> " );
		for ( int i = chr.length - 1; i > 0; i -- )
			System.out.print ( chr[i] + " " );

		System.out.println ( "" );
	}
}

看上去还是蛮简洁的：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入第 1 个字符 <<< a
请输入第 2 个字符 <<< r
请输入第 3 个字符 <<< y
请输入第 4 个字符 <<< f
请输入第 5 个字符 <<< s
请输入第 6 个字符 <<< x
请输入第 7 个字符 <<< z
请输入第 8 个字符 <<< m
原字符序列为 >>> a r y f s x z m
升序处理后的字符序列为 >>> a f m r s x y z
请输入新字符 <<< d
待插入字符的下标为 >>> 3
插入后的字符升序为 >>> a d f m r s x y z
插入后的字符降序为 >>> z y x s r m f d a

C:\Users\byme\javaTest>java test
请输入第 1 个字符 <<< a
请输入第 2 个字符 <<< b
请输入第 3 个字符 <<< c
请输入第 4 个字符 <<< d
请输入第 5 个字符 <<< f
请输入第 6 个字符 <<< g
请输入第 7 个字符 <<< h
请输入第 8 个字符 <<< y
原字符序列为 >>> a b c d f g h y
升序处理后的字符序列为 >>> a b c d f g h y
请输入新字符 <<< e
待插入字符的下标为 >>> 6
插入后的字符升序为 >>> a b c d e f g h y
插入后的字符降序为 >>> y h g f e d c b a

C:\Users\byme\javaTest>

下面演示了什么叫没有位置了就丢掉：

/*    demo:
C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
原字符序列 >>> a c u b e p f z 
升序处理后 >>> a b c e f p u z
插入字符的下标是 >>> 6
待插入的字符是 >>> m
插入后的字符序列是 >>> a b c e f m p u
 */

import java.util.*;

public class test {

	public static void main(String[] args) {

		char[] chr = new char[9];
		chr[0] = 'a';
		chr[1] = 'c';
		chr[2] = 'u';
		chr[3] = 'b';
		chr[4] = 'e';
		chr[5] = 'p';
		chr[6] = 'f';
		chr[7] = 'z';

		System.out.print ( "原字符序列 >>> " );
		for ( int i = 0; i < chr.length; i ++ )
			System.out.print ( chr[i] + " " );

		Arrays.sort ( chr );
		System.out.print ( "\n升序处理后 >>> " );
		for ( int i = 0; i < chr.length; i++ )
			System.out.print ( chr[i] + " " );

		char ch = 'm';
		int where = 0;
		for ( int i = 0; i < chr.length; i ++ ) {

			if ( ch < chr[i] ) {

				where = i;
				break;
			}
		}

		System.out.print ( "\n插入字符的下标是 >>> " + where );
		System.out.println ("\n待插入的字符是 >>> "+ ch );
		for ( int i = chr.length - 1; i > where; i -- )
			chr[i] = chr[i - 1];

		chr[where] = ch;
		System.out.print ( "插入后的字符序列是 >>> " );
		for ( int i = 0; i < chr.length; i ++ )
			System.out.print ( chr[i] + " " );
		System.out.println();
	}
}

##################################################

小项目程序测试

——————————

查询一组数列的最小值和下标

需求：

vip 用户消费积分最高的 5 位顾客
分别为 20、26、56、43、9
请使用数组接收找出最低积分并指出下标

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入第 1 个 VIP 积分 <<< 20
请输入第 2 个 VIP 积分 <<< 26
请输入第 3 个 VIP 积分 <<< 56
请输入第 4 个 VIP 积分 <<< 43
请输入第 5 个 VIP 积分 <<< 9
最低 VIP 积分为 >>> 9
9 的下标为 >>> 4

C:\Users\byme\javaTest>java test
请输入第 1 个 VIP 积分 <<< 100
请输入第 2 个 VIP 积分 <<< 200
请输入第 3 个 VIP 积分 <<< 300
请输入第 4 个 VIP 积分 <<< 400
请输入第 5 个 VIP 积分 <<< 500
最低 VIP 积分为 >>> 100
100 的下标为 >>> 0

C:\Users\byme\javaTest>

code：

import java.util.*;

public class test {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);

		int VIP[] = new int[5];

		for ( int i = 0; i < VIP.length; VIP[i] = input.nextInt(), i ++ )
			System.out.print ( "请输入第 " + (i + 1) + " 个 VIP 积分 <<< " );

		int min = VIP[0], index = 0;

		for ( int i = 0; i < VIP.length; i ++ )
			if ( VIP[i] < min ) {
				min = VIP[i];
				index = i;
			}

		System.out.println ( "最低 VIP 积分为 >>> " + min );
		System.out.println ( min + " 的下标为 >>> " + index );
	}
}

——————————

在一组数列中寻找符合条件的数值

需求：

使用 int 数组接收 10 个值
合法值为 0、1、2
汇报合法值和非法值的个数

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入 10 个整数数值 >>>
0 1 2 3 4 5 6 7 8 9
合法值 0 的个数为 >>> 1
合法值 1 的个数为 >>> 1
合法值 2 的个数为 >>> 1
非法值的个数为 >>> 7

C:\Users\byme\javaTest>java test
请输入 10 个整数数值 >>>
100
200
0
0
1
2
2
1
1000
0
合法值 0 的个数为 >>> 3
合法值 1 的个数为 >>> 2
合法值 2 的个数为 >>> 2
非法值的个数为 >>> 3

C:\Users\byme\javaTest>java test
请输入 10 个整数数值 >>>
20 1 2 0
23 45 1000
00
800
2
合法值 0 的个数为 >>> 2
合法值 1 的个数为 >>> 1
合法值 2 的个数为 >>> 2
非法值的个数为 >>> 5

C:\Users\byme\javaTest>

code：

import java.util.*;

public class test {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);    /* Scanner 输入方法 */

		int nums[] = new int[10];    /* 接收输入 */
		int nums_OK[] = new int[] { 0, 0, 0, 0, };		/* 统计信息 合法 [1]、[2]、[3] 非法 [0] */

		System.out.println ( "请输入 10 个整数数值 >>> " );    /* 交互信息 */
		for ( int i = 0; i < nums.length; i ++ )
		/* 循环录入 */
			nums[i] = input.nextInt();

		for ( int i = 0; i < nums.length; i ++ )
		/* 遍历统计 */
			if ( nums[i] == 0 )
				nums_OK[1] ++;
			else if ( nums[i] == 1 )
				nums_OK[2] ++;
			else if ( nums[i] == 2 )
				nums_OK[3] ++;
			else
				nums_OK[0] ++;

		/*	其实 使用 switch 更好 ：
		 * for ( int i = 0; i < nums.length; i ++ ) {
		 *	switch ( nums[i] ) {
		 *
		 *		case 0:
		 * 				nums_OK[1] ++;
		 *			break;
		 *
		 *		case 1:
		 *				nums_OK[2] ++;
		 *			break;
		 *
		 *		case 2:
		 *				nums_OK[3] ++;
		 *			break;
		 *
		 *		default:
		 *				nums_OK[0] ++;
		 *			break;
		 *	}
		 * }
		 */

		/* 回显信息 */
		System.out.println ( "合法值 0 的个数为 >>> " + nums_OK[1] );
		System.out.println ( "合法值 1 的个数为 >>> " + nums_OK[2] );
		System.out.println ( "合法值 2 的个数为 >>> " + nums_OK[3] );
		System.out.println ( "非法值的个数为 >>> " + nums_OK[0] );
	}
}

——————————

将原数列逆序存储

需求：

        请将数组
int A[] = new int[] { "-1, 1, -2, 2, 100" };
        用新整形数组逆序储存
        若值 < 0 则按 0 储存

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入 5 个整数 <<< 1 34 95 80 0
新数组元素 >>> 0 80 95 34 1

C:\Users\byme\javaTest>

code：

import java.util.*;

public class test {

	public static void main(String[] args) {

		/* 为了突出程序逻辑 均临时声明变量 */
		int A[] = new int[5];
		System.out.print ( "请输入 5 个整数 <<< " );
		Scanner input = new Scanner(System.in);	
		for ( int i = 0; i < A.length; i ++ )
			A[i] = input.nextInt();

		int B[] = new int[5];
		for ( int i = A.length - 1, j = 0, A_B = 0; i >= 0; i --, j ++ ) {
		/* 为了突出程序逻辑 使用 if 与 switch 结合 */

			if ( A[i] >= 0 )
				A_B = 0;
			if ( A[i] < 0 )
				A_B = 1;

			switch ( A_B ) {

				case 0:
						B[j] = A[i];
					break;

				case 1:
						B[j] = 0;
					break;
			}
		}

		System.out.print ( "新数组元素 >>> " );
		for ( int i = 0; i < B.length; i ++ )
			System.out.print ( B[i] + " " );
		System.out.println();
	}
}

但是负数全部存储为 0 了：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入 5 个整数 <<< -1 1 -2 2 100
新数组元素 >>> 100 2 0 1 0

C:\Users\byme\javaTest>

我也不知道怎么处理负数 double 类型也不支持啊：

/*    demo：
C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入 5 个数 <<< -1 1 -2 2 100
新数组元素 >>> 100.0 2.0 0.0 1.0 0.0

C:\Users\byme\javaTest>
 */

import java.util.*;

public class test {

	public static void main(String[] args) {

		double A[] = new double[5];
		System.out.print ( "请输入 5 个数 <<< " );
		Scanner input = new Scanner(System.in);	
		for ( int i = 0; i < A.length; i ++ )
			A[i] = input.nextDouble();

		double B[] = new double[5];
		for ( int i = A.length - 1, j = 0, A_B = 0; i >= 0; i --, j ++ ) {

			if ( A[i] >= 0 )
				A_B = 0;
			if ( A[i] < 0 )
				A_B = 1;

			switch ( A_B ) {

				case 0:
						B[j] = A[i];
					break;

				case 1:
						B[j] = 0;
					break;
			}
		}

		System.out.print ( "新数组元素 >>> " );
		for ( int i = 0; i < B.length; i ++ )
			System.out.print ( B[i] + " " );
		System.out.println();
	}
}

其实可以找一种算法来代替 j 的迭代减少程序计算资源

新数组下标 = 原数组长度 - 当前下标 - 1

新数组本来就是 0 只要大于 0 就替换

/*    demo：
C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
请输入 5 个整数 <<< 12 87 2 0 89
新数组元素 >>> 89 0 2 87 12

C:\Users\byme\javaTest>
 */

import java.util.*;

public class test {

	public static void main(String[] args) {

		int A[] = new int[5];
		System.out.print ( "请输入 5 个整数 <<< " );
		Scanner input = new Scanner(System.in);	
		for ( int i = 0; i < A.length; A[i] = input.nextInt(), i ++ )
			;;

		int B[] = new int[] { 0, 0, 0, 0, 0 };
		for ( int i = A.length - 1; i >= 0; i -- ) {
		/* 新数组下标为 原数组长度 - 当前下标 - 1 */

			if ( A[i] > 0 )
				B[ A.length - i - 1 ] = A[ i ];
			else
				continue;
		}

		System.out.print ( "新数组元素 >>> " );
		for ( int i = 0; i < B.length; i ++ )
			System.out.print ( B[i] + " " );
		System.out.println();
	}
}

——————————

新增歌曲名

需求：

完成增加新歌曲名的一个小功能
歌曲排序名称按 A~Z 排序

就是插入新字符串呗。。说的那么高大上。。

demo：

C:\Users\byme\javaTest>javac test.java

C:\Users\byme\javaTest>java test
歌单 >>>
        《Go》 《This..》 《NO!》 《EMMM..》 《FUCK!哟》
请输入新歌曲名称 开头必须为英文
<<< 奥特曼a

请输入新歌曲名称 开头必须为英文
<<< a奥特曼
插入后的数组为 >>>
        《EMMM..》 《FUCK!哟》 《Go》 《NO!》 《This..》 《a奥特曼》

C:\Users\byme\javaTest>java test
歌单 >>>
        《Go》 《This..》 《NO!》 《EMMM..》 《FUCK!哟》
请输入新歌曲名称 开头必须为英文
<<< A
插入后的数组为 >>>
        《A》 《EMMM..》 《FUCK!哟》 《Go》 《NO!》 《This..》

C:\Users\byme\javaTest>java test
歌单 >>>
        《Go》 《This..》 《NO!》 《EMMM..》 《FUCK!哟》
请输入新歌曲名称 开头必须为英文
<<< A奥特曼
插入后的数组为 >>>
        《A奥特曼》 《EMMM..》 《FUCK!哟》 《Go》 《NO!》 《This..》

C:\Users\byme\javaTest>

code：

import java.util.*;

public class test {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);

		/* 程序准备 */
		String name = "";	/* 新歌名字 */
		boolean Go = true;	/* 判断输入是否合法 */
		char Name = '\0';	/* 新歌首字符 */

		/* 初始化数组信息 检测到 "/NULL" 就跳过 表示空值 这个 "/NULL" 完全是我瞎编的 你当然也可以自己变成 "/null" */
		String musics[] = new String[] { "Go", "This..", "/NULL", "NO!", "EMMM..", "FUCK!哟", "/NULL" };	/* String 的默认值为 NULL 这边为了直观指定为 "/NULL" */

		/* 回显信息 */
		System.out.print ( "歌单 >>> \n\t" );
		for ( String i : musics ) {

			if ( i.equals("/NULL") )
			/* 如果 值为 "/NULL" 就跳过此次检查 进入下一次检查 */
				continue;
				
			System.out.print ( "《" + i + "》 " );
		}

		do {
		/* 判断输入合法/非法 合法放行 非法就再来一遍 */
		
			System.out.print ( "\n请输入新歌曲名称 开头必须为英文 \n<<< " );
			name = input.next();
			
			char N_chr[] = name.toCharArray();	/* 把 name 挨个抠出来 让 N_chr[] 挨个存着 */
			Name = N_chr[0];	/* Name 就是 name 的第一个字符！ */
			/*	因为 name 是字符串 我们需要判断第一个字母 要抠出来 再进行比较
			 *	我们完全可以抠出来赋值给另一个 String 可是我们偏偏要赋值给 char 为什么？接下来让你大开眼界！！！
			 *
			 *	我们可以通过数组储存单个字符
			 *
			 *	至于 怎么把字符串的值抠出来？ 我们使用这个方法：
			 * 字符数组 = 字符串.toCharArray();
			 *	例如：
			 * String str = "ABC";
			 * Char chr[] = str.toCharArray();
			 *	然后 chr[0] 就是 str 中的第一个字符了！
			 * chr[0] = 'A';
			 * chr[1] = 'B';
			 * chr[2] = 'C';
			 */

			if ( (Name == 'a') || (Name == 'A')
					|| (Name == 'b') || (Name == 'B')
					|| (Name == 'c') || (Name == 'C')
					|| (Name == 'd') || (Name == 'D')
					|| (Name == 'e') || (Name == 'E')
					|| (Name == 'f') || (Name == 'F')
					|| (Name == 'g') || (Name == 'G')
					|| (Name == 'h') || (Name == 'H')
					|| (Name == 'i') || (Name == 'I')
					|| (Name == 'j') || (Name == 'J')
					|| (Name == 'k') || (Name == 'K')
					|| (Name == 'l') || (Name == 'L')
					|| (Name == 'm') || (Name == 'M')
					|| (Name == 'N') || (Name == 'N')
					|| (Name == 'o') || (Name == 'O')
					|| (Name == 'p') || (Name == 'P')
					|| (Name == 'q') || (Name == 'Q')
					|| (Name == 'r') || (Name == 'R')
					|| (Name == 's') || (Name == 'S')
					|| (Name == 't') || (Name == 'T')
					|| (Name == 'u') || (Name == 'U')
					|| (Name == 'v') || (Name == 'V')
					|| (Name == 'w') || (Name == 'W')
					|| (Name == 'x') || (Name == 'X')
					|| (Name == 'y') || (Name == 'Y')
					|| (Name == 'z') || (Name == 'Z')
				) {
				/* 合法条件必须是字母 不管大小写
				 *	判断首字母是否合法 包括大小写
				 *	看到这里是不是萌比了？ 这不是比较字符吗 为什么还是整型比较？？
				 *
				 *	char 能用 == 吗？其实 char 还是基本数据类型 完全可以使用 ==
				 *	在机器中 char 的范围是 0 ~ 65535 仍然是整数！包含在 int 中 既然是整数 便可以进行整数比较
				 *	还记得 ASCII 码吗？？？
				 *	可以自己写个文件试试这个语句：
				 * System.out.println ( 'a' == 'a' );
				 *
				 *	char 在 Java 中不是用一个字节表示 而是 2 个字节是 16 位 可以表示 2 ^ 16 个不同的符号！
				 *	前面的都是 ASCII 这是为了和以前的 ASCII 码兼容 其实 char 用的是 Unicode
				 *	你可以写个文件试试：
				 * System.out.println ( '哈' == '滚' );
				 * System.out.println ( (int)'哈' );
				 * System.out.println ( (int)'滚' );
				 * System.out.println ( (char)20154 );
				 * System.out.println ( (char)29983 );
				 *
				 *	我们经常说 char 是 C/C++ 整形数据中比较古怪的一个。。
				 *
				 *	code：
				 * public class test {
				 *
				 *	public static void main(String args[]) {
				 *
				 *		System.out.println ( 'a' == 'a' );
				 *		System.out.println ( '哈' == '滚' );
				 *		System.out.println ( (int) '哈' );
				 *		System.out.println ( (int) '滚' );
				 *		System.out.println ( (char) 21704 );
				 *		System.out.println ( (char) 28378 );
				 *	}
				 * }
				 *
				 *	demo：
				 * >javac test.java
				 * >java test
				 * true
				 * false
				 * 21704
				 * 28378
				 * 哈
				 * 滚
				 * > 
				 *
				 *	可以看出来什么吗？比如 '哈' 这个字符 在计算机内部用 21703 表示
				 */

					Go = false;
					break;
				}

				/* 	请补充一段代码来检测 合法/非法 字符
				 *
				 *	code：
				 *	boolean Go = true;
				 *	do {
				 *		if ( 条件堆 ) {
				 *			System.out.println ( "合法" );
				 *			Go = false;
				 *			break;
				 *		}
				 *	} while (Go);
				 * System.out.println( "非法" );
				 *
				 *	demo:
				 * >java test.java 
				 * 歌单 >>> 
				 * 《Go》 《This..》 《NO!》 《EMMM..》 《FUCK!哟》 
				 * 请输入新歌曲名称 开头必须为英文 
				 * <<< 哈
				 * 非法
				 * 
				 * 请输入新歌曲名称 开头必须为英文 
				 * <<<  Y呀  
				 * 合法
				 * root@Debian:/work/5.Java/3.Test# java test.java
				 * 歌单 >>> 
				 * 《Go》 《This..》 《NO!》 《EMMM..》 《FUCK!哟》 
				 * 请输入新歌曲名称 开头必须为英文 
				 * <<< 2w
				 * 非法
				 * 
				 * 请输入新歌曲名称 开头必须为英文 
				 * <<< w2
				 * 合法
				 * >
				 */
		} while (Go);

		/*	寻找插入位置 就需要进行比较
		 *	那么问题来了 我们该怎么比较字符串的大小呢？
		 *	int 有 >、<、== 等运算符
		 *	比较字符串是否相同有 字符串.equals(字符串) 方法
		 *	甚至还可以拿 Arrays.sort(字符数组) 方法来给数组排序
		 *	but。。怎么比较字符串？
		 *
		 *	你可能想到了 先把字符串的字母抠出来 然后再循环比较
		 *
		 *	能想到这个办法已经很不错了 其实 我们可以使用字符串的 compareToIgnoreCase() 方法：
		 * 字符串.compareToIgnoreCase(字符串);
		 *
		 *	这个 compareToIgnoreCase() 方法返回的值是 int 类型 按照字典顺序比较两个字符串。。
		 *	方便的是 忽略了大小写！
		 *	这个 code 的意思是 如果按照字典顺序 第一个字符串 大于 第二个字符串 则返回一个正整数 即 1
		 *	否则 就是 如果按照字典顺序 第一个字符串 小于 第二个字符串 则返回一个负整数 即 -1
		 *	如果按照字典顺序 第一个字符串 等于 第二个字符串 则返回 0
		 *
		 *	新歌插入的位置就是新歌曲数组元素中按照字典顺序第一个大于新歌的位置
		 *	所以在 if 条件中 可以利用 compareToIgnoreCase() 方法找到插入位置！
		 *	示例 code：
		 * if ( 歌曲数组[i].compareToIgnoreCase(新歌名字) > 0 ) {
		 *
		 *	index = i;	// 插入位置
		 *	break;	// 跳出三界外，不再五行中。。呸！ 跳出循环。。。
		 * }
		 *
		 *	怎么样 比笨方法强了吧？ 不过 只要能解决问题 管他什么方法呢！！。。
		 *
		 *	不过 我们不打算寻找插入位置 因为 不是有两个空值吗。。。。。
		 *	懂我意思吧。。 我们直接插入空值 然后 Arrays.sort(歌曲数组) 排序 不就好了吗？！
		 *	什么寻找字符串首字符 什么compareToIgnoreCase啥的 都不用 咱就要偷懒！。。
		 *	能偷懒就偷懒啊。。 不过 我思路和备用方法备用代码都给你了 挑不挑战自己就看你的自己的咯 不强迫。。
		 */
		musics[2] = name;
		Arrays.sort( musics );    /* 插入后 */
		System.out.print ( "插入后的数组为 >>> \n\t" );
		for ( String i : musics ) {

			if ( i.equals( "/NULL" ) )
			/* 如果 值为 "/NULL" 就跳过此次检查 进入下一次检查 */
				continue;

			System.out.print ( "《" + i + "》 " );
		}
		System.out.println();
	}
}

燃吹

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
2
评论
6.3_[Java 数组]-经典的 Java 算法

遍历数组倒历数组利用 foreach 增强型 for 循环遍历输出数组输入求和求平均数升序降序字符排序求最大值插入元素插入字符查询一组数列的最小值和下标在一组数列中寻找符合条件的数值将原数列逆序存储新增歌曲名......
复制链接

扫一扫