Java零基础学习Day06---数组

一.基础内容

1.定义

概念：用于存储同种数据类型的多个值，同时也是一种数据类型，是引用类型。

注意点：考虑隐式转换，大的可以装小的。

2.初始化

静态初始化：往定义的数组中手动存入数据，地址值表示数组存储于空间的哪个具体位置

public class HelloWorld {
    public static void main(String[] args) {
        /*数组的格式：
        数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};   完整版本
        数据类型[] 数组名 = {元素1,元素2,元素3...};                简化版本
         */
        //定义一个数组，存储3个元素
        int[] arr = new int[]{11,22,33};
        //定义一个数组，存储3个元素
        int[] arr2 = {11,22,33};
        //定义一个数组，存储4个学生的名字
        String[] arr3 = {"zhangsan","lisi","wangwu","zhaoliu"};
        //定义一个数组，存储3个学生的成绩
        double[] arr4 = {99.5,88.5,77.5};
        }
}

动态初始化：手动指定数组长度，系统会给出默认初始化值

public class HelloWorld {
    public static void main(String[] args) {
        /*数组动态初始化
          数据类型[] 数组名 = new 数据类型[数组长度];
          默认初始化为0，各种数据类型的0，bool为false
         */
        //定义一个长度为5的数组
        int[] arr = new int[5];
        arr[0] = 10;
        arr[1] = 20;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
 
        //定义一个长度为5的string数组
        String[] arr1 = new String[5];
        arr1[0] = "hello";
        arr1[1] = "world";
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
    }
}

3.元素访问

数组的索引从0开始

arr[0],打印会输出11

arr[0]=77,然后打印会输出77，给数组元素的值进行覆盖

4.遍历

利用for循环 ，快速生成

//定义一个数组
int[] arr = new int[]{1,2,3,4,5,6,7,8,9,10};
//遍历数组，输入数组名.fori后，回车即可出现for循环
for (int i = 0; i < arr.length; i++) {
     System.out.println(arr[i]);
}

public class HelloWorld {
    public static void main(String[] args) {
        //定义一个数组遍历后求其元素的总和
        int[] arr = {1, 2, 3, 4, 5};
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("数组元素的总和为：" + sum);
 
        //定义一个数组遍历得到每个元素统计数组里共有多少个能被3整除的元素
        int[] arr1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int count = 0;
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] % 3 == 0) {
                count++;
            }
        }
        System.out.println("数组中能被3整除的元素个数为：" + count);
 
        //定义一个数组存储1~10的整数，遍历后如果是奇数则扩大两倍，如果是偶数则缩小为原来的一半
        int[] arr2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        for (int i = 0; i < arr2.length; i++) {
            if (arr2[i] % 2 == 0) {
                arr2[i] /= 2;
            }   else {
                arr2[i] *= 2;
            }
        }
        System.out.println("处理后的数组为：");
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }
    }
}

二.数组练习

1.第一道   

创建一个 char 类型的 26 个元素的数组，分别 放置'A'-'Z' 。使用 for 循环访问所有元素并打印出来。提示：char 类型 数据运算 'A'+2 -> 'C'    ArrayExercise01.java

public class ArrayExercise01 {

    //编写一个main 方法
    public static void main(String[] args) {

        /*
            创建一个 char 类型的 26 个元素的数组，分别 放置'A'-'Z'。 使用for 循环访问    所有元素并打印出来。
            提示：char 类型数据运算 'A'+1 -> 'B'

            思路分析

            1.  定义一个 数组  char[] chars = new char[26]
            2.  因为 'A' + 1 = 'B'  类推，所以老师使用 for 来赋值
            3.  使用for 循环访问所有元素
            */
            char[] chars = new char[26];
            for( int i = 0; i < chars.length; i++) {//循环 26 次 
                //chars  是 char[]
                //chars[i]  是 char
                chars[i] = (char)('A' + i); //'A' + i  是 int ,  需要强制转换 }
             }
                //循环输出
            System.out.println("===chars 数组===");
            for( int i = 0; i < chars.length; i++) {                                                                
                //循环 26 次                     
                System.out.print(chars[i] + " ");
             }

        }
    }

2.第二道

请求出一个数组 int[]的最大值 {4,-1,9, 10,23} ，并得到对应的下标。 ArrayExercise02.java

public class ArrayExercise02 {


//编写一个main 方法
public static void main(String[] args) {






//请求出一个数组 int[]的最大值 {4,-1,9, 10,23} ，并得到对应的下标
//老韩思路分析
//1.  定义一个 int 数组 int[] arr = {4,-1,9, 10,23};
//2.  假定 max = arr[0]  是最大值 , maxIndex=0;
//3.  从下标 1  开始遍历 arr ， 如果 max <  当前元素，说明 max  不是真正的 //      最大值,  我们就 max=当前元素; maxIndex=当前元素下标
//4.  当我们遍历这个数组 arr 后 , max 就是真正的最大值，maxIndex 最大值 //      对应的下标

    int[] arr = {4,-1,9, 10,23};
    int max = arr[0];//假定第一个元素就是最大值
    int maxIndex = 0; //


    for(int i = 1; i < arr.length; i++) {//从下标 1  开始遍历 arr


        if(max < arr[i]) {//如果 max <  当前元素
        max = arr[i]; //把 max  设置成 当前元素
        maxIndex = i;
      }
    }
    //当我们遍历这个数组 arr 后 , max 就是真正的最大值，maxIndex 最大值下标                         
    System.out.println("max=" + max + " maxIndex=" + maxIndex);
  }
}

三.数组内存图

• 内存分配：栈，堆，方法区（后面整改为元空间），本地方法栈，寄存器
• 栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行
• 堆：存储对象和数组，new创建，有地址值
• 方法区：存储可运行的class文件
• 本地方法栈：JVM使用操作系统功能时使用，和开发无关
• 寄存器：cpu使用，和开发无关

数值赋值机制(重点,  难点.)

1)   基本数据类型赋值，这个值就是具体的数据，而且相互不影响。 int n1 = 2; int n2 = n1;

2)   数组在默认情况下是引用传递，赋的值是地址。

       看一个案例，并分析数组赋值的内存图

       //代码 ArrayAssign.java

       int[] arr1 = {1,2,3};

       int[] arr2 = arr1;

两个数组指向同一个空间的内存图