JavaSE基础篇【2】
2022年6月2日
第三部分 字符串
3.1 String 类
Java中 char 类型只能表示单个字符，不能表示由多个字符连接而成的字符串。在Java语言里面，需要将字符串作为对象来处理，可以通过 java.lang 包中的 String 类来创建字符对象。
1. 声明字符串
在Java语言中字符串必须包含在一对双引号（" "）之内。例如：
“23.23” " ABCDE" “你好”
可以通过以下语法格式来声明字符串变量：
String str;
其中 String 指的是该变量为字符串类型，而 str 则代表为字符串变量的名称。
2. 创建字符串
创建对象要使用类的构造方法。String 类的常用构造方法如下：
- ① String(char a[ ])
用一个数组 a 创建 String 对象。 - ② String(char a[ ], int offset, int length)
提取字符数组 a 中的一部分创建一个字符串对象。参数 offset 表示开始截取字符串的位置，length 表示截取字符串的长度。 - ③ String(char [ ] value)
该构造方法可分配一个新的 String 对象，使其表示字符串数组参数中所有元素连接的结果。
除了上述几种使用 String 类的构造方法来创建字符串变量外，还可以通过字符串常量的引用赋值给一个字符串变量。
3.2 连接字符串
1. 连接多个字符串
使用 “+” 运算可以实现连接多个字符串的功能。“+” 运算符可以连接多个运算符并产生一个 String 对象。
package Chapter5;
import java.util.Date;
public class Join {
public static void main(String[] args) {
String s1= new String("hello"); //new String("XXX")创建字符串
String s2= new String("world");
String s=s1+" "+s2;//利用+可以将不同的字符串给连接起来
System.out.println(s);
}
}2. 连接其他类型数据
字符串也可以和其他基本数据类型进行连接。如果将字符串同这些数据类型数据进行连接，会将这些数据直接转化为字符串。
public class Join {
public static void main(String[] args) {
System.out.println("I like"+" "+
"java");//可以换行写，但是得注意引号的位置
System.out.println("我每天花费"+booktime+"小时看书； "+
(practice+booktime)+"小时上机练习。");
}
}3.3 获取字符串信息
1. 获取字符串长度
使用 length( ) 的方法可以获得字符串长度。
str.length( );
2. 字符串查找
String 类提供了两种字符串查找的方法，即 indexOf( ) 方法和 lastIndexOf( ) 方法。这两种方法都允许字符串中搜索指定条件的字符或字符串。indexOf( ) 方法返回的是搜索的字符或字符串首次出现的位置，lastIndexOf( ) 方法返回的是搜索字符或字符串最后一次出现的位置。
public class Join {
public static void main(String[] args) {
String str="We are students ";
int size=str.lastIndexOf("");
System.out.println("字符串的长度为："+str.length());
System.out.println("去除空格后的字符串长为："+str.trim().length());
System.out.println("空字符在字符串中的位置是："+size);
System.out.println("字符串str中索引位置是5的字为："+str.charAt(5));
}
}3. 获取指定索引位置的字符
使用 charAt( ) 方法可以将指定索引位置的字符返回。语法为：
str.charAt(int index)
其中 index 为指定索引的位置。代码在上述已经给出。
3.4 字符串操作
1. 获取子字符串
通过 String 类的 substring( ) 方法可对字符串进行截取。这些方法的共同点就是都利用字符串的下标进行截取，且应明确字符串的下标是从0开始的。
substring( ) 方法被两种不同的方法重载，来满足不同的需要。
- ① substring(int beginIndex)
- ② substring(int beginIndex, int endIndex)
public class Join {
public static void main(String[] args) {
String str="We are students ";
String substr=str.substring(2, 5);
System.out.println("截取后的字符段为："+substr);
}
}2. 去除空格
trim( ) 方法返回字符串的副本，忽略前导空格和尾部空格。具体用法和代码前述已经给出。
System.out.println("去除空格后的字符串长为："+str.trim().length());3. 字符串替换
replace( ) 方法可实现将指定的字符或字符串替换成新的字符或字符串。语法如下：
str. replace(char oldChar, cahr newChar)
replace( ) 方法返回的结果是一个新的字符串。如果字符串 oldChar 没有出现在该对象表达式中的字字符串序列中，则将原字符串返回。
4. 判断字符串的开始与结尾
startsWith( ) 方法与 endsWith( ) 方法分别用于判断字符串是否以指定的内容开始或结束。这个两个方法的返回值都是 boolean 类型。
- ① startsWith( ) 方法
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：
str.startsWith(String prefix)
其中，prefix 是指作为前缀的字符。
- ② endsWith( ) 方法
该方法用于判断当前字符串是否为以给定的子字符串结束。语法如下：
str.endsWith(String suffix)
其中，suffix 是指作为后缀的字符串。
public class Join {
public static void main(String[] args) {
String str="We are students ";
System.out.println("更换后的字符串为："+str.replace("a", "A"));
boolean b1=str.startsWith("W");
boolean b2=str.endsWith("S");
System.out.println("字符串是以W开头的吗："+b1);
System.out.println("字符串是以S开头的吗："+b2);
}
}5. 判断字符串是否相等
对字符串对象进行比较不能简单地使用比较运算符 “==” ，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回 false。
因此，要比较两个字符串内容是否相等，应使用 equals( ) 方法和 equalsIgnoreCase( ) 方法。
- ① equals( ) 方法
如果两个字符串具有相同的字符和长度，则使用 equals( ) 方法进行比较时，返回 true。
语法如下：
str.equals(String otherstr)
其中，str、otherstr 是要比较的两个字符串对象。
- ② equalsIgnoreCase( ) 方法
使用 equals( ) 方法对字符串进行比较时是区分大小写的，而使用 equalsIgnoreCase( ) 方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍为 boolean 类型。语法如下：
str.equalsIgnoreCase(String otherstr)
其中，str、otherstr 是要比较的两个字符串对象。
public class Join {
public static void main(String[] args) {
String str="We are students ";
String str1="WE ARE STUDENTS";
boolean b3=str.equals(str);//区分大小写
boolean b4=str.equalsIgnoreCase(str1);//不区分大小写
System.out.println("字符串str和str1是否相等："+(b3));
System.out.println("字符串str和str1是否相等："+(b4));
}
}6. 按字典顺序比较两个字符串
compareTo( ) 方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的 Unicode 值，按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较，如果按照字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数；如果按照字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。语法如下：
str.compareTo(String otherstr)
System.out.println("a "+ "compareTo"+ " b"+":"+a.compareTo(b));其中，str、otherstr 为两个要比较的对象。
compareTo( ) 方法只有在 equals(Object) 方法返回 true 时才返回0。
7. 字母大小写替换
字符串的 toLowerCase( ) 方法可将字符串中的所有字符从大写字符改为小写字母，而 toUpperCase( ) 方法可将字符串中的小写字符改为大写字符。
- ① toLowerCase( ) 方法
该方法将 String 转换为小写。如果字符串中没有应该被转换的字符，则将原字符返回；否则将返回一个新的字符串，将原字符串中每个该进行小写转换的字符都转换为等价的小写字符。字符长度与原字符长度相同。语法如下：
str.toLowerCase( )
- ② toUpperCase( ) 方法
该方法将 String 转换为大写。如果字符串中没有应该被转换的字符，则将原字符返回；否则将返回一个新的字符串，将原字符串中每个该进行大写转换的字符都转换为等价的大写字符。字符长度与原字符长度相同。语法如下：
str.toUpperCase( )
其中 str 为待转换的字符串。
public class UpAndLower{
public static void main(String args[]){
String str=new String("abc DEF");
String newstr1=str.toLowerCase();
String.newstr2=str.toUpperCase();
System.out.println(newstr1);
System.out.println(newstr2);
}
}8. 字符串分割
使用 split( ) 方法可以使字符串按指定的分割字符或者字符串对内容进行分割，并将分割后的结果存放在字符串数组中。 split( ) 方法提供了以下两种字符串分割形式。
str.split(String sign)
str.split(String sign, int limit)
其中 sign 为分割字符的分割符，也可以使用正则表达式。而 limit 为模式匹配次数，如果设置的值为 n，那么将根据正则表达式匹配 n-1 次，得到的结果数组的长度不会大于 n，数组的最后一项是最后匹配的分割符以后的全部内容。
3.5 格式化字符串
String 类的静态 format( ) 法用于创建格式化的字行申。forma( ) 方法有两种重载形式。
(1) format(String format, Object…args)
该方法使用指定的格式宇符串和参数返回一个格式化字行串，格式化后的新字符串使用本地默认的语言环境。如法如下：
str.format(String format, Object…args)
(2) format(Local 1, String format, Object…args)
- 1：格式化过程中要应用的语言环境。如果1为 null，则不进行本地化。
1. 日期和时间字符串格式化
- 日期格式化
首先来看返回一个月中的天数，实例代码如下：
Date date=new Date();
String s= String.format("%te",date);常用的日期格式化转换符为：
%te: 一个月中的某一天（1~31），如 2；
%tb: 指定语言环境的月份简称，如 Feb（英文），二月（中文）；
%tB: 指定语言环境的月份全称；
%tA: 指定语言环境的星期几全称；
%ta: 指定语言环境的星期几简称；
%tc: 包含全部日期和时间信息；
%tY: 4位年份，如 2008；
%tj: 一年中的第几天，如 085；
%tm: 月份，如 04；
%td: 一个月中的第几天，如 025；
%ty: 2位年份，
import java.util.Date;
public class Eval{
public static void main(String args[]){
Date date=new Date();
String year=String.format("%tY",date);
String month=String.format("%tB",date);
String day=String.format("%td",date);
System.out.println("今年是："+year+"年");
Syetem.out.println("现在是："+month+"月")；
Syetem.out.println("今天是："+day+"号")；
}
}- 时间格式化
时间格式化的转换符主要如下所示：
- 格式化常见的日期和时间组合
常见的格式如下：
%tF: "年-月-日"格式（4位年份），如2022-06-02；
%tD: "月/日/年"格式（2位年份），如06/02/22；
%te: 全部日期和时间信息；
%tr: "时:分:秒 PM(AM)"格式（12时制），如03:22:06 下午；
%tT: "时:分:秒"格式（24时制），如15:23:50；
%tR: "时:分"格式（24时制），如15:23。
2. 常规类型格式化
常规类型的格式化可应用于任何参数类型。
%tb、%tB：结果被格式化为布尔类型；
%th、%tH：结果被格式化为散列码；
%ts、%tS：结果被格式化为字符串类型；
%tc、%tC：结果被格式化为字符类型；
%d：结果被格式化为十进制类型；
%o：结果被格式化为八进制类型；
%x、%X：结果被格式化为十六进制类型；
%e：结果被格式化为科学计数表示的十进制数；
%a：结果被格式化为带有效位数和指数的十六进制浮点数；
%n：结果为特定于平台的行分割符；
%%：结果为字面值%。
3.6 使用正则表达式
正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一个格式。正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。正则表达式中元字符及意义如下：
元字符 | 正则表达式中的写法 | 意义 |
. | . | 表示任意一个字符 |
\d | \d | 代表0~9的任何一个数字 |
\D | \D | 代表任何一个非数字字符 |
s | \s | 代表空白字符，如"\t",“\n” |
S | \S | 代表非空白字符 |
w | \w | 代表可用作标识符的字符，但不包括"$" |
W | \W | 代表不可用于标识符的字符 |
\p{Lower} | \p{Lower} | 代表小写字母a~z |
\p{Upper} | \p{Upper} | 代表大写字母A~Z |
\p{ASCII} | \p{ASCII} | ASCII字符 |
\p{Alpha} | \{Alpha} | 字母字符 |
\p{Digit} | \p{Digti} | 十进制数，即0~9 |
\p{Almum} | \p{Almum} | 数字或字母字符 |
\p{Punct} | \p{Punct} | 标点符号 |
\p{Graph} | \p{Graph} | 可见字符 |
\p{print} | \p{print} | 可打印字符 |
\p{Black} | \p{Black} | 空格或制表符 |
\p{Cntrl} | \p{Cntrl} | 控制字符 |
在正则表达式中可以使用括号括起若干字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。
在正则表达式中允许使用限定修饰符来限定元字符出现的次数。常见的限定修饰符如下表所示：
限定修饰符 | 意义 | 示例 |
？ | 0次或者1次 | A？ |
* | 0次或者多次 | A* |
+ | 1次或者多次 | A+ |
{n} | 正好出现n次 | A{2} |
{n,} | 至少出现n次 | A{2,} |
{n,m} | 出现n~m次 | A{2,3} |
- 字符串生成器 StringBuilder
第四部分 数组
数组是具有相同类型的一组数据的集合。在Java中将数组看作为一个对象。
4.1 一维数组的创建和使用
一维数组实质上是一组相同类型数据的线性集合。
数组作为对象允许使用new关键字进行内存分配。在使用数组前，需要先定义数组变量所属的类型。
- 1. 创建一维数组
- 方法1：先声明，再用new运算符进行内存分配
数组元素类型 数组名字[ ];
数组元素类型[ ] 数组名字;
int arr[];
String str[];然后再为数组分配内存空间：
数组名字 = new 数组元素的类型[数组元素的个数]；
int arr=new int[5];- 方法2：声明的同时为数组分配内存
int month= new int[12];- 2. 初始化一维数组
数组的初始化可分别初始化数组中的每个元素。
int arr1=new int[]{1,2,3,4,5};
int arr2={1,2,3,4,6};- 3. 使用一维数组
public class shuzu {
public static void main(String[] args) {
int Day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};
for(int j=0;j<12;j++) {
System.out.println((j+1)+"月有"+Day[j]+"天");
}
}
}4.2 二维数组的创建和使用
- 1. 创建二维数组
先声明，再弄new运算符进行内存分配。
//直接位每一维分配内存空间
a=new int[2][4];
//分别为每一位分配内存空间
a=new int[2][];
a[0]=new int[2];
a[1]=new int[3];- 2. 初始化二维数组
type arrayname[][]={value 1,value 2,…,value n}
- 3. 使用二维数组
public class shuzu {
public static void main(String[] args) {
int a[][]=new int[3][4];//二维数组
for(int i=0;i<a.length;i++) {
for(int j=0;j<a[i].length;j++) {
System.out.print(a[i][j]);
}
System.out.println();
}
}
}4.3 数组的基本操作
- 1. 遍历数组
数组遍历就是获取数组中的每个元素。通常遍历数组都是用for循环来实现。遍历二维数组需要使用双层for循环，通过数组的 length 属性可获得数组的长度。
public class shuzu {
public static void main(String[] args) {
int a[][]=new int[3][4];//二维数组
for(int i=0;i<a.length;i++) {
for(int j=0;j<a[i].length;j++) {
System.out.print(a[i][j]);
}
System.out.println();
}
}
}在遍历数组时，使用 foreach 语句会更简单。
public class Tautog{ //创建类
public static void main(String[] args){ //主方法
int arr2[][]={{4,3},{1,2}}; //定义二维数组
System.out.println("数组中的元素是："); //提示信息
int k=0; //外层循环计数器变量
for(int x[]:arr2) { //外层循环变量为一维数组
k++; //外层循环计数器递增
int j=0; //内层循环计数器
for(int e:x) { //循环遍历每一个数组元素
j++; //内存计数器递增
if(k==arr2.length&&j==x.length) { //判断变量是二维数组中的最后一个元素
System.out.println(e); //输出二维数组的最后一个元素
}
else //如果不是二维数组中的最后一个元素
System.out.print(e+"、"); //输出信息
}
}
}
}- 2. 填充替换数组元素
数组中的元素定义完成后，可通过Arrays类的静态方法 fill( ) 来对数组中的元素进行替换。该方法通过各种重载的形式可完成对任意类型的数组元素的替换。 - fill(int[ ] a, int value)
该方法可以将指定的 int 值分配给 int 型数组的每个元素。其中：
① a： 表示要进行元素替换的数组。
② value： 要存储数组中所有原色的值。
import java.util.Arrays;
public class Swap{
public static void main(String[] args){
int arr[]=new int[5];
Arrays.fill(A, 8);//整个数组全部填充
System.out.println("全部填充后的数组元素为：");
for(int i=0;i<5;i++){
System.out.print(A[i]+" ");
}
}
}- fill(int[ ] a, int fromIndex, int toIndex, int value)
① a： 表示要进行元素替换的数组。
② value： 要存储数组中所有原色的值。
③ int fromIndex： 要使用指定值填充的第一个元素的索引（包括）
④ int toIndex： 要使用指定值填充的最后一个元素的索引（不包括）
import java.util.Arrays;
public class Displace{
public static void main(String[] args){
int arr[]=new int[]{45,12,2,10};
Arrays.fill(arr, 1, 2, 8);//填充结果包括起始的第一个，不包括结尾的最后一个
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
}- 3. 数组排序
通过Arrays类的静态 sort() 方法可以实现对数组的排序。sort() 方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：
Arrays.sort(object)
在这里，利用 Arrays.sort(arr,Collections.reverseOrder()) 可以实现逆序排序。
import java.util.Arrays;
public class Displace{
public static void main(String[] args){
int arr[]=new int[] {1,8,3,2,5,8,9,3,5,0};
Arrays.sort(arr);//升序排列
for(int i=0;i<10;i++){
System.out.print(arr[i]+" ");
}
Integer[] arr3= {1,2,3,4,5,6,7,8,9};
System.out.println();
System.out.println("降序后的数组为元素为：");
Arrays.sort(arr3,Collections.reverseOrder());//降序排列
for(int i:arr3){
System.out.print(i+" ");
}
}
}- 4. 数组复制
Arrays类的 copyOf( ) 方法与 copyOfRange( ) 方法可以实现对数组的复制。copyOf( ) 方法是复制数组至指定长度，copyOfRange( ) 方法则将指定数组的指定长度复制到一个新数组中。 - copyOf( ) 方法
copyOf(arr,int newlength)
newlength 指的是复制后新数组的长度
- copyOfRange( ) 方法
copyOfRange(arr,int fromIndex, int toIndex)
import java.util.Arrays;
public class Displace{
public static void main(String[] args){
System.out.println();
System.out.println("复制后的数组为元素为：");//全局复制
int newarr1[]=Arrays.copyOf(arr, 15);
for(int i:newarr1){
System.out.print(i+" ");
}
System.out.println();
System.out.println("部分复制后的数组为元素为：");//部分复制
int newarr2[]=Arrays.copyOfRange(arr,0,5);
for(int i:newarr2){
System.out.print(i+" ");
}
}
}- 5. 数组查询
Arrays类的 binarySearch( ) 方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch( ) 方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch( ) 方法有两种参数类型：
① binarySearch(Object[ ] a,Object key )
② binarySearch(Object[ ] a, int fromIndex, int toIndex, Object key )
其中 Object key为要搜索的元素。
import java.util.Arrays;
public class Displace{
public static void main(String[] args){
int arr[]=new int[] {1,8,3,2,5,8,9,3,5,0};
int index1=Arrays.binarySearch(arr, 2);//全局查询
System.out.println("arr中元素2的索引位置为："+index1);
int index2=Arrays.binarySearch(arr,0,3,2);//索引位置0到3的范围查询元素3的索引位置
System.out.println("arr中第1到4个元素中元素3的索引位置为："+index2);
}
}4.4 数组排序算法
- 1. 冒泡排序法
- 基本思想
冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。 - 算法示例
冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，一般为要排序的数组长度减1次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内层循环主要用于对比数组中每个邻近元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。例如，一个拥有6个元素的数组，在排序过程中每一次循环的排序过程和结果如下图所示:
第一轮外层循环时把最大元素值63移动到了最后面（相应地，比63小的元素向前移动，类似气泡上升），第二轮外层循环不再对比最后一个元素值63，因为它已经被确认为最大（不需要上升），应该放在最后，需要对比和移动的是其他剩余元素，这次将元素24移动到了63的前一个位置上。其他循环将以此类推，继续完成排序任务。 - 算法实现
import java.util.Arrays;
import java.util.Collections;
public class MaoPaopx {
public static void main(String[] args) {
Integer[] array= {63,4,24,1,3,15};
// 创建一个数组，这个数组的元素是乱序的
MaoPaopx sorter=new MaoPaopx();
// 创建冒泡排序类的对象
sorter.sort(array);
//调用排序方法将数组排序
}
// 冒泡排序
public void sort(Integer[] array) {
for(int i=1;i<array.length;i++) {//比较相邻两个元素，较大的数往后冒泡
for(int j=0;j<array.length-i;j++) {
if(array[j]>array[j+1]) {
int temp=array[j];//把第一个元素值保存到临时变量中
array[j]=array[j+1];//把第二个元素保存到第一个元素单元中
array[j+1]=temp;//把临时变量（也就是第一个元素值）保存到第二个元素中
}
}
}
showArray(array);//输出冒泡排序后的数组元素（顺序）
showshowArray(array);//输出冒泡排序后的数组元素（倒序）
}
//显示数组中的所有元素（顺序）
public void showArray(Integer[] array) {
System.out.print("冒泡排序结果为（顺序）：");
for(int i:array) {
System.out.print(i+" ");
}
System.out.println();
}
//显示数组中的所有元素（倒序）
public void showshowArray(Integer[] array) {
System.out.print("冒泡排序结果为（倒序）：");
Arrays.sort(array,Collections.reverseOrder());//倒排序
for(int i:array) {
System.out.print(i+" ");
}
}
}- 2. 直接选择排序法
直接选择排序方法属于选择排序的一种，它的排序速度比冒泡排序快一些，也是常用的排序算法。
- 基本思想
直接选择排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值。注意这里与冒泡排序的区别，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换(如从最后一个元 素开始排序)，这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。
这就好比有一个小学生， 从包含数字1~10的乱序的数字堆中分别选择合适的数字，组成一个1至10的排序，而这个学生首先从数字堆中选出1，放在第一位，然后选出2 (注意这时数字堆中已经没有1了)，放在第二位，依此类推，直到其找到数字9，放到8的后面，最后剩下10，就不用选择了，直接放到最后就可以了。
与冒泡排序相比，直接选择排序的交换次数要少很多，所以速度会快一些。 - 算法示例
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序地放在已排好地数列地最后，直到全部待排序的数据元素排完。
①初始数据资源 【63 4 24 1 3 15】
②第一趟排序后 【15 4 24 1 3】63
③第二趟排序后 【15 4 3 1】24 63
③第三趟排序后 【1 4 3】15 24 63
④第四趟排序后 【1 3】4 15 24 63
⑤第五趟排序后 【1】3 4 15 24 63 - 算法实现
import java.util.Arrays;
import java.util.Collections;
public class SelectSort {
public static void main(String[] args) {
Integer[] array= {63,4,24,1,3,15};
SelectSort sorter=new SelectSort();
sorter.sort(array);//调用排序对象的方法将数组排序
}
//直接选择排序
public void sort(Integer[] array) {
int index;
for(int i=1;i<array.length;i++) {
index=0;
for(int j=1;j<=array.length-i;j++) {
if(array[j]>array[index]) {
index=j;
}
}
int temp=array[array.length-i];
array[array.length-i]=array[index];
array[index]=temp;
}
showArray(array);
showshowArray(array);
}
//显示数组中所有元素（顺序）
public void showArray(Integer[] array) {
System.out.print("ֱ直接选择排序（顺序）输出为：");
for(int i:array) {
System.out.print(i+" ");
}
System.out.println();
}
//显示数组中的所有元素（倒序）
public void showshowArray(Integer[] array) {
System.out.print("ֱ直接选择排序（倒序）输出为：");
Arrays.sort(array,Collections.reverseOrder());//元素顺序翻转
for(int i:array) {
System.out.print(i+" ");
}
}
}- 3. 反转排序法
顾名思义，反转排序就是以相反的顺序把原有数组的内容重新排序。
- 基本思想
反转排序的基本思想比较简答，其实现思路就是把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有元素反转替换。 - 算法示例
反转排序是对数组两边的元素进行替换，所以只需要循环数组长度的半数次，如数组长度为7，那么for循环只需要循环3次。
①初始数据资源 【10 20 30 40 50 60】
②第一趟排序后 60【20 30 40 50 10】
③第二趟排序后 60 50【30 40】20 10
④第三趟排序后 60 50 40 30 20 10 - 算法实现
public class ReverseSort {
public static void main(String[] args) {
int[] array= {10,20,30,40,50,60};
ReverseSort sorter=new ReverseSort();
sorter.sort(array);
// 调用排序对象的方法，将数组反转
}
//反转排序
public void sort(int[] array) {
System.out.println("数组原有内容：");
showArray(array);
int temp;
for(int i=0;i<array.length/2;i++) {
temp=array[i];
array[i]=array[array.length-i-1];
array[array.length-i-1]=temp;
}
System.out.println("数据反转后的内容：");
showArray(array);//输出排序后的数组元素
}
//显示数组中的所有元素
public void showArray(int[] array) {
for(int i:array) {
System.out.print("\t"+i);//输出每个数组元素的值
}
System.out.println();
}
}
