第五章总结

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。

遍历数组需使用双层for循环，通过数组的length属性可获得数组的长度。

例：呈梯形输出二维数组中的元素。

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 < b.length; k++){
            for (int c = 0; c <b[k].length; c++){//循环遍历二维数组中的每个元素
            System.out.println(b[k][c]);//将数组中的元素输出
        }
        System.out.println();//输出空格
    }
   }
}
结果如下

 

在遍历数组时，使用foreach语句可能会更简单

例：使用foreach语句遍历数组。

public class Tautog {                                        //创建类
    public static void main(String[] args) {                //主方法
        // TODO Auto-generated method stub
        int arr2[][] = {{4,3},{1,2}};                        //定义二维数组
        System.out.println("数组中的元素是：");                    //提示信息
        int i = 0;                                            //外层循环计数器变量
        for (int x[] :arr2) {                                //外层循环变量为一维数组
            i++;                                            //外层计数器递增
            int j = 0;//内层循环计数器变量
            for (int e : x) {//循环遍历每一个数组元素
                j++;//内层计数器递增
                if(i == arr2.length && j == x.length) {//判断变量是二维数组中的最后一个元素
                    System.out.println(e);//输出二维数组的最后一个元素
                }else//如果不是二维数组中的最后一个元素
                    System.out.print(e + "、");//输出信息
            }
        }
    }
}

结果如下

 

2.填充替换数组元素
替换数组元素

Arrays.fill(数组名，值)；

替换部分数组元素：前改后不改

Arrays.fill(数组名，前索引，后索引，值)；

例：使用fill（）方法填充数组元素

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 < arr.length; i++) {//循环遍历数组中的元素
            System.out.println("第" + i +"个元素是：" + arr[i]);//将数组中的元素依次输出
        }
    }
}
运行结果

 

例：使用fill（）数组替换数组中的元素

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,10};//声明数组
        Arrays.fill(arr, 1,4,8);//将数组进行排序
        for(int i = 0; i < arr.length; i++) {//循环遍历数组后的数组
            System.out.println("第" + i +"个元素是：" + arr[i]);//将排序后数组中的各个元素输出
        }
        
    }
 
}
结果如下

 

4.复制数组
复制数组元素：空位补0，溢出去掉

新数组名 = Arrays.copyOf(旧数组名，新数组长度)；

复制数组部分元素：前在后不在

新数组名 = Arrays.copyOfRange(旧数组名，前索引，后索引)

例：复制数组。

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(newarr[i]);//将新数组输出
        }
    }
 
}
结果如下

 

例：按照索引复制数组。

import java.util.Arrays;//导入java.util。Arrays类
public class Repeat {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        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]);//将新数组中的各个元素输出
        }
    }
 
}
结果如下

 

3.对数组进行排序
arrays.sort(数组名)

例：使用sort（）将数组排序后输出。

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);//将数组进行排序
        for(int i = 0; i < arr.length; i++) {//循环遍历排序后的数组
            System.out.println(arr[i]);//将排序后数组中的各个元素输出
        }
    }
 
}
结果如下

 

查询数组元素：先排序在查询

索引 = Arrays.binarySearch(数组名，元素)；

查询数组元素：先排序在查询

索引 = Arrays.binarySearch(数组名，前索引，后索引，元素)；

查找元素在数组中的索引位置。

import java.util.Arrays;//导入java.util。Arrays类
public class Reference {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        int ia[] = new int[] {1,8,9,4,5};//定义int型数组ia
        Arrays.sort(ia);//将数组进行排序
        int index = Arrays.binarySearch(ia, 4);//查找数组ia中元素4的索引位置
            System.out.println("4的索引位置是：" + index);//将索引输出
    }
 
}
结果如下

 

例：在指定范围内查找元素在数组中的索引位置。

import java.util.Arrays;//导入java.util。Arrays类
public class Rakel {//创建类
 
    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub
        String str[] = new  String[] {"ab","cd","ef","yz"};    //定义string型数组str
        Arrays.sort(str);//将数组进行排序
        int index = Arrays.binarySearch(str,0,2,"cd");//在指定范围内搜索元素"cd"的索引位置
        System.out.println("cd的索引位置是：" + index);//将索引输出
    }
 
}
结果如下

 

数组排序算法
1.冒泡排序
冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将较小的数往前放。较大的数往后放，类似水中气泡往上升的动作，所以称为冒泡排序

例：冒泡排序。

public class BubbleSort {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {63,4,24,1,3,15};//创建一个数组，元素是乱序的
        BubbleSort sorter = new BubbleSort();//创建冒泡排序类的对象
        sorter.sort(array);//调用排序方法，对数组排序
    }
    public void sort(int[] 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);//输出冒泡排序后的数组元素
    }
    public void showArray(int[] array) {
        for (int i : array) {//遍历数组
            System.out.print(">" + i);    //输出每个数组元素值
        }
        System.out.println();
    }
}

结果如下

 

2.直接选择排序
直接选择排序属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法。

直接选择排序的基本思想是将指定排序位置元素与其他数组元素分别对比，如果满足条件就交换元素值。

例：直接选择排序。

public class SelectSort {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] array = {63,4,24,1,3,15};//创建一个数组，元素是乱序的
        SelectSort sorter = new SelectSort();//创建直接排序类的对象
        sorter.sort(array);//调用排序对象方法，对数组排序
    }
    
    public void sort(int[] 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;
        }
    } 
    //交换在位置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) {
    for (int i : array) {//遍历数组
        System.out.print(">" + i);//输出每个数组元素值
    }
    System.out.println();//输出空格
    }
    }

结果如下

 

3.反转排序
顾名思义，反转排序就是一相反的顺序把原有数组的内容重新排序。

反转排序的基本思想，把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换。

例：反转排序。

public class ReverseSort {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        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;
        int len = array.length;
        for (int i = 0; i < len / 2;i++) {
            temp = array[i];
            array[i] = array[len - 1 - i];
            array[len - 1 - i] = temp;
        }
        System.out.println("数组反转后内容：");
        showArray(array);//输出排序后的数组元素
    } 
    
    public void showArray(int[] array) {
    for (int i : array) {//遍历数组
        System.out.print("\t" + i);//输出每个数组元素值
    }
    System.out.println();//输出空格
    }
}

结果如下

 

总结：深刻了解了一维数组，二维数组，填充替换，数组排序。
————————————————