数组的定义及操作、二维数组的定义及操作、内存中的堆栈-EW帮帮网

第一章数组的概述及数组的定义

1.问题：如果我们想存储一个数据，我们可以使用变量，但是变量一次只能存储一个数据，所以我们想能不能一次存储多个数据

2.数组概述：是一个容器，数组本身属于引用数据类型

3.作用：一次存储多个数据

4.特点：

a.既可以存储基本数据类型的数据，还能存储引用数据类型的数据

b.定长（定义数组时长度为多长，最多就能存储多少数据）

5.定义：

a.动态初始化：在定义数组时没有给具体的数据，只指定了长度

数据类型[ ] 数组名 = new 数据类型[长度]

数据类型数组名[ ] = new 数据类型[长度]

b.静态初始化：在定义数组的时候，我们直接给了数据

数据类型[ ] 数组名 = new 数据类型[ ]{元素1，元素2...}

数据类型数组名[ ] = new 数据类型[ ]{元素1，元素2...}

c.简化的静态初始化：

数据类型[ ] 数组名 = {元素1，元素2...}

public class Demo01Array {
    public static void main(String[] args) {
        //动态初始化数组
        int[] arr1 = new int[3];

        String[] arr2 = new String[3];
        
        //简化的静态初始化
        int[] arr3 = {1,2,3,4,5,6,7};
        
        String[] arr4 = {"蒋敦豪","鹭卓","李耕耘"};
    }
}

6.区别：动态初始化定义的时候只指定了长度，没有存具体的数据；静态初始化在定义的时候就知道了想要存储的数据

第二章数组的操作

1.获取数组长度

1.格式：

数组名.length

2.注意：

length后边不要带小括号，因为length不是数组中的方法，而是数组中的一个属性

public class Demo02Array {
    public static void main(String[] args) {
        String[] arr1 = {"蒋敦豪","鹭卓","李耕耘","李昊","赵一博","卓沅","赵小童"};

        int len = arr1.length;
        System.out.println("len = " + len);
    }
}

2.索引介绍

1.概述：元素在数组中存储的位置（编号，下标）

2.特点：索引唯一，索引都是从0开始，最大长度是数组长度-1

3.作用：

我们将来操作元素必须通过索引来操作

存数据、取数据、查数据都要指定索引

3.存储元素

1.格式：

数组名[索引值] = 值 ->将等号右边的数组放到指定数组的索引位置上

public class Demo03Array {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr1 = new int[3];
        
        arr1[0] = 100;
        arr1[1] = 200;
        arr1[2] = 300;

        System.out.println("==============================");
        
        String[] arr2 = new String[3];
        
        arr2[0] = "王一珩";
        arr2[1] = "陈少熙";
        arr2[2] = "何浩楠";
    }
}

import java.util.Scanner;

public class Demo04Array {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请依次输入三个整数");
        int[] arr1 = new int[3];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = sc.nextInt();
        }
    }
}

import java.util.Random;
import java.util.Scanner;

public class Demo05Array {
    public static void main(String[] args) {
        int[] arr1 = new int[3];
        for (int i = 0; i < arr1.length; i++) {
            Random rd = new Random();
            arr1[i] = rd.nextInt(10);//在0-9之间随机一个整数存到数组当中
        }
    }
}

4.获取元素

1.格式：

数组名[索引值]

2.细节说明：

a.直接输入数组名输出的是数组在内存中的地址值

b.地址值：数组在内存中的唯一标识

c.如果数组中没有存数据仍然可以获取一些数据（元素的默认值）

整数：0

小数：0.0

字符：‘’\u000' ->对应的Int值是0

布尔：false

引用：null

public class Demo06Array {
    public static void main(String[] args) {
        int[] arr = new int[3];
//        System.out.println(arr);//[I@b4c966a
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//0

    }
}

5.遍历元素

1.遍历：将元素从数组中依次取出（循环）

public class Demo07Array {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr);//[I@b4c966a
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//0

        //存数据
        arr[0] = 100;
        arr[1] = 200;
        arr[2] = 300;
        System.out.println(arr[0]);//100
        System.out.println(arr[1]);//200
        System.out.println(arr[2]);//300

        System.out.println("==================================");

        String[] arr2 =new String[3];
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);

        arr2[0] = "蒋敦豪";
        arr2[1] = "鹭卓";
        arr2[2] = "李耕耘";
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);

        System.out.println("==============遍历arr2数组==================");

        //数组多长就循环多少次
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
}

快捷键：

数组名.fori

第三章操作数组时两个常见的问题

1.数组索引越界异常_ArrayIndexOutOfBoundsException

1.原因：

操作的索引已经超出了数组索引范围

public class Demo08ArrayException {
    public static void main(String[] args) {
        int[] arr = new int[3];
        arr[0] = 100;
        arr[1] = 200;
        arr[2] = 300;
       // arr[3] = 400;//索引3超出了数组范围

//        for (int i = 0; i < 4; i++) {
//            System.out.println(arr[i]);//超出范围
//        }
    }
}

2.空指针异常_NullPinterException

1.原因：

当一个对象为null,在调用此对象中的其他成员就会发生空指针异常

public class Demo09ArrayException {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr.length);

        arr = null;
        System.out.println(arr.length);//空指针异常
    }
}

以上两个问题我们只需要知道原因即可

第四章数组的练习

1.求出数组中的元素最大值

import java.util.Scanner;

public class Demo01GetMax {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[7];
        System.out.println("请输入七个数：");
        for(int i=0;i<7;i++) {
            arr[i] = sc.nextInt();
        }
        int max = arr[0];
        for (int j=0;j<7;j++){
            if (max<=arr[j]){
                max = arr[j];
            }
        }
        System.out.println(max);
        }
    }

2.随机生成10个[0,100]之间的整数，统计即是3又是5，但不是7的倍数的个数

import java.util.Random;
import java.util.Scanner;

public class Demo02GetMax {
    public static void main(String[] args) {
        Random rd = new Random();
        int[] arr = new int[10];
        int i=0;
        while(i<arr.length){
            arr[i] = rd.nextInt(101);//随机生成0-100之间的整数
            i++;
        }
        int[] arr2 = new int[10];
        for (int j = 0; j < arr.length; j++) {
            if(arr[j]%3==0 && arr[j]%5==0 && arr[j]%7!=0){
                arr2[j]=arr[j];
            }
        }
        for (int k = 0; k < arr2.length; k++) {
            System.out.print("   arr  "+arr[k]);
            System.out.print("   arr2  "+arr2[k]);
        }
    }
}

3.定义一个数组int[] arr = {1,2,3,4},遍历数组输出元素按照[1,2,3,4]

public class Demo03Put {
    public static void main(String[] args) {
        int[] arr ={1,2,3,4};
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i==arr.length-1){
                System.out.print(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }

        }
    }
}

4.随机50个1-100之间的整数，统计偶数的个数

import java.util.Random;

public class Demo04Put {
    public static void main(String[] args) {
        Random rd = new Random();
        int[] arr = new int[50];
        int count = 0;
        for (int i = 0; i < 50; i++) {
            arr[i] = rd.nextInt(101)+1;
            if (arr[i]%2==0){
                count++;
            }
        }
        System.out.println(count);
    }
}

5.键盘录入一个整数，找出整数在数组中存储的索引位置，如果查找失败则提示

import java.util.Random;
import java.util.Scanner;

public class Demo05Put {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = {2,3,89,49,20,8,67};
        System.out.println("请输入一个整数：");
        int temp = sc.nextInt();
        int i = 0;
        while (i < arr.length) {
            if(temp!=arr[i]){
                i++;
            }else{
                System.out.println(i);
                break;
            }
        }
        if (i==arr.length){
            System.out.println("输入有误！");
        }
    }
}

6.数组扩容，定义一个数组int[] arr1 = {1,2,3,4,5},将数组由原来的长度扩容到10

public class Demo06Put {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5};
        System.out.println(arr1.length);
        int[] arr2 = new int[10];
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
        //把新数组的地址赋值给老数组
        arr1 = arr2;
        System.out.println(arr1.length);
        //遍历扩容后的数组
        for (int j = 0; j < arr1.length; j++) {
            System.out.print(arr1[j]);
        }
    }
}

7.数组合并：int[] arr1 = {1,2,3}

int[] arr2 = {4,5,6}

public class Demo07Put {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3};
        int[] arr2 = {4,5,6};
        int[] arr3 = new int[arr1.length+arr2.length];
        for (int i = 0; i < arr1.length; i++) {
            arr3[i] = arr1[i];
        }
        for (int j = 0; j < arr2.length; j++) {
            arr3[arr1.length+j] = arr2[j];
        }
        for (int i = 0; i < arr3.length; i++) {
            System.out.print(arr3[i]+" ");
        }
    }
}

第五章内存图

1.内存：可以理解为内存条，所有的软件，程序运行起来都会进入内存，占用内存，在java的世界中，将内存划分为5块

2.分为哪五块：

a.栈（重点）（Stack）

主要运行方法，方法的运行都会进栈内存运行，运行完毕之后，需要“弹栈”，为了腾空间

b.堆（重点）（Heap）

保存的是对象，数组，每new一次都会在堆内存中开辟空间，并为这个空间分配地址值

堆内存中的数据都是有默认值的

整数：0

小数：0.0

字符：‘\u000’

布尔：false

引用：null

c.方法区（重点）（Method Area）

代码的“预备区”，记录了类的信息以及方法的信息

方法区中主要保存class文件以及其中的信息

代码运行之前，需要先进内存（方法区）

d.本地方法栈（了解）（Native Method Stack）：专门运行native方法（本地方法）

本地方法可以理解为，对java功能的扩充

有很多功能，java语言实现不了，所以就需要依靠本地方法完成（c语言编写）

e.寄存器（了解）（pc register）

和cpu有关

1.一个数组的内存图

public class Demo01Array {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr);//地址值
        System.out.println(arr[1]);//默认值0
        arr[1] = 100;
        System.out.println(arr[1]);
    }
}

2.两个数组指向同一片内存空间

arr2不是new出来的，而是把arr1的地址值直接赋值给了arr2，那么arr1和arr2指向的是同一片地址空间，此时改变一个数组元素会影响到另外一个数组

public class Demo03Array {
    public static void main(String[] args) {
        int[] arr1 = new int[3];
        System.out.println(arr1);//arr1的地址值
        System.out.println(arr1[1]);//默认值0
        arr1[1] = 100;

        int[] arr2 = arr1;
        System.out.println(arr2);//arr2的地址值
        arr2[1] = 200;

        System.out.println(arr1[1]);//100
        System.out.println(arr2[1]);//200
    }
}

第六章二维数组

1.二维数组的定义格式

1.概述：数组中套了多个数组

2.如何定义：

a.动态初始化

数据类型[ ][ ] 数组名 = new 数据类型[m][n];

数据类型数组名[ ][ ] = new 数据类型[m][n];

数据类型[ ] 数组名[ ] = new 数据类型[m][n];

m: 二维数组的长度

n：二维数组中每一个一维数组的长度

数据类型[ ][ ] 数组名 = new 数据类型[m][]; ->二维数组中的一维数组没有被创建

b.静态初始化

数据类型[ ][ ] 数组名 = new 数据类型[ ][ ]{{元素1，元素2...},{元素1，元素2...}};

数据类型数组名[ ][ ] = new 数据类型[ ][ ]{{元素1，元素2...},{元素1，元素2...}};

数据类型[ ] 数组名[ ] = new 数据类型[ ][ ]{{元素1，元素2...},{元素1，元素2...}

c.简化静态初始化

数据类型[ ][ ] 数组名 = {{元素1，元素2...},{元素1，元素2...}};

数据类型数组名[ ][ ] = {{元素1，元素2...},{元素1，元素2...}};

数据类型[ ] 数组名[ ] = {{元素1，元素2...},{元素1，元素2...}}；

public class Demo01Array {
    public static void main(String[] args) {
        int[][] arr1 = new int[2][2];
        int[][] arr2 = new int[2][];

        System.out.println("========================");
        
        //简化的静态初始化
        String[][] arr3 = {{"蒋敦豪","鹭卓","李耕耘"},{"李昊","赵一博","卓沅"},{"赵小童","何浩楠","陈少熙"},{"王一珩"}};
    }
}

2.获取二维数组长度

1.格式：

数组名.length

2.获取每一个一维数组长度，需要先遍历二维数组，将每一个一维数组遍历出来

public class Demo02Array {
    public static void main(String[] args) {
        //简化的静态初始化
        String[][] arr1 = {{"蒋敦豪","鹭卓","李耕耘"},{"李昊","赵一博","卓沅"},{"赵小童","何浩楠","陈少熙"},{"王一珩"}};
        //获取二维数组的长度
        System.out.println(arr1.length);

        System.out.println("=========================");

        //获取每一个一维数组长度
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i].length);
        }
    }
}

3.获取二位数组中的元素

1.格式：

数组名[i][j]

i:代表的是一维数组在二维数组中的索引位置

j:元素在一维数组中的索引位置

public class Demo03Array {
    public static void main(String[] args) {
        //简化的静态初始化
        String[][] arr1 = {{"蒋敦豪","鹭卓","李耕耘"},{"李昊","赵一博","卓沅"},{"赵小童","何浩楠","陈少熙"},{"王一珩"}};
        System.out.println(arr1[0][1]);
        System.out.println(arr1[1][2]);
        System.out.println(arr1[2][2]);
    }
}

4.二维数组中存储元素

1.格式：

数组名[i][j] = 值

i:代表的是一维数组在二维数组中的索引位置

j:元素在一维数组中的索引位置

public class Demo04Array {
    public static void main(String[] args) {
        String[][] arr = new String[2][6];

        arr[0][0] = "蒋敦豪";
        arr[0][1] = "鹭卓";
        arr[0][2] = "李耕耘";

        System.out.println(arr[0][0]);
        System.out.println(arr[0][1]);
        System.out.println(arr[0][2]);
    }
}

5.二维数组的遍历

1.先遍历二维数组，将每一个一维数组遍历出来

2.在遍历没一个一维数组，将元素遍历出来

public class Demo05Array {
    public static void main(String[] args) {
        String[][] arr = new String[2][6];

        arr[0][0] = "蒋敦豪";
        arr[0][1] = "鹭卓";
        arr[0][2] = "李耕耘";
        arr[1][0] = "李昊";
        arr[1][1] = "卓沅";

        //遍历二维数组
        for (int i = 0; i < arr.length; i++) {
            /*
                arr[i] 代表的就是每一个一维数组
            * */
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"   ");
            }
        }
    }
}

数组的定义及操作、二维数组的定义及操作、内存中的堆栈

第一章数组的概述及数组的定义

第二章数组的操作

1.获取数组长度

2.索引介绍

3.存储元素

4.获取元素

5.遍历元素

第三章操作数组时两个常见的问题

1.数组索引越界异常_ArrayIndexOutOfBoundsException

2.空指针异常_NullPinterException

第四章数组的练习

第五章内存图

1.一个数组的内存图

2.两个数组指向同一片内存空间

第六章二维数组

1.二维数组的定义格式

2.获取二维数组长度

3.获取二位数组中的元素

4.二维数组中存储元素

5.二维数组的遍历

网站公告

今日签到

热门文章

最新发布

数组的定义及操作、二维数组的定义及操作、内存中的堆栈

第一章 数组的概述及数组的定义

第二章 数组的操作

1.获取数组长度

2.索引介绍

3.存储元素

4.获取元素

5.遍历元素

第三章 操作数组时两个常见的问题

1.数组索引越界异常_ArrayIndexOutOfBoundsException

2.空指针异常_NullPinterException

第四章 数组的练习

第五章 内存图

1.一个数组的内存图

2.两个数组指向同一片内存空间

第六章 二维数组

1.二维数组的定义格式

2.获取二维数组长度

3.获取二位数组中的元素

4.二维数组中存储元素

5.二维数组的遍历

网站公告

今日签到

热门文章

最新发布

第一章数组的概述及数组的定义

第二章数组的操作

第三章操作数组时两个常见的问题

第四章数组的练习

第五章内存图

第六章二维数组