day04 IDEA&数组

最新推荐文章于 2023-03-10 17:21:57 发布

qq_41447079

最新推荐文章于 2023-03-10 17:21:57 发布

阅读量313

点赞数

本文链接：https://blog.csdn.net/qq_41447079/article/details/115036101

版权

本文介绍了IDEA的快捷键和基本操作，并深入讲解了Java中的数组，包括数组的定义格式、动态和静态初始化、元素访问、内存分配、常见问题以及数组的应用场景如查找最大值和评委打分等。

摘要由CSDN通过智能技术生成

第一部分 : IDEA开发工具

参见：IEDA的安装请参考文件夹PPT中的 04_IDEA.ppt

快捷键：

psvm+回车：快速生成main方法
sout+回车：快速生成输出语句
alt+1:快速打开/隐藏工程目录结构
alt+4:快速打开/隐藏控制台
ctrl+alt+l:格式化代码；
Alt+enter:代码修正提示；
ctrl+d:向下复制一行；
Ctrl+x:剪切当前行；
Ctrl+/:批量加入单行注释，再按一次取消；
Ctrl+shift+/:批量加入多行注释，再按一次就是取消

alt+shift+向上标：上移当前行；
alt+shift+向下标：下移当前行；

基本操作

IDEA中新建模块

File->Project Structure->Modules->±>new Modules……

IDEA中删除模块

选中模型->鼠标右键->Remove Modules

IDEA中导入模块

File->Project Structure->Modules->±>Import Modules….

1.数组

1.1 数组介绍

数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。

1.2 数组的定义格式

1.2.1 第一种格式

数据类型[] 数组名

示例：

int[] arr;        
double[] arr;      
char[] arr;

1.2.2 第二种格式

数据类型数组名[]

示例：

int arr[];
double arr[];
char arr[];

1.3 数组的动态初始化

1.3.1 什么是动态初始化

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

1.3.2 动态初始化格式

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

int[] arr = new int[3];

1.3.3 动态初始化格式详解

等号左边：
- int:数组的数据类型
- []:代表这是一个数组
- arr:代表数组的名称
等号右边：
- new:为数组开辟内存空间
- int:数组的数据类型
- []:代表这是一个数组
- 5:代表数组的长度

代码 :

package com.itheima.array;

public class Demo2Array {
    /*
        数组的动态初始化:
                        在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.

        动态初始化格式:
                        数据类型[] 数组名 = new 数据类型[数组的长度];

        注意:
                        打印数组变量的时候, 会打印出数组的内存地址

        [I@10f87f48 :

                        @ : 分隔符
                        [ : 当前的空间是一个数组类型
                        I : 当前数组容器中所存储的数据类型
                        10f87f48 : 十六进制内存地址

                                0 1 2 3 4 5 6 7 8 9 a b c d e f
     */
    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[数组的长度];
        // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录
        int[] arr = new int[5];
        // [I@10f87f48
        System.out.println(arr);

        byte[] bArr = new byte[3];
        // [B@b4c966a
        System.out.println(bArr);

    }
}

1.4 数组元素访问

1.4.1 什么是索引

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。

这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

1.4.2访问数组元素格式

数组名[索引];

1.4.3示例代码

package com.itheima.array;

public class Demo3ArrayIndex {
    /*
        数组动态初始化:
                初始化的时候, 手动指定数组长度, 系统会为数组容器分配初始值.

        数组的元素访问格式:
                数组名[索引]

                索引: 数组中数据的编号方式, 编号从0开始
                作用: 访问数组容器中的空间位置

        注意:
                数组在创建完毕后, 即使没有赋值, 也可以取出, 但取出的元素都是默认初始化值.

     */
    public static void main(String[] args) {
        int[] arr = new int[3];         // 0 1 2
        System.out.println(arr);        // 数组的内存地址  [I@10f87f48

        // 数组名[索引]  访问数组容器中的空间位置
        System.out.println(arr[0]);     // 0  系统自动分配的默认初始化值
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        System.out.println("--------------");

        // 数组名[索引]
        arr[0] = 11;
        arr[1] = 22;
        arr[2] = 33;

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

1.5 内存分配

1.5.1 内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。

我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。

必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

1.5.2 java中的内存分配

目前我们只需要记住两个内存，分别是：栈内存和堆内存

区域名称	作用
寄存器	给CPU使用，和我们开发无关。
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区	存储可以运行的class文件。
堆内存	存储对象或者数组，new来创建的，都存储在堆内存。
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

1.6 Java内存分配-一个数组内存图

方法区：加载class文件

栈：执行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nfzSTo0o-1616249607472)(E:\新版JAVASE基础\day04\资料\一个数组内存图.png)]

1.7 两个数组内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UXjFMMQl-1616249607474)(E:\新版JAVASE基础\day04\资料\两个数组内存图.png)]

1.8 多个数组指向相同内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pedp5Vi7-1616249607478)(E:\新版JAVASE基础\day04\资料\多个数组指向相同内存图.png)]

1.9 数组的静态初始化

1.9.1 什么是静态初始化

在创建数组时，直接将元素确定

1.9.2 静态初始化格式

完整版格式

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};

简化版格式

数据类型[] 数组名 = {元素1,元素2,...};

1.9.3示例代码

package com.itheima.array2;

public class Demo1Array {
    /*
        数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度

        完整格式:
                    数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
        简化格式:
                    数据类型[] 数组名 = {数据1,数据2,数据3...};
     */
    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
        int[] arr = new int[]{11,22,33};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        // 数据类型[] 数组名 = {数据1,数据2,数据3...};
        int[] arr2 = {44,55,66};
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);

    }
}

两种初始化的区别对比：

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

1.只明确元素个数，不明确具体数值，推荐使用动态初始化。
```
int[] arr = new int[5];
```
2.需求中已经明确了要操作的具体数据，直接静态初始化即可。
```
int[] arr={11,22,33};
```

1.10 数组操作的两个常见问题

1.10.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 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
解决方案

将错误的索引修改为正确的索引范围即可！

1.10.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.11 数组遍历

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

注意：遍历只是取出数据的过程，不能等同于打印；

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 到 lenght-1 ，可以作为循环的条件出现。

public class ArrayTest01 {
    //数组遍历：通过循环获取数组中所有元素
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11, 22, 33, 44, 55};
//动态获取数组中元素个数格式：数组名.length
        System.out.println("arr数组中元素的个数为："+arr.length);
        //for(int i = 0;i<5;i++) 手动写死了，不推荐
        //使用通用的遍历格式 
        for(int x=0; x<arr.length; x++) {//arr.fori
            System.out.println(arr[x]);
        }
    }
}

1.12 数组获取最大值

最大值获取：从数组的所有元素中找出最大值。
实现思路：
- 定义变量，保存数组0索引上的元素
- 遍历数组，获取出数组中的每个元素
- 将遍历到的元素和保存数组0索引上值的变量进行比较
- 如果数组元素的值大于了变量的值，变量记录住新的值
- 数组循环遍历结束，变量保存的就是数组中的最大值

代码实现：

package com.itheima.test;

import java.util.Scanner;

public class Test2Array {
    /*
        需求: 从数组中查找最大值

                int[] arr = {12,45,98,73,60};

        实现步骤:
                1. 假设数组中的第一个元素为最大值
                2. 遍历数组, 获取每一个元素, 准备进行比较
                3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
                4. 循环结束后, 打印最大值.
     */
    public static void main(String[] args) {
        int[] arr = {12,45,98,73,60};
        // 1. 假设数组中的第一个元素为最大值
        int max = arr[0];
        // 2. 遍历数组, 获取每一个元素, 准备进行比较
        for(int i = 1; i < arr.length; i++){
            // 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
            if(arr[i] > max){
                max = arr[i];
            }
        }
        //  4. 循环结束后, 打印最大值.
        System.out.println("max:" + max);
    }
}

1.13 数组元素求和

需求：键盘录入5个整数，存储到数组中，并对数组求和
思路：
1.创建键盘录入对象，准备键盘录入
2.定义一个求和变量，准备记录累加后的结果
3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
4.将键盘录入的数值存储到数组中
5.遍历数组，取出每一个元素，并求和
6.输出总和

代码实现：

package com.itheima.test;

import java.util.Scanner;

public class Test3Array {
    /*
        需求：键盘录入5个整数，存储到数组中，并对数组求和

        思路：
            1.创建键盘录入对象，准备键盘录入
            2.定义一个求和变量，准备记录累加后的结果
            3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
            4.将键盘录入的数值存储到数组中
            5.遍历数组，取出每一个元素，并求和
            6.输出总和
     */
    public static void main(String[] args) {
        // 1.创建键盘录入对象，准备键盘录入
        Scanner sc = new Scanner(System.in);
        // 2.定义一个求和变量，准备记录累加后的结果
        int sum = 0;
        // 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
        int[] arr = new int[5];
        // 4.将键盘录入的数值存储到数组中
        for(int i = 0; i < arr.length; i++){
            System.out.println("请输入第" + (i+1) + "个整数:");
            //arr[i] = 10;
            arr[i] = sc.nextInt();
        }

        // 5.遍历数组，取出每一个元素，并求和
        for (int i = 0; i < arr.length; i++)/*数组名.fori快捷键输入*/
        {
            sum += arr[i];
        } 

        // 6.输出总和
        System.out.println("sum:" + sum);

    }
}

1.14 数组基本查找【应用】

需求：
已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控
制台输出找到的索引值。
思路：
1.定义一个数组，用静态初始化完成数组元素的初始化
2.键盘录入要查找的数据，用一个变量接收
3.定义一个索引变量，初始值为-1
4.遍历数组，获取到数组中的每一个元素
5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
6.输出索引变量

代码实现：

public static void main(String[] args) {
        // 1.定义一个数组，用静态初始化完成数组元素的初始化
        int[] arr = {19, 28, 37, 46, 50};
        // 2.键盘录入要查找的数据，用一个变量接收
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查找的元素:");
        int num = sc.nextInt();
        // 3.定义一个索引变量，初始值为-1
        // 假设要查找的数据, 在数组中就是不存在的
        int index = -1;
        // 4.遍历数组，获取到数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            // 5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
            if(num == arr[i]){
                // 如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
                index = i;
                break;
            }
        }
        //  6.输出索引变量
        System.out.println(index);
    }
}

1.15 评委打分【应用】

需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
选手的最后得分为：去掉一个最高分和一个最低分后的4个评委平均值 (不考虑小数部分)。
思路：
1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
2.键盘录入评委分数
3.由于是6个评委打分，所以，接收评委分数的操作，用循环
4.求出数组最大值
5.求出数组最小值
6.求出数组总和
7.按照计算规则进行计算得到平均分
8.输出平均分

代码实现：

    public static void main(String[] args) {
        // 1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
        int[] arr = new int[6];
        // 2.键盘录入评委分数
        Scanner sc = new Scanner(System.in);
        //  3.由于是6个评委打分，所以，接收评委分数的操作，用循环
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i+1) + "个评委的打分:");
            int score = sc.nextInt();
            if(score >= 0 && score <= 100){
                // 合法的分值
                arr[i] = score;
            }else{
                // 非法的分值
                System.out.println("您的打分输入有误, 请检查是否是0-100之间的");
                i--;
            }
        }

        // 4.求出数组最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i]){
                max = arr[i];
            }
        }

        // 5.求出数组最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(min > arr[i]){
                min = arr[i];
            }
        }

        // 6.求出数组总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }

        // 7.按照计算规则进行计算得到平均分
        int avg = (sum - max - min ) / 4;

        // 8.输出平均分
        System.out.println(avg);
    }
}

1.16总结和案例

/*
数组的概述：
1.数组的理解，数组（array）,是多个相同类型数据按一定顺序排列的集合，
并使用一个名字命名，通过编号的方式对这些数据进行统一管理。
2.数组的特点：
数组是有序排列的；
数组属于引用数据类型的变量，数组的元素，既可以是基本数据类型，也可以是引用数据类型；
创建数组对象会在内存中开辟一整块连续的空间；
数组的长度一旦确定，就不能更改。
3.数组的分类：
>按照维度：一维数组，二维数组...;
>按照数组元素的类型：基本数据类型元素的数组，引用数据类型的数组
4.一维数组使用：
>一维数组的声明和初始化；
>如何使用数组的指定位置元素；
>如何获取数组的长度；
>如何遍历数组；
>数组元素的默认初始化值:见Demo4.java
>数组的内存解析

   */
public class Demo {
    public static void main(String[] args) {
        //1.数组的声明和初始化
        int[] ids;//声明
        //1.1静态初始化
        ids = new int[]{1001,1002,10003};
         //1.2动态初始化
        String[] names = new String[5];
        //注意：数组一旦初始化完成，其长度就确定了
        //2.如何调用数组的指定位置的元素：通过角标的方式调用；
        //数组的角标或索引号从0开始，到数组的长度-1结束。
        names[0] = "老王";
        names[0] = "老胡";
        names[0] = "老彭";
        names[0] = "老乔";
        names[0] = "老夏";
        //3.如何获取数组的长度：
        //属性：length
        System.out.println(names.length);//5
        System.out.println(ids.length);
        //4.如何遍历数组;
       /* System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);
        System.out.println(names[3]);
        System.out.println(names[4]);*/

        for (int i =0;i< names.length;i++){
            System.out.println(names[i]);

        }


    }
}

public class Demo1 {
    public static void main(String[] args) {
        /*
        数组定义格式：
        1.数据类型[] 数组名；
        2.数据类型 数组名[];
         */
        //数据类型[] 数据名；
        //定义一个int类型的数组，数组名叫arr;
        //int[] arr;创建数组容器；
        //定义一个char类型的数据，数据名叫cArr;
        //char[] cArr;


    }
}

public class Demo2 {
    /*
    数组的动态初始化格式：
    在初始化的时候，需要手动指定数组长度，系统会为数组容器分配初始值
    动态初始化格式：
    数据类型[] 数组名=new数据类型[数组长度]；
    注意：打印数组变量的时候，会打印数组的内存地址
    [I@1540e19d：
    @：分隔符；
    [：当前空间是一个数组类型；
    I：当前数组容器中所存储的数据类型；
    1540e19d：16进制的内存地址

     */
    public static void main(String[] args) {
//数据类型[] 数组名=new数据类型[数组长度]；
        int [] arr = new int[5];//通过new关键字创建一个int类型的数组容器，该容器可以存储5个int类型的整数，该整数被arr记录；
        System.out.println(arr);//输出[I@1540e19d
        byte [] bArr = new byte[5];
        System.out.println(bArr);//输出[B@677327b6
        //数组名[索引] 访问数组容器中的空间位置
        System.out.println(arr[0]);//0 系统自动分配的默认初始值
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        //数组名[索引]
        arr[0]=11;
        arr[1]=11;
        arr[2]=22;
        arr[3]=33;
        arr[4]=44;
        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]);
    }
}


import java.util.Arrays;
//求数组中元素的最大值
public class Demo3 {
    public static void main(String[] args) {
        int[] arr= {4,54,5464,5,1212,5,15};
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max<arr[i]){
                max = arr[i];
            }
        }
        System.out.println(max);
        }

        }

public class Demo4 {
    public static void main(String[] args) {
        /*5.数组元素的默认初始化值
        >数组元素是整型时：0
        >数组元素是浮点型：0.0
        >数组元素是boolean类型：false
        >数组元素是char型时：ALLSCA码中的0
        >数组元素是引用数据类型：null
        6.数组的内存解析。
        栈：存放局部变量。
        堆：存放new出来的结构：对象，数组
        方法区：1.常量池：如String.2.静态域：如static
         */
        int[] arr = new int[4];
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("********");
        short[] arr1 = new short[4];
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
        System.out.println("*********");
        double[] arr2 = new double[4];
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        System.out.println("*********");
        char[] arr3 = new char[4];
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }
        System.out.println("*********");
        boolean[] arr4 = new boolean[4];
        for (int i = 0; i < arr4.length; i++) {
            System.out.println(arr4[i]);
        }
        System.out.println("*********");
        String[] arr5 = new String[4];
        for (int i = 0; i < arr5.length; i++) {
            System.out.println(arr5[i]);
        }
    }
}

//电话号码案例
public class Demo5 {
    public static void main(String[] args) {
        int[] arr = new int[]{8,2,1,0,3};
        int[] index = new int[]{2,0,3,2,4,0,1,3,2,3,3,};
        String tel = "";
        for (int i = 0; i < index.length; i++) {
            tel +=arr[index[i]];
        }
        System.out.println("联系方式："+tel);
    }
}

//案例：从键盘读入学生成绩，找出最高分，并输出学生的成绩等级
public class Demo6 {
    public static void main(String[] args) {
        //思路：
        //1.使用Scanner读取学生个数
        //2.创建数组，存储学生成绩，动态初始化
        //3.给数组中的元素附值；
        //4.获取数组中的元素的最大值：最高分；
        //5.根据学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
        //1.使用Scanner读取学生个数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生人数：");
        int number = sc.nextInt();
        //2.创建数组，存储学生成绩，动态初始化
        int[] scores = new int[number];
        //3.给数组中的元素附值；
        System.out.println("请输入"+number+"个"+"学生成绩：");
        for (int i = 0; i < scores.length; i++) {
            scores[i] = sc.nextInt();//从键盘读入学生成绩
        }
        //4.获取数组中的元素的最大值：最高分
        int maxScore = 0;
        for (int i = 0; i < scores.length; i++) {
            if (maxScore < scores[i]){
                maxScore = scores[i];
            }
            System.out.println("最高分为："+maxScore);
        }
//5.根据学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
        char level;
        for (int i = 0; i < scores.length; i++) {
            if (maxScore - scores[i] <= 10){
                level = 'A';
            }else if (maxScore - scores[i]<=20){
                level = 'B';
            }else if (maxScore - scores[i]<=30){
                level = 'C';
            }else{
                level = 'D';
            }
            System.out.println("student"+i+"score is"+scores[i]+"grade is"+level);
        }

    }
}

/*
算法的考察：求数值型数组中元素的最大值，最小值，平均数，总和等；

定义一个int类型的一维数组，包含10个元素，分别赋一些随机整数；
然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
要求：所有的随机数都是两位数。

附值随机数公式：
[10,99]
公式：(int)(Math.random()*(99-10+1)+10)
 */
public class Demo7 {
    public static void main(String[] args) {
        int[] arr = new int[10];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random()*(99-10+1)+10);
        }
        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]+"\t");
        }
        System.out.println();
        //求数组元素的最大值
        int maxValue = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (maxValue<arr[i]){
                maxValue = arr[i];
            }
        }
        System.out.println("最大值为："+maxValue);

        //求数组元素的最小值
        int minValue = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (minValue>arr[i]){
                minValue = arr[i];
            }
        }
        System.out.println("最小值为："+minValue);

        //求数组元素的总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println("总和为："+sum);

        //求数组元素的平均数
        int avgValue = sum/arr.length;
        System.out.println("平均数："+avgValue);


    }
}

/*
使用简单数组：
（1）创建一个名为ArrayText,在main()方法中声明array1和array2两个变量，他们是int[]类型的数组；
（2）使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19.
（3）显示array1的内容；
（4）赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值（如array[0]=0,array[2]=2）,打印array1；

思考：array1和array2是什么关系？array1和array2的地址值相同，都指向堆空间中的唯一的一个数组实体
拓展：实现array1对array2数组的复制
 */
public class Demo8 {
    public static void main(String[] args) {
        int[] array1,array2;
        array1 = new int[]{2,3,5,7,11,13,17,19};
        //显示array1的内容
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]+"\t");
        }

        //数组的复制：
        array2 = new int[array1.length];
        for (int i = 0; i < array2.length; i++) {
            array2[i] = array1[i];
        }

        //赋值array2变量等于array1
        array2 = array1;
        //修改array2中的偶索引元素使其等于索引值
        for (int i = 0; i < array2.length; i++) {
            if(i%2==0){
                array2[i]=i;
            }
        }
        System.out.println(array2+"\t");

    }


}

/*
算法考察：数组的复制，反转，查找（线性查找，二分法查找）
*/
public class Demo9 {
    public static void main(String[] args) {
        String[] arr = new String[]{"11", "22", "33", "44", "55", "66"};

        //数组的复制（区别于数组的附值，arr1=arr）
        String[] arr1 = new String[arr.length];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = arr[i];
            //System.out.println(arr1[i]);
        }
        //数组的反转：
//        for (int i = 0; i < arr.length / 2; i++) {
//            String temp = arr[i];
//            arr[i] = arr[arr.length - i - 1];
//            arr[arr.length - i - 1] = temp;
//        }

        //遍历：
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] + "\t");
        }

        //查找（或搜索）
        //线性查找:
        String dest = "66";
        boolean isFlag = true;
        for (int i = 0; i < arr.length; i++) {
            if (dest.equals(arr[i])) {
                System.out.println("找到了指定的元素：" + i);
                isFlag = false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("很遗憾没有找到哦！");
        }
        //二分法查找：
        //使用前提：所用的变量必须有序
        int[] arr2 = new int[]{-98,-34,2,4,35,62,98,102,165};

        int dest1 = -34;
        int head = 0 ;//初始首索引
        int end = arr2.length - 1;//初始末索引

        boolean isFlag1 = true;
        while(head <= end){
            int middle = (head + end)/2;
            if (dest1 == arr2[middle]){
                System.out.println("找到了指定的元素，位置为："+middle);
                isFlag1=false;
                break;
            }else if(arr2[middle]>dest1){
                end = middle -1;
            }else{
                head = middle + 1;
            }
            if (isFlag1){
                System.out.println("没有找到");
            }
        }


    }
}

public class Demo10 {
    public static void main(String[] args) {
        int[] arr = new int[]{43,56,456,-98,97,-65,-64};
        //冒泡排序
        for (int i = 0; i < arr.length-1; i++) {
            for(int j = 0;j<arr.length -1 - 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]+"\t");
        }
    }

}

import java.lang.reflect.Array;
import java.util.ArrayList;

//设计一个movie类，私有成员变量：title,director,type,并生成相应的get/set方法
//定义测试类，在main方法中完成以下要求：
//创建三个movie对象，分别为”唐山大地震“，"冯小刚"，"灾难"；羞羞的铁拳，宋阳，喜剧，集合号，冯小刚，历史
//将三个对象添加到list集合中
//遍历集合，将导演为冯小刚的电影按照如下格式打印到控制台上
//唐山大地震-冯小刚-灾难4
//集结号-冯小刚-历史
public class Movie {
    public static void main(String[] args) {
        MovieDemo m1 = new MovieDemo("唐山大地震", "冯小刚", "灾难");
        MovieDemo m2 = new MovieDemo("羞羞的铁拳", "宋阳", "喜剧");
        MovieDemo m3 = new MovieDemo("集合号", "冯小刚", "历史");
        ArrayList<MovieDemo> list= new ArrayList<>();
        //添加三部电影
        list.add(m1);
        list.add(m2);
        list.add(m3);
        for (int i = 0; i < list.size(); i++) {
            //判断电影的导演的属性是不是冯小刚
            //m1
            if (list.get(i).getDirector().equals("冯小刚")){
                //打印i索引对应的电影的所有属性
                System.out.println(list.get(i).getTitle()+"-"+list.get(i).getDirector()+"-"+list.get(i).getType());
            }
        }
    }
}

public class MovieDemo {
    private String title;
    private String director;
    private String type;

    public MovieDemo() {
    }

    public MovieDemo(String title, String director, String type) {
        this.title = title;
        this.director = director;
        this.type = type;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getDirector() {
        return director;
    }

    public void setDirector(String director) {
        this.director = director;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

import java.util.Random;
//定义一个长度为5的数组arr1，用于存放5个1-9的随机整数（范围包含1和9）
/*在定义一个长度为2的数组arr2,统计arr1中的元素对2求余等于0的个数，保存到arr2[0]中；
统计arr1中的元素对3求余等于0的个数，保存到arr2[1],在控制台打印输出arr2的所有元素*/
public class Demo {
    public static void main(String[] args) {
        int[] arr1 = new int[5];
        int[] arr2 = new int[2];
        Random r = new Random();
        int count = 0;
        int count1 = 0;
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = r.nextInt(9) + 1;
            System.out.println(arr1[i]);
            if (arr1[i] % 2 == 0) {
                /*count++;*/ arr2[0]++;
            }
            if (arr1[i] % 3 == 0) {
                /*count1++;*/arr2[1]++;
        }
        }
        /*arr2[0] = count;
        arr2[1] = count1;*/
        System.out.println("对2求余等于0的个数" + arr2[0]);
        System.out.println("对3求余等于0的个数" + arr2[1]);
    }
   }
ing getDirector() {
        return director;
    }

    public void setDirector(String director) {
        this.director = director;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

import java.util.Random;
//定义一个长度为5的数组arr1，用于存放5个1-9的随机整数（范围包含1和9）
/*在定义一个长度为2的数组arr2,统计arr1中的元素对2求余等于0的个数，保存到arr2[0]中；
统计arr1中的元素对3求余等于0的个数，保存到arr2[1],在控制台打印输出arr2的所有元素*/
public class Demo {
    public static void main(String[] args) {
        int[] arr1 = new int[5];
        int[] arr2 = new int[2];
        Random r = new Random();
        int count = 0;
        int count1 = 0;
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = r.nextInt(9) + 1;
            System.out.println(arr1[i]);
            if (arr1[i] % 2 == 0) {
                /*count++;*/ arr2[0]++;
            }
            if (arr1[i] % 3 == 0) {
                /*count1++;*/arr2[1]++;
        }
        }
        /*arr2[0] = count;
        arr2[1] = count1;*/
        System.out.println("对2求余等于0的个数" + arr2[0]);
        System.out.println("对3求余等于0的个数" + arr2[1]);
    }
   }