目录
4.1 数组的概述
4.2 一维数组
4.2.1 创建一维数组
4.2.2 初始化一维数组
4.2.3 获取数组长度
例4.1 代码
例4.1 结果
4.2.4 使用一维数组
例4.2 代码
例4.2 结果
4.3 二维数组
4.3.1 创建二维数组
4.3.2 初始化二维数组
例4.3 代码
例4.3 无结果
4.3.3 使用二维数组
例4.4 代码
例4.4 结果
例4.5 代码
例4.5 结果
4.4 数组的基本操作
4.4.1 遍历数组
例4.6 代码
例4.6 结果
4.4.2 填充和批量替换数组元素
例4.7 代码
例4.7 结果
例4.8 代码
例4.8 结果
4.4.3 复制数组
例4.9 代码
例4.9 结果
例4.10 代码
例4.10 结果
4.5 数组的排序
4.5.1 算法：冒泡排序
1.基本思想
2.计算过程
3.算法实现
例4.11 代码
例4.11 结果
4.5.2 算法：选择排序
1.基本思想
2.计算过程
3.算法实现
例4.12 代码
例4.12 结果
4.5.3 Arrays.Sort （）方法
例4.13 代码
例4.13 结果
数组是具有相同数据类型的一组数据的集合，在程序设计中，可以将这些集合称为数组，数组中的每个元素具有相同的数据类型，在JAVA中同样将数组看作一个对象，虽然基本数据类型不是对象，但是由基本数据类型组成的数组则是对象，在程序设计中引入数组可以有效地管理和处理数据。我们经常使用数组，包括一维数组和二维数组等。
4.2 一维数组
一维数组实质上是一组相同类型数据的线性集合，当在程序中需要处理一组数据，或者传递一组数组时，就可以使用数组实现，一维数组的创建及使用。
4.2.1 创建一维数组
数组元素类型决定了数组的数据类型。它可以是Iva中任意的数据关型包括基本数据类型和其他引用类型。数组名字为一个合法的标识符，符号“[]”指明该变量是一个数组类型变量。单个“[]”表示要创建的数组是一个一维组。
4.2.2 初始化一维数组
数组可以与基本数据类型一样进行初始化操作， 也就是赋初值。数组的初始化可分别初始化数组中的每个元素。
从中可以看出，数组的初始化就是包括在大括号之内用逗号分开的表达式列表。用逗号“”分隔数组中的各个元素，系统自动为数组分配一定的空间。
4.2.3 获取数组长度
例4.1 代码
package hellohello;
public class GetArrayLength { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
char a[]= {'A','B','C','D'}; //创建一维数组
System.out.println("数组a的长度为"+a.length); //输出a的长度
char b[]=a; //创建一维数组b，直接等于数组a
System.out.println("数组b的长度为"+b.length); //输出b的长度
}
}
例4.1 结果
package hellohello;
public class GetArrayLength { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
char a[]= {'A','B','C','D'}; //创建一维数组
System.out.println("数组a的长度为"+a.length); //输出a的长度
char b[]=a; //创建一维数组b，直接等于数组a
System.out.println("数组b的长度为"+b.length); //输出b的长度
}
}
例4.1 结果
4.2.4 使用一维数组
例4.2 代码
package hellohello;
public class GetDay { //创建主类
public static void main(String[] args) { //创建并初始化一维数组
// TODO Auto-generated method stub
int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31}; //输出一年12月中每月的天数
for (int i=0;i<12;i++) { //利用循环将信息输出
System.out.println((i+1)+"月有"+day[i]+"天"); //输出的信息
}
}
}
例4.2 结果
package hellohello;
public class GetDay { //创建主类
public static void main(String[] args) { //创建并初始化一维数组
// TODO Auto-generated method stub
int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31}; //输出一年12月中每月的天数
for (int i=0;i<12;i++) { //利用循环将信息输出
System.out.println((i+1)+"月有"+day[i]+"天"); //输出的信息
}
}
}
例4.2 结果
4.3 二维数组
比如快捷酒店，每-个楼层都有很多房问，这些房问都可以构成维数组， 如果这个酒店有500个房间，并且所有房间都在同一个楼层里，那么拿到499号房钥匙的旅客可能就不高兴了，从1号房走到499号房要花好长时间，因此每个酒店都不只有一个楼层， 而是很多楼层，每一个楼层 都会有很多房间，形成一个立体的结构， 把大量的房间均摊了下来，这种结构就是二维表结构， 如图4.7所示，在计算机中，这种二维表结构可以使用二维数组来表示。如图4.7所示，每一个楼层都是一个一维数组，楼层数本身又构成了一个数组，这样一家酒店 就构成了一个二维数组。
4.3.1 创建二维数组
4.3.2 初始化二维数组
例4.3 代码
package hellohello;
public class InitTDArray { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int tdarr1[][]= {{1,3,5},{5,9,10}}; //定义二维数组
int tdarr2[][]=new int[][] {{65,55,12},{92,7,22}}; //定义新的二维数组
int tdarr3[][]=new int[2][3]; //先给数组分配内存空间
tdarr3[0]=new int[] {6,54,71}; //给第一行分配一个一维数组
tdarr3[1][0]=63; //给第二行第一列赋值给63
tdarr3[1][1]=10; //给第二行第二列赋值给10
tdarr3[1][2]=7; //给第二行第三列赋值给7
}
}
例4.3 无结果
4.3.3 使用二维数组
例4.4 代码
package hellohello;
public class Poety { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
char arr[][] = new char[4][]; // 创建一个4行的二维数组
arr[0] = new char[] { '春','眠','不','觉','晓'}; // 给第一行赋值
arr[1] =new char[] { '处','处','闻','啼','鸟'}; // 给第二行赋值
arr[2] = new char[] { '夜','来','风','语','声'}; // 给第三行赋值
arr[3] = new char[] { '花','落','知','多','少' };// 给第四行赋值
System.out.println("---横版---"); //输出横版
for (int i = 0; i < 4; i++) {// 循环4行
for( int j=0;j < 5;j++){//循环5列
System.out.print(arr[i][j]);//输出数组中的素
}
if (i % 2 == 0) {
System.out.println(",");//如果是一、三句，输出号
}else {
System.out.println("。");//如果是二、四句，输出句号
}
}
System.out.println("n-----竖版-----"); //输出竖版
for (int j = 0; j < 5; j++) {// 列变行
for (int i = 3; i >=0; i--) {// 行变列，反序输出
System.out.print(arr[i][j]);//输出数组中的元素
}
System.out.println();//换行
}
System.out.println("。，。，");//输出最后的标点
}
}
例4.4 结果
package hellohello;
public class InitTDArray { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int tdarr1[][]= {{1,3,5},{5,9,10}}; //定义二维数组
int tdarr2[][]=new int[][] {{65,55,12},{92,7,22}}; //定义新的二维数组
int tdarr3[][]=new int[2][3]; //先给数组分配内存空间
tdarr3[0]=new int[] {6,54,71}; //给第一行分配一个一维数组
tdarr3[1][0]=63; //给第二行第一列赋值给63
tdarr3[1][1]=10; //给第二行第二列赋值给10
tdarr3[1][2]=7; //给第二行第三列赋值给7
}
}
例4.3 无结果
4.3.3 使用二维数组
例4.4 代码
package hellohello;
public class Poety { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
char arr[][] = new char[4][]; // 创建一个4行的二维数组
arr[0] = new char[] { '春','眠','不','觉','晓'}; // 给第一行赋值
arr[1] =new char[] { '处','处','闻','啼','鸟'}; // 给第二行赋值
arr[2] = new char[] { '夜','来','风','语','声'}; // 给第三行赋值
arr[3] = new char[] { '花','落','知','多','少' };// 给第四行赋值
System.out.println("---横版---"); //输出横版
for (int i = 0; i < 4; i++) {// 循环4行
for( int j=0;j < 5;j++){//循环5列
System.out.print(arr[i][j]);//输出数组中的素
}
if (i % 2 == 0) {
System.out.println(",");//如果是一、三句，输出号
}else {
System.out.println("。");//如果是二、四句，输出句号
}
}
System.out.println("n-----竖版-----"); //输出竖版
for (int j = 0; j < 5; j++) {// 列变行
for (int i = 3; i >=0; i--) {// 行变列，反序输出
System.out.print(arr[i][j]);//输出数组中的元素
}
System.out.println();//换行
}
System.out.println("。，。，");//输出最后的标点
}
}
例4.4 结果
例4.4 代码
package hellohello;
public class Poety { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
char arr[][] = new char[4][]; // 创建一个4行的二维数组
arr[0] = new char[] { '春','眠','不','觉','晓'}; // 给第一行赋值
arr[1] =new char[] { '处','处','闻','啼','鸟'}; // 给第二行赋值
arr[2] = new char[] { '夜','来','风','语','声'}; // 给第三行赋值
arr[3] = new char[] { '花','落','知','多','少' };// 给第四行赋值
System.out.println("---横版---"); //输出横版
for (int i = 0; i < 4; i++) {// 循环4行
for( int j=0;j < 5;j++){//循环5列
System.out.print(arr[i][j]);//输出数组中的素
}
if (i % 2 == 0) {
System.out.println(",");//如果是一、三句，输出号
}else {
System.out.println("。");//如果是二、四句，输出句号
}
}
System.out.println("n-----竖版-----"); //输出竖版
for (int j = 0; j < 5; j++) {// 列变行
for (int i = 3; i >=0; i--) {// 行变列，反序输出
System.out.print(arr[i][j]);//输出数组中的元素
}
System.out.println();//换行
}
System.out.println("。，。，");//输出最后的标点
}
}
例4.4 结果
例4.5 代码
package hellohello;
public class IrregularArray { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int a[][]=new int[3][]; //创建二维数组，指定行数，不指定列数
a[0]= new int[] { 52, 64, 85, 12, 3, 64 }; //第一行分配6个元素
a[1]= new int[] { 41, 99, 2 }; //第二行分配3个元素
a[2]= new int[] { 285, 61, 278, 2 }; //第三行分配4个元素
for(int i=0;i
例4.5 结果
4.4 数组的基本操作
4.4.1 遍历数组
遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for 循环来实现的。遍历维数组很简单，也很好理解，下面详细介绍遍历二维 数组的方法。
遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。
例4.6 代码
package hellohello;
public class Trap { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int b[][]=new int[][] {{1},{2,3},{4,5,6}}; //定义二维数组
for (int k=0;k
例4.6 结果
4.4.2 填充和批量替换数组元素
数组中的元素定义完成后，可通过Arrays类的静态方法fll0来对数组中的元素进行分配，可以起到填充和替换的效果。fll()方法有两种参数类型，下面以int型数组为例介绍fill()方法的使用。
1.fill(int[] a,int,value)
方法可将指定的int值分配给int型数组的每个元素
a: 要进行元素分配的数组
value：要存储数组中所以元素的值
例4.7 代码
package hellohello;
import java.util.Arrays; //导入java.util.Arrays类
public class Swap { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int arr[]=new int[5]; //创建int型数组
Arrays.fill(arr, 8); //使用同一个值对数组进行填充
for(int i=0;i
例4.7 结果
2.fill(int[] a,int fromlndex,int value)
方法将指定的int值分配给int型数组指定范围中的每个元素，填充的范围从索引fromlndex一直索引toinde。如果fromindex==toindex，则填空范围为空
a：要进行元素分配的数组
fromlndex：要使用指定值填充的第一个元素的索引
toindex：要使用指定值填充的最后一个元素的索引
value：要存储所在数组所有元素中的值
例4.8 代码
package hellohello;
import java.util.Arrays; //导入java.util.Arrays类
public class Displace { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int arr[]=new int[] {45,12,2,77,31,91,10}; //定义并初始化int型数组arr
Arrays.fill(arr,1,4,8);
for(int i=0;i
例4.8 结果
4.4.3 复制数组
例4.9 代码
package hellohello;
import java.util.Arrays; //导入java.util.Arrays类
public class Cope { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int arr[] = new int[] { 23, 42, 12 };// 定义数组
int newarr[]=Arrays.copyOf(arr, 5); //复制数组arr
for (int i = 0; i < newarr.length; i++) {//循环变量复制后的新数组
System.out.println("第" + i + "个元素是:" + newarr[i]); //将新数组输出
}
}
}
例4.9 结果
例4.10 代码
package hellohello;
import java.util.Arrays; //导入java.util.Arrays类
public class Repeat { //创建主类
public static void main(String[] args) { //主方法
int arr[]=new int[] {23,42,12,84,10}; // 定义数组
int newarr[] = Arrays.copyOfRange(arr, 0, 3); // 复制数组
for (int i =0; i < newarr.length; i++){ //循环遍历复制后的新数组
//将数组中的每个元素输出
System.out.println(newarr[i]);// 将新数组中的每个元素输出
}
}
}
例4.10 结果
4.5 数组的排序
在程序设计中，经常需要将一-组数据进行排序，这样更加方便统计与查询。程序常用的排序方法有冒泡排序、选择排序等。本节将对常用的数据排序方法进行详细讲解。
4.5.1 算法：冒泡排序
冒泡排序是最常用的数组排序算法之-一，它以简洁的思想与实现方法备受青睐，是初学者最先接触的一个排序算法。使用冒泡排序时，排序数组元素的过程总是小数往前放，大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。
1.基本思想
冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。
2.计算过程
冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，般是 要排序的数组长度减1次，因力最后一次循环只剩下-一个数组元素，不需要对比，同时数组已经完成排序了。而内层循平主要用于对比数细中每个临近元素的大小，以确定见否交换位置，对比和交换次数以排序轮数而碗少。
第一轮外层循环时把最大的元素值63移动到了最后面(相应的比63小的元素向前移动，类似气泡上升)，第二轮外层循环不再对比最后个元素值63,因为它已经确认为最大 (不需要上升)，应该放在最后，需要对比和移动的是其他剩余元素，这次将元素24移动到了63的前一一个位置。其他循环将依此类推，继续完成排序任务。
3.算法实现
例4.11 代码
package hellohello;
public class BubbleSort { //创建主类
public void sort(int[] array) { //主方法
//比较相邻两个元素，较大的数往后冒泡
for (int i=1;i< array.length;i++) { //定义i的值
for(int j=0;jarray[j+1]) {
//如果前一个元素比后一个元素大，则两元素互换
int temp=array[j]; // 把第一个元素值保存到临时变量中
array[j]=array[j+1];//把第二个元素值保存到第一个元素单元中
array[j+1]=temp;}}}// 把临时变量(也就是第一个元素原值)保存到第二个元素中
showArray(array);}//输出冒泡排序后的数组元素
public void showArray(int[] array) {
System.out.println("冒泡排序的结果:");//输入输出结果
for(int i:array) {// 遍历数组
System.out.print(i+" ");//输出每个数组元素值
}
System.out.println();//创建排序类的对象
}
public static void main(String[] args) {//创建一个数组，这个数组元素是乱序的
int[]array= {63, 4, 24, 1, 3, 15 };
BubbleSort sorter=new BubbleSort(); //输出BubbleSoort的值
sorter.sort(array);//调用排序方法数组排序
}
}
例4.11 结果
4.5.2 算法：选择排序
直接选择排序方法属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法，是初学者应该掌握的。
1.基本思想
直接选择川序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而尼把满足条件的元水与指定的排序位置交换(如从最后一个元水开始那序)，这样排序好的位置足渐扩大，最后格个数组都成为已排序好的格式。
这就好比有一个小学生，从包含数字1~10的乱序的数字推中分别选择合适的数字，组成一个从1~10的排序，而这个学生'先从数字地中必出1，放在第一位，然后选出2 (注意这时数字堆中已经没有1了)，放在第二位，依此类推，自到找到数字9,放到8的后面，最后剩下10,就不用选择了，直接放到最后就可以了。
与冒泡排序相比，直接选择排序的交换次数观少很多，所以速度会快些。
2.计算过程
每一趟从待排序的数据元素中必出最小（或最大)的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
3.算法实现
例4.12 代码
package hellohello;
public class SelectSort { //创建主类
public void sort(int[] array) { //主方法
int index;
for (int i = 1; i array[index]) {
index = j;
}
}
// 换在置array.length-i和index(最大值)上的两个数
int temp = array[array.length - i]; // 把第一个元素值保存到临时变量中
array[array.length - i] = array[index]; // 把第二个元素值保存到第一个元素单元中
array[index] = temp; // 把临时变量也就是第一个元素原值保存到第二个元素中
}
showArray(array);//输出直接选择排序后的数组值
}
public void showArray(int[] array) {
System.out.println("选择排序的结果为:"); //选择排序的结果
for (int i : array) { //遍历数组
System.out.print(i + " ");//输出每个数组元素值
}
System.out.println(); //输出信息
}
public static void main(String[] args) {
//创建一个数组，这个数组元素是乱序的
int[] array = { 63, 4, 24, 1, 3, 15 };
//创建直接排序类的对象
SelectSort sorter = new SelectSort();
//调用排序对象的方法将数组排序
sorter.sort(array);
}
}
例4.12 结果
4.5.3 Arrays.Sort （）方法
通过Arrays类的静态sort（）方法可实现对数组的排序，sort（）方法提供了多种使用方式，可对任意类型数组进行升序排序。
例4.13 代码
package hellohello;
import java.util.Arrays; //导入java.util.Arrays类
public class Taxis { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int arr[]=new int[] {23,42,12,8};//声明数组
Arrays.sort(arr);//将数组进行排序
System.out.println("排序后的结果为:"); //输出排序结果
for(int i=0;i
例4.13 结果
例4.6 结果
4.4.2 填充和批量替换数组元素
数组中的元素定义完成后，可通过Arrays类的静态方法fll0来对数组中的元素进行分配，可以起到填充和替换的效果。fll()方法有两种参数类型，下面以int型数组为例介绍fill()方法的使用。
1.fill(int[] a,int,value)
方法可将指定的int值分配给int型数组的每个元素
a: 要进行元素分配的数组
value：要存储数组中所以元素的值
例4.7 代码
package hellohello;
import java.util.Arrays; //导入java.util.Arrays类
public class Swap { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int arr[]=new int[5]; //创建int型数组
Arrays.fill(arr, 8); //使用同一个值对数组进行填充
for(int i=0;i
例4.7 结果
2.fill(int[] a,int fromlndex,int value)
方法将指定的int值分配给int型数组指定范围中的每个元素，填充的范围从索引fromlndex一直索引toinde。如果fromindex==toindex，则填空范围为空
a：要进行元素分配的数组
fromlndex：要使用指定值填充的第一个元素的索引
toindex：要使用指定值填充的最后一个元素的索引
value：要存储所在数组所有元素中的值
例4.8 代码
package hellohello;
import java.util.Arrays; //导入java.util.Arrays类
public class Displace { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int arr[]=new int[] {45,12,2,77,31,91,10}; //定义并初始化int型数组arr
Arrays.fill(arr,1,4,8);
for(int i=0;i
例4.8 结果
4.4.3 复制数组
例4.9 代码
package hellohello;
import java.util.Arrays; //导入java.util.Arrays类
public class Cope { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int arr[] = new int[] { 23, 42, 12 };// 定义数组
int newarr[]=Arrays.copyOf(arr, 5); //复制数组arr
for (int i = 0; i < newarr.length; i++) {//循环变量复制后的新数组
System.out.println("第" + i + "个元素是:" + newarr[i]); //将新数组输出
}
}
}
例4.9 结果
package hellohello;
import java.util.Arrays; //导入java.util.Arrays类
public class Cope { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int arr[] = new int[] { 23, 42, 12 };// 定义数组
int newarr[]=Arrays.copyOf(arr, 5); //复制数组arr
for (int i = 0; i < newarr.length; i++) {//循环变量复制后的新数组
System.out.println("第" + i + "个元素是:" + newarr[i]); //将新数组输出
}
}
}
例4.9 结果
例4.10 代码
package hellohello;
import java.util.Arrays; //导入java.util.Arrays类
public class Repeat { //创建主类
public static void main(String[] args) { //主方法
int arr[]=new int[] {23,42,12,84,10}; // 定义数组
int newarr[] = Arrays.copyOfRange(arr, 0, 3); // 复制数组
for (int i =0; i < newarr.length; i++){ //循环遍历复制后的新数组
//将数组中的每个元素输出
System.out.println(newarr[i]);// 将新数组中的每个元素输出
}
}
}
例4.10 结果
4.5 数组的排序
4.5 数组的排序
在程序设计中，经常需要将一-组数据进行排序，这样更加方便统计与查询。程序常用的排序方法有冒泡排序、选择排序等。本节将对常用的数据排序方法进行详细讲解。
4.5.1 算法：冒泡排序
冒泡排序是最常用的数组排序算法之-一，它以简洁的思想与实现方法备受青睐，是初学者最先接触的一个排序算法。使用冒泡排序时，排序数组元素的过程总是小数往前放，大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。
1.基本思想
冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。
2.计算过程
冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，般是 要排序的数组长度减1次，因力最后一次循环只剩下-一个数组元素，不需要对比，同时数组已经完成排序了。而内层循平主要用于对比数细中每个临近元素的大小，以确定见否交换位置，对比和交换次数以排序轮数而碗少。
第一轮外层循环时把最大的元素值63移动到了最后面(相应的比63小的元素向前移动，类似气泡上升)，第二轮外层循环不再对比最后个元素值63,因为它已经确认为最大 (不需要上升)，应该放在最后，需要对比和移动的是其他剩余元素，这次将元素24移动到了63的前一一个位置。其他循环将依此类推，继续完成排序任务。
3.算法实现
例4.11 代码
package hellohello;
public class BubbleSort { //创建主类
public void sort(int[] array) { //主方法
//比较相邻两个元素，较大的数往后冒泡
for (int i=1;i< array.length;i++) { //定义i的值
for(int j=0;jarray[j+1]) {
//如果前一个元素比后一个元素大，则两元素互换
int temp=array[j]; // 把第一个元素值保存到临时变量中
array[j]=array[j+1];//把第二个元素值保存到第一个元素单元中
array[j+1]=temp;}}}// 把临时变量(也就是第一个元素原值)保存到第二个元素中
showArray(array);}//输出冒泡排序后的数组元素
public void showArray(int[] array) {
System.out.println("冒泡排序的结果:");//输入输出结果
for(int i:array) {// 遍历数组
System.out.print(i+" ");//输出每个数组元素值
}
System.out.println();//创建排序类的对象
}
public static void main(String[] args) {//创建一个数组，这个数组元素是乱序的
int[]array= {63, 4, 24, 1, 3, 15 };
BubbleSort sorter=new BubbleSort(); //输出BubbleSoort的值
sorter.sort(array);//调用排序方法数组排序
}
}
例4.11 结果
package hellohello;
public class BubbleSort { //创建主类
public void sort(int[] array) { //主方法
//比较相邻两个元素，较大的数往后冒泡
for (int i=1;i< array.length;i++) { //定义i的值
for(int j=0;jarray[j+1]) {
//如果前一个元素比后一个元素大，则两元素互换
int temp=array[j]; // 把第一个元素值保存到临时变量中
array[j]=array[j+1];//把第二个元素值保存到第一个元素单元中
array[j+1]=temp;}}}// 把临时变量(也就是第一个元素原值)保存到第二个元素中
showArray(array);}//输出冒泡排序后的数组元素
public void showArray(int[] array) {
System.out.println("冒泡排序的结果:");//输入输出结果
for(int i:array) {// 遍历数组
System.out.print(i+" ");//输出每个数组元素值
}
System.out.println();//创建排序类的对象
}
public static void main(String[] args) {//创建一个数组，这个数组元素是乱序的
int[]array= {63, 4, 24, 1, 3, 15 };
BubbleSort sorter=new BubbleSort(); //输出BubbleSoort的值
sorter.sort(array);//调用排序方法数组排序
}
}
例4.11 结果
4.5.2 算法：选择排序
直接选择排序方法属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法，是初学者应该掌握的。
1.基本思想直接选择川序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而尼把满足条件的元水与指定的排序位置交换(如从最后一个元水开始那序)，这样排序好的位置足渐扩大，最后格个数组都成为已排序好的格式。
这就好比有一个小学生，从包含数字1~10的乱序的数字推中分别选择合适的数字，组成一个从1~10的排序，而这个学生'先从数字地中必出1，放在第一位，然后选出2 (注意这时数字堆中已经没有1了)，放在第二位，依此类推，自到找到数字9,放到8的后面，最后剩下10,就不用选择了，直接放到最后就可以了。
与冒泡排序相比，直接选择排序的交换次数观少很多，所以速度会快些。
每一趟从待排序的数据元素中必出最小（或最大)的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
3.算法实现例4.12 代码
package hellohello;
public class SelectSort { //创建主类
public void sort(int[] array) { //主方法
int index;
for (int i = 1; i array[index]) {
index = j;
}
}
// 换在置array.length-i和index(最大值)上的两个数
int temp = array[array.length - i]; // 把第一个元素值保存到临时变量中
array[array.length - i] = array[index]; // 把第二个元素值保存到第一个元素单元中
array[index] = temp; // 把临时变量也就是第一个元素原值保存到第二个元素中
}
showArray(array);//输出直接选择排序后的数组值
}
public void showArray(int[] array) {
System.out.println("选择排序的结果为:"); //选择排序的结果
for (int i : array) { //遍历数组
System.out.print(i + " ");//输出每个数组元素值
}
System.out.println(); //输出信息
}
public static void main(String[] args) {
//创建一个数组，这个数组元素是乱序的
int[] array = { 63, 4, 24, 1, 3, 15 };
//创建直接排序类的对象
SelectSort sorter = new SelectSort();
//调用排序对象的方法将数组排序
sorter.sort(array);
}
}
例4.12 结果
4.5.3 Arrays.Sort （）方法
通过Arrays类的静态sort（）方法可实现对数组的排序，sort（）方法提供了多种使用方式，可对任意类型数组进行升序排序。
例4.13 代码
package hellohello;
import java.util.Arrays; //导入java.util.Arrays类
public class Taxis { //创建主类
public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
int arr[]=new int[] {23,42,12,8};//声明数组
Arrays.sort(arr);//将数组进行排序
System.out.println("排序后的结果为:"); //输出排序结果
for(int i=0;i
例4.13 结果
