第五章总结（数组）

数组是最常见的一种数据结构，是相同类型的用一个标识符封装到一起的基本数据类型数据序列或对象序列。

数组概述

数组是具有相同数据类型的一组数据的集合。例如，球类的集合——足球,篮球，羽毛球等；电器集合——电视机，洗衣机，电风扇等。在程序设计中，可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。在java中同样将数组看作一个对象，虽然基本数据类型不是对象，但由基本类型组成的数组却是对象。在程序设计中引入数组可以有效地管理和处理数据。可根据数组的维数将数组分为一堆数组，二维数组······

一维数组

一维数组实质上是一组相同类型数据的线性集合，当在程序中需要处理一组数据，或者传递一组数据时，可以应用这种类型的数组。

1. 创建一维数组

数组作为对象允许使用new关键字进行内存匹配。在使用数组之前，必须首先定义数组变量所属的类型。一维数组的创建有两种方式：

1先声明，再用new关键字进行内存分配

2声明的同时为数组分配内存

2.初始化一维数组

数组与基本数据类型一样可以进行初始化操作。数组的初始化可分别初始化数组中的每个元素。

3.使用一维数组

在java集合中，一维数组是常见的一种数据结构。

例：使用一维数组输出1~12月每个月份的天数

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};    //创建并初始化一维数组            
        for(int i = 0; i < day.length;i++) {                                //利用循环将信息输出
            System.out.println((i + 1)+"月有" + day[i] + "天");        //输出每月的天数
        }
    }
}

结果如下

二维数组

1.创建二维数组

先声明，再用new关键字进行内存分配

声明的同时为数组分配内存

数组名 = new 数组元素的类型[行数][列数]

二维数组分配内存同时设置初始值

数组名 = new 数组元素的类型[][]{值1，值2,...},{值1，值2，...}，...，{值1，值2，...};

2.初始化二维数组

二维数组的初始化与一维数组初始化类似，同样可以使用大括号完成。

二维数组元素赋值

数组名[行号] = {值1，值2，...}；

数组名[行号][列号] = 值；

3.使用二维数组

二维数组在实际应用得非常广泛。

例:输出一个3行4列且所有元素都为0的矩阵。

public class Matrix {                                //创建类
    public static void main(String[] args) {        //主方法    
        // TODO Auto-generated method stub
        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();                    //输出空格
        }
    }

}

结果如下

数组的基本操作

1.遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用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();//输出空格
    }
}

结果如下

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