大数据笔记7—java基础篇3（数组和方法及方法重载）

苟有恒，何必三更眠五更起； 最无益，莫过一日曝十日寒。

1.数组定义格式

数据类型[] 变量； int[] array;（常用）

数据类型 变量[] ； int array[];

2.数组初始化

2.1 动态初始化

（不确定数据值用动态）

只定义长度，由系统为数组分配初始值

格式：数据类型[] 变量 = new 数据类型（）；

int[] array = new array(3); 3为定义的长度

如果打印arr[i] 打印出来的是一串字符，这个是在开辟内存空间的一个地址（了解即可）

2.2静态初始化

（明确具体数值用静态）

静态初始化:初始化时，就可以指定数组要存储的元素，系统还会自动计算出该数组长度

格式:数据类型[]变量名= new 数据类型[ ]{数据1，数据2，数据3，……};

范例:
int [ ]arr = new int[]{ }
int[ ]{ 1,2,3 };

简化格式:数据类型[]变量名={数据1，数据2，数据3，……};(常用也是上面的缩写）

2.3两种初始化的区别对比

动态初始化：手动指定数组长度，由系统给出默认初始化值。
静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度

3.数组元素访问

数组内部保存的数据的访问方式，访问数组容器 中的空间位置

数组名[索引]

索引是数组容器中空间的编号
特征①：索引从0开始
特征②：索引是连续的
特征③：索引逐一增加，每次加1

arr[i]数组中是从下标为0开始的一串数组。

若要访问第一个数值则需要打印arr[0];

4内存分配

数组内存图（多个数组）

每new一个新的数组 在堆中都会开辟新的空间且互相不重复

栈内存：方法运行时，进入的内存，局部变量都存放于这块内存当中
堆内存：new出来的内容都会进入堆内存，并且会存在地址值
方法区：字节码文件(.class文件)加载时进入的内存

5 数组操作的两个常见小问题

5.1索引越界

访问了数组中不存在的索引，造成索引越界问题

解决方法：不访问哈哈哈

做个判断 如果判断访问到外面直接结束

5.2空指针异常

空指针异常（NullPointerException）：访问的数组已经不再指向堆内存的数据，造成

null：空值，引用数据类型的默认值，表示不指向任何有效对象

arr = null这样 在内存中不指向这个数组了 相当于是个空数组。

4.遍历

数组遍历：将数组中所有的内容取出来，取出来之后可以（打印，求和，判断…）

遍历指的是取出数据的过程，不要局限的理解为，遍历就是打印！

案例

e.g.获取最值

1定义一组数据，取出其中的最大值，最小值

int[]  array ={1,2,3,4,5,6};
int max=array[0];
int min=array[0];
for(int i=0;i<array.length;i++){
	if(max<array[i]){
        max=array[i];
    }
    if(min>array[i]){
        min=array[i];
    }

}

System.out.println("max为:"+max+"\t"+"min为"+min);

2需求：键盘录入5个整数，存储到数组中，并对数组求和

思路

1定义一个变量存求和的值

2初始化一个长度为5的int数组，利用键入录入值。

3键盘录入5个int 利用动态存取

4遍历求和

数组常见操作

5输出

        int sum = 0;
        int[] array = new int[5];
        for(int i=0;i<array.length;i++){
            System.out.println("请输入五个数值");
            Scanner sc = new Scanner(System.in);
            array[i] = sc.nextInt();
            System.out.println("第"+(i+1)+"个"+array[i]);
            sum+=array[i];
        }
        System.out.println("sum为"+sum);

3评委打分

需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。

1 定义一个数组 可以键入分数

2定义一个可以接受最高和最低的分数 以及成绩综合

3求出最大、最小、平均值

4输出

 int[] arr = new int[6];
        for (int i = 0; i < arr.length; i++) {
            System.out.println("输入" + (i + 1) + "个分数：");
            Scanner sc = new Scanner(System.in);
            arr[i] = sc.nextInt();
        }
        //2.求出最高分和最低分  和平均分
        int max=arr[0];
        int min=arr[0];
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            if(max < arr[i]) {
                max = arr[i];
            }
            if(min > arr[i]) {
                min = arr[i];
            }
        }
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        int avg = (sum-max-min)/(arr.length-1);
        //3.输出
        System.out.println("最大值："+max);
        System.out.println("最小值："+min);
        System.out.println("总分值："+sum);
        System.out.println("平均值："+avg);

4.系统产生一个70-80之间的随机数，请猜出这个数字是多少。**

（猜中之后程序就结束，没有猜中则继续猜）

详细步骤：

​ ① 、利用Random产生一个随机数，范围70-80（包括70和80）。

​ ②、提示用户键盘录入猜的数字

​ ③、比较这两个数字(用if语句)

​ 大了：给出提示大了，并且继续猜

​ 小了：给出提示小了，并且继续猜

​ 猜中了：给出提示，恭喜你，猜中了，并且结束循环

public static void main(String[] args) {
    //定义一个int类型的数组
    while (true) {
        int ran = (int) (Math.random() * 11) + 70;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数:");
        int test = sc.nextInt();
        if (test < ran) {
            System.out.println("猜小了!");
        } else if (test > ran) {
            System.out.println("猜大了");
        } else {
            System.out.println("恭喜您猜对了!");
            break;
        }
    }
}

------

方法

public static 修饰符，目前先记住这个格式
返回值类型 方法操作完毕之后返回的结果数据，所对应的数据类型
如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
方法名 调用方法时候使用的标识
参数 由数据类型和变量名组成，多个参数之间用逗号隔开
（理解：方法运行之前所需要的材料）
方法体 完成功能的代码块
return 如果方法操作完毕，有数据返回，用于把数据返回给调用者

---

定义方法时，要做到两个明确
明确参数：主要是明确参数的类型和数量
明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型

---

public static void main() {

}

类似main方法,是jvm底层调用的方法.如果我们自己自己定义的就叫做方法.

方法的定义位置:类中方法外

每个方法都是平级关系 自己定义的跟main也是平级.

方法必须在main方法**调用,**因为main是程序的入口.(意思main必须参与其中,晾起来就运行不了了)

调用

可以多次调用

在栈中调用,栈先进后出

方法执行过程:在栈中,只会执行顶层的方法,顶层的方法执行完,会弹栈,最顶层的会被移除,接着执行下一层的方法.

一个方法(1)执行的时候调用另一个方法(2), 先执行另一个方法(2),只要(2)方法不执行,(1)方法就不会执行.

无参----无返回值

public static void 方法名() {

​ //方法体;

}

e.g. 判断奇偶

public static void main(String[] args) {
    isEvenNumber();
}
public static void isEvenNumber(){
    int  num = 12;
    if(num %2 == 0){
    System.out.println("这个数是偶数");
    }else
    System.out.println("这个数是奇数");
}

main调用isEvenNumber函数进行执行判断奇偶;

无参无返回值的是写死的,如果算其他数字则需要改程序,现在引入参数这个概念.

形参和实参

形参:方法中定义的参数

//小窍门:使用形参的时候,把她看成具体某个值

实参:方法中调用的参数

有参----无返回值

public static void 方法名(参数类型 参数名1, 参数类型 参数名2) { //这里可以写多个参数

​ //方法体;

}

具体调用格式

方法名(参数值1, 参数值2); //注意: 参数的个数, 以及对应的参数类型都要和定义方法的参数列表保持一致.

public static void main(String[] args) {
    //调用方法
    isEvenNumber(20);
}
public static void isEvenNumber(int num){
    if(num %2 == 0){
        System.out.println("这个数是偶数");
    }else
        System.out.println("这个数是奇数");
}

//小窍门:使用形参的时候,把她看成具体某个值 把num看成20

如果没有返回值,有参和无参只是打印到控制台让你看一眼,并不能拿到这个值.

例题

1、定义功能，遍历数组中的所有元素，打印并以逗号( , )隔开每个元素。

有数组： int[] arr = {1,2,3,4,5,6,7,8,9};

public static void main(String[] args) {
    int[] array={1,2,3,4,5,6,7,8,9};
    arrayCircle(array);

        }
public static void arrayCircle(int[] arr){
    System.out.print(" {" );
    for (int i = 0; i < arr.length; i++) {

        if(i != arr.length-1){
            System.out.print( arr[i]+ ", " );
        }  else
            System.out.println( arr[i]+ "} " );
    }



}

定义功能完成数组的求和。一个功能求偶数和，一个功能求奇数和。一个功能求总和。

public static void main(String[] args) {
    int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    arraySum(array);
}

public static void arraySum(int[] arr) {
    int even = 0, odd = 0, sum = 0;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] % 2 == 0) {
            even += arr[i];//2
            System.out.println("偶数 = " + arr[i]);
        } else {
            odd += arr[i];//1
            System.out.println("奇数 =" + arr[i]);
        }
        sum += arr[i];

    }
    System.out.println("偶数为" + even + "奇数为" + odd + "总和为" + sum);
}

3、定义功能，计算出数组中的最小值。

public static void main(String[] args) {
    int[] array = {1, 43, 43, 5, 4, 6, 6, 7, 7, 88, 9, 9, 9, 0, 0, 9};
    arraySum(array);
}

public static void arraySum(int[] arr) {
    int min = 0;
    for (int i = 0; i < arr.length; i++) {
        if (min > arr[i]) {
            min = arr[i];
        }

    }
    System.out.println("最小值为" + min);
}

4定义功能，计算出数组中指定元素出现的次数。

​ 数组: int[] arr = {1,43,43,5,4,6,6,7,7,88,9,9,9,0,0,9};

​ 指定元素: int x = 9;

public static void main(String[] args) {
    int[] array = {1,43,43,5,4,6,6,7,7,88,9,9,9,0,0,9};
    int x = 9;
    arraySum(array);

}

public static void arraySum(int[] arr) {
    int x = 9,count=0;
    for (int i = 0; i < arr.length; i++) {
        if (x  == arr[i] )
           count++;
    }
   System.out.println("9出现的次数为" + count+"次");
}

5.定义功能，将数组中的0元素，使用1-10之间的随机数替换掉。

​ 数组: int[] arr = {1,43,43,5,4,6,6,7,7,88,9,9,9,0,0,9};

public static void main(String[] args) {
    int[] array = {1,43,43,5,4,6,6,7,7,88,9,9,9,0,0,9};
    arrayRandom(array);
}

public static void arrayRandom(int[] arr) {

    for (int i = 0; i < arr.length; i++) {

        if (arr[i] == 0){
            arr[i] = (int) (Math.random()*10+1 );

        System.out.println(arr[i]);
    }
    }
}

6.定义 getNewArr()静态方法:要求传入一个int类型的数组arr,遍历数组，将数组中小于10的元素替换成0，然后返回修改之后的数组

在main方法中完成:

​ 1. 定义一个长度为5的int类型的数组

​ 2. 随机生成5个随机数存入数组(随机数的范围为5到50,包括5和50)，并把数组中的元素打印在控制台

​ 3. 调用getNewArr方法,在控制台打印返回后的数组中的元素

public static void main(String[] args) {
    int[] array = new int[5];
    for (int i = 0; i < array.length; i++) {
        array[i]= (int)(Math.random()*(46));
        System.out.println("数组的第"+i+"值为" + array[i]);
    }
    getNewArr(array);

}

public static void getNewArr(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        if( arr[i] <10 )
        arr[i]= 0;
        System.out.println("数组的第"+i+"值为" + arr[i]);
    }
}

无参—有返回值

public static 返回值的数据类型 方法名() {

​ //方法体;

​ return 具体的返回值;

}

返回类型要对应返回值!!! 不然会报错

举例:

public static boolean main(String[] args) {
    
    return  true;
}
public static void main(String[] args) {
    void不用return;
}

具体调用格式

1、直接调用

​ 方法名(); //直接调用, 无意义

2、输出调用

​ System.out.println(方法名()); //输出调用, 在课堂上我可能会经常用, 因为简单

3、赋值调用

​ 数据类型 变量名 = 方法名(); //赋值调用, 实际开发中推荐使用

public static void main(String[] args) {
    //调用方法
    int max = getSum(10,20);
    System.out.println(max);
}
public static int getSum(int num1,int num2){

    return(num1>num2 )? num1:num2;

}

方法的注意事项

1.不能嵌套

2.方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写
如果要编写return，后面不能跟具体的数据。

3.return语句下面，不能编写代码，因为永远执行不到，属于无效的代码

有参—有返回值

public static 返回值的数据类型 方法名(参数类型 参数1, 参数类型 参数2) {

​ //方法体;

​ return 具体的返回值;

}

具体调用格式

1、直接调用

2、输出调用

3、赋值调用

方法重载

同一个类中, 出现方法名相同, 但是参数列表不同的两个或以上的方法时称为方法重载. 方法重载与方法的返回值的数据类型无关.

注意: 参数列表不同分为两种情况

参数的个数不同.

对应参数的数据类型不同.

跟返回的数据类型无关(public static 中的int,boolean等等)

可变参数(int放在最后)

public static void(boolean flag,int....)

'可变参数可以接收任意个同类型实参
'其实就是将接收到的实参存储到一个数组中也就是说我们可以将可变参数当做一个数组来使用注意:
1.可变参数底层是一个数组所以也可以接收一个数组
2.如果可变参数与其他形参配合使用可变参数必须放到列表的最后面
3.可变参数可以给任意个参数,但是普通参数必须给一个实参
4.可变参数在参数列表中只能存在一个
多个返回值用数组