Java数组

一、数 组

数组：是具有相同数据类型的一组数据的集合。

二、一 维 数 组

数组作为对象允许使用new关键字进行内存分配。（使用new时，各元素的初始值都为0）

1.创建一维数组

1.先声明，再使用new分配内存，俩种方式
    数组元素类型 数组名字[]
    数组原始类型【】 数组名字
    
2.分配内存空间的语法格式
    数组名字 = new 数组元素的类型【数组元素的个数】                 //数组元素的个数是指数组中变量的个数，即数组的长度
    
3.声明的同时为数组分配内存
    数组元素类型 数组名 = new 数组元素的类型【数组元素的个数】
    eg：int a[] = new int[12]                        //数组的长度为12

2.初始化一维数组

数组的初始化俩种方式：
int arr[] = new int[]{1,2,3,5};         //第一种
int arr1[] ={12,23,36};                 //第二种

三、二 维 数 组

1.创建二维数组

1.先声明，再使用new分配内存，俩种方式:
    数组元素类型 数组名字[][]
    数组原始类型[][] 数组名字
2.声明的同时为数组分配内存  
        eg:int a = new int[3][2]           //三行二列

//输出古诗  声明一个字符型二维数组，将古诗《春晓》的内容赋值于二维数组，然后分别用很版和竖版俩种方式输出
public class wen_p772 {
    public static void main(String[] args) {
        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(); // 换行i
        }
        System.out.println("。，。，"); // 输出最后的标点
    }
}

四、数 组 的 基 本 操 作

1、遍历数组

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

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

public class Trap { // 创建类
    public static void main(String[] args) { // 主方法
        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.print(b[k][c]); // 将数组中的元素输出
            }
            System.out.println(); // 输出空格
        }
    }
}

foreach

public class Tautog { // 创建类
    public static void main(String[] args) { // 主方法
        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.print(e); // 输出二维数组的最后一个元素
                } else
                    // 如果不是二维数组中的最后一个元素
                    System.out.print(e + "、"); // 输出信息
            }
        }
    }
}
​

2、填充替换数组元素

数组中的元素定义完成后，可通过arrays类的静态方法fill()来对数组中的元素进行替换。

该方法通过各种重载形式可完成对任意类型的数组元素的替换。

fill（）方法有俩种参数类型：

1. fill（int【】 a，int value）

a： 要进行元素替换的数组。

value： 要存储的数组中所有元素的值。

import java.util.Arrays; //导入java.util.Arrays类
​
public class Swap { // 创建类
    public static void main(String[] args) { // 主方法
        int arr[] = new int[5]; // 创建int型数组
        Arrays.fill(arr, 8); // 使用同一个值对数组进行填充
        for (int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素
            // 将数组中的元素依次输出
            System.out.println("第" + i + "个元素是：" + arr[i]);
        }
    }
}

2. fill (int[] a,int fromlndex , int tolndex , int value)

a： 要进行元素替换的数组。

fromledex: 要使用指定值填充的第一个元素的索引（包括）。

tolndex： 要使用指定值填充的最后一个元素的索引（不包括）。

value: 要分配给数组指定范围中的每个元素的值。

import java.util.Arrays;
public class wen_p792 {
    public static void main(String[] args) {
        int a[] =new int[]{45,12,2,10};
        Arrays.fill(a,1,3,999);      //使用fill方法替换数组指定范围的元素
        for (int i=0;i<a.length;i++){
            System.out.println("第"+i+"个元素是："+a[i]);
        }
    }
}

3、对数组进行排序

通过arrays类静态方法sort（）可以实现对数组的排序。

sort（）方法提供了多种重载形式

arrays.sort（object） //object是指进行排序的数组名称

import java.util.Arrays;
public class wen_p801 {
    public static void main(String[] args) {
        int a[]=new  int[]{23,8,45,31};            //声明数组
        Arrays.sort(a);                            //将数组进行排序
        for (int i=0;i<a.length;i++){                
            System.out.println(a[i]);
        }
    }
}

4、复制数组

arrays类的copyOf()方法与copyOfRange（）方法可以实现对数组的复制。

copyOf()方法是复制数组至指定长度

copyOfRange（）方法则将指定数组的指定长度复制到一个新数组中

1.copyOf()方法

copyof（arr ， int newlength）

arr ：要进行复制的数组

newlength：int型常量，指复制后的新数组的长度。如果新数组的长度大于数组arr的长度，则用0填充。（根据复制数组的类型来决定填充的值，整形数组用0填充，char型数组则使用null来填充）；如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取至满足新数组长度为止。

import java.util.Arrays;
public class wen_p811 {
    public static void main(String[] args) {
        int a[]= new int[]{23,45,15};          //定义数组
        int b[]= Arrays.copyOf(a,5);  //复制arr数组
        for (int i=0;i<b.length;i++){
            System.out.println(b[i]);
        }
    }
}

2.copyOfRange（）方法

copyOfRange（arr , int formindex , int tolndex）

formindex: 指定开始复制数组的索引位置。formindex必须在0至整个数组的长度之间。新数组包括索引是formindex的元素。

toindex： 要复制范围的最后索引位置。可大于数组arr的长度。新数组不包括索引是toindex的元素。

import java.util.Arrays;
public class wen_p821 {
    public static void main(String[] args) {
        int a[]= new int[]{45,15,35,66,8};             //定义数组a
        int b[]= Arrays.copyOfRange(a,1,5);           //复制数组a
        for (int i=0;i<b.length;i++){
            System.out.println(b[i]);
        }
    }
}

5、查询数组

arrays类的binarySearch（）方法，可使用二分搜索法来搜索指定数组，以获得指定的对象。

binarySearch（）方法的俩种参数类型

1.binarySearch（Object[] a , int formindex , int toindex , object key）

a: 要搜索的数组。

formindex： 要所搜的第一个元素的索引（包含formindex）。

toindex： 要搜索的最后一个元的索引（不包括toindex）。

key： 要搜索的值。 //如果key包含在数组中，则返回搜索值的索引；否则返回-1或“-”（插入点）。插入点是搜索键将要插入数组的哪一个点，即第一个大于此键的元素索引。

查询前必须要对数组进行排序，否者查询的结果是不确定

import java.util.Arrays;
public class wen_p831 {
    public static void main(String[] args) {
        int a[]= new int[]{12,45,23,6,9,1};       //定义数组
        Arrays.sort(a);                          //对数组排序
        int b=Arrays.binarySearch(a,6);         //查询数组中元素6的索引位置
        System.out.println("6de搜索位置是："+b);
    }
}

**2.binarySearch（Object[] a , int formindex , int toindex , object key）

a: 要进行检索的数组

formindex：指定范围的开始处索引（包括）

toindex：指定范围的结束处索引（不包括）

import java.util.Arrays;
public class wen_p841 {
    public static void main(String[] args) {
        String a[]= new String[]{"ab","cd","ct","ad"};        //定义数组
        Arrays.sort(a);                                         //进行数组排序
        int b=Arrays.binarySearch(a,2,4,"ct");        //在指定范围内搜索
        System.out.println("ad的索引位置是："+b);
    }
}

五、数 组 排 序 算 法

1、冒泡排序

①、基本思想

冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把比小的元素移动到数组的前面，把较大的元素移动到数组后面，这样较小的元素就像气泡一样从底部上升到顶部。

②、算法

冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，一般为要排序的数组长度减一次，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。而内层循环主要用于对比数组中每个邻近元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。

import java.util.Arrays;
public class wen_p8511 {
    public static void main(String[] args) {
        int a[] =new int[]{99,12,16,2,5};
        int[] sort = sort(a);         //调用完我们自己写的排序方法以后，返回一个排序后的数组
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array){
        for (int i = 0; i < array.length-1 ; i++) {            // 比较相邻两个元素，较大的数往后冒泡
            for (int j = 0; j <array.length-1-i ; j++) {
                if (array[j]>array[j+1]){
                    int m=array[j];       // 把第一个元素值保存到临时变量中
                    array[j]=array[j+1];  // 把第二个元素值保存到第一个元素单元中
                    array[j+1]=m;           // 把临时变量（也就是第一个元素原值）保存到第二个元素中
                }
            }
        }
        return array;        //返回出来
    }
}

2、直接选者排序

①、基本思想

直接选者排序的基本思想是将指定排序位置元素与其他数组元素分别对比，如果满足条件就交换元素值。注意这里与冒泡排序的区别，不是交换相邻的元素，而是把满足条件的元素与指定的排序位置元素交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，直至整个数组都变成已排序好的格式。

与冒泡排序相比，直接选择排序的交换次数要少很多，所以速度会快些。

②、算法

public class wen_p871 {
    public static void main(String[] args) {
        // 创建一个数组，这个数组元素是乱序的
        int[] array = { 63, 4, 24, 1, 3, 15 };
        // 创建直接排序类的对象
        wen_p871 sorter = new wen_p871();
        // 调用排序对象的方法将数组排序
        sorter.sort(array);
    }

    /**
     * 直接选择排序
     *
     * @param 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); // 输出直接选择排序后的数组元素
    }

    /**
     * 显示数组中的所有元素
     *
     * @param array 要显示的数组
     */
    public void showArray(int[] array) {
        for (int i : array) { // 遍历数组
            System.out.print(" >" + i); // 输出每个数组元素值
        }
        System.out.println();
    }
}

3、反转排序

①、基本思想

反转排序的基本思想比较简单，也很好理解，其实现思路就是把数组最后一个元素与第一个元素替换，倒数第二个元素与第一个元素替换，以此类推，直到把所有数组元素反转替换。

②、算法

反转排序是对数组俩边的元素进行替换，所以只需要循环数组长度的半数次，如果数组长度为7，那for循环只需要循环3次。

/**
 * 反转排序算法实例
 */
public class ReverseSort {
	public static void main(String[] args) {
		// 创建一个数组
		int[] array = { 10, 20, 30, 40, 50, 60 };
		// 创建反转排序类的对象
		ReverseSort sorter = new ReverseSort();
		// 调用排序对象的方法，将数组反转
		sorter.sort(array);
	}

	/**
	 * 反转排序
	 * 
	 * @param 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); // 输出排序后的数组元素
	}

	/**
	 * 显示数组中的所有元素
	 * 
	 * @param array 要显示的数组
	 */
	public void showArray(int[] array) {
		for (int i : array) { // 遍历数组
			System.out.print("\t" + i); // 输出每个数组元素值
		}
		System.out.println();
	}
}

·