java阶段初级数组

心念无她

已于 2023-05-23 10:27:40 修改

阅读量89

点赞数

文章标签： java

于 2023-05-23 10:26:24 首次发布

本文链接：https://blog.csdn.net/m0_64681445/article/details/130814103

版权

数组(array)

是一种用于存储多个相同类型数据的存储模型

数组的初始化状态

动态初始化：格式：数据类型 [ ] 变量名 = new 数据类型[数组长度];
静态初始化：格式：数据类型 [ ] 变量名 = new 数据类型[ ] { 数据1 , 数据2 , 数据3 , ……} ; 简化格式：数据类型 [ ] 变量名 = { 数据1 , 数据2 , 数据3 , ……} ;

数组元素访问

数组变量访问方式格式：数组名
数组内部保存的数据的访问方式格式：数组名[索引]
索引是数组中数据的编号方式
作用：索引用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名特征①：索引从0开始
特征②：索引是连续的
特征③：索引逐一增加，每次加1

数组操作中常见的两个小问题

索引越界：访问了数组中不存在的索引对应的元素，造成索引越界问题
空指针异常：访问的数组已经不再指向堆内存的数据，造成空指针异常

数组常见操作

遍历：通用格式

int[] arr = {……};
for(int x=0; x<arr.length; x++) {
    arr[x]	 
}

最值：通用格式

//思路：
//1：定义一个变量，用于保存最大值（或最小值）
         int max;
//2：取数组中第一个数据作为变量的初始值
         int max = arr[0];
//3：与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
           for(int x=1; x<arr.length; x++) {
                      if(arr[x] > max) {
                                  max = arr[x];    
                  }
            }
//4：循环结束后打印变量的值
           System.out.println("max:"+max);

数组课后练习：

现有一个小数数组{12.9,53.54,75.0,99.1,3.14}。请编写代码，找出数组中的最小值并打印。

public class ShuZu1 {
    public static void main(String[] args) {
        double[] arr = {12.9,53.54,75.0,99.1,3.14};
        double min = arr[0];
        for (int i = 0; i < arr.length; i++){
            if (arr[i] < min){
                min = arr[i];
            }
        }
        System.out.println("最小值是:" + min);
    }
}

有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}。再通过键盘录入一个整数数字。要求：把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧是从小到大排列的。执行效果如下：请输入一个整数数字：50

//有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}。再通过键盘录入一个整数数字。
// 要求：把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧是从小到大排列的。执行效果如下：
//请输入一个整数数字：50

import java.util.Scanner;
public class ShuZu1{
    public static void main(String[] args) {
        //定义原数组
        int[] arr = {12,14,23,45,66,68,70,77,90,91};
        //定义新的数组
        int[] arr1 = new int[11];
        //键盘输入一个整数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数的数字");
        int num = sc.nextInt();
        //定义变量代表要插入的位置
        int index = 0;
        for (int i = 0; i < arr.length; i++){
            if (arr[i] <= num){
                //如果元素小于等于插入的数字，直接存放
                arr1[i] = arr[i];
                //把i后面的位置记录下来
                index = i + 1;
            }else{
                //如果元素大于插入的数字，则往后存放一个位置
                arr1[i + 1] = arr[i];
            }
        }
        //index的存储就是要插入的位置
        arr1[index] = num;
        System.out.print("生成的新数组是: ");
        for (int i = 0; i < arr1.length; i++){
            System.out.print(arr1[i] + " ");
        }
    }
}

定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边。（可以创建其他数组，不必须在原数组中改变）

//定义一个数组其中包含多个数字。用自己的方式最终实现，奇数放在数组的左边，偶数放在数组的右边。（可以创建其他数组，不必须在原数组中改变）
public class ShuZu1{
    public static void main(String[] args) {
        //定义原数组
        int[] arr = {12,23,34,45,67,78,11,22};
        //定义空数组
        int[] brr = new int[arr.length];
        //定义变量代表奇数要存放的位置
        int left = 0;
        //定义变量代表偶数要存放的位置
        int right = arr.length-1;
        //对原数组进行遍历
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] % 2 == 1){
                //如果是奇数就往左边放
                brr[left] = arr[i];
                //存放之后让索引向右移动
                left++;
            }else{
                //如果是偶数就往右边放
                brr[right] = arr[i];
                //存放之后让索引向左移动
                right--;
            }
        }
        //打印brr数组
        for (int i = 0; i < brr.length; i++) {
            System.out.print(brr[i] + " ");
        }
    }
}

从键盘读入学生成绩，找出最高分，并输出学生成绩等级。成绩>=最高分-10 等级为’A’；成绩>=最高分-20 等级为’B’；成绩>=最高分-30 等级为’C’；其余等级为’D’。

//从键盘读入学生成绩，找出最高分， 并输出学生成绩等级。
//成绩>=最高分-10 等级为’A’
//成绩>=最高分-20 等级为’B’
//成绩>=最高分-30 等级为’C’
//其余 等级为’D’

import java.util.Scanner;
public class ShuZu1{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生人数");
        int num = sc.nextInt(); //定义变量来输入学生人数
        int[] arr = new int[num];
        Scanner sc1 = new Scanner(System.in);
        System.out.println("请输入学生的成绩");
        int max = 0;
        for (int i = 0;i < arr.length; i++){
            int a = sc1.nextInt();
            arr[i] = a;
            if (arr[i] > max){
                max = arr[i];
            }
            System.out.println("最高分为:" + max);
        }for (int i = 0;i < arr.length; i++){
            if (arr[i] >= max-10){
                System.out.println("等级为'A'");
            }else if (arr[i] >= max-20 ){
                System.out.println("等级为'B'");
            }else if (arr[i] >= max-30 ){
                System.out.println("等级为'C'");
            }else{
                System.out.println("等级为'D'");
            }
        }
    }
}

求一个3*3矩阵对角线元素之和，要求矩形里面的值为随机赋值

import java.util.Random;
public class ShuZu1 {
    public static void main(String[] args) {
        int[][] arr = new int[3][3];
        int sum = 0;
        Random ra = new Random();
        for(int i = 0; i < 3; i++)
        {
            for(int j = 0; j < 3; j++)
            {
                arr[i][j] = ra.nextInt(100);//随机的值可自由决定
                if(i == j)
                    sum += arr[i][j];
                if((i == 0 && j ==2) || (i == 2 && j == 0))
                    sum += arr[i][j];
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println(sum);
    }
}

冒泡排序，首先实现如下的数组从小到大排序，再完成下面的需求。
int[] arr = new int[]{34,5,22,-98,6,-76,0,-3};
(1).反转上面的数组。请代码实现
(2).复制上述数组，得到一个新的数组
(3).使用线性查找，从上述数组中查找22是否存在。存在，返回所在位置的索引。不存在，输出提示信息。

//  冒泡排序，首先实现如下的数组从小到大排序，再完成下面的需求。
// 	int[] arr = new int[]{34,5,22,-98,6,-76,0,-3};
//	(1).反转上面的数组。请代码实现
//	(2).复制上述数组，得到一个新的数组
//	(3).使用线性查找，从上述数组中查找22是否存在。存在，返回所在位置的索引。不存在，输出提示信息。
public class ShuZu1 {
    public static void main(String[] args) {
        int[] arr = new int[]{34,5,22,-98,6,-76,0,-3};
        //冒泡排序
        bubbleSort(arr);
        print(arr);

        //反转
        reversionArr(arr);
        print(arr);

        //复制
        int[] brr=copyArr(arr);
        print(brr);

        //查找
        int num =22;
        int flag = findArr(arr, num);
        //打印
        if (flag!=-1)
        {
            System.out.println("找到了，下标为："+flag);
        }else
        {
            System.out.println("没有找到");
        }

    }

    public static int findArr(int[] arr, int num) {
        int index=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]==num)
            {
                index=i;
                return index;
            }
        }
        return -1;
    }

    public static int[] copyArr(int[] arr) {
        int[] brr =new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            brr[i]=arr[i];
        }
        return brr;
    }

    public static void reversionArr(int[] arr) {
        for(int i=0;i<arr.length/2;i++){
            int temp=arr[i];
            arr[i]=arr[arr.length-1-i];
            arr[arr.length-1-i]=temp;
        }
    }

    //冒泡方法
    public static void bubbleSort(int[] arr) {
        int temp=0;
        for (int i = arr.length-1; i >0 ; i--) {
            for (int j = 0; j <i ; j++) {
                if (arr[j]>arr[j+1])
                {
                    //交换
                    temp=arr[j+1];
                    arr[j+1]=arr[j];
                    arr[j]=temp;
                }
            }
        }
    }
    //反转方法
    //打印方法
    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
    }
}