java数组笔记

1 数组概述

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

2 一维数组的创建与使用

2.1 创建一维数组

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

1. 先声明，再用new运算符进行内存分配

数组元素类型 名字[];
数组元素类型[] 名字;
//具体声明如下：
int arr[];
String str[];

声明数组后还不能立即访问它的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，要想使用数组，还要为它分配内存空间，必须指明数组的长度，格式如下：

数组名字 = new 数组元素的类型[数组元素的个数];
//实例代码如下：
arr = new int[5];

2. 声明的同时为数组分配内存 ：(java)中普遍使用的方法
语法如下：

数组元素的类型 数组名 = new 数组元素的类型[数组元素个数]
//实例代码如下：
int month[] = new int[12];

2.2 初始化一维数组

2.3 使用一维数组

例2.3 创建类GetDay,在主方法中创建int型数组，并实现将各月的天数输出

public class GetDay{                         //创建类
    public static void main(String[] args){  //创建主方法
        int[] day = new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
        for(int i=0;i<12;i++)
            System.out.println((i+1)+"月有"+day[i]+"天");
    }
}

//输出示例
/*
1月有31天
2月有28天
3月有31天
4月有30天
5月有31天
6月有30天
7月有31天
8月有31天
9月有30天
10月有31天
11月有30天
12月有31天
Process finished with exit code 0
*/

3 二维数组的创建与使用

如果一维数组中的各个元素仍然是一个数组，那么它就是一个二维数组。

3.1 创建二维数组

1. 先声明，再用new运算符进行内存分配

数组元素类型 名字[][];
数组元素类型[][] 名字;
//具体声明如下：
int myarr[][];

同一维数组一样，二维数组在声明时也没有分配内存空间，同样要使用new关键字来分配内存，然后才可以进行访问每个元素，对于高维数组，有两种为数组分配内存的方式：

//（1）直接为每一维分配内存空间，实例如下：
a = new int[2][4];

//(2)分别为每一维分配内存空间
a = new int[2][];
a[0] = new int[2];
a[1] = new int[3];

3.2 初始化二维数组

type arrayname[][] = {value1,value2...valuen};
//type:数组数据类型
//arrayneme:数组名称，一个合法的标识符
//value:数组中各元素的值
//初始化实例如下：
int myarr[][] = {{12,0},{45,10}};

3.3 使用二维数组

例3.3 创建类Matrix,在主方法中编写代码实现输出一个3行4列且所有元素都为0的矩阵：

public class Matrix{                         //创建类
    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();
        }
    }
}
//输出示例
/*
0000
0000
0000
Process finished with exit code 0
*/

4 数组的基本操作

4.1 遍历数组

遍历二维数组需要使用双层for循环，通过数组的length属性可获得数组的长度
例4.1.1 创建类Trap，在主方法中编写代码，定义二维数组，将二维数组中的元素呈梯形输出：

public class Trap {
    public static void main(String[] args) {
        int[][] a = new int[][]{{1}, {2, 3}, {4, 5, 6}};//定义二维数组
        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
23
456
Process finished with exit code 0
*/

在遍历数组时，使用foreach语句可能会更加简单，下面的实例就是通过foreach语句遍历二维数组。
例4.1.2 创建类Tautog,在主方法中定义二维数组，使用foreach语句遍历二维数组：

public class Tautog {
    public static void main(String[] args) {
        int[][] arr2 = new int[][]{{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 + "、");    //  输出信息
                }
            }
        }
    }
}

//输出示例：
/*
数组中的元素是：
4、3、1、2
Process finished with exit code 0
*/

4.2 填充替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法il()来对数组中的元素进行替换。该方法通过各种重载形式可完成任意类型的数组元素的替换。fll()方法有两种参数类型。下面以int型数组为例介绍ill()方法的使用方法。

（1）fill(int[] a,int value)
//该方法可将指定的int值分配给int型数组的每个元素，语法如下：
fill(int[] a,int value);
//a:要进行元素替换的数组
//value:要存储数组中所有元素的值

例4.2.1 创建类Swap，在主方法中创建一维数组，并实现通过fill()方法填充数组元素，最后将数组中各个元素输出。

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]);
        }
    }
}

//输出示例：
/*
第0个元素是8
第1个元素是8
第2个元素是8
第3个元素是8
第4个元素是8
Process finished with exit code 0
*/

(2)fill(int[] a,int fromIndex,int toIndex,int value)
//该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromIndex（包括）到索引toIndex（不包括），如果fromIndex==toIndex,则填充范围为空，语法如下：

fill(int[] a,int fromIndex,int toIndex,int value);
//a:要进行填充的数组
//fromIndex:要使用指定值填充的第一个元素的索引（包括）
//toIndex:要使用指定值填充的最后一个元素的索引（不包括）
//value:要存储在数组所有元素的值

例4.2.2 创建类Displace,创建一维数组，并通过fill()方法替换数组元素，最后将数组中的各个元素输出。

import java.util.Arrays;    //  导入java.util.Arrays类

public class Displace {
    public static void main(String[] args) {
        int[] arr = new int[]{45,12,2,10};  //  创建int型数组
        Arrays.fill(arr,1,2,8); //  使用同一个值对数组进行填充
        for (int i = 0; i < arr.length; i++) { //  循环遍历数组中的元素
            System.out.println("第" + i + "个元素是" + arr[i]);
        }
    }
}

//输出示例：
/*
第0个元素是45
第1个元素是8
第2个元素是2
第3个元素是10
Process finished with exit code 0
*/

4.3 对数组进行排序

通过Arrays类的静态sort()方法可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：

Arrays.sort(object)
//object:指进行排序的数组名称

例4.3 创建类Taxis，在主方法中创建一维数组，将数组排序后输出。

import java.util.Arrays;    //  导入java.util.Arrays类

public class Taxis {
    public static void main(String[] args) {
        int[] arr = new int[]{23,42,12,8};  //  创建int型数组
        Arrays.sort(arr); //  将数组进行排序
        for (int i = 0; i < arr.length; i++) { //  循环遍历数组中的元素
            System.out.println(arr[i]);
        }
    }
}

//输出示例：
/*
8
12
23
42
Process finished with exit code 0
*/

4.4 复制数组

Arrarys类的copyOf()方法与copyOfRange()方法可实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

（1）copyOf()方法，语法如下：
copyOf(arr,int newlength);
//arr:要进行复制的数组
//newlenghth:int型常量，指复制后的新数组长度。如果新数组长度大于数组arr的长度，则用0填充（整型0填充，char型null填充），如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取到满足新数组长度为止

例4.4.1 创建类Cope,在主方法中创建一维数组，实现将此数组复制得到一个长度为5的新数组，并将新数组输出：

import java.util.Arrays;    //  导入java.util.Arrays类

public class Cope {
    public static void main(String[] args) {
        int[] arr = new int[]{23, 42, 12};  //  创建int型数组
        int[] newarr = Arrays.copyOf(arr, 5); //  复制数组arr
        for (int i = 0; i < newarr.length; i++) { //  循环遍历数组中的元素
            System.out.println(newarr[i]);
        }
    }
}

//输出示例：
/*
23
42
12
0
0
Process finished with exit code 0
*/

（2）copyOfRange()方法，语法如下：
copyOfRange(arr,int fromIndex,int toIndex);
//arr:要进行复制的数组对象
//fromIndex:指定开始复制数组的索引位置，必须在0-整个数组长度之间，新数组包括fromIndex元素
//toIndex:要复制范围的最后索引位置，可以大于数组arr长度，新数组不包括toIndex元素

例4.4.2 创建类Repeat,在主方法中创建一维数组，并将数组中索引位置是0-3的元素复制到新数组中，最后将新数组输出：

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型数组
        int[] newarr = Arrays.copyOfRange(arr, 0, 3); //  复制数组arr
        for (int i = 0; i < newarr.length; i++) { //  循环遍历数组中的元素
            System.out.println(newarr[i]);
        }
    }
}

//输出示例：
/*
23
42
12
Process finished with exit code 0
*/

5 数组排序算法

5.1 冒泡排序

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

5.1.1 基本思想

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

5.1.2 算法实现

public class HelloWorld {
    public static void main(String []args) {
		int[] arr = {18,13,50,15,4,17,18};
		int temp  = 0 ;
        
		for(int i = 0 ;i< arr.length -1; i++){
			for(int j = 0; j<arr.length-1-i; j++){
				if(arr[j]>arr[j+1]){
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		 System.out.println("arr排序后：");
				
        for(int i = 0; i<arr.length; i++){
			 System.out.print(arr[i]+"\t");
		}	

    }
}