关于java:JavaSE第05篇Java基础语法之数组方法

本篇咱们将会学习 Java 根底语法之数组和办法。数组，是一种根底的数据结构，数组能够让咱们通过一个变量治理一组数据；办法能够将一个性能封装，在须要这个性能的中央，只须要调用办法即可，而不必再反复编写冗余的代码。接下来，咱们将会具体解说 Java 中的数组、办法。

第一章：数组

1.1- 为什么要学习数组（理解）

需要：统计 10 集体每个人的薪资，并计算出 10 集体薪资的总和以及均匀薪资？

此时，面临这个需要，咱们会怎么做呢？

依照目前曾经学过的常识，咱们可能会这么解决：

1. 定义 10 个变量，寄存 10 人的薪资
2. 让 10 个变量相加，计算总薪资
3. 让总薪资除以 10，计算均匀薪资

以上的解决方案，的确能够满足咱们的需要，代码如下：

package com.penglei666.com;

public class Test01 {public static void main(String[] args) {
        /*
        * 定义 10 个变量，寄存 10 集体的薪资
        * */
        double salary1 = 10000;
        double salary2 = 13000;
        double salary3 = 15888;
        double salary4 = 12000;
        double salary5 = 11888;
        double salary6 = 15888;
        double salary7 = 10000;
        double salary8 = 13000;
        double salary9 = 12000;
        double salary10 = 11888;
        // 计算总薪资
        double sum = salary1 + salary2 + salary3 + salary4 + salary5 + salary6 + salary7 + salary8 + salary9 + salary10;
        // 计算均匀薪资
        double avg = sum / 10;
        System.out.println("总薪资：" + sum);
        System.out.println("均匀薪资：" + avg);

    }
}

然而咱们能够发现，一些不好的景象：

1. 变量定义太多，若是计算 100 集体的薪资，那岂不是要定义 100 个变量，那 1000 集体、10000 集体更不用说了。
2. 间断累加，计算反复。

以上这些不好的问题，基本的起因，就是变量定义太多，一个具体的薪资数据对应一个变量，导致操作简单且臃肿。

如何解决以上的问题呢？咱们当然要从根本上解决，想方法实现，让一个变量治理一组数据。

此时，咱们就须要学习数组。

1.2- 什么是数组（了解）

一个 固定长度 的数据容器，能够 有序 地寄存 同类型的数据。

• 固定长度，存放数据的个数。
• 有序，容器中的每一个数据都有一个索引（编号），从左向右，索引从 0 开始。
• 同类型的数据，容器中的寄存的数据类型要统一。

1.3- 数组的定义格局（记忆）

格局 1：

数据类型[] 数组名

double[]salay;
int[]age;
char[]arr;

格局 2：

数据类型 数组名[]

double salay[];
int age[];
char arr[];

以上仅仅是定义了数组的名称，然而未赋值。

1.4- 数组的动静初始化（记忆）

什么是动静初始化

数组动静初始化就是 只给定数组的长度 ，由 零碎给出默认初始化值

• double 类型数组，默认值 0.0
• int 类型数组，默认值是 0
• boolean 类型数组，默认值是 false
• char 类型数组，默认值是 0.0
• 对象类型数组，默认值是 null

动静初始化格局：

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

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

double[]salary = new double[10];

=右边：

• double，示意数组的类型
• []，示意是一个数组
• salary，示意数组的名称（变量名）

=左边：

• new，为数组开拓内存空间
• double，示意数组的类型
• []，示意是一个数组
• 10，示意数组的长度

1.5- 拜访数组元素（记忆）

拜访数组元素（数组中的数据），就是获取数组中的某一个地位的数据。

索引

每一个存储到数组的元素，都会主动的领有一个编号，从 0 开始，向后逐个加 1。

这个主动编号称为数组索引(index)，能够通过数组的索引拜访到数组中的元素。

拜访数组元素格局

数组名[索引]

package com.penglei666.com;

public class Test02 {public static void main(String[] args) {double[]salary = new double[10];
        // 输入数组, 输入后果：[D@b684286
        System.out.println(salary);
        // 输入数组中索引为 0 的元素，double 数组中数据默认值是 0.0
        System.out.println(salary[0]);
        System.out.println(salary[0]);
        System.out.println(salary[0]);
    }
}

1.6- 内存调配（了解）

内存

• 内存是计算机中的重要原件，长期存储区域，作用是运行程序。
• 咱们编写的程序是寄存在硬盘中的，在硬盘中的程序是不会运行的。
• 必须放进内存中能力运行，运行结束后会清空内存。
• Java 虚拟机要运行程序，必须要对内存进行空间的调配和治理。

Java 中的内存调配

目前咱们只须要记住两个内存，别离是：栈内存 和堆内存。

数组在内存中的调配过程

public static void main(String[] args) {double[]salary = new double[10];
    // 输入数组, 输入后果：[D@b684286
    System.out.println(salary);
    // 输入数组中索引为 0 的元素，double 数组中数据默认值是 0.0
    System.out.println(salary[0]);
    System.out.println(salary[1]);
    System.out.println(salary[2]);
}

执行过程：

• ① 程序运行时，首先 main 办法，入栈执行。
• ② main 办法执行时，发现 new 关键字创立数组，则会在堆内存中，为数组开拓间断的空间，并设置默认值。
• ③ 数组开拓空间后，返回内存地址给数组名称，输入数组名称，则输入了内存地址。
• ④ salary[0]示意，通过数组内存地址，找到内存堆区中数组空间中的索引为 0 的数据。
• ⑤ salary[1]示意，通过数组内存地址，找到内存堆区中数组空间中的索引为 1 的数据。
• ⑥ salary[2]示意，通过数组内存地址，找到内存堆区中数组空间中的索引为 2 的数据。

1.7- 根本类型和援用类型的区别（了解）

根本数据类型和援用数据类型

根本数据类型，之前学习的数据类型，如：int、long、double、boolean 等。

援用数据类型，当初学习的 数组 就是援用数据类型

区别 1：程序运行时，在内存中创立数据时，内存调配不同

• 根本数据类型：

  • 会在栈内存开拓一块空间存放数据。

• 援用数据类型：

  • 会在堆内存开拓一块空间存放数据具体信息。
  • 同时也会在栈内存开拓一块空间寄存堆数据的援用（堆区的地址）

区别 2：数据传递过程不同

• 根本数据类型是值传递（数据在栈中会克隆一份新的，两个数据互不影响）。
• 援用数据类型是援用传递（数据的援用在栈中会克隆一份新的，但两个援用指向堆区中的同一个具体数据）

package com.penglei666.com;

public class Test02 {public static void main(String[] args) {
        /*【根本数类型值传递】*/
        // 创立变量 a，赋值为 10
        int a = 10;
        // 把变量 a，赋值给变量 b
        int b = a;
        // 更改变量 b 的值
        b = 20;
        // 变量 b 产生扭转，后果：20
        System.out.println(b);
        // 变量 a 没有产生扭转，后果：10
        System.out.println(a);

        /*【援用类型援用传递】*/
        // 创立数组 arr1
        int[]arr1 = new int[2];
        // 创立数组 arr2，并把 arr1 赋值给 arr2
        int[]arr2 = arr1;
        // 输入 arr1 索引为 0 的值，后果为 0
        System.out.println(arr1[0]);
        // 输入 arr2 索引为 0 的值，后果为 0
        System.out.println(arr2[0]);
        // 更改 arr1 索引为 0 的值
        arr1[0] = 99;
        // 输入 arr1 索引为 0 的值，后果为 99
        System.out.println(arr1[0]);
        // 输入 arr2 索引为 0 的值，后果为 99
        System.out.println(arr2[0]);

    }
}

根本数据类型数据传递过程

援用数据类型数据传递过程

1.8- 数组动态初始化（记忆）

什么是动态初始化

在创立数组时，间接将元素确定

动态初始化格局：

• 完整版格局：数据类型[] 数组名 = new 数据类型[]{元素 1, 元素 2,…};
• 简化版格局：数据类型[] 数组名 = {元素 1, 元素 2,…};

public class ArrayDemo {public static void main(String[] args) {
        // 定义数组
        int[] arr = {1, 2, 3};

        // 输入数组名
        System.out.println(arr);

        // 输入数组中的元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

1.9- 数组中常见的问题（理解）

问题 1：索引越界异样

public class ArrayDemo {public static void main(String[] args) {int[] arr = new int[3];
        System.out.println(arr[3]);  // 异样
    }
}

数组长度为 3，索引范畴是 0~2，然而咱们却拜访了一个 3 的索引。

程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异样。在开发中，数组的越界异样是不能呈现的，一旦呈现了，就必须要批改咱们编写的代码。

解决形式：将谬误的索引批改为正确的索引范畴即可！

问题 2：空指针异样

public class ArrayDemo {public static void main(String[] args) {int[] arr = new int[3];

        // 把 null 赋值给数组，变量将不会执行任何无效对象。arr = null;
        System.out.println(arr[0]);
    }
}

arr = null 这行代码，意味着变量 arr 将不会在保留数组的内存地址，也就不容许再操作数组了，因而运行的时候会抛出 NullPointerException 空指针异样。

解决形式：给数组一个真正的堆内存空间援用即可！

1.10- 数组遍历（重点）

数组遍历：就是将数组中的每个元素别离获取进去，就是遍历。遍历也是数组操作中的基石。

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

以上代码是能够将数组中每个元素全副遍历进去，然而如果数组元素十分多，这种写法必定不行，因而咱们须要革新成循环的写法。数组的索引是 0 到 length-1，能够作为循环的条件呈现。

• 获取数组的长度：数组名.length

public class ArrayTest01 {public static void main(String[] args) {
        // 定义数组
        int[] arr = {11, 22, 33, 44, 55};

        // 应用通用的遍历格局
        for(int x=0; x<arr.length; x++) {System.out.println(arr[x]);
        }
    }
}

1.12- 数组利用（重点）

需要：统计 10 集体的薪资，计算总薪资、均匀薪资和最大薪资。

package com.penglei666.com;

public class Test03 {public static void main(String[] args) {
        // 创立数组，并动态初始化 10 集体的薪资
        double[]salary={12000,10000,13000,15000,14000,18000,10000,13000,15000,14000};
        // 创立变量 sum，示意总薪资，初始化为 0
        double sum = 0;
        // 创立变量 avg, 示意均匀薪资，初始化为 0
        double avg = 0;
        // 创立变量 maxValue，示意最高薪资，初始化数组索引 0 为最大值，最终谁是最大值，须要比拟
        double maxValue = salary[0];
        // 循环遍历每一个人的薪资
        for(int i = 0; i < salary.length; i++) {
            // 取出每一个人的薪资，累计到变量 sum 中
            sum+=salary[i];
            // 从索引 1 开始，和 maxValue 比拟，比 maxValue 值大，就把谁赋值给 maxValue
            if(i>0) {if(salary[i]>maxValue) {maxValue = salary[i];
                }
            }
        }
        // 计算均匀薪资
        avg = sum / salary.length-1;
        // 输入总薪资
        System.out.println("薪资总和：" + sum);
        System.out.println("均匀薪资：" + avg);
        System.out.println("最大薪资：" + maxValue);
    }
}

第二章：办法

2.1- 为什么要学习办法（了解）

需要

一个简略的需要：有三个数组如下：

int[]arrA = {22,11,44,33};
int[]arrB = {1,4,5,2,3};
int[]arrC = {20,33,29,18};

别离计算并输入数组中最大值。

剖析

依照现学的常识，咱们可能会这么做：

• 计算数组 arrA 中的最大值

  1. 定义一个变量如：maxA，示意最大值，初始化为 arrA[0]
  2. 循环遍历数组 arrA，取出每一个值与 maxA 比拟，若遍历的元素大于 maxA，则把以后元素赋值给 maxA
  3. 遍历完结后，maxA 的值就代表最大值。

• 计算数组 arrB 中的最大值

  1. 思路同上

• 计算数组 arrC 中的最大值

  1. 思路同上

package com.penglei666.com;

public class Test04 {public static void main(String[] args) {
        /* 定义三个数组 */
        int[]arrA = {22,11,44,33};
        int[]arrB = {1,4,5,2,3};
        int[]arrC = {20,33,29,18};
        /* 求数组 arrA 中的最大值 */
        int maxA = arrA[0];
        for(int i = 1; i < arrA.length; i++){if(arrA[i]>maxA) {maxA = arrA[i];
            }
        }
        System.out.println("最大值：" + maxA);
        /* 求数组 arrB 中的最大值 */
        int maxB = arrB[0];
        for(int i = 1; i < arrB.length; i++){if(arrB[i]>maxB) {maxB = arrB[i];
            }
        }
        System.out.println("最大值：" + maxB);
        /* 求数组 arrC 中的最大值 */
        int maxC = arrC[0];
        for(int i = 1; i < arrC.length; i++){if(arrC[i]>maxC) {maxC = arrC[i];
            }
        }
        System.out.println("最大值：" + maxC);
    }
}

问题及解决方案

以上解决方案的确能够实现性能。然而存在这样的问题：

• 代码反复

此处的反复，是逻辑反复，若有更多的数组须要计算，岂不是要写更多一样的逻辑代码，这样代码会越来越臃肿且难以保护，若需要更变，要求最小值，岂不是要逐个批改。

那如何去解决呢？以上是逻辑反复，变动的仅仅是数组，所以咱们想方法这样解决问题：

1. 把逻辑封装一个模板。
2. 向这个模板中传入一个数组，就会失去一个最大值的后果，传入一个数组，就会失去一个最大值的后果。

这个模板只须要定义一次，在须要的时候调用这个模板即可。

在编程中，的确提供了这样的语法来实现把逻辑封装成一个模块，这个语法机制就是 办法

2.2- 什么是办法（理解）

办法，在编程中也叫函数，也示意性能。

办法，能够将一段代码封装在一个代码块中，代表一个性能

留神：

• 办法必须先创立才能够应用，该过程成为 办法定义
• 办法创立后并不是间接能够运行的，须要手动应用后，才执行，该过程成为 办法调用

2.3- 无参数办法定义和调用（记忆）

定义格局

public static void 办法名 ( ) {// 办法体;}

示例如下：

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

    /**
     * 定义一个求数组中最大值的办法
     */
    public static void getMax(){int[]arr = {22,11,44,33};
        int max = arr[0];
        for(int i = 1; i < arr.length; i++){if(arr[i]>max) {max = arr[i];
            }
        }
        System.out.println(max);
    }
}

留神：办法定义不能嵌套，比方：不能再 main 办法中定义 getMax。

调用办法

调用格局：办法名()

示例如下：

public class Test05 {public static void main(String[] args) {
        // 调用 getMax 办法
        getMax();}

    /**
     * 定义一个求数组中最大值的办法
     */
    public static void getMax(){int[]arr = {22,11,44,33};
        int max = arr[0];
        for(int i = 1; i < arr.length; i++){if(arr[i]>max) {max = arr[i];
            }
        }
        System.out.println(max);
    }
}

为什么在 main 办法中调用，因为 main 办法是程序执行的入口。

每个办法在被调用执行的时候，都会进入栈内存，并且领有本人独立的内存空间，办法外部代码调用结束之后，会从栈内存中弹栈隐没。

2.4- 带参数办法定义和调用（记忆）

定义格局

参数：由数据类型和变量名组成，数据类型 变量名

办法定义时，参数中的数据类型与变量名都不能短少，短少任意一个程序将报错，多个参数之间用 , 宰割

public static void 办法名 (参数 1) {办法体;}

public static void 办法名 (参数 1, 参数 2, 参数 3...) {办法体;}

示例：

public static void isEvenNumber(int number){...}
public static void getMax(int num1, int num2){...}

案例改良：

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

    /**
     * 求一个数组中的最大值
     * @param arr 示意一个数组
     */
    public static void getMax(int[]arr){int max = arr[0];
        for(int i = 1; i < arr.length; i++){if(arr[i]>max) {max = arr[i];
            }
        }
        System.out.println(max);
    }
}

调用

办法名(参数);

办法名(参数 1, 参数 2);

办法调用时，要传入理论的数据。

public class Test05 {public static void main(String[] args) {
        /* 定义三个数组 */
        int[]arrA = {22,11,44,33};
        int[]arrB = {1,4,5,2,3};
        int[]arrC = {20,33,29,18};
        /* 求数组 arrA 中的最大值 */
        getMax(arrA);
        /* 求数组 arrB 中的最大值 */
        getMax(arrB);
        /* 求数组 arrC 中的最大值 */
        getMax(arrC);
    }

    /**
     * 求一个数组中的最大值
     * @param arr 示意一个数组
     */
    public static void getMax(int[]arr){int max = arr[0];
        for(int i = 1; i < arr.length; i++){if(arr[i]>max) {max = arr[i];
            }
        }
        System.out.println(max);
    }
}

办法调用时，参数的数量与类型必须与办法定义中的设置相匹配，否则程序将报错。

2.5- 形参和实参（了解）

形参：在定义方法时，小括号中定义的变量。

实参：在办法调用时，小括号中传入的理论的数据。

2.6- 带返回值办法的定义和调用（记忆）

需要：计算三个数组中三个最大值的和。

此时，咱们须要调用完办法后，失去后果，这个后果不是输入，而是用来和其余最大值相加。

如何失去后果呢？

能够应用办法返回值，就是一个办法调用结束后，能够通过一个变量接管办法的返回值。

带返回值的办法定义：

public static 数据类型 办法名 (参数) {return 数据 ;}

办法定义时 return 前面的返回值与办法定义上的数据类型要匹配，否则程序将报错。

范例：

// 检测一个数字是否是偶数
public static boolean isEvenNumber(int number) {           
    boolean isEven = number%2==0;
    return isEven;
}
// 求两个不同数字的最大值
public static int getMax(int a, int b) {if(a>b) {return a;}else {return b;}
}

调用

调用形式：返回值类型 变量名 = 办法名(实参)

示例：

public class Test06 {public static void main(String[] args) {
        // 检测 8 是否是偶数
        boolean isEven = isEvenNumber(8);
        System.out.println(isEven);  // isEven 是 true
        // 求 10 和 100 哪个数字比拟大
        int max = getMax(10,100);
        System.out.println(max);     // max 是 100
    }

    /**
     * 检测要给数字是否是偶数
     * @param number , 传入一个数字
     * @return 返回布尔值，true 示意是偶数，false 示意不是偶数
     */
    public static boolean isEvenNumber(int number) {
        boolean isEven = number%2==0;
        return isEven;
    }

    /**
     * 求两个数字中的最大值
     * @param a 一个数字
     * @param b 另一个数字
     * @return  返回较大的 int 类型数字
     */
    public static int getMax(int a, int b) {if(a>b) {return a;}else {return b;}
    }
}

案例代码：

public class Test05 {public static void main(String[] args) {
        /* 定义三个数组 */
        int[]arrA = {22,11,44,33};
        int[]arrB = {1,4,5,2,3};
        int[]arrC = {20,33,29,18};
        /* 求数组 arrA 中的最大值 */
        int maxA = getMax(arrA);
        /* 求数组 arrB 中的最大值 */
        int maxB =getMax(arrB);
        /* 求数组 arrC 中的最大值 */
        int maxC = getMax(arrC);
        // 求最大值的和
        System.out.println(maxA + maxB + maxC);  // 82
    }

    /**
     * 求一个数组中的最大值
     * @param arr 示意一个数组
     * @return 返回一个 int 类型的数字，示意最大值
     */
    public static int getMax(int[]arr){int max = arr[0];
        for(int i = 1; i < arr.length; i++){if(arr[i]>max) {max = arr[i];
            }
        }
        return max;
    }
}

2.7- 办法注意事项（理解）

① 办法不能嵌套定义

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

    public static void methodOne() {public static void methodTwo() {// 这里会引发编译谬误!!!}
    }
}

② void 示意无返回值，能够省略 return，也能够独自的书写 return，前面不加数据

public class MethodDemo {public static void main(String[] args) { }
    public static void methodTwo() {
        //return 100; 编译谬误，因为没有具体返回值类型
        return;    
        //System.out.println(100); return 语句前面不能跟数据或代码
    }
}

2.8- 办法通用格局（记忆）

通用格局

public static 返回值类型 办法名(参数) {
   办法体; 
   return 数据 ;
}

• public static，修饰符，目前先记住这个格局
• 返回值类型，办法操作结束之后返回的数据的数据类型，如果办法操作结束，没有数据返回，这里写 void，而且办法体中个别不写 return
• 办法名，调用办法时候应用的标识，定义规定和变量名一样。
• 参数，由数据类型和变量名组成，多个参数之间用逗号隔开。
• 办法体，实现性能的代码块
• return，如果办法操作结束，有数据返回，用于把数据返回给调用者

如何定义方法

• 明确返回值类型：次要是明确办法操作结束之后是否有数据返回，如果没有，写 void；如果有，写对应的数据类型。
• 明确参数：次要是明确参数的类型和数量

如何调用办法

void 类型的办法，间接调用即可。

非 void 类型的办法，举荐用变量接管调用。

2.9- 办法的重载（了解）

在 Java 程序中，能够定义的多个·重名 的参数列表不同 (参数的个数或类型不同) 的办法。这种景象叫做办法的重载。

public static void fn(int num1,int num2){System.out.print(num1 + num2);                        
}
// 定义有参有返回值办法
public static int fn(int num1,int num2,int num3){return num1 + num2 + num3;}

留神：办法的 重载与办法的返回值没有关系

谬误示例：以下不是办法重载，与返回值没有关系。

public static int fn(int num1,int num2){ }
public static void fn(int num1,int num2){}

第三章：IDEA 装置下载教程

链接：https://pan.baidu.com/s/1fuZu…
提取码：bfbc