Java数组笔记

数组

1 一维数组的创建及使用

1.1 创建一维数组（两种方法）

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

​ 声明方法（两种）：

数组元素类型 数组名[];
 如：String str[];
数组元素类型[] 数组名;//可用于同时声明几个数组
 如：int [] arr,arr1,arr2;

​ 内存分配方法：

数组名字 = new 数组元素类型[数组元素的个数];
 如：arr = new int[5];//创建一个五个元素的整型数组，并将其赋给变量arr。元素的下标为0~4。

2）声明的同时进行内存分配

​ 语法如下：

数组元素类型 数组名[] = new 数组元素类型[数组元素的个数];
 如：int arr[]=new int[5];//这是Java编写程序的常用做法

1.2 初始化一维数组（两种方式）

int arr[] = new int[]{1,2,3,4,5};
int arr[] = {1,2,3,4,5};//(,)分割数组的各个元素，系统自动分配空间

1.3 使用一维数组

例：创建类GetDay，在主方法中创建int型数组，实现各月天数输出。

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

2 二维数组的创建及使用

2.1 创建二维数组（两种方法）

1）先声明，再进行内存分配

声明方法（两种）：

数组元素类型 数组名[][];
 如：String str[][];
数组元素类型[][] 数组名;//可用于同时声明几个数组
 如：int [][] arr,arr1,arr2;

​ 内存分配方法：

数组名字 = new 数组元素类型[(n-1)维数组的个数][(n-1)维数组内数组元素的个数];
 如：arr = new int[5][6];//创建一个二维数组arr，包含5个长度为6的一维数组

2）声明的同时进行内存分配

​ 语法如下：

数组元素类型 数组名[] = new 数组元素类型[(n-1)维数组的个数][(n-1)维数组内数组元素的个数];
 如：int arr[][]=new int[5][6];//这是Java编写程序的常用做法

2.2 初始化二维数组

type arrayname [][] = {value1,value2...valuen};
 如：int arr [][] = {{1,2},{3,4};//注意数组下标都为0开始，如arr[1][1] = 4；且皆为大括号{}

2.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<3(a.length);i++){
               for(int n=0;n<4(a[i].length);n++){
                    System.out.println(a[i][n]);
               }
          }
     }
}

3 数组的基本操作

3.1 遍历数组（两种方法）

1）双重for语句法

例：创建类Trap，定义二维数组，将二维数组中的元素呈梯形输出。

public class Trap{
    public static void main(String[] args){
         int a[][] = new int[][]{{1},{1,2},{1,2,3}};
         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( );
         }
    }
}

2）foreach语句法

例：创建类Tautog，定义二维数组，使用foreach语句遍历二维数组。

public class Tautog{
    public static void main(String[] args){
        int a[][]=new int[][]{{1,2},{3,4}};    //int a[][]={{1,2},{3,4}};
        System.out.println("数组中的元素是：");
        int i=0;                               //外层循环计数器变量
        for(int x[]:a){                        //外层循环变量为一维数组
            i++;                               //外层计数器递增
            int j=0;                           //内层循环计数器变量
            for(int e:x){                      //循环遍历每个数组元素
                j++;                           //内层计数器递增（实际上到这里就已经能够输出数组的所有元素了）
                if(i==a.length&&j==x.length){  //判断变量是二维数组的最后一个元素➡主要是为了去掉最后一个“、”
                    System.out.print(e);       //输出二维数组的最后一个元素
                }else
                    System.out.print(e+"、");  //否则输出其他元素
            }
        }
    }
}

3.2 填充替换数组元素

数组中的元素定义完成后，可以通过Arrays类的静态方法fill()来对数组中的元素进行替换。fill()方法有两种参数类型。

fill()方法的使用方法（int型数组为例）如下：

1）将指定的int值分配给int型数组的每一个元素

语法如下：

(Arrays.)fill(int[] a,int value);
//a:要进行元素替换的数组
//value:要填充/替换数组元素的值

例：创建类Swap，并创建一维数组，通过fill()方法填充一维数组元素。并输出数组所有元素。

import java.util.Arrays;                                //注意！使用fill()方法前需要导入java.util.Arrays类
public class Swap{
    public static void main(String[] args){
        int arr[]=new int[5];
        Arrays.fill(arr,8);
        for(int i=0;i<arr.length;i++){
            System.out.println("No."+i+":"+arr[i]);
        }
    }
}

2)将指定的int值分配给int型数组指定范围内的每个元素

语法如下：

Arrays.fill(int[] a,int fromIndex,int toIndex,int value);
//a,value的意义与上述一致
//fromIndex:要填充的第一个元素的索引(包括)
//toIndex:要填充的最后一个元素的索引(不包括)

例：创建类Displace，创建一维数组，通过fill()方法替换数组元素，并输出所有数组元素。

import java.util.Arrays;
public class Displace{
    public static void main(String[] args){
        int a[]=new int[]{1,2,3,4,5,6};
        Arrays.fill(a,3,5,2);
        System.out.println("被替换后的一维数组的元素有：");
        for(int i=0;i<a.length;i++){
            if(i==(a.length-1)){
                System.out.print(a[i]);
            }
            System.out.print(a[i]+" ");
        }
    }
}

练习：编写Java程序，创建Change类和一维数组，实现将数组a中索引位置为2的元素替换为“bb”，并将替换前后的数组元素分别输出。

import java.util.Arrays;
public class Change {
	public static void main(String[] args) {
		String a[]=new String[]{"a","b","c","c"};
		System.out.print("替换前的一维数组的数组元素有：");
		for(int i=0;i<a.length;i++) {
			if(i==(a.length-1)) {
				System.out.println(a[i]);
			}else
				System.out.print(a[i]+" ");	
		}
		String str="bb";
        Arrays.fill(a,2,3,str);
        System.out.print("替换后的一维数组的数组元素有：");
        for(int j=0;j<a.length;j++) {
        	if(j==(a.length-1)) {
        		System.out.print(a[j]);
        	}else
        		System.out.print(a[j]+" ");
        }
	}
}
//结果是：
//替换前的一维数组的数组元素有：a b c c
//替换后的一维数组的数组元素有：a b bb c

3.3 对数组进行排序

数组中的元素定义完成后，可以通过Arrays类的静态方法sort()方法实现对数组元素的排序。可对任意类型的数组进行**“升序”**排序。

语法如下：

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

例：创建类Taxis，创建一维数组，将数组排序后输出。

import java.util.Arrays;
public class Taxis{
    public static void main(String[] args){
        int a[]=new int[]{4,28,12,1};
        Arrays.sort(a);
        System.out.print("通过排序后的数组元素是：");
        for(int i=0;i<a.length;i++){
            if(i==(a.length-1)){
                System.out.print(a[i]);
            }else
                System.out.print(a[i]+" ");
        }
    }
}

练习：编写Java程序，将数组中最小的数输出。

import java.util.Arrays;
public class Min{
    public static void main(String[] args){
        int a[]=new int[]{22,42,4,5,2};
        Arrays.sort(a);
        System.out.print("数组的最小数组元素是：")；
        System.out.print(a[0]);
    }
}