Java基础语法(一维数组、二维数组、Arrays工具类)

Java基础语法(一维数组、二维数组、Arrays工具类),第1张

Java基础语法(一维数组、二维数组、Arrays工具类)

Java基础语法(一维数组、二维数组)
  • 1 一维数组
    • 1.1 数组语法
    • 1.2 数组动态赋值
    • 1.3 数组异常
      • 1.3.1 下标越界
      • 1.3.2 空指针异常
    • 1.4 一维数组练习
    • 1.5 数组排序算法
      • 1.5.1 冒泡排序与 Arrays.sort(array)
      • 1.5.2 直接选择排序
  • 2 二维数组
    • 2.1 二维数组语法
    • 2.2 二维数组练习
  • 3 Arrays工具类

1 一维数组 1.1 数组语法

Java 语言中提供的数组是用来存储固定大小的同类型元素。

你可以声明一个数组变量,如 numbers[100] 来代替直接声明 100 个独立变量 number0,number1,…,number99。

声明数组变量的方式有如下两种,第一种为首选:

  1. 类型[] 数组名;
  2. 类型 数组名[]。

Java语言使用 new *** 作符来创建数组,有如下两种初始化方式:

  1. 静态初始化:
    类型[] 数组名 = new 类型[]{值1,值2,…};
  2. 动态初始化:
    类型[] 数组名=new 类型[长度 n];
    数组名[下标 0]=值0;
    数组名[下标 1]=值1;

    数组名[下标 n-1]=值n-1;

数组 *** 作:

  • 获取数组中的元素:可以通过下标;
  • 给数组赋值:可以通过下标;
  • 获取数组长度:数组名.length。
  • 动态数组初始化有默认值:整型 0,浮点 0.0,布尔 false,字符 ‘u0000’,引用 null。

数组动态初始化默认值展示:

public class ArrayOperation01 {

    public static void main(String[] args) {
        // 基本类型
        // 整型默认值 0 char short int long
        byte[] b1=new byte[5];   //有5个0
        b1[0]=13;
        //输出第一个元素
        System.out.println(b1[0]);

        // 小数 默认值 0.0  float double
        float[] f1 = new float[3];  //有3个0.0
        System.out.println(f1[0]);

        //char  默认值  'u0000'  空格
        char[] c1 = new char[5];   //空格
        System.out.println("第二个元素:["+c1[1]+"]");  //输出第二个元素
        //boolean  默认值  false
        boolean[] bools = new boolean[3];
        System.out.println(bools[0]);

        //引用类型   默认值 null;
        String[] names =new String[5];  //null
        names[2]="张三";
        System.out.println(names[2]);

    }
}
1.2 数组动态赋值

通过键盘数据给数组动态赋值:

import java.util.Arrays;
import java.util.Scanner;


public class ArrayDynamic {
    public static void main(String[] args) {
        // 导入键盘输入类
        Scanner input = new Scanner(System.in);
        // 动态初始化一维数组 num,长度为 3
        int[] num = new int[3];

        // for 循环往动态数组中赋值
        for(int i = 0; i < num.length; i++) {
            // 打印赋值开始提示
            System.out.println("请输入第"+(i+1)+"个整数:");
            // 键盘开始输入赋值
            num[i]=input.nextInt();
        }
        // 输出数组信息,导入包 Arrays 工具类.
        System.out.println(Arrays.toString(num));

        // 或者 for 循环遍历输出数组信息
        for(int j = 0;j<3;j++) {
            System.out.print(num[j]+"t");
        }

        System.out.println("n===================");
        // 直接输出数组名得到的是数组地址
        System.out.println(num);

        // 直接输出变量名得到的是变量值
        int a = 100;
        System.out.println(a);

    }
}

运行结果如下所示;

请输入第1个整数:
10
请输入第2个整数:
11
请输入第3个整数:
12
[10, 11, 12]
10	11	12	
===================
[I@7ea987ac
100

1.3 数组异常 1.3.1 下标越界

创建一个数组,长度为4,正确下标是0 ~ 3:

int[] score = new int[]{80,79,65,90};
// 打印下标4 报错,异常 java.lang.ArrayIndexOutOfBoundsException
System.out.println(score[4]);

1.3.2 空指针异常
// 初始化一个一维数组
int[] score = new int[]{80,79,65,90}; 
// 将数组赋值为 null
score = null;
// 打印数组长度,异常 java.lang.NullPointerException
System.out.println(score.length);

或者

// 创建一个引用类型的一维数组,默认值都为 null
String[] names = new String[3];
// 将数组赋值为 null
names=null;
// 打印数组信息,异常 java.lang.NullPointerException
System.out.println(names.toString());

1.4 一维数组练习
  1. 数组中最大元素,最小元素,和,平均值:
public class ArrayOperation02 {

    public static void main(String[] args) {
        //声明一个静态整型数组
        int[] num = new int[]{89,34,7,66,90};
        //假设数组最后一个值是最大值
        int max = num[num.length-1];
        //假设数组最后一个值是最小值
        int min = num[num.length-1];
        //求和
        int sum = 0;
        for (int i = 0; i < num.length; i++){
            // 如果现在的最大值 < 当前数组下标的值
            if(max < num[i]) {
                // 当前数组下标的值为现在的最大值,赋值给 max
                max = num[i];
            }
            // 如果现在的最小值 > 当前数组下标的值
            if(min > num[i]) {
                // 当前数组下标的值为现在的最小值,赋值给 min
                min = num[i];
            }
            // 求和,累加当前数组下标的值
            sum += num[i];
        }
        System.out.println("最大值:" + max);
        System.out.println("最小值:" + min);
        System.out.println("数组中元素的和:" + sum);
        System.out.println("元素的平均值:" + (sum * 1.0 / num.length));
    }
}

程序运行结果如下所示:

最大值:90
最小值:7
数组中元素的和:286
元素的平均值:57.2

  1. 数组复制,反转:

浅拷贝(数组地址赋值,其中一个数组对象改变会影响另一个数组对象):

import java.util.Arrays;


public class ArrayCopy01 {
    public static void main(String[] args) {
        // 声明一个数组
        int[] num = {1,2};
        // 打印当前数组地址
        System.out.println(num);
        // 浅拷贝
        int[] newnum = num;
        // 导入包 Arrays 工具类,打印浅拷贝的数组内容
        System.out.println(Arrays.toString(newnum));

        // 简单 for 循环打印数组内容
//		for(int i=0;i 

深拷贝(改变其中一个数组对象中的数据,不会影响另一个数组对象的数据):

  • 1、按下标赋值;
  • 2、系统函数:System.arraycopy(a, 0, b, 0, a.length);
  • 3、工具类函数:Arrays.copyOf(a, a.length);
  • 4、数组自带函数:a.clone();
import java.util.Arrays;


public class ArrayCopy02 {
    public static void main(String[] args) {
        //1、按下标赋值
//		int[] a = {1,2};
//		int[] b = new int[a.length];
//		for(int i=0;i
//			b[i]=a[i];
//		}
//		b[1]=8;
//		System.out.println(Arrays.toString(a));
//		System.out.println(Arrays.toString(b));

        //2、深拷贝
//		int[] a = {1,2};
//		int[] b = new int[a.length];  //0
//		System.arraycopy(a, 0, b, 0, a.length);
//		b[1]=8;
//		System.out.println(Arrays.toString(a));
//		System.out.println(Arrays.toString(b));

        //3、深拷贝
//		int[] a = {1,2};
//		int[] b = Arrays.copyOf(a, a.length);
//		b[1]=8;
//		System.out.println(Arrays.toString(a));
//		System.out.println(Arrays.toString(b));

        //4、深拷贝
        int[] a = {1,2};
        int[] b = a.clone();
        b[1] = 8;
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));

    }
}

反转:

import java.util.Arrays;


public class ArrayReversal {
    public static void main(String[] args) {
        int[] num = {12,56,3,78,45};
        System.out.println("反转前:" + Arrays.toString(num));

        // 1、逆序输出(没有改变数组中的元素)
        System.out.print("逆序输出:");
        for(int i = num.length-1;i>=0;i--) {
            System.out.print(num[i] + "t");
        }

        // 2、改变数组中数据顺序实现反转
        for(int i = 0; i < num.length / 2; i++) {
            int temp = num[i];
            num[i] = num[num.length-1-i];
            num[num.length-1-i] = temp;
        }
        System.out.println("n反转后:" + Arrays.toString(num));
    }
}

  1. 键盘接收学员的成绩(数组长度为学员人数),获取数组中的最高分,并且根据计算规则输出相应成绩的等级:
    如:int[] score = new int[长度];
    成绩 >= 最高分-10 A级
    成绩 >= 最高分-20 B级
    成绩 >= 最高分-30 C级
    否则是D级
    最后输出例子:成绩 65 分,等级 C 级
import java.util.Scanner;


public class ArrayOperation03 {
    public static void main(String[] args) {
        // 键盘输入类
        Scanner inputScore = new Scanner(System.in);
        // 初始化一维数组存储每个学员的分数,假设有5个学员
        int[] score = new int[5];
        // 记录最高分
        int maxScore = score[0];
        // 键盘依次录入每个学员成绩
        for (int i = 0; i < score.length; i++) {
            System.out.println("请输入第 " + (i + 1) + " 个学员的成绩:");
            // 开始接收键盘输入,并赋值给数组
            score[i] = inputScore.nextInt();
            // 判断当前输入的分数是否是当前最高的分数
            if (maxScore < score[i]){
                // 当前输入的分数是最高的,替换
                maxScore = score[i];
            }
        }

        // 输出每个分数的等级
        for (int i = 0; i < score.length; i++) {
            if(score[i] >= maxScore - 10) {
                System.out.println("成绩 "+score[i]+" 分,等级 A 级");
            }else if(score[i] >= maxScore-20) {
                System.out.println("成绩 "+score[i]+" 分,等级 B 级");
            }else if(score[i] >= maxScore-30) {
                System.out.println("成绩 "+score[i]+" 分,等级 C 级");
            }else {
                System.out.println("成绩 "+score[i]+" 分,等级 D 级");
            }

        }
    }
}

运行结果如下所示:

请输入第 1 个学员的成绩:
65
请输入第 2 个学员的成绩:
99
请输入第 3 个学员的成绩:
45
请输入第 4 个学员的成绩:
87
请输入第 5 个学员的成绩:
76
成绩 65 分,等级 D 级
成绩 99 分,等级 A 级
成绩 45 分,等级 D 级
成绩 87 分,等级 B 级
成绩 76 分,等级 C 级

1.5 数组排序算法 1.5.1 冒泡排序与 Arrays.sort(array)

排序(数组元素从小到大或从大到小):

  1. Arrays.sort(数组变量名);,从小到大排列;
  2. 冒泡排序:
    比较相邻的元素。如果第一个比第二个大,就交换他们两个。
    对每一对相邻元素做同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
    针对所有的元素重复以上的步骤,除了最后一个。
    持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
    规则:两两比较,小在前,从小到大;
    口决:外层循环 N-1 次,内层循环 N-1-i 次。
import java.util.Arrays;


public class BubbleSort {
    public static void main(String[] args) {
        // 静态初始化一个整型数组 numArrSort,用于工具类 Arrays 排序
        int[] numArrSort = {12,4,78,56,32};
        System.out.println("Arrays 工具类排序前:" + Arrays.toString(numArrSort));
        // 复制数组下来用于冒泡排序
        int[] numBubSort = numArrSort.clone();
        // 修改冒泡排序数组中两个值
        numBubSort[0] = 63;
        numBubSort[1] = 42;
        System.out.println("冒泡排序前:" + Arrays.toString(numBubSort));

        // 1、Arrays.sort()
        // 使用 Arrays 工具类排序算法函数 sort:从小到大排序
		Arrays.sort(numArrSort);
		// 打印排序后的数组内容
		System.out.println("Arrays 工具类从小到大排序:" + Arrays.toString(numArrSort));

		// 2、冒泡排序
        //规则 :两两比较,小在前,从小到大排序
        for(int i = 0; i < numBubSort.length-1; i++) {
            for(int j = 0; j < numBubSort.length-1-i; j++) {
                if(numBubSort[j] > numBubSort[j+1]) {
                    int temp = numBubSort[j];
                    numBubSort[j]=numBubSort[j+1];
                    numBubSort[j+1]=temp;
                }
            }
        }
        System.out.println("冒泡排序从小到大排序:" + Arrays.toString(numBubSort));

    }
}

程序运行结果如下所示:

Arrays 工具类排序前:[12, 4, 78, 56, 32]
冒泡排序前:[63, 42, 78, 56, 32]
Arrays 工具类从小到大排序:[4, 12, 32, 56, 78]
冒泡排序从小到大排序:[32, 42, 56, 63, 78]

1.5.2 直接选择排序

直接选择排序(Straight Select Sorting) 也是一种简单的排序方法。
它的基本思想是:

  • 第一次从array[0] ~ array[n-1]中选取最小值,与 array[0] 交换;
  • 第二次从 array[1] ~ array[n-1] 中选取最小值,与 array[1] 交换,…;
  • 第 i 次从 array[i-1] ~ array[n-1] 中选取最小值,与 array[i-1] 交换,…;
  • 第 n-1 次从 array[n-2] ~ array[n-1] 中选取最小值,与 array[n-2] 交换;
  • 总共通过 n-1 次,得到一个按排序码从小到大排列的有序序列。
import java.util.Arrays;


public class StraightSelSort {
    public static void main(String[] args) {
        // 1、静态初始化一个数组
        int[] num = {12,4,78,56,32};

        // 选择轮数
        for(int i = 0; i < num.length - 1; i++){
            // t 记录最小值坐标
            int t = i;
            for (int j = i + 1; j < num.length; j++){
                if (num[t] > num[j]){
                    // 有比 t 下标的值更小,替换当前最小值下标
                    t = j;
                }
            }

            if (t != i){
                // 当前轮数 i 下标不是最小值下标 t,替换掉数组数据最小值
                int temp = num[i];
                num[i] = num[t];
                num[t] = temp;
            }
        }
        
        System.out.println(Arrays.toString(num));
    }
}

运行结果如下所示:

[4, 12, 32, 56, 78]

2 二维数组 2.1 二维数组语法

多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。

语法首选第一种:

  1. 类型[][] 数组名;
  2. 类型 数组名[][] ;
  3. 类型[] 数组名[];

初始化方式:

  1. 静态初始化:
    数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
    也可以是:
    数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
    举例:int[][] arr = {{1,3,5},{4,5},{6}};。
  2. 动态初始化 1:
    数据类型[][] 变量名 = new 数据类型[m][n];
    m 表示这个二维数组有多少个一维数组;
    n 表示每一个一维数组的元素个数;
    举例:定义了一个二维数组 array:
    int[][] array =new int[3][2];
    这个二维数组有 3 个一维数组,名称是 array[0],array[1],array[2];
    每个一维数组有 2 个元素,可以通过 array[m][n]来获取,比如第一个一维数组的两个元素:array[0][0],array[0][1]。
  3. 动态初始化 2:
    数据类型[][] 变量名=new 数据类型[m][];
    m 表示这个二维数组有多少个一维数组,
    这一次没有直接给出一维数组的元素个数,可以动态的给出。
    举例:定义了一个二维数组 array:
    int[][] array=new int[3][];
    给第一个一维数组给定长度为2;
    array[0] = new int[2];
    给第二个一维数组给定长度为3;
    array[1]= new int[3];
    给第三个一维数组给定长度为1;
    array[2]=new int[1];

二维数组的长度:数组变量名.length;
二维数组中一维数组的长度:数组变量名[m].length;

2.2 二维数组练习

1、遍历一个行列确定的二维数组,静态初始化:

public class TwoDimensionalArray01 {
    public static void main(String[] args) {
        int[][] num = new int[][]{{1,2},{3,4,5},{6,7,8,9}};
        System.out.println("二维数组的长度:" + num.length);
        System.out.println("二维数组中第三个一维数组的长度:" + num[2].length);
        // 遍历二维数组
        for(int i=0; i < num.length; i++) {
            for(int j = 0; j < num[i].length; j++) {
                System.out.print(num[i][j]+"t");
            }
            System.out.println();
        }

    }
}

运行结果:

二维数组的长度:3
二维数组中第三个一维数组的长度:4
1	2	
3	4	5	
6	7	8	9	

2、公司年销售额求和,某公司按照季度和月份统计的数据如下:
第一季度:22,66,44
第二季度:77,33,88
第三季度:11,66,99
第四季度:25,45,65

public class TwoDimensionalArray02 {

    public static void main(String[] args) {
        int[][] num ={{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
        int sum = 0;
        // 遍历二维数组
        for(int i=0; i < num.length; i++) {
            for(int j = 0; j < num[i].length; j++) {
                sum += num[i][j];
            }
        }
        System.out.println("公司年销售额:" + sum);
    }

}

运行结果如下:

公司年销售额:641

3、杨辉三角

1
1	1
1	2	1
1	3	3	1
1	4	6	4	1
1	5	10	10	5	1
......

杨辉三角规则:
第 1 行有 1 个元素,第 N 行有 N 个元素,每一行中第一个元素和最后一个元素是 1,从第三行开始除第一个元素和最后一个元素,每个元素是前一行前两项之和:
num[i][j] = num[i-1][j] + num[i-1][j-1];

打印一个 10 行的杨辉三角:

public class YangHuiTriangle {
    public static void main(String[] args) {
        // 定义一个二维数组存储 10 行的杨辉三角
        int[][] yh = new int[10][];

        // 初始化杨辉三角每一行的元素个数,一维数组的长度
        for (int i = 0; i < yh.length; i++){
            yh[i] = new int[i + 1];
        }

        // 杨辉三角每一行元素赋值
        for (int i = 0; i < yh.length; i++) {
            for (int j = 0; j < yh[i].length; j++) {
                // 第一行第二行都为 1
                if (i == 0 || i == 1){
                    yh[i][j] = 1;
                } else {
                    // 从第三行开始,第一个元素和最后一个元素都为 1
                    if (j == 0 || j == yh[i].length - 1){
                        yh[i][0] = 1;
                        yh[i][yh[i].length - 1] = 1;
                    } else {
                        // 中间的元素等于上一行的相同列与前一列的两数之和
                        yh[i][j] = yh[i - 1][j] + yh[i - 1][j - 1];
                    }
                }
            }
        }

        // 打印杨辉三角
        //遍历
        for(int i=0; i < yh.length; i++) {
            for(int j=0; j < yh[i].length; j++) {
                System.out.print(yh[i][j] + "t");
            }
            System.out.println();
        }

    }
}

运行结果:

1	
1	1	
1	2	1	
1	3	3	1	
1	4	6	4	1	
1	5	10	10	5	1	
1	6	15	20	15	6	1	
1	7	21	35	35	21	7	1	
1	8	28	56	70	56	28	8	1	
1	9	36	84	126	126	84	36	9	1	

3 Arrays工具类

java.util.Arrays 类能方便地 *** 作数组,它提供的所有方法都是静态的。

具有以下功能:

  • 给数组赋值:通过 fill 方法。
  • 对数组排序:通过 sort 方法,按升序。
  • 比较数组:通过 equals 方法比较数组中元素值是否相等。
  • 查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法 *** 作。

具体说明请查看下表:

序号方法说明1public static int binarySearch(Object[] a, Object key)用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。2public static boolean equals(long[] a, long[] a2)如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。3public static void fill(int[] a, int val)将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。4public static void sort(Object[] a)对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/zaji/4667717.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-11-06
下一篇 2022-11-06

发表评论

登录后才能评论

评论列表(0条)

保存