01idea安装

02idea项目结构

03idea中的第一个代码

04idea常用快捷键

05idea操作模块

06idea打开关闭项目-类包名修改

(以上为工具使用,略过)

07数组介绍

08数组的定义格式

  1. package com.itheima.array;
  3. public class Demo1Array {
  4.     /*
  5.         数组的定义格式:
  7.             1: 数据类型[] 数组名;
  8.             2: 数据类型 数组名[];
  9.      */
  10.     public static void main(String[] args) {
  11.         // 数据类型[] 数组名;
  12.         // 定义了一个int类型的数组, 数组名叫arr
  14.         /*
  15.             这里虽然是定义了一个数组, 但也仅仅只是一个数组类型的[变量], 变量没有进行初始化, 就直接使用了, 这就是错误原因.
  16.          */
  17.         //int[] arr = 创建数组容器;
  18.         //System.out.println(arr);
  20.         // 定义了一个char类型的数组, 数组名叫cArr
  21.         char[] cArr;
  22.         //System.out.println(cArr);
  24.         int a = 10;
  25.         System.out.println(a);
  26.     }
  28. }

09数组的动态初始化

  1. package com.itheima.array;
  3. public class Demo2Array {
  4.     /*
  5.         数组的动态初始化:
  6.                         在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.
  8.         动态初始化格式:
  9.                         数据类型[] 数组名 = new 数据类型[数组的长度];
  11.         注意:
  12.                         打印数组变量的时候, 会打印出数组的内存地址
  14.         [I@10f87f48 :
  16.                         @ : 分隔符
  17.                         [ : 当前的空间是一个数组类型
  18.                         I : 当前数组容器中所存储的数据类型
  19.                         10f87f48 : 十六进制内存地址
  21.                                 0 1 2 3 4 5 6 7 8 9 a b c d e f
  22.      */
  23.     public static void main(String[] args) {
  24.         // 数据类型[] 数组名 = new 数据类型[数组的长度];
  25.         // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录
  26.         int[] arr = new int[5];
  27.         // [I@10f87f48
  28.         System.out.println(arr);
  30.         byte[] bArr = new byte[3];
  31.         // [B@b4c966a
  32.         System.out.println(bArr);
  34.     }
  36. }

10数组元素访问

  1. package com.itheima.array;
  3. public class Demo3ArrayIndex {
  4.     /*
  5.         数组动态初始化:
  6.                 初始化的时候, 手动指定数组长度, 系统会为数组容器分配初始值.
  8.         数组的元素访问格式:
  9.                 数组名[索引]
  11.                 索引: 数组中数据的编号方式, 编号从0开始
  12.                 作用: 访问数组容器中的空间位置
  14.         注意:
  15.                 数组在创建完毕后, 即使没有赋值, 也可以取出, 但取出的元素都是默认初始化值.
  17.      */
  18.     public static void main(String[] args) {
  19.         int[] arr = new int[3];         // 0 1 2
  20.         System.out.println(arr);        // 数组的内存地址  [I@10f87f48
  22.         // 数组名[索引]  访问数组容器中的空间位置
  23.         System.out.println(arr[0]);     // 0  系统自动分配的默认初始化值
  24.         System.out.println(arr[1]);
  25.         System.out.println(arr[2]);
  27.         System.out.println("--------------");
  29.         // 数组名[索引]
  30.         arr[0] = 11;
  31.         arr[1] = 22;
  32.         arr[2] = 33;
  34.         System.out.println(arr[0]);
  35.         System.out.println(arr[1]);
  36.         System.out.println(arr[2]);
  37.     }
  39. }
  1. package com.itheima.array;
  3. public class Demo4Array {
  4.     public static void main(String[] args) {
  5.         int[] arr1 = new int[2];
  6.         System.out.println(arr1);
  7.         arr1[0] = 11;
  8.         arr1[1] = 22;
  9.         System.out.println(arr1[0]);
  10.         System.out.println(arr1[1]);
  12.         System.out.println("-------------");
  14.         int[] arr2 = new int[3];
  15.         System.out.println(arr2);
  16.         arr2[0] = 33;
  17.         arr2[1] = 44;
  18.         arr2[2] = 55;
  19.         System.out.println(arr2[0]);
  20.         System.out.println(arr2[1]);
  21.         System.out.println(arr2[2]);
  22.     }
  24. }

11Java内存分配一个数组内存图

12两个数组内存图

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

  1. package com.itheima.array;
  3. public class Demo5Array {
  4.     /*
  5.         两个数组指向相同
  6.      */
  8.     public static void main(String[] args) {
  9.         int[] arr1 = new int[2];
  10.         arr1[0] = 11;
  11.         arr1[1] = 22;
  13.         /*
  14.             数组类型的变量应该记录什么?
  15.                 地址值
  16.          */
  17.         int[] arr2 = arr1;
  18.         arr2[0] = 33;
  20.         System.out.println(arr1[0]);
  21.         System.out.println(arr1[1]);
  22.         System.out.println("---------");
  23.         System.out.println(arr2[0]);
  24.         System.out.println(arr2[1]);
  26.     }
  28. }

14数组的静态初始化

  1. package com.itheima.array2;
  3. public class Demo1Array {
  4.     /*
  5.         数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度
  7.         完整格式:
  8.                     数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
  9.         简化格式:
  10.                     数据类型[] 数组名 = {数据1,数据2,数据3...};
  11.      */
  12.     public static void main(String[] args) {
  13.         // 数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
  14.         int[] arr = new int[]{11,22,33};
  15.         System.out.println(arr[0]);
  16.         System.out.println(arr[1]);
  17.         System.out.println(arr[2]);
  19.         // 数据类型[] 数组名 = {数据1,数据2,数据3...};
  20.         int[] arr2 = {44,55,66};
  21.         System.out.println(arr2);
  22.         System.out.println(arr2[0]);
  23.         System.out.println(arr2[1]);
  24.         System.out.println(arr2[2]);
  26.     }
  28. }

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

  1. package com.itheima.exception;
  2. public class ArrayException {
  3.     public static void main(String[] args) {
  4.         int[] arr = new int[3]; // 0 1 2
  5.         System.out.println(arr[2]);
  6.         // 空指针异常
  7.         arr = null; // 空值
  8.         System.out.println(arr[0]);
  9.     }
  10. }

16数组遍历

  1. package com.itheima.test;
  3. public class Test1Array {
  4.     /*
  5.         数组的遍历: 通过循环获取数组中的所有元素(数据)
  7.         动态获取数组元素个数 : 数组名.length
  8.      */
  9.     public static void main(String[] args) {
  10.         int[] arr = {11, 22, 33, 44, 55};
  12.         // 数组名.length
  13.         System.out.println("arr数组中元素的个数为:" + arr.length);
  15.         //for(int i = 0; i < 5; i++){       手动写死了, 不严谨, 不推荐
  16.         for(int i = 0; i < arr.length; i++){
  17.             // i : 0 1 2 3 4
  18.             System.out.println(arr[i]);
  19.         }
  20.     }
  22. }

17数组获取最大值

  1. package com.itheima.test;
  2. import java.util.Scanner;
  3. public class Test2Array {
  4.     /*
  5.         需求: 从数组中查找最大值
  6.                 int[] arr = {12,45,98,73,60};
  7.         实现步骤:
  8.                 1. 假设数组中的第一个元素为最大值
  9.                 2. 遍历数组, 获取每一个元素, 准备进行比较
  10.                 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
  11.                 4. 循环结束后, 打印最大值.
  12.      */
  13.     public static void main(String[] args) {
  14.         int[] arr = {12,45,98,73,60};
  15.         // 1. 假设数组中的第一个元素为最大值
  16.         int max = arr[0];
  17.         // 2. 遍历数组, 获取每一个元素, 准备进行比较
  18.         for(int i = 1; i < arr.length; i++){
  19.             // 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
  20.             if(arr[i] > max){
  21.                 max = arr[i];
  22.             }
  23.         }
  24.         //  4. 循环结束后, 打印最大值.
  25.         System.out.println("max:" + max);
  26.     }
  27. }

18数组元素求和

  1. package com.itheima.test;
  3. import java.util.Scanner;
  5. public class Test3Array {
  6.     /*
  7.         需求：键盘录入5个整数，存储到数组中，并对数组求和
  9.         思路：
  10.             1.创建键盘录入对象，准备键盘录入
  11.             2.定义一个求和变量，准备记录累加后的结果
  12.             3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
  13.             4.将键盘录入的数值存储到数组中
  14.             5.遍历数组，取出每一个元素，并求和
  15.             6.输出总和
  16.      */
  17.     public static void main(String[] args) {
  18.         // 1.创建键盘录入对象，准备键盘录入
  19.         Scanner sc = new Scanner(System.in);
  20.         // 2.定义一个求和变量，准备记录累加后的结果
  21.         int sum = 0;
  22.         // 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
  23.         int[] arr = new int[5];
  24.         // 4.将键盘录入的数值存储到数组中
  25.         for(int i = 0; i < arr.length; i++){
  26.             System.out.println("请输入第" + (i+1) + "个整数:");
  27.             //arr[i] = 10;
  28.             arr[i] = sc.nextInt();
  29.         }
  31.         // 5.遍历数组，取出每一个元素，并求和
  32.         for (int i = 0; i < arr.length; i++) {
  33.             sum += arr[i];
  34.         }
  36.         // 6.输出总和
  37.         System.out.println("sum:" + sum);
  39.     }
  41. }

19数组基本查找

  1. package com.itheima.test;
  3. import java.util.Scanner;
  5. public class Test4Array {
  6.     /*
  7.         需求：
  8.             已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控
  9.             制台输出找到的索引值。
  11.        思路：
  12.             1.定义一个数组，用静态初始化完成数组元素的初始化
  13.             2.键盘录入要查找的数据，用一个变量接收
  14.             3.定义一个索引变量，初始值为-1
  15.             4.遍历数组，获取到数组中的每一个元素
  16.             5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
  17.             6.输出索引变量
  18.      */
  19.     public static void main(String[] args) {
  20.         // 1.定义一个数组，用静态初始化完成数组元素的初始化
  21.         int[] arr = {19, 28, 37, 46, 50};
  22.         // 2.键盘录入要查找的数据，用一个变量接收
  23.         Scanner sc = new Scanner(System.in);
  24.         System.out.println("请输入您要查找的元素:");
  25.         int num = sc.nextInt();
  26.         // 3.定义一个索引变量，初始值为-1
  27.         // 假设要查找的数据, 在数组中就是不存在的
  28.         int index = -1;
  29.         // 4.遍历数组，获取到数组中的每一个元素
  30.         for (int i = 0; i < arr.length; i++) {
  31.             // 5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
  32.             if(num == arr[i]){
  33.                 // 如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
  34.                 index = i;
  35.                 break;
  36.             }
  37.         }
  38.         //  6.输出索引变量
  39.         System.out.println(index);
  40.     }
  42. }

20评委打分

  1. package com.itheima.test;
  3. import java.util.Scanner;
  5. public class Test5Array {
  6.     /*
  7.         需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
  8.                 选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
  10.         思路：
  11.             1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
  12.             2.键盘录入评委分数
  13.             3.由于是6个评委打分，所以，接收评委分数的操作，用循环
  14.             4.求出数组最大值
  15.             5.求出数组最小值
  16.             6.求出数组总和
  17.             7.按照计算规则进行计算得到平均分
  18.             8.输出平均分
  20.      */
  21.     public static void main(String[] args) {
  22.         // 1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
  23.         int[] arr = new int[6];
  24.         // 2.键盘录入评委分数
  25.         Scanner sc = new Scanner(System.in);
  26.         //  3.由于是6个评委打分，所以，接收评委分数的操作，用循环
  27.         for (int i = 0; i < arr.length; i++) {
  28.             System.out.println("请输入第" + (i+1) + "个评委的打分:");
  29.             int score = sc.nextInt();
  30.             if(score >= 0 && score <= 100){
  31.                 // 合法的分值
  32.                 arr[i] = score;
  33.             }else{
  34.                 // 非法的分值
  35.                 System.out.println("您的打分输入有误, 请检查是否是0-100之间的");
  36.                 i--;
  37.             }
  38.         }
  40.         // 4.求出数组最大值
  41.         int max = arr[0];
  42.         for (int i = 1; i < arr.length; i++) {
  43.             if(max < arr[i]){
  44.                 max = arr[i];
  45.             }
  46.         }
  48.         // 5.求出数组最小值
  49.         int min = arr[0];
  50.         for (int i = 1; i < arr.length; i++) {
  51.             if(min > arr[i]){
  52.                 min = arr[i];
  53.             }
  54.         }
  56.         // 6.求出数组总和
  57.         int sum = 0;
  58.         for (int i = 0; i < arr.length; i++) {
  59.             sum += arr[i];
  60.         }
  62.         // 7.按照计算规则进行计算得到平均分
  63.         int avg = (sum - max - min ) / 4;
  65.         // 8.输出平均分
  66.         System.out.println(avg);
  67.     }
  69. }