JAVASE基础--数组

Danielddd1999

已于 2022-08-29 04:44:21 修改

阅读量219

点赞数 1

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

于 2022-08-26 08:54:54 首次发布

本文链接：https://blog.csdn.net/qq_43498155/article/details/126535672

版权

java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

数组是最简单的数据结构

{1,2,3,4,5}

球队是一个数组，几号队员就可以取出

int[i,o,j,k]

避免定义相同变量

数组的定义

数组是相同类型数据的有序集合

数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成

其中，每一个数据称做一个数组元素，每一个数组元素可以通过一个下标来访问它们

数组的声明和创建

变量类型变量名称 = 变量的值

首先必须声明数组变量，才能在程序中使用数组。下面是生命数组变量的语法：

dataType[] array RefVar; //首选的方法
dataType arrayRefVar[];  //效果相同，但不是首选

举例：

int[] nums;  //java中采用的
int nums[];  //C和C++中适用，为了让C程序员快速适应

Java语言使用new操作符来创建数组，语法如下：

datatype[] arrayRefVar = new dataType[arraySize];
int [] nums = new int[10];

获取数组长度：

array.lenth
nums.lenth     //example

应用：

public class Demo4 {
    public static void main(String[] args) {

        int [] nums;   //声明数组
        nums = new int[10];//创建数组
        nums[0] = 1;       //给数组赋值
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;
        System.out.println(nums[5]);
        //计算所有数字只和
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }
        System.out.println(sum);
    }
}

数组的四个基本特点：

1.数组的长度是确定的，一旦被创建，他的大小是无法被改变的

2.数组的元素必须是相同类型

3.数组中的元素可以是任何数据类型，包括基本类型和引用类型

4.数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

内存分析

Java内存区分为堆、栈、方法区

堆：存放new出来的对象和数组

栈：存放变量类型

举例:

1.声明数组：int[] array = null;

这个时候堆中并没有东西，栈中会压入一个array

2.创建数组：array = new int[10];

new后会在堆中开辟一个空间，被分为10个小份，这10个小格就是10个int对象

3.给数组赋值

nums[0] = 1;       //给数组赋值
        nums[1] = 2;
        nums[2] = 3;
        nums[3] = 4;
        nums[4] = 5;
        nums[5] = 6;
        nums[6] = 7;

未赋值的空间存在默认初始化的值

如果数组下标超过创建数组范围，想要输出会出现异常

举例：

System.out.println(nums[10]);

ArrayIndexOutOfBoundsException（数组下标越界）

数组的三种初始化

静态初始化

//静态初始化 创建+赋值
int[] array = {1,2,3,4,5,6};
System.out.println(array[1]);

动态初始化（默认初始化）

//动态初始化，包含：默认初始化
        int[] b = new int[10];
        b[0] = 1;
        System.out.println(b[0]);

没有被初始化的空间都为0（int类型），（string类型）初始值为null

数组的四个基本特点：

1.其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

2.其元素必须是相同类型，不允许出现混合类型。

int[ ]中全部是int类型

3.数组中的元素可以是任何数据类型，包括基本类型和引用类型。

可以是int 类型，也可以重新创建类，引用过来

public class Man {
    public Man(int i, int i1) {
    }

    public static void main(String[] args) {
        
    }
}

public class array02 {
    public static void main(String[] args) {
        //静态初始化 创建+赋值
        int[] array = {1,2,3,4,5,6};
        Man[] mans = {new Man(1,1),new Man(2,2)};
        System.out.println(array[1]);

    }
}

4.数组变量属引用类型，数组也可以看成是对象，数组中的每一个元素相当于该对象的成员变量。

数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，

数组对象本身是在堆中的

无论原始类型或其他类型都会存储在堆中

数组的使用

For-Each循环

for循环基本用法：

public class Array03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //打印全部数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
            System.out.println("=========");
        }
        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum = sum +arrays[i];
            //sum += arrays[i];
        }
        System.out.println(sum);
        System.out.println("=========");
        //查找最大元素
        int max =arrays[0];
        for (int i = 0; i < arrays.length; i++) {
            if (arrays[i]>max){
                max = arrays[i];
            }
        }
        System.out.println(max);
    }
}

for-each循环（增强for循环）

用来遍历数组

public static void main(String[] args) {
int[] arrays= {1,2,3,4,5};
//JDK1.5后才有的新循环，没有下标，也取不到下标
for (int array : arrays) {
//array 数组，arrays 数组中的每个元素
System.out.println(array);

缺点，无法取数组的下标

遍历二维数组

public static void main(String[] args) {
        
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        for (int[] ints : array1) {   //for each循环(array1.for)
            for (int anInt : ints) {  //ints.for
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

数组作方法入参

public class array04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        printArrays(arrays);
    }
    public static void printArrays(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]);
        }
    }
}

数组作返回值

public class array04 {
    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};
        printArrays(arrays);
        int[] reverse = reverse(arrays);
        printArrays(reverse);

    }
    public static void printArrays(int[] arrays) {
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]);
        }
    }
    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0,j = arrays.length-1; i < arrays.length; i++,j--) {
            result[j]  = arrays [i];}
        return result;
    }
}

多维数组

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

比方说arr是一个数组arr[0]中还有一个数组

相当于数组的嵌套

二维数组

二维数组如何定义

int a[][] = new int[2][4];

解析：可以将此数组当成2行4列的数组

public class array05 {
    public static void main(String[] args) {
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
//1,2 array 0;
//2,3 array 1;
//3,4 array 2;
//4,5 array 3;
        System.out.println(array [0][0]);
    }
}

数组长度

System.out.println(array.length);//4
System.out.println(array[0].length);//2

打印二维数组

public class array05 {
    public static void main(String[] args) {
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
//1,2 array 0;
//2,3 array 1;
//3,4 array 2;
//4,5 array 3;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }

        }

    }
}