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

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

第一章：数组

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

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

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

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

定义10个变量，寄存10人的薪资
让10个变量相加，计算总薪资
让总薪资除以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);    }}

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

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

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

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

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

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);    }}

问题及解决方案

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

代码反复

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

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

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

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

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

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