第四天javaSE基础

Java EE基础班课程（第四天）

学习目标:

• 熟悉idea安装和配置
• 熟悉项目创建，删除，导入
• 熟悉模块的删除和导入
• 了解数组的定义和初始化
• 熟悉数组的遍历
• 熟悉数组求最值,求和

idea安装和配置

1.idea安装和配置

不能安装在系统盘或者C盘

2.idea配置

1,idea配置jdk
    file --> project structure ... 在在弹出框中配置项目或者模块的JDK
2,idea编码  UTF-8
3,idea字体
   

数组

2.1数组定义和初始化 数组索引 数组的取值，动态初始的数组有默认值

/*
       数组：
        数组的定义格式
            1.数据类型 [] 数组名;
                int [] arr;
            2.数据类型 数组名 [];
                double brr [];

         数组初始化：
            格式1：动态初始化
                数据类型 [] 变量名 = new 数据类型[length];
                int [] arr = new int[5];
 */
public class Demo01 {
    public static void main(String[] args) {
        //数组的定义
        //1.数据类型 [] 数组名;
        int [] arr;
        // 2.数据类型 数组名 [];
        double brr [];

        //数组初始化：
        //数组的动态初始化:
        // 数据类型 [] 变量名 = new 数据类型[length];
        int [] crr = new int[5];//定义了一个可以存放5个int类型数据的数组

        //数组的取值
        //格式：数据类型 变量名 = 数组名[索引]

        /*
            索引就是 数组中空间标号， 标号是int类型，从0开始到数组长度减一
         */
        //通对索引分析：我们知道 刚才定义的数组的索引是 0,1,2,3,4  就可以使用数组取值的格式取出每一个索引对象数据

        int num1 = crr[0];
        System.out.println(num1);
        int num2 = crr[1];
        System.out.println(num2);
        int num3 = crr[2];
        System.out.println(num3);
        int num4 = crr[3];
        System.out.println(num4);
        int num5 = crr[4];
        System.out.println(num5);

        /*
           通过对数组crr的取值，我们可以知道 int类型的数组有初始化值，是0
         */
        byte[] drr = new byte[2];
        byte n1 = drr[0];
        System.out.println(n1);
        byte n2 = drr[1];
        System.out.println(n2);
        /*
           通过对数组drr的取值，我们可以知道 byte类型的数组有初始化值，是0
         */
        short [] err = new short[2];
        System.out.println(err[0]);
        System.out.println(err[1]);
         /*
           通过对数组err的取值，我们可以知道 short类型的数组有初始化值，是0
         */
        long[] frr = new long[2];
        System.out.println(frr[0]);
        System.out.println(frr[1]);
         /*
           通过对数组frr的取值，我们可以知道 long类型的数组有初始化值，是0
         */
        float[] irr = new float[2];
        System.out.println(irr[0]);
        System.out.println(irr[1]);
        /*
           通过对数组irr的取值，我们可以知道 float类型的数组有初始化值，是0.0
         */
        double[] jrr = new double[2];
        System.out.println(jrr[0]);
        System.out.println(jrr[1]);
        /*
           通过对数组jrr的取值，我们可以知道 double类型的数组有初始化值，是0.0
         */

        char[] krr = new char[2];
        System.out.println(krr[0]);
        System.out.println(krr[1]);
        /*
           通过对数组krr的取值，我们可以知道 char类型的数组有初始化值，是\u0000 就是空
         */
        boolean[] lrr = new boolean[2];
        System.out.println(lrr[0]);
        System.out.println(lrr[1]);
        /*
           通过对数组lrr的取值，我们可以知道 boolean类型的数组有初始化值，是false
         */
        String[] srr = new String[2];
        System.out.println(srr[0]);
        System.out.println(srr[1]);
        /*
           通过对数组srr的取值，我们可以知道 引用数据类型的数组有初始化值，是null
         */

    }
}

2.2上午小结

数组：
        数组的定义格式
            1.数据类型 [] 数组名;
                int [] arr;
            2.数据类型 数组名 [];
                double brr [];

         数组初始化：
            格式1：动态初始化
                数据类型 [] 变量名 = new 数据类型[length];
                int [] arr = new int[5];

         索引：
            数组中开辟空间标号，从0到数组的长度减一
         数组取值：
            格式：数组的数据类型 变量名 = 数组名[索引];
            取数组0索引对应的元素：
                int a = arr[0];
         基本类型数组有默认值：
            整型byte short int long 的数组 默认值 0
            浮点型 float double 的数组 默认值 0.0
            字符型 char 的数组 默认值 \u0000
            布尔类型 boolean 的数组 默认值 false
         引用数组类型数组有默认值：null
            举栗子：
                String[] s = new String[2];
                两个默认值 null

2.3 数组赋值

/*
    数组的赋值:
        根据索引来赋值
        格式：
         数组名[索引] = 新值;
 */
public class Demo02数组的赋值 {
    public static void main(String[] args) {
        //定义一个长度为5的int类型数组
        int [] arr = new int[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]);
        // 格式：
        //  数组名[索引] = 新值;
        //  98 99 100 99 99
        arr[0] = 98;
        arr[1] = 99;
        arr[2] = 100;
        arr[3] = 99;
        arr[4] = 99;

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

2.4数组取值

/*
    数组的取值 :
        根据索引来取值
        格式：
            数组的数据类型 变量名 = 数组名[索引]
            int[] arr = new int[5];
         举栗子：
            int  a = arr[0];

*/
public class Demo03数组的取值 {
    public static void main(String[] args) {
        //定义一个长度为5的int类型数组
        int[] arr = new int[5];
        arr[0] = 98;
        arr[1] = 99;
        arr[2] = 100;
        arr[3] = 99;
        arr[4] = 99;

        //方式一：
        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]);

        System.out.println("-------------");
        //方式二： 推荐使用
        for (int i = 0; i < 5; i++) {
            System.out.println(arr[i]);
        }

    }
}

2.5数组动态初始化小结

/*
    数组的动态初始化的各种操作：
        1.数组定义
        2.数组的初始化
        3.数组赋值
        4.数组取值
        5.索引 索引从0开始 到数组长度减一
 */

2.6数组的静态初始化

/*
    数组的静态初始化：
        格式1：
            数据类型[] 数组名 = new 数据类型[]{};
            举栗子：
             int[] arr = new int[]{.......};
        格式2： 推荐使用
            数据类型[] 数组名 = {......};
            举栗子：
             int[] brr = {.......};

 */
public class Demo04数组的静态初始化 {
    public static void main(String[] args) {
        // 格式1：
        //    数据类型[] 数组名 = new 数据类型[]{};
        //    举栗子：
        int[] arr = new int[]{1,2,3,4,5,6,7,8,9};
        //格式2：
        //  数据类型[] 数组名 = {......};
        //  举栗子：
        int[] brr = {1,2,3,4,5,6,7,8,9};

        /*
            动态初始化和静态初始化的使用：
                1.当我们不知道数据具体值，只知道有多少个数据 ，使用动态初始化
                2.明确知道数据多少，数据的具体值，使用静态初始化
         */

    }
}

2.7数组取值的改进版 length

/*
    数组的静态初始化取值:
        格式：
        数组的数据类型 变量名 = 数组名[索引]
 */
public class Demo05数组的静态初始化取值 {
    public static void main(String[] args) {
        //定义数组
        int[] brr = {11, 22, 33, 44, 55, 66, 77, 88, 99};

        //数组取值
        for (int i = 0; i < 9; i++) {
            System.out.println(brr[i]);
        }
        System.out.println("----------------");
        //数组取值改进版：
        //length : 数组提供了一个属性length，用来计算数组的长度
        //数组名.length
        int length = brr.length;
        System.out.println(length);
        System.out.println("----------------");

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

java内存分配

Java 程序在运行时，需要在内存中分配空间。
为了提高运算效率，就对空间进行了不同区域的划分
每一片区域都有特定的处理数据方式和内存管理方式。

3.1内存的区域

栈内存   【知道】
  	    方法运行时，进入的内存，局部变量都存放于这块内存当中

    堆内存   【知道】
        new出来的内容都会进入堆内存，并且会存在地址值

    方法区   【知道】
        字节码文件(.class文件)加载时进入的内存

    本地方法栈
        调用操作系统相关资源  了解

    寄存器
        就是一片空间，用来高速执行程序
    程序计数器

    GC   【知道】
        垃圾收集 Garbage Collection 通常被称为“GC”,回收不用java程序

3.2 java内存分配中 堆栈方法区示意图 以及单个数组的内存图

3.3多个数组的内存图,多个数组指向自己堆内存

/*
    多个数组的内存图:
        多个数组指向自己堆内存，无论如何操作，再去取值的时候，取得是操作后最新值
 */
public class Demo02 {
    public static void main(String[] args) {
        int [] arr = new int[3];
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        int [] brr = new int[3];
        System.out.println(brr);
        System.out.println(brr[0]);
        System.out.println(brr[1]);
        System.out.println(brr[2]);
        brr[0] = 40;
        brr[1] = 50;
        brr[2] = 60;
        System.out.println(brr);
        System.out.println(brr[0]);
        System.out.println(brr[1]);
        System.out.println(brr[2]);


    }
}

3.4多个数组指向同一块堆内存

package com.itheima._02java内存分配;

/*
    多个数组指向同一片堆内存，无论谁修改堆内存中的数据，最后取值的时候取得是修改后的最新值
 */
public class Demo03 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        int[] brr = arr;
        System.out.println(brr);

        brr[0] = 40;
        brr[1] = 50;
        brr[2] = 60;
        System.out.println(brr);
        System.out.println(brr[0]);
        System.out.println(brr[1]);
        System.out.println(brr[2]);
        System.out.println(arr);
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

数组的练习

4.1数组的遍历

/*
    遍历数组：
        1.使用for循环
        2.length属性
        3.数组操作 赋值 或取值
 */
public class Demo01数组的遍历 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66,77,88,99};
        //使用for循环遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

4.2数组求最大值

/*
    求最值：
        1.定义一个最大值
        2.使用for循环遍历 拿到所有数组中元素 ，和最大值比较
        3.如果比最大值还要大，更新最大值
 */
public class Demo02数组的最大值 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {88,66,99,100,78,99,120,66,88,99,101};
        //定义最大值
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            //和最大值比较
            if (arr[i]>max){
                //如果比最大值还要大，更新最大值
                max = arr[i];

            }
        }
        System.out.println("数组的最大值是："+max);
    }
}

4.3求数组最小值

/*
    1.先定义最小值
    2.使用for循环遍历数组 拿到每一数据，和最小值比较
    3.如果你比最小值还要小
    4.更新最小值
 */
public class Demo03数组的最小值 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {88,66,99,100,78,99,120,66,88,99,101};
        //定义最小值
        int min = arr[0];
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            //和最小值比较
            if (arr[i]<min){
                //更新最小值
                min = arr[i];
            }
        }
        System.out.println("数组的最小值是："+min);
    }
}

4.4数组元素求和 求平局值

/*
    1.先定义求和变量
    2.遍历数组取出数组中元素
    3.和求和变量累加
    4.打印和
 */
public class Demo04数组求和求平均值 {
    public static void main(String[] args) {
        // 1--100;
        /*int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum+=i;
        }
        System.out.println(sum);*/

        //定义数组
        int[] arr = {88,66,99,100,98,99,120,96,88,99,101};
        //定义求和变量
        int sum = 0;
        //遍历数组取出每一元素
        for (int i = 0; i < arr.length; i++) {
            //System.out.println(arr[i]);
            sum+=arr[i];
        }
        System.out.println("数组中所有元素和："+sum);
        //求平局值
        //在求平局值的时候 如果想得到小数，必须要有浮点数参与运算
        double avg = sum*1.0/arr.length;
        System.out.println("数组中所有元素的平均值："+avg);
    }
}

4.5评委打分

import java.util.Arrays;
import java.util.Scanner;

/*
    需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
          选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
    分析：
        1.动态数组 长度 6
        2.评委打分 键盘录入
        3.把打分存储到数组中
        4.去掉最高分和最低分
        5.求平均值

 */
public class Demo05评委打分 {
    public static void main(String[] args) {
        //1.动态数组 长度 6
        int [] arr = new int[6];
        //2.评委打分 键盘录入
        for (int i = 0; i < arr.length; i++) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入第"+(i+1)+"个评委的打分");
            arr[i] = scanner.nextInt();
        }
        //3.输出数组中所有评委的打分
        System.out.println(Arrays.toString(arr));

        //4.求最高分
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]>max){
                max = arr[i];
            }
        }
        System.out.println("最高分："+max);
        //5.求最低分
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]<min){
                min= arr[i];
            }
        }
        System.out.println("最低分："+min);

        //6.求和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+= arr[i];
        }
        System.out.println("总分："+sum);

        //7.去掉最高分和最低分
        int score =  sum - max - min;
        //8.求平均值
        int avg = score/(arr.length-2);
        System.out.println("运动员的最终成绩："+avg);
    }
}

){
max = arr[i];
}
}
System.out.println(“最高分：”+max);
//5.求最低分
int min = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i]<min){
min= arr[i];
}
}
System.out.println(“最低分：”+min);

    //6.求和
    int sum = 0;
    for (int i = 0; i < arr.length; i++) {
        sum+= arr[i];
    }
    System.out.println("总分："+sum);

    //7.去掉最高分和最低分
    int score =  sum - max - min;
    //8.求平均值
    int avg = score/(arr.length-2);
    System.out.println("运动员的最终成绩："+avg);
}

}