当前位置:   article > 正文

java数组知识总结_java数组学习个人总结

java数组学习个人总结

数组

理解容器的概念
掌握数组的第一种定义方式
掌握数组的第二种定义方式
掌握数组的第三种定义方式
使用索引访问数组的元素
了解数组的内存图解
了解空指针和越界异常
掌握数组的遍历
掌握数组最大值的获取
了解数组反转的原理
了解数组作为方法参数传递
了解数组作为方法的返回值


1.1 数组的定义

数组(Array):是多个相同数据类型数据按一定顺序排列的集合,并使用一个名字命名,并通过编号的方式对这些数据进行统一管理。

数组定义: 数组就是存储相同数据类型的,长度固定的数据 的容器。

理解数组:
容器:是将多个数据存储到一起,每个数据称为该容器的元素。
生活中的容器:水杯,衣柜,教室

1.2数组相关的概念:

数组名:
元素:
角标/下标/索引
数组的长度:元素的个数

1.3数组的特点:

1.数组本身是引用数据类型,而数组中的元素尅是任何数据类型,包括基本数据类型和引用数据类型。
2.创建数组对象会在内存中开辟一整块连续的空间,而数组名中引用的是这块连续空间的首地址。
3.数组的长度一旦确定,就不能修改(长度在程序运行期间不可改变)
4.我们可以直接通过下标(或索引)的方式调用指定位置的元素。速度很快。

1.4 数组的分类

按照维度:一维数组、二维数组、三维数组、…
按照元素的数据类型分:基本数据类型元素的数组,引用数据类型元素的数组(即对象数组)

1.5一维数组的使用

(1)一维数组的声明和初始化
(2)如何调用数组的指定位置的元素
(3)如何获取数组的长度
(4)如何遍历数组
(5)数组元素的默认初始化值
(6)数组内存解析

分割线----------------------------------------------------------------------------------------------

数组的初始化:在内存当中创建一个数组,并且向其中赋予一些默认值。
两种常见的初始化方式:

  1. 动态初始化(指定长度)
  2. 静态初始化(指定内容)
  3. 动态初始化数组的格式:
    数据类型[] 数组名称 = new 数据类型[数组长度];
    解析含义: 左侧数据类型:也就是数组当中保存的数据,全都是统一的什么类型 左侧的中括号:代表我是一个数组 左侧数组名称:给数组取一个名字 右侧的new:代表创建数组的动作 右侧数据类型:必须和左边的数据类型保持一致 右侧中括号的长度:也就是数组当中,到底可以保存多少个数据,是一个int数字

方式一:动态初始化

格式:
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

数组定义格式详解:
数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
[] : 表示数组。
数组名字:为定义的数组起个变量名,满足标识符规范,可以使用名 字操作数组。
new:关键字,创建数组使用的关键字。
数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
[长度]:数组的长度,表示数组容器中可以存储多少个元素。
注意:数组有定长特性,长度一旦指定,不可更改。
和水杯道理相同,买了一个2升的水杯,总容量就是2升,不能多也不能少。
举例:
定义可以存储3个整数的数组容器,代码如下:
int[] arr = new int[3];

方式二:静态初始化

格式:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
举例:int[] arr = new int[]{1,2,3,4,5};
定义存储1,2,3,4,5整数的数组容器。

代码演示数组初始化:

package com.fan.pojo;

public class ArrayTest {
    public static void main(String[] args) {
        //引入:在说一维数组的初始化之前。我们类比变量的声明和初始化
        int num;//声明变量
        num = 10;//变量的初始化
        //或者这种一步到位的
        int a = 100;//变量的 声明 + 初始化

        //同样,数组的类似
        int[] arr1;//声明
        //1.静态初始化:数组的初始化和数组元素的赋值操作同时进行
        arr1 = new int[]{1,2,3,4};
        //2.动态初始化:数组的初始化和数组的赋值操作分开进行
        String[] names = new String[5];

    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

初始化方式三:省略初始化

格式:数据类型[] 数组名 = {元素1,元素2,元素3…};
举例:int[] arr = {1,2,3,4,5};
定义存储1,2,3,4,5整数的数组容器

总结三种定义方式:当带长度的时候,不能一起带数组的元素,当带数组元素的时候不能带数组的长度。
比较:
int[] arr = new int[3];
int[] arr = new int[]{1,2,3,4,5};
int[] arr = {1,2,3,4,5};

1.6 数组的访问

索引: 每一个存储到数组的元素,都会自动的拥有一个编号,从0开始,这个自动编号称为数组索引,有时候也叫下标或者角标;
(index),可以通过数组的索引访问到数组中的元素。
格式:数组名[索引]
数组的长度属性: 每个数组都具有长度,而且是固定的,Java中赋予了数组的一个属性,可以获取到数组的长度,语句为: 数组名.length ,属性length的执行结果是数组的长度,int类型结果。由次可以推断出,数组的最大索引值为 数组名.length-1 。

public static void main(String[] args) {
int[] arr = new int[]{1,2,3,4,5};
//打印数组的属性,输出结果是5
System.out.println(arr.length);
}
  • 1
  • 2
  • 3
  • 4
  • 5

获取数组的长度

属性:length

//int[] arr1 = new int[]{1,2,3,4,5};
System.out.println(arr1.length);
  • 1
  • 2

数组的默认初始化值:

数组元素是整型(byte/short/int/long):0
数组元素是浮点型:0.0
数组元素是char型:0或者’\u0000’,而非’0’
数组元素是boolean型:false
数组元素是引用数据类型:null

一维数组的内存解析:

在这里插入图片描述

2.二维数组的使用

二维数组的理解:

我们可以画一张表格,一维数组的话,表格中只有一行;二维数组的话,表格中就有多行。也就是 我们可以看成一维数组arr又作为另一个一维数组arr2 的元素而存在。从数组的底层运行机制来看,其实没有多维数组的。
内存结构图理解:
在这里插入图片描述

2.1二维数组的初始化:

代码演示:

package com.fan.pojo;

public class ArrayTest {
    public static void main(String[] args) {
       //引入:先看一维数组的初始化
        int[] arr =  new int[]{1,2,3};//一维数组的初始化

        //二维数组的初始化
        //静态初始化
        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
        //动态初始化1
        String[][] arr2 = new String[3][4];
        //动态初始化2:
        String[][] arr3 =  new String[3][];
        //错误情况
        //String [][] arr4 = new String[][4];
        //String [4][3] arr5 = new String[][];
        //int [][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};

        //真确写法:将[][]放到变量名后也可以,一维数组也有类似的写法
        int arr4[][] = new int[][]{{1,2,3},{4,5},{6,7,8}};
        int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

2.2二维数组如何调用指定位置的元素和遍历

代码演示说明:

package com.fan.pojo;

public class ArrayTest {
    public static void main(String[] args) {
       //引入:先看一维数组的初始化
        int[] arr =  new int[]{1,2,3};//一维数组的初始化

        //二维数组的初始化
        //静态初始化
        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
        //动态初始化1
        String[][] arr2 = new String[3][4];
        //动态初始化2:
        String[][] arr3 =  new String[3][];
        //错误情况
        //String [][] arr4 = new String[][4];
        //String [4][3] arr5 = new String[][];
        //int [][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};

        //真确写法:将[][]放到变量名后也可以,一维数组也有类似的写法
        int arr4[][] = new int[][]{{1,2,3},{4,5},{6,7,8}};
        int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};

        //2.如何调用数组的指定位置的元素
        System.out.println(arr1[0][1]);//arr1的第一行第二个元素:2
        System.out.println(arr2[1][1]);//arr2数组的第二行第二列元素:null

        arr3[1] = new String[4];//如果要不报错,需要添加这一行代码。并将地址给arr3[1]
        System.out.println(arr3[1][0]);//运行报错:空指针异常,因为只是申请了三个元素的位置,但是每一个位置上没有东西。

        //3.获取数组的长度
        System.out.println(arr4.length);//3,其实就是外层数组的长度。即行数
        System.out.println(arr4[0].length);//arr4[0]还是一个数组,是数组就有length属性。//3,即列数
        System.out.println(arr4[1].length);//2,即{4,5}的元素的个数

        //4.如何遍历二维数组:几维数组遍历就需要几个for循环
        for (int i = 0; i < arr4.length ; i++) {
            for (int j = 0; j < arr4[i].length; j++) {
                System.out.println(arr4[i][j] + " ");
            }
            System.out.println();//换行
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

2.3二维数组的默认初始化

规定:二维数组分为外层数组的元素,内层数组的元素

int[] arr = new int[4][3];
//外层元素:arr[0],arr[1]等
//内层元素:arr[0][0],arr[1][2]等。
  • 1
  • 2
  • 3

针对一初始化方式一:比如int[][] arr = new int[4][3];;

  • 外层元素的初始化值为:地址值
  • 内层元素的初始化值为:与一维数组初始化情况相同

针对于初始化方式二:比如:int[][] arr = new int[4][];

  • 外层元素的初始化值为:null
  • 内层元素的初始化值为:不能调用,否则报错,空指针异常。

在这里插入图片描述

代码演示说明:

package com.fan.pojo;

public class ArrayTest {
    public static void main(String[] args) {
        int[][] arr = new int[4][3];
        System.out.println(arr[0]);//地址值:[I@5ebec15其中【代表是数组,I代表是int型,@后为位置
        System.out.println(arr[0][0]);//0

        System.out.println(arr);//[[I@6d06d69c
        System.out.println("\n=======================");
        //初始化方式一
        String[][] arr2 = new String[4][2];//4行2列中每个元素先赋值为默认值null
        System.out.println(arr2[1]);//地址值
        System.out.println(arr2[1][1]);//null

        System.out.println("\n========================");
        //初始化方式二
        double [][] arr3 = new double[4][];
        System.out.println(arr3[1]);//null
        //System.out.println(arr3[1][0]);//报空指针异常。因为我们没有给内层数组指定空间。
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

二维数组内存图解:

在这里插入图片描述

数组经典练习

1.利用二维数组打印杨辉三角。

package com.fan.pojo;
/*利用二维数组打印杨辉三角*/
public class ArrayTest {
    public static void main(String[] args) {
        int[][] arr = new int[10][];//动态赋值的一种方式
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new int[i+1];//[i+1]内层数组元素的个数是不同的
            for (int j = 0; j < arr[i].length; j++) {
                if(j == 0 || i == j){//给第一列 赋值为1,给行列相等的位置也赋值为1
                    arr[i][j] = 1;
                }else{//其他位置元素符合,当前元素  等于 头顶元素  + 头顶元素的前一个元素的 和
                    arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
                }
            }
        }

        //遍历输出赋值后的二维数组:
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

二分法查找:前提是:数组有序

package com.fan.pojo;
/*二分查找方法*/
public class ArrayTest {
    public static void main(String[] args) {
        //静态初始化,二分查找的前提是,数组必须有序,升序或者降序
        int[] arr = new int[]{1,3,5,7,9,11};
        //定义要查找的数key
        int key = 99;
        //定义开始索引和结束索引
        int start = 0;
        int end = arr.length - 1;

        //设置是否找到的开关、旗帜,flag
        boolean flag = false;
        while (start <= end){
            int middle = (start + end)/2;//在循环中,每次求出的中间索引
            if(key == arr[middle]){//如果目标值等于  数组中间索引所对应的元素,则找到了
                System.out.println("找到了"+key+",位置是:"+middle);
                flag = true;
                break;
            }else if(arr[middle] > key){//假如中间数大于目标值,则在左半边找。右边界索引重置成 middle
                end = middle - 1;//索引等一  middle的前一个索引
            }else{//目标值在右边
                start = middle + 1;//middle的后一个索引
            }
        }

        //循环外判断开关
        if(!flag){
            System.out.println("没找到");
        }

    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

数组的排序

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

3.1 数组越界异常

创建数组,赋值3个元素,数组的索引就是0,1,2,没有3索引,因此我们不能访问数组中不存在的索引,程序运
行后,将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中,数组的越界异常是不能出现的,一
旦出现了,就必须要修改我们编写的代码。

3.2 数组空指针异常

arr = null 这行代码,意味着变量arr将不会在保存数组的内存地址,也就不允许再操作数组了,因此运行的时候
会抛出 NullPointerException 空指针异常。在开发中,数组的越界异常是不能出现的,一旦出现了,就必须要修
改我们编写的代码。

3.4 数组获取最大值元素(比武招亲)

求最大值的

最大值获取:从数组的所有元素中找出最大值。
实现思路:
定义变量,保存数组0索引上的元素
遍历数组,获取出数组中的每个元素
将遍历到的元素和保存数组0索引上值的变量进行比较
如果数组元素的值大于了变量的值,变量记录住新的值
数组循环遍历结束,变量保存的就是数组中的最大值

public static void main(String[] args) {
	int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
	//定义变量,保存数组中0索引的元素
	int max = arr[0];
	//遍历数组,取出每个元素
	for (int i = 0; i < arr.length; i++) {
	//遍历到的元素和变量max比较
	//如果数组元素大于max
	if (arr[i] > max) {
	//max记录住大值
	max = arr[i];
	}
	}
	System.out.println("数组最大值是: " + max);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

第四章 数组作为方法参数和返回值

数组作为方法参数传递,传递的参数是数组内存的地址。
数组作为方法的返回值,返回的是数组的内存地址

public static void main(String[] args) {
//调用方法,接收数组的返回值
//接收到的是数组的内存地址
int[] arr = getArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
	/*
	创建方法,返回值是数组类型
	return返回数组的地址
	*/
	public static int[] getArray() {
	int[] arr = { 1, 3, 5, 7, 9 };
	//返回数组的地址,返回到调用者
	return arr;
	}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

总结: 方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小桥流水78/article/detail/782734
推荐阅读
相关标签
  

闽ICP备14008679号