Java数组（零基础小白入门教程8）

Love The Way You Lie 2023-10-06 15:27 11阅读 0赞

提纲：

1、方法的概念
    2、方法语法
    3、方法使用
    4、参数
    5、返回值
    6、方法的分类
    7、作业

### **一、数组的概念** ###

####    **1.1、为什么使用数组** ####

如果说程序中，需要存储大量的相同类型的一组数据，如果直接使用变量来进行存储，每个变量只能存储一个值，就需要大量的变量。
    1、代码过于臃肿
    2、程序的可读性差
    3、数据维护较差

#### **1.2、数组的概念** ####

数组的概念：
    就是一组相同数据类型的数据。内存上是开辟的连续的内存空间。

#### **1.3、数组的特点？** ####

1、定长。容量固定。数组一旦创建后，那么长度不能更改。(容量，长度，都是指存储的数量)
    2、存储的数据类型必须都一致。
    3、在内存中空间连续挨个。
    4、数组是引用类型的数据，存在栈和堆的地址引用关系。
    
    Java中：两大数据类型
      基本：4类8种
      引用：数组，对象，集合。。。。

### **二、数组的使用** ###

#### **2.1、数组的使用** ####

step1：先创建数组
    step2：使用数组：存储数据，访问数据。

#### **2.2、数组的语法** ####

创建数组的语法：
      数据类型[] 数组名 = new 数据类型[长度、容量、个数];
      数据类型 数组名[] = new 数据类型[长度];//也可以
      
    使用的语法：
      数组名[index]，操作数组
      index：因为一个数组存储了多个数据(也叫元素)，每个元素都有一个下标，也叫索引，index。理解起来就是给每个数据排个编号，固定从0开始，0,1,2,3,4.。。。到长度减1。
      数组的下标不能超出这个范围。否则就会下标越界：java.lang.ArrayIndexOutOfBoundsException

示例代码：

public class Test1Array
    {
      public static void main(String[] args){
        //1.变量的定义
        int num = 10;
        System.out.println(num);
    
        //2.数组
        /*
        创建数组：语法格式
          数据类型[] 数组名 = new 数据类型[容量/长度/个数];
    
        数组是引用类型的数据：
          a中存储的是数组的实际的地址。
        */
    
        int[] a = new int[5];//声明一个数组，并创建出来，然后就可以使用这个数组了。
        System.out.println(a);
    
        //3.使用数组：存储数据
        a[0] = 10;
        a[1] = 20;
        a[2] = 30;
        a[3] = 40;
        a[4] = 50;
        //a[5] = 100;//java.lang.ArrayIndexOutOfBoundsException
    
        //获取数据
        System.out.println(a[0]);//打印数组的第一个元素
        System.out.println(a[1]);//打印数组的第二个元素
        System.out.println(a[2]);//打印数组的第三个元素
        System.out.println(a[3]);//打印数组的第四个元素
        System.out.println(a[4]);//打印数组的第五个元素
    
        
        //课堂练习：创建一个数组， 存储班级5位同学的性别。
        char[] arr2 = new char[5];
        arr2[0] = '男';
        arr2[1] = '男';
        arr2[2] = '男';
        arr2[3] = '女';
        arr2[4] = '女';
    
        //打印悄悄
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println(arr2[3]);
        System.out.println(arr2[4]);
        
    
      }
    }

#### **2.3、内存分析(扩展)** ####

内存：存储数据
    A：栈，存放的是基本数据类型的变量，以及引用类型变量的引用。
      特点：函数中的变量所占用的空间，执行之后就会销毁。
    B：堆，存放的是new出来的东西。
      特点：执行之后，堆里存储的内容(对象等)，会被标记为垃圾，但是不会立即被销毁，而是等待系统的垃圾回收机制来回收(GC)。
      JVM,GC(Grabage Collection)

####    **2.4、数组的长度** ####

获取数组的长度：length，数组的一个属性。
    数组名.length--->获取这个数组的长度。

####    **2.5、使用循环遍历数组** ####

#### **2.5.1、普通的循环** ####

1、遍历：依次访问数组中每个元素。可以赋值，可以取值。
    2、因为操作数组，就是数组名字配合下标，而下标固定都是从0开始，到长度减1。
    for(int i = 0;i < arr2.length;i++){
      System.out.println(arr2[i]);
    }

示例代码：

class Test2ArrayFor 
    {
      public static void main(String[] args) 
      {
        //定义了一个数组，存储了5个学生的性别。
        char[] arr2 = new char[5];
        arr2[0] = '男';
        arr2[1] = '男';
        arr2[2] = '男';
        arr2[3] = '女';
        arr2[4] = '女';
    
        /*
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
        System.out.println(arr2[3]);
        System.out.println(arr2[4]);
        */
    
        //借助循环来打印数组：for，while，do-while循环
    
        for(int i = 0;i < arr2.length;i++){
          //i:0,1,2,3,,5
          System.out.println(arr2[i]);
          //arr2[0],arr2[1],arr2[2],arr2[3],arr2[4]
        }
    
    
        System.out.println(arr2.length);//专门用于获取一个数组的长度,5
        
      
        //课堂练习1：定义一个int类型的数组，求该数组中所有元素的总和。
    
        //课堂练习2：统计这个数组中元素的平均值。
      }
    }

#### **2.5.2、for-each循环** ####

for-each循环：【扩展】
    增强for循环：JDK1.5的版本出现的。
    特定的用法：专门用于获取数组中的每一个元素的值。
    语法结构：
    for(数据类型 变量名 : 数组名){
        System.out.println(变量名);
    }
    工作原理：
    for(int e :arr){
        System.out.println(e);
    }
    int e，定义变量e，
        依次获取数组的元素，赋值给e
    注意点：
        A：for-each只能获取数组的数据，但是不能给数组进行赋值
        B：for-each，在代码这个层面，不能操作下标。

示例代码：

public class Test1ForEach
    {
      public static void main(String[] args){
        /*
        循环的遍历：依次获取里面的每一个元素
        方法一：一个一个的获取
    
        方法二：普通的循环：for循环
    
        方法三：for-each循环：
        for(数据类型 变量名 : 数组名){
          System.out.println(变量名);
        }
    
        element，元素。数组中存储的数据-->数组的元素。
        */
    
        int[] arr = new int[4];
        arr[0] = 1;
        arr[1] = 4;
        arr[2] = 3;
        arr[3] = 5;
        //方法一：
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
    
        //方法二：
        for(int i=0;i < arr.length;i++){
          System.out.println("--->" + arr[i]);
        }
    
    
        //方法三：
        /*
        index-->0,1,2,3
        arr--->[1,4,3,5]
    
        工作原理：
          int e，定义变量e，
            依次获取数组的元素，赋值给e
        
        */
        for(int e : arr){
          //int e = 1;
          //e = 4;
          //e = 3;
          //e = 5;
          System.out.println(e);
        }
    
        System.out.println("------------------");
    
        //普通的for循环赋值
        int[] arr2 = new int[5];//1,3,5,7,9
        for(int i = 0;i<arr2.length;i++){
          //i:0,0 1
          //i:1,2 3
          //i:2,4 5
          //i:3,6 7
          //i:4,8 9
          arr2[i] = i * 2 + 1;
        }
        for(int i=0;i<arr2.length;i++){
          System.out.println(arr2[i]);
        }
    
        //通过for-each给数组进行赋值？不能给数组赋值。
        for(int e : arr2){
          // int e :1
          e = 10;//仅仅是给变量e进行赋值，和arr2数组无关。
        }
        for(int e : arr2){
          System.out.println(e);
        }
      }
    }

#### **2.6、数组中的默认值** ####

数组的默认值，就是数组创建后，里面存储的默认的数据。
    数组的引用存在栈内存中，数组本身存在堆内存中。
    数组创建完，就有默认的数据了。
    数组中存储的默认值：
                数组中是有默认值的
                整数：0
                小数：0.0
                字符：\u0000
                布尔：false
                其他：null

示例代码：

class Test2DefaultValue 
    {
      public static void main(String[] args) 
      {
        /*
        数组中存储的默认值：
          数组中是有默认值的
          整数：0
          小数：0.0
          字符：\u0000
          布尔：false
          其他：null
    
    
        arr[i]?
          1.先根据arr中存储的地址，找到这块堆内存的数组元素。
          2.找到这块数组内存后，根据i来获取对应的空间
        */
    
        int n ;//可能尚未初始化变量n
        System.out.println(n);
    
        int[] arr = new int[5];
    
        for(int i = 0;i<arr.length;i++){
          System.out.println(arr[i]);//
        }
    
        String[] arr2 = new String[3];
    
        for(int i = 0;i < arr2.length;i++){
          System.out.println(arr2[i]);
        }
        System.out.println("Hello World!");
      }
    }

**2.7、创建数组的其他语法**

/*
    动态创建数组：先创建数组，然后再根据下标一个一个存储数据。
    A：先声明，再创建(分配内存空间)
    数据类型 [] 数组名;
    数组名 = new 数据类型[长度];
    
    B：声明并创建
    数据类型 [] 数组名 = new 数据类型[长度];
    数据类型  数组名[] = new 数据类型[长度];
    
    
    //静态创建数组：声明，创建，赋值一起写完。
    C：声明，创建，并赋值
    数据类型[] 数组名 = {数值1,数值2,数值3,数值4.。。。};
    //=左边声明数组，=右边，会先根据{}中数据的个数，然后再将{}中数据，按照顺序存储进去。
    完成了几件事：
                1.先声明：int[] c
                2.根据{}中数组值的个数，开辟堆内存
                3.将{}中的数组值，依次按照顺序存入数组中
    D：声明，创建，并赋值
    数据类型[] 数组名 = new 数据类型[]{数值1,数值2,数值3,数值4.。。。}
    */

示例代码：

class Test3ArrayCreate 
    {
      public static void main(String[] args) 
      {
        //创建方式1：先声明，再创建
        int[] a = null;//引用类型默认赋值null
        a = new int[5];//创建，有new表示开辟堆内存，创建数组了，才可以使用数组。
        
        
        //创建方式2：声明和创建写一起
        int[] b = new int[5];
        System.out.println(a);
    
        //创建方式3：声明，创建，赋值，写一起
        int[] c = {1,2,3,4,5};
        /*
          完成了几件事：
          1.先声明：int[] c
          2.根据{}中数组值的个数，开辟堆内存
          3.将{}中的数组值，依次按照顺序存入数组中
        */
        System.out.println(c.length);
        for(int e :c){
          System.out.println(e);
        }
    
        //创建方式4：
        int[] d = new int[]{1,2,3,4,5};
        System.out.println(d.length);
    
    
    
        int[] e;
        e = new int[]{1,2,3,4,5};
        for(int i:e){
          System.out.println(i);
        }
    
      }
    }

#### **2.8、数组的地址转移** ####

Java中的数据分为两大类：
    基本类型：4类8种
      操作的都是数值本身
    引用类型：数组
      操作的是地址
    
    基本类型进行赋值：数值
    引用类型进行赋值：地址

示例代码：

class Test4ArrayAddress 
    {
      public static void main(String[] args) 
      {
        /*
        数组：引用类型的数据
          数组名，存储是引用地址。
        */
    
        int[] a = new int[3];
        System.out.println(a.length);//3
        System.out.println(a);//a数组的地址
        System.out.println(a[0]);//0
    
        a[0] = 1;
        a[1] = 2;
        a[2] = 3;
    
        int[] b = {4,5,6,7};
        System.out.println(b.length);//4
        System.out.println(b);//b的地址
        System.out.println(b[0]);//4
    
        int[] c = a;//将a的值赋值给c，就是将a存储的数组的地址赋值给c
        //a和c存储的地址相同，那么就指向了同一个数组
        System.out.println(c.length);//3
        System.out.println(c);//a的地址
        System.out.println(c[0]);//1
    
        c[0] = 100;
        System.out.println(a[0]);
        System.out.println(b[0]);
        System.out.println(c[0]);
    
    
        b = c;
    
        b[1] = 200;
        System.out.println(a[1]);//200
        System.out.println(b[1]);//200
        System.out.println(c[1]);//200
    
        System.out.println("Hello World!");
      }
    }

内存分析：

![77c340a7caa04334817d87509a0f7a5b.png][]

### **三、数组在方法中的使用** ###

#### **3.1、数组作为参数** ####

数组是引用类型：传递的是地址。就是参数也会指向这块内存。当方法结束的时候，参数就销毁了。

class Test5ArrayMethod 
    {
    
        //设计一个方法，用于打印数组
        public static void printArray(int[] arr){//int[] arr = a;a的地址给了arr，那么arr和
           // a指向同一块内存的数组
            for(int e : arr){
                System.out.print(e +"\t");
            }
            System.out.println();
        }
    
        public static void main(String[] args) 
        {
    
            int[] a = {1,2,3,4,5};
    
            //设计一个方法，用于打印数组
            printArray(a);//将a的地址，传递给arr
            System.out.println("Hello World!");
        }
    }

内存分析：

![dc809154bc8243cb9450b98ab18accc7.png][]

#### **3.2、数组作为返回值** ####

示例代码：

//设计一个方法，用于创建一个数组， 并赋值。数组要返回给调用处
        public static int[] createArray(int len){
            int[] arr = new int[len];
            for(int i = 0;i <arr.length;i++){
                arr[i] = i * 2;
            }
            return arr;
        }

![ea2716051c20464e9364a6410383870e.png][]

**3.3、可变参数【扩展】**

概念：一个方法可以接收的参数的数量不定(0-多个)，但是类型固定。
    
    语法：数据类型 ... 参数名，可变参数在方法中当数组使用。
    
    注意事项：
        1、如果参数列表中，除了可变参数还有其他的参数，可变参数要写在整个参数列表的最后。
        2、一个方法最多只能有一个可变参数。

示例代码：

class Test6Array 
    {
        
        //求一组int类型的数据的和
        public static void getSum(int ... nums ){
            int sum = 0;
            for(int i = 0;i <nums.length;i++){
                sum += nums[i];
            }
            System.out.println("结果：" + sum);
        }
    
        public static void main(String[] args) 
        {
            /*
            可变参数：同一种类型的参数，类型固定的，但是个数不固定。
    
            语法的支持：
                数据类型 ... 参数名
    
                可变参数，类型固定，个数可变。0-多个
    
            在方法中可变参数当数组使用
            */
    
            getSum(1,2,3);
            getSum(1,2,3,4,5,6,7,8,9,10);
            System.out.println("Hello World!");
        }
    }

### **四、数组的排序** ###

排序：数组是存储一组数据，而且这些数据是有顺序的。但是数值本身可能是无序的。通过算法来实现给数组进行排序，升序(数值从小到大)，降序(数值从大到小)。

#### **4.1 冒泡排序** ####

冒泡排序：思路(升序)：比较相邻的两个数，较大的数据需要向后移动。长度减1。

1、冒泡排序：Bubble Sort
    原理：比较相邻的两个数，将较大的数，向后移动。
        
    class Test7BubbleSort 
    {
      public static void main(String[] args) 
      {
        int[] arr = {15,23,8,10,7};
        
    
        for(int i= 1; i<arr.length;i++){//控制轮数：
          //i=1,2,3,4
          /*
          i=1,  j<4
          i=2,  j<3
          i=3,  j<2
          */
          for(int j = 0;j < arr.length - 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;i++){
          System.out.println(arr[i]);
        }
    
      }
    }

选择排序：思路(升序)：每次找个基准值，定一个变量k表示比较小的值的下标。每轮比较完，都在基准值上放一个比较小数。

#### **4.2 选择排序** ####

示例代码：

package com.qf.array;
    
    public class Test1SelectionSort {
    
      public static void main(String[] args) {
        /*
         * 选择排序： 思路： 每一轮找个基准值：在基准值上放一个比较小的数。
         * 
         * 定义一个变量k，用于标记比较小的数的下标
         */
        int[] arr = { 15, 23, 8, 10, 7 };
    
        for (int i = 0; i < arr.length - 1; i++) {
          // i = 0,1,2,3,表示轮数
          // 用于标记本轮中，要找的比较小的值。
          int k = i;
    
          // 依次比较arr[k]
          for (int j = k + 1; j < arr.length; j++) {
            // 比较arr[k]和arr[j],如果arr[k]值大于arr[j]的值，将j赋值给k
            if (arr[k] > arr[j]) {
              k = j;
            }
          }
    
          // 交换arr[i]和arr[k]
          // i = 0, 第一轮：arr[0],arr[k]
          // i = 1,第二轮， arr[1],arr[k]
          // i =2,第三轮，arr[2],arr[k]
          if (k != i) {
            int temp = arr[i];
            arr[i] = arr[k];
            arr[k] = temp;
          }
        }
    
        // 排序后，打印数组
        for (int e : arr) {
          System.out.println(e);
        }
    
      }
    
    }

### **五、Arrays工具类** ###

#### **5.1、工具类：Arrays** ####

JDK提供好的类：
        A：Scanner，读取键盘
        B：String，字符串
        C：Math，数学的
        D：Arrays，提供数组的常规操作的
        E：System，
        。。。

#### 在Arrays类中，提供了很多关于数组常用的操作方法。 ####

#### **5.2、数组的复制** ####

就是将一个数组的数据，复制到另一个数值中。

方法一：通过循环，依次复制，将原数组的数据，一个一个，复制到目标数组中
    方法二：Arrays类里方法：copyOf(原数组，新数组的长度)-->返回值是新数组
    方法三：System类里的方法：arraycopy(原数组，原数组位置，新数组，新数组位置，拷贝的个数)

示例代码：

package com.qf.array;
    
    import java.util.Arrays;
    
    public class Test3Copy {
    
      public static void main(String[] args) {
        int[] a = {1,2,3};
        
        int[] b = new int[10];
        //数组的拷贝：
        //方法一：自己通过循环依次复制，吭哧吭哧
        for(int i=0;i<a.length;i++){
          b[i] =a[i];
        }
        
        for(int e :b){
          System.out.println(e);
        }
        System.out.println("---------");
        
        //方法二：借助于Arrays类
        /*
         * copyOf(int[] 原始数组，int 新数组的长度)
         * 返回值就是新的数组
         * 
         */
        int[] c = Arrays.copyOf(a, 5);//int[] c = {1,2,3,0,0}
        for(int e:c){
          System.out.println(e);
        }
        
        
        System.out.println("--------");
        //方法三：借助于System类
        /*
         * arraycopy(src, srcPos, dest, destPos, length)
         * 第一个参数：原始数组
         * 第二个参数：从原始数组的哪个下标开始复制
         * 第三个参数：目标数组
         * 第四个参数：目标数组从哪个下标开始贴
         * 第五个参数：拷贝几个数据
         */
        //int[] a = {1,2,3};
        int [] d = new int[10];
        System.arraycopy(a, 1, d, 5, 20);
        for(int e:d){
          System.out.print(e+"\t");
        }
        
      }
    
    }

![7beaae9baafb4742ba51cc086f4eef03.png][]

### **六、二维数组** ###

维度：dimension
        数组：存储相同类型的一组数据。
        一维数组：数组中存储的就是数据了。
        二维数组：存储的是一维数组。本质也叫数组的数组。也被称为矩阵：行和列的。
        多维数组。。。

示例代码：

package com.qf.array;
    
    public class Test4TDArray {
    
      public static void main(String[] args) {
        //二维数组
        //一维数组
        int[] a = {1,2,3,4};
        int[][] b = {
            {1,2,3},
            {4,5,6},
            {7,8,9,10}
            };
        System.out.println(b);//打印的是b这个二维数组的地址
        System.out.println(b.length);//3
        System.out.println(b[0]);//第一个一维数组的地址
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[0][1]);//2
        System.out.println(b[1][2]);//6
        
        
        for(int i=0;i<b.length;i++){
          for(int j = 0;j<b[i].length;j++){
            System.out.print(b[i][j]+"\t");
          }
          System.out.println();
        }
        
        //遍历第三个一维数组
    //    for(int j = 0;j<b[2].length;j++){
    //      System.out.println(b[2][j]);
    //    }
        
        
        System.out.println("------");
        //for(数据类型 变量名 :数组)
        for(int[] arr :b){
          for(int e :arr){
            System.out.print(e+"\t");
          }
          System.out.println();
        }
      }
    
    }

![b1c75a904ff34283826a6a339d2ba278.png][]

示例代码：

package com.qf.array;
    
    public class Test5TDArray {
    
      public static void main(String[] args) {
        //二维数组的创建语法
        //1.先声明，再创建
        int[][] a = new int[3][4];//二维，一维一起创建
        
        //2.先创建二维数组，后创建一维数组
        int[][] b= new int[3][];//只是创建了二维数组，但是一维还没有创建
        b[0] = new int[3];
        b[1] = new int[4];
        b[2] = new int[4];
        
        //3.声明，创建，赋值
        int[][] c = {
       {},{},{}};
        
        //4.
        int[][] d = new int[][]{
       {},{},{}};
      }
    
    }

### **七、作业** ###

1、给定一个整数数组，例如\{2，4，5，6，7，8\}和一个数字，例如10，请设计一个方法，找出两个元素，并且使这两个数的和为给定数字，并打印出来。

2、某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5，然后再用加5后的数字除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。打印加密后的数字。

3、定义一个数组，存储以下数据：\{1,2,3,4,5,6,7,8,9\}，请查找该数组中，是否存在数字8。

[77c340a7caa04334817d87509a0f7a5b.png]: https://img-blog.csdnimg.cn/77c340a7caa04334817d87509a0f7a5b.png
[dc809154bc8243cb9450b98ab18accc7.png]: https://img-blog.csdnimg.cn/dc809154bc8243cb9450b98ab18accc7.png
[ea2716051c20464e9364a6410383870e.png]: https://img-blog.csdnimg.cn/ea2716051c20464e9364a6410383870e.png
[7beaae9baafb4742ba51cc086f4eef03.png]: https://img-blog.csdnimg.cn/7beaae9baafb4742ba51cc086f4eef03.png
[b1c75a904ff34283826a6a339d2ba278.png]: https://img-blog.csdnimg.cn/b1c75a904ff34283826a6a339d2ba278.png