数组：一种容器，可以用来存储同种数据类型的多个值

数组容器在存储数据的时候，需要结合隐式转换考虑

数组的定义：

格式一：数据类型[ ] 数组名   范例：int  [ ] array

格式二：数据类型 数组名 []   范例：int  array [ ]

数组的静态初始化

初始化：在内存中，为数组容器开辟空间，并将数据存入容器的过程

格式：数据类型[ ] 数组名 = new 数据类型[] {元素1，元素2，元素3……}

简化格式：数据类型[ ] 数组名 = {元素1，元素2，元素3……}

int [] array = {11,22,33};//数组的长度为3

package com.itheima.arraydemo;

public class ArrayDemo1 {
    public static void main(String[] args) {
        //静态初始化
        //数据类型 [] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
        //简化格式：数据类型 [] 数组名 = {元素1,元素2,元素3...};
        //定义数组存储五个学生的年龄
        //int[] ages = new int[]{18, 20, 22, 24, 26};
        int[] ages = {18, 20, 22, 24, 26};
        //创建数组定义学生的姓名
//        String[] names = new String[]{"张三", "李四", "王五", "赵六", "田七"};
        String[] names = {"张三", "李四", "王五", "赵六", "田七"};
        //定义数组存储学生的身高
//        double[] heights = new double[]{1.75, 1.80, 1.85, 1.90, 1.95};
        double[] heights = {1.75, 1.80, 1.85, 1.90, 1.95};
        

    }
}

数组的地址值：数组在内存中的位置

int  [ ] array = {1，2，3，4，5}；

System.out.println(array);//打印的是地址值

double[] heights = {1.75, 1.80, 1.85, 1.90, 1.95};
        System.out.println(heights);//[D@3f99bd52
        //解释一下地址值的格式含义
        //[]当前是一个数组
        //D：当前数组都是double类型
        //@：表示一个间隔符号
        //3f99bd52：内存地址值（十六进制）

数组元素访问

格式：数组名[索引]；

索引：也叫角标，从0开始，逐个加1增长，不间断。

package com.itheima.arraydemo;

public class ArrayDemo2 {
    public static void main(String[] args) {
        //获取数组里面的元素
        //1、创建一个数组
        int [] ages = {18, 20, 22, 24, 26};
        //2、获取数组里面的元素
//        System.out.println("张三的年龄是："+ages[1]+"岁");
        //把数据存储到数组中
        //格式：数组名[索引] = 数据；
        ages[0] = 17;
        System.out.println(ages[0]);
    }
}

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

package com.itheima.arraydemo;

public class ArrayDemo3 {
    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]);
        //利用for循环进行遍历数组
        //开始条件：0
        //结束条件：最大索引=数组长度-1
        //数组的长度属性：length
        //调用方式：数组名.length

//        for(int i=0;i<=4;i++){
        for(int i = 0;i <= arr.length - 1;i++){
            System.out.println(arr[i]);
        }
        //快速生成数组的遍历方式
        //数组名.fori


    }
}

 练习-遍历数组并求和

package test;

public class Test1 {
    public static void main(String[] args) {
        //定义一个数组
        int arr[] = {10, 20, 30, 40, 50};
        //定义一个变量，用于存储求和之后的结果
        int sum = 0;
        //遍历数组求和
        for (int i = 0; i < arr.length; i++) {
            //i:依次表示数组里面每一个索引
            //arr[i]:依次表示数组里面每一个元素
            sum = sum + arr[i];
        }
        //输出求和结果
        System.out.println(sum);//150
    }
}

练习-统计个数

package test;

public class Test2 {
    public static void main(String[] args) {
        //定义一个数组，存储1-10
        int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        //定义一个变量用来统计个数
        int count = 0;
        //遍历数组，获取每一个元素
        for (int i = 0; i < arr.length; i++) {
            //统计数组里面有多少个能被三整除(取余为0)的元素
            if(arr[i]%3==0){
                count++;
                System.out.println(arr[i]);
            }

        }
        System.out.println("能被三整除的个数为："+count);//3
    }
}

练习-变化数据

package test;

public class Test3 {
    public static void main(String[] args) {
        //定义一个数组，存储1-10
        int arr [] = {1,2,3,4,5,6,7,8,9,10};
        //遍历得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            //System.out.println(arr[i]);
            //如果是奇数（对2取余为1），则将当前数字扩大两倍
            if(arr[i]%2==1){
                //扩大两倍放回原来的地方
                arr[i] = arr[i] *2;
            }
            else {
                //如果是偶数(对2取余为0)，则将当前数字变为二分之一
                arr[i] = arr[i] / 2;
            }
//            System.out.println(arr[i]);
        }
        //一个循环只干一件事
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

数组的动态初始化：初始化时只指定数组的长度，由系统为数组分配初始值

package com.itheima.arraydemo;

public class ArrayDemo4 {
    public static void main(String[] args) {
        /*定义一个数组，用来存班级50个学生的姓名
        * 姓名未知，等学生报道之后，再进行添加*/
        //格式：
        //数据类型 [] 数组名 = new 数据类型 [长度]
        //在创建的时候，由我们之间指定数组长度，
        // 由虚拟机给出默认的初始化值
        String [] names = new String[50];
        //添加学生
        names[0] = "张三";
        names[1] = "李四";
        //获取
        System.out.println(names[0]);//张三
        System.out.println(names[1]);//李四
        System.out.println(names[2]);//null
        
        //数组默认初始化值的规律
        //整数：0
        //小数：0.0
        //字符：'\u0000'表示空格
        //布尔：false
        //引用数据类型：null
      


    }


}

数组动态初始化和静态初始化的区别

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

只明确元素个数，不明确具体数值，推荐动态初始化

静态初始化：手动指定数组长度，系统会根据元素个数，计算出数组长度

需求中国已经明确了要操作的具体数据，直接静态初始化即可

数组常见问题

当访问数组中不存在的索引就会引发索引越界异常

package com.itheima.arraydemo;

public class ArrayDemo5 {
    public static void main(String[] args) {
        //1、定义一个数组
        int [] arr = {1,2,3,4,5};
        //长度：5
        //索引：0 1 2 3 4
        //最大索引=数组长度-1
        System.out.println(arr[9]);//引发异常
        
    }
}

求最值

package test;

public class Test4 {
    public static void main(String[] args) {
        //已知数组元素为{68,27,95,88,171}，
        // 请找到数组中的最大值并打印在控制台

        //扩展问题：
        //为什么max要记录arr[0],默认值不能是0吗？
        //不能写0，因为数组中的元素可能都是负数，
        // max的初始化值一定要是数组中的值
        //循环的开始条件一定是0吗？
        //循环的开始条件如果为0，那么第一次循环的时候是自己跟自己比
        //对结果没有任何影响，但是效率偏低
        //为提高效率，减少一次循环次数，循环开始条件可以写1
        //定义数组
        int arr [] = {700,200,95,900,171};
        //找最大值
        //定义一个变量，用来存储最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(arr[i]>max){
                max = arr[i];
            }
        }
        System.out.println("最大值为：" + max);
        

    }
}

练习-生成10个1-100的随机数存入数组，并求所有数据的和、平均值、以及比平均值小的数据的个数

package test;

import java.util.Random;

public class Test5 {
    public static void main(String[] args) {
        //生成10个1-100之间的随机数存入数组
        Random random = new Random();
        //定义数组（动态初始化）,用来存放随机数，长度为10
        int [] arr = new int[10];
        //定义一个变量，用来存放数组的和
        int sum = 0;
        //定义一个变量，用来存放数组的平均值
        int average = 0;
        //定义一个变量用来统计比平均值小的数据的个数
        int count = 0;
        //生成10个1-100之间的随机数存入数组
        for (int i = 0; i < arr.length; i++) {
            //每循环一次生成一个新的随机数
            arr[i] = random.nextInt(100)+1;//1-100
            //把生成的随机数打印出来
            System.out.print(arr[i]+' ');
        }
        //遍历数组，把数组中的数据相加，求出数组的和
        for (int j=0;j<arr.length;j++) {
            sum = sum + arr[j];
            average = sum/arr.length;
        }
        for (int k=0;k<arr.length;k++) {
            if (arr[k]<average) {
                count++;
            }
        }
        System.out.println("数组的和为：" + sum);
        System.out.println("数组的平均值为：" + average);
        System.out.println("数组中比平均值小的数据的个数" + count);
    }
}

练习-交换数组中的数据

package test;

public class Test6 {
    public static void main(String[] args) {
        //定义一个数组，存入1，2，3，4，5
        int arr [] = {1,2,3,4,5};
        System.out.print("交换前：");
        //遍历数组，把数组中的数据打印出来
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        //定义一个临时变量,并把第一个值赋值给临时变量
        int temp = arr[0];
        arr[0] = arr[4];
        arr[4] = temp;
        System.out.print("\n");
        System.out.print("交换后：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

练习-逆序排序

package test;

public class Test7 {
    public static void main(String[] args) {
        //定义数组存储数据
        int[] arr = {11, 22, 33, 44, 55};
        //利用循环交换数组
        //最大索引 = 数组长度 - 1
        for (int i = 0,j = arr.length-1; i < j; i++, j--) {
            //交换变量i和j指向的元素
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //当循环结束之后，那么数组中的数据实现了头尾交换
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

打乱数组中的数据

package test;

import java.util.Random;

public class Test8 {
    public static void main(String[] args) {
        //获取数组中的随机索引
        //定义一个数组
        int arr [] = {1,2,3,4,5};
        //索引值为0，1，2，3，4
        Random random = new Random();
        //生成随机索引值0-4
        //int r = random.nextInt(5);//5是数组长度
        int index = random.nextInt(arr.length);
        //打乱数组中所有元素的顺序
        for (int i = 0; i < arr.length; i++) {
            //定义一个变量用来存储临时索引
            int temp =arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

}

Java内存分配

 1、只要是new出来的一定是在推里面开辟了一个小空间；

2、如果new了多次，那么 在推空间里面由多个小空间，每个小空间都有各自的数据。

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

1、当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果。

方法：程序中最小的执行单元

重复的代码、具有独立功能的代码可以抽取到方法中

可以提高代码的复用性和可维护性

方法的格式

方法定义：把一些代码打包在一起

方法调用：方法定义之后不会主动运行，需要手动调用才能执行

方法的定义格式：3种

一、最简单的方法定义和调用

 

方法必须先定义，后调用

package com.itheima.methoddemo;

public class Methoddemo1 {
    public static void main(String[] args) {
        //最简单的方法定义和调用
        //调用两次method方法
        method();
        method();
    }
    //定义一个方法
    public static void method(){
        System.out.println("这是一个最简单的方法");
    }
}

练习-看代码说结果

a,d,e,c,b

练习-人肉计算器

package test;

public class Test2 {
    public static void main(String[] args) {
        //需求：在方法里面定义两个变量并求和
        sum();
    }
    public static void sum(){
        int a= 10;
        int b= 20;
        int sum = a + b;
        System.out.println(sum);//30
    }

二、带参数的方法的定义和调用

形参和实参

形参：形式参数，方法定义中的参数

形参：实际参数，方法调用中的参数

方法定义小技巧：

1、我要干什么？ 方法体

2、我干这件事需要什么才能完成？  形参

练习-求长方形的周长，并将结果在方法中打印

package test;

public class Test3 {
    public static void main(String[] args) {
        //需求：定义一个方法，求长方形的周长，将结果在方法中打印
        //根据不同需求，选择定义无参的方法还是带参数的方法
        getPerimeter(1.0,2.1);
    }
    /**
     * 定义一个方法，求长方形的周长
     * @param length 长方形的长
     * @param width 长方形的宽
     */
    public static void getPerimeter(double length,double width){
        //长方形的周长 = （长 + 宽）* 2
        double perimeter = (length + width) * 2;
        System.out.println("长方形的周长是：" + perimeter);//6.2
    }
}

练习-利用方法求圆的面积并打印结果

package test;

public class Test4 {
    public static void main(String[] args) {
        //需求：定义一个方法，求圆的面积，将结果在方法中进行打印
        //根据不同的需求，选择定义无参的方法还是带参数的方法
        getArea(2.0);
    }
    /**
     * 定义一个方法，求圆的面积，将结果在方法中进行打印
     * 圆的面积 = 半径 * 半径 * 3.14
     * 半径：double 形参
     */
    public static void getArea(double r){
        //计算圆的面积
        double area = 3.14 * r * r;
        //打印圆的面积
        System.out.println("圆的面积为：" + area);//12.56
    }
}

三、带返回值的方法的定义和调用

方法的返回值其实就是方法运行的最终结果

如果在调用处要根据方法的结果，去编写另一段代码逻辑

为了在调用处拿到方法产生的结果，就需要定义带有返回值的方法

package com.itheima.methoddemo;

public class Methoddemo3 {
    public static void main(String[] args) {
        //带返回值方法的定义和调用
        //直接调用
        //getSum(10,20,30);
        //赋值调用
        // sum = getSum(10,20,30);
        //输出调用
//        System.out.println(getSum(10,20,30));
        //先计算第一个季度的营业额
        int sum1 = getSum(10,20,30);
        //计算第二个季度的营业额
        int sum2 = getSum(20,20,30);
        //计算第三个季度的营业额
        int sum3 = getSum(20,20,20);
        //计算第四个季度的营业额
        int sum4 = getSum(30,20,30);
        //求全年的总营业额
        int sum = sum1 + sum2 + sum3;
        System.out.println(sum);//190

    }
    public static int getSum(int num1, int num2, int num3){
        int result = num1 + num2 + num3;
        return result;//返回给方法调用处
    }
}

1、什么时候用到有返回值的方法？

在调用处要根据方法的结果，去编写另外一段代码

2、有返回值方法的定义格式

3、有返回值方法的调用格式

直接调用、赋值调用、输出调用

4、有返回值方法中参数的运行过程

练习-比较两个长方形的面积

package test;

public class Test5 {
    public static void main(String[] args) {
        //定义方法，比较两个长方形的面积
        //方法如果要用，那么方法必须要有返回值
        //一般把重复的代码或者具有独立功能的代码抽取到方法中
        double area1 = getArea(1.6,2.9);
        double area2 = getArea(1.8,3.1);
        if(area1 > area2){
            System.out.println("长方形1的面积更大");
        }
        else if(area1 < area2){
            System.out.println("长方形2的面积更大");
        }
        else{
            System.out.println("两个长方形的面积相同");
        }
    }
    //double是返回值的类型
    public static double getArea(double length, double width){
        double area = length * width;
        return area;
    }
}

方法的注意事项

1、方法不调用就不执行；

2、方法与方法之间是平级关系，不能互相嵌套定义；

3、方法的编写顺序和执行顺序无关；

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

5、return语句下面，不能编写代码，因为永远执行不到。

return关键字

方法没有返回值：可以省略不写，如果书写，表示结束方法；

方法有返回值：必须要写，表示结束方法和返回结果。