Java数组

最新推荐文章于 2024-06-21 22:23:19 发布

陈培学(●—●)

最新推荐文章于 2024-06-21 22:23:19 发布

阅读量61

点赞数

分类专栏： javaSE 文章标签： java

本文链接：https://blog.csdn.net/m0_53550060/article/details/126635509

版权

javaSE 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

Java数组

1.数组概述

什么是数组？
数组是一种线性数据结构。是多个相同类型数据按一定顺序列的集合，并使用一个名字命名，通过编号的方式对这些数据进行统一管理。

数组的特点

数组是有序排列的
数组属于引用数据类型的变量，数组的元素，既可以是基本数据类型，也可以是引用数据类型。
创建数组对象会在内存中开辟一套整块连续的空间
数组的长度一旦确定，就不可修改，

数组的分类

按维度分：一维数组、二维数组、. . .
按数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组。

2.一维数组

声明和初始化

public class ArrayDemo {
    public static void main(String[] args) {
        //数组的声明，声明时不能指定数组长度
        int []score;
        //1.静态初始化：数组的初始化和数组元素的赋值操作同时进行
        score = new int []{32,56,89};
        
        //2.动态初始化，数组的初始化和数组元素的赋值操作分开进行
        score = new int[3];
        score [0]=98;
        score [1]=33;
        score [2]=75;
        //数组的声明和创建
        int [] count = new int[3];
    }
}

遍历数组

public class ArrayDemo {
    public static void main(String[] args) {
      
        //赋值创建数组
        int [] great ={0,1,2,3};
        for (int i=0;i< great.length;i++){//获取数组的长度
            System.out.println(great[i]);
        }
        //新加的
        for (int x:great){
            System.out.println(x);
        }
    }
}

默认初始化值

数组元素是整型：0
数组元素是浮点型：0.0
数组元素是char型：0或‘\u0000',而非‘0‘
数组元素是boolean型：false

数组元素是引用数据类型：null

一维数组的内存解析

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RtsF2jWe-1661988025403)(C:\Users\chenpeixue\AppData\Roaming\Typora\typora-user-images\image-20220829211736476.png)]$

/**
 *从键盘输入学生成绩，找出最高分，并输出学生的成绩等级。（成绩>=最高分-10 等级‘A’
 *成绩>=最高分-20 等级‘B’  成绩>=最高分-30 等级‘C’  其它情况 等级‘D’）
 */
import java.util.Scanner;
public class ScoreText {
    public static void main(String[] args) {
        //1.从键盘输入学生的个数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生的个数");
        int number = scanner.nextInt();
        //2.创建数组，从键盘上输入学生的成绩
        int[]score = new int[number];
        System.out.println("请输入学生的成绩");
        for(int i =0;i<score.length;i++){
            score[i] = scanner.nextInt();
        }
        //3.输出学生成绩的最大值
        int maxscore = 0;
        for(int i = 0;i<score.length;i++){
            if(maxscore<score[i]){
                maxscore=score[i];
            }
        }
        System.out.println("成绩最高为："+maxscore);
        //4.输出学生的成和等级
        char level;
        for(int i = 0;i<score.length;i++) {
            if (score[i]>=maxscore - 10) {
                level='A';
            }else if(score[i]>=maxscore - 20){
                level='B';
            }else if(score[i]>=maxscore - 30){
                level='C';
            }else{
                level='D';
            }
            System.out.println("studnet"+i+"score is"+score[i]+",gerat is"+level);
        }
    }
}

3.二维数组

理解：我们可以看成是一维数组Array1作为一维数组Array2的元素而存在。

声明和初始化

public class Array {
    public static void main(String[] args) {
        //二维数组的声明和初始化
        //1.静态初始化
        int[][]num = new int[][]{{1,2,3},{4,5}};
        //2.动态初始化
        String [][]arr = new String[3][2];
        String [][]arr1 = new String[3][];
        //其它正确写法
        int[] arr2[] = new int[][]{{1,2,3},{4,5}};
        int[] arr3[] = {{1,2,3},{4,5}};
    }
}

遍历数组

public class Array {
    public static void main(String[] args) {
        int[] arr2[] = new int[][]{{1,2,3},{4,5}};
        //遍历二维数组
        for(int i =0;i< arr2.length;i++){
            for(int j = 0;j<arr2[i].length;j++){
                System.out.print(arr2[i][j]+" ");
            }
            System.out.println();
        }
    }
}

默认初始化值

//二维数组的默认初始化值
针对于初始化方式一、
    比如：int[][]arr = new int[2][3];
	外层元素的初始化值为：地址值
	内层元素的初始化值为：与一维数组的初始化情况一致
        
针对于初始化方式二
    比如：int[][]arr = new int[2][];
	外层元素的初始化值为：null
    内层元素的初始化值为：不能调用，否则报错

二维数组的内存解析

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2HlNxvjl-1661988025405)(C:\Users\chenpeixue\AppData\Roaming\Typora\typora-user-images\image-20220829213916099.png)]$

4.数组中常见的算法

数组元素的赋值

杨辉三角

public class YangHui {
    public static void main(String[] args) {
        //1.创建二维数组
        int [][]yanghui = new int[10][];
        //2.赋值
        for(int i = 0;i<yanghui.length;i++){
            yanghui[i] = new int[i+1];
            yanghui[i][0] = yanghui[i][i] = 1;
            for(int j = 1;j<yanghui[i].length-1;j++){
                System.out.println(yanghui[i][j]=yanghui[i-1][j]+yanghui[i-1][j-1]);
            }
        }
        //3.遍历二维数组
        for (int i = 0;i<yanghui.length;i++){
            for(int j = 0;j<yanghui[i].length;j++){
                System.out.print(yanghui[i][j]+" ");
            }
            System.out.println();
        }
    }
}

求数值型数组元素的各种值

/*
* 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
* 然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。要求:所有随机数都是两位数。
*
* [10,99]
* 公式  ：(int)(Math.random()*(99-10+1)+10)
 */
public class HelloWorld {
    public static void main(String[] args) {
        int[] array = new int[10];
        for (int i = 0; i <array.length ; i++) {
            array[i] =  (int)(Math.random()*(99-10+1)+10);
            System.out.print(array[i]+"\t");
        }
        System.out.println();
//        最大值
        int maxValue = array[0];
        for (int i = 0; i <10 ; i++) {
           if(maxValue<array[i]){
               maxValue = array[i];
           }
        }
        System.out.println("最大值=>"+maxValue);
//        最小值
        int minValue = array[0];
        for (int i = 0; i <10 ; i++) {
            if(minValue>array[i]){
                minValue =array[i];
            }
        }
        System.out.println("最小值=>"+minValue);
//        平均值
        int sum = 0;
        for (int i = 0; i <10 ; i++) {
            sum += array[i];
        }
        System.out.println("和=>"+sum);
        System.out.println("平均值=>"+sum / array.length);
    }
}

数组元素的复制

public class Test {
    public static void main(String[] args) {
        //数组元素的复制
        String[]array = new String[]{"aa","bb","cc","dd"};
        //数组的复制不同于数组的赋值（array1=array 只改变了变量名，但其地址值是相同的，公用相同的数据）
        String[]array1 = new String[array.length];
        for (int i= 0;i<array.length;i++){
            array1[i]=array[i];
            System.out.print(array1[i]+"\t");
        }
    }
}

数组元素的反转

public class Test {
    public static void main(String[] args) {
        String[]array = new String[]{"aa","bb","cc","dd"};
        for (int i = 0; i <(array.length/2) ; i++) {
            String temp = array[i];
            array[i] = array[array.length-i-1];
            array[array.length-i-1] = temp;
        }
        for (int i = 0; i <array.length ; i++) {
            System.out.println(array[i ]+"\t");
        }
    }
}

数组的查找

顺序查找

public class Test {
    public static void main(String[] args) {
        String[]array = new String[]{"aa","bb","cc","dd"};
        String bib = "aa";
        boolean isFlog = true;
        for(int i=0;i<array.length;i++){
            if(bib.equals(array[i])){
                System.out.println("已查找到搜索元素，当前位置"+i);
                isFlog = false;
                break;
            }
        }
        if(isFlog){
            System.out.println("未找到所查找元素");
        }
    }
}

二分法查找

public class ArrayTest {
    public static void main(String[] args) {
        //二分法查找：必须是有序的
        int []arr = new int[]{12,23,34,45,56,67,78,89};
        int be = 34;
        int head = 0;//出事的首索引
        int end = arr.length-1;//出事的末索引
        boolean isFlog1 = true;
        while (head <= end) {
            int mid = (head+end)/2;
            if (be == arr[mid]) {
                System.out.println("已查找到搜索元素，当前位置" + mid);
                isFlog1 = false;
                break;
            }else if(be <arr[mid]){
                end = mid - 1;
            }else if(be >arr[mid]){
                head = mid +1;
            }
        }
        if(isFlog1) {
            System.out.println("未找到所查找元素");
        }
    }
}

排序算法

排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

冒泡排序

public class Arrays {
    public static void main(String[] args) {
        int[]arr = new int[]{10,12,32,-25,89,62,-15,0,16};
        //冒泡排序 （相邻之间经行排序 i是轮数，j是次数）
        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]){
                 int temp = arr[j];
                 arr[j] = arr[j+1];
                 arr[j+1] = temp;
                }
            }
        }for(int i = 0;i<arr.length-1;i++){
            System.out.print(arr[i]+"\t");
        }
    }
}

5.Arrays工具类

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v6lkSGpI-1661988025406)(C:\Users\chenpeixue\AppData\Roaming\Typora\typora-user-images\image-20220901070816016.png)]$

public class ArratsText {
    public static void main(String[] args) {
        int[]arr = new int[]{1,2,3,4};
        int[]arr1 = new int[]{1,3,2,4};
        //equals(int[] a, int[] a2) 如果两个指定的int数组彼此 相等 ，则返回 true 。
        boolean isFlog = Arrays.equals(arr,arr1);
        System.out.println(isFlog);
        //toString(int[] a) 返回指定数组的内容的字符串表示形式。
        System.out.println(Arrays.toString(arr));
        //fill(int[] a, int val) 将指定的int值分配给指定的int数组的每个元素。
        Arrays.fill(arr,10);
        System.out.println(Arrays.toString(arr));
        //sort(int[] a) 按照数字顺序排列指定的数组。
        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1));
        //binarySearch(int[] a, int key) 使用二叉搜索算法搜索指定的int数组的指定值。
        int digit = Arrays.binarySearch(arr1,3);
        System.out.println("第"+digit+"位");
    }
}