java之数组

一维数组

数组的定义

数组的定义方式和变量类似

public class Main {
    public static void main(String[] args) {
        int[] a = new int[10], b;
        float[] f = new float[33];
        double[] d = new double[123];
        char[] c = new char[21];
    }
}

数组的初始化

public class Main {
    public static void main(String[] args) {
        int[] a = {0, 1, 2};        // 含有3个元素的数组，元素分别是0, 1, 2
        int[] b = new int[3];       // 含有3个元素的数组，元素的值均为0
        char[] d = {'a', 'b', 'c'}; // 字符数组的初始化
        String[] a = new String[10];//这个数组里面包含10个String类型的变量
    }
}

[]是数组类型，java中把[]写到前面是把所有的数组类型都写到前面，后面定义的都是数组。
（而c++中是int b[10]）
①java中的数组是可以重新赋值的，其实就是一个变量，跟普通变量没有区别。

int[] a = {0, 1, 2};
a = new int[10];

②java中没有指针的概念
③java中的数组如果不初始化是不能用的，是一个空数组null。必须先赋初值后使用
变量也是一样的，如果不赋初值也不能用。
所以java不容易出错。

访问数组元素

通过下标访问数组。

public class Main {
    public static void main(String[] args) {
        int[] a = {0, 1, 2};  // 数组下标从0开始

        System.out.printf("%d %d %d\n", a[0], a[1], a[2]);

        a[0] = 5;

        System.out.println(a[0]);
    }
}

java中数组长度可以是变量，而c++中最好是常量
int[] f = new int[n+1];

练习题

使用数组实现求斐波那契数列的第 N 项

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        int[] f = new int[n + 1];//通过数组来做，类似递归
        f[0] = 0;
        f[1] = 1;
        for (int i = 2; i <= n; i ++ )
            f[i] = f[i - 1] + f[i - 2];

        System.out.println(f[n]);
    }
}

输入一个 n，再输入 n个整数。将这 n 个整数逆序输出。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        int[] a = new int[n];
        for (int i = 0; i < n; i ++ )
            a[i] = sc.nextInt();

        for (int i = n - 1; i >= 0; i -- )
            System.out.printf("%d ", a[i]);
    }
}

== 输入 n 个数，将这 n 个数按从小到大的顺序输出。==

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i ++ )
            a[i] = sc.nextInt();

        for (int i = 0; i < n; i ++ )
            for (int j = i + 1; j < n; j ++ )
                if (a[i] > a[j]) {
                    int t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                }

        for (int i = 0; i < n; i ++ )
            System.out.printf("%d ", a[i]);
    }
}

数组不可以直接比较，如果要比较，我们需要这样

或者可以用比较函数（以倒序为例）

如果要是倒序排的话要加比较函数，比较函数的话就不可以用基本类型，我们数组的基本类型必须是一个对象才可以

int/*的对象是*/Integer

就是对象类型的整数，然后我们就可以用比较函数，由Array.sort(q)改为

Array.sort(q,(x,y)->{
	return y-x;//如果返回值是正数，说明x要排在y的后面否则反之
	//如果要是正序则return x-y即可
});

即：

当然我们也可以完成一个二维数组的输出
多维数组就是由一维数组组成的，一维数组本身就是一个对象，故而不用Integer

二维数组展开要用deepToString

多维数组

多维数组就是数组的数组。

public class Main {
    public static void main(String[] args) {
        int[][] a = new int[3][4]; // 大小为3的数组，每个元素是含有4个整数的数组。
        int[][][] b = new int[10][20][30]; // 将所有元素的初值为0
        // 大小为10的数组，它的每个元素是含有20个数组的数组
        // 这些数组的元素是含有30个整数的数组
    }
}

public class Main {
    public static void main(String[] args) {
        int[][] a = {           // 三个元素，每个元素都是大小为4的数组
            {0, 1, 2, 3},       // 第1行的初始值
            {4, 5, 6, 7},       // 第2行的初始值
            {8, 9, 10, 11}      // 第3行的初始值
        };


        for (int i = 0; i < 4; i ++ )  // 将第一行全部变成0
            a[0][i] = 0;

        for (int i = 0; i < 3; i ++ ) {  // 输出二维数组
            for (int j = 0; j < 4; j ++ ) {
                System.out.printf("%d ", a[i][j]);
            }
            System.out.println();
        }
    }
}

①二维数组中每一维的长度可以是不一样的，但一般是一样的。

②属性length：返回数组长度，注意不加小括号
（这个不是API）
a.length; //返回数组a的长度
a[i].length; //如果a是二维数组，返回每一维数组的长度

数组的范围遍历

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int[][] a = {
            {0, 1, 2, 3},
            {4, 5, 6, 7},
            {8, 9, 10, 11},
        };

        for (int[] row: a) {  // 范围遍历
            for (int x: row)  // 范围遍历
                System.out.printf("%d ", x);
            System.out.println();
        }
    }
}

for(数据类型 变量名：数组名)
{
这个变量名就代表数组中的每一项元素了，直接使用变量名进行操作
}

常用API

• 属性length：返回数组长度，注意不加小括号
• Arrays.sort()：数组排序
• Arrays.fill(int[] a, int val)：填充数组
• Arrays.toString()：将数组转化为字符串（最外层）——一维
• Arrays.deepToString()：将多维数组转化为字符串
• 数组不可变长
• 使用Arrays需要import java.util.Arrays
• 使用Arrays需要import java.util.Arrays

(1)Arrays.sort(q)：将数组q中的元素从小到大排序
要想实现从大到小排序里面要使用匿名函数(类似Python的Lambda表达式)，并且数组要用对象定义的方式
①一维数组：
Integer[] q= new Integer[n]; //Integer是对象类型的整数
Arrays.sort(q, (x,y) ->{ //加一个匿名函数
return x-y; // x-y从小到大排序，y-x从大到小排序
} )
②二维数组：
二维数组中的每一个一维数组本身就是一个对象，所以他不需要用Integer
Arrays.sort(q, (x,y) ->{ //加一个匿名函数
return x[0]-y[0];
} )

(2)Arrays.toString(q)：将数组q转化为字符串展开
(3)Arrays.deepToString(q)：将多维数组q转化为字符串展开
(4)Arrays.fill(int[] q, int val)：填充数组,只能初始化一维数组，不能初始化多维数组
例：Arrays.fill(q, -1)

数组的利用

数组作方法参数

public static void function(int [] array){
}

数组作为返回值（是解决返回多种结果的一种方法）

public static int [] caloulate(int a,int b,int c){
		int sum=a+b+c;
		int avg=sum/3;
		int []array={sum,avg};
		return array;
}