day04

学习目标

• 了解数组的定义
• 掌握数组的动态初始化
• 掌握数组的静态初始化
• 掌握数组的遍历
• 掌握数组求最值
• 掌握数组的排序 冒泡排序
• 了解数组的内存图
  • 了解java的内存分配
  • 了解一个数组内存图
  • 了解多个数组指向各自空间的内存图
  • 了解多个数组指向同一内存的内存图

1.数组的定义

数组就是用来存储相同数据类型数据的容器

1.1数组定义的格式

/*
           数组定义格式
           数据类型【】变量名；
           interesting【】arr定义了一个数组，只能存放int类型相匹配的数据
           数据类型  变量名【】；
           double brr[];//定义了一个double类型的数组，可以存放和double相匹配的数据
           */
           public class Demo01数组定义格式{
           }

1.2数组的动态初始化

       /*
       数组的动态初始化：
               数据类型【】数组名=new 数据类型【长度】；
               */
       public  class Demo02数组的动态初始化{
               public static void main(String[] agrs){
                     //定义一个长度为3的int类型的数据
                     int 【】arr=new int 【3】；
                     //定义了一个长度为5的float类型的数组
                               float 【】 brr=new float[5];     
          }

1.3动态数组的基本操作 取值 赋值

   动态初始化数组的基本操作 
    取值：
     格式：数组的数据类型 变量名=数组名【索引】；
     索引：师叔祖在内存中开辟空间编号，从0开始到数组长度减一 例如 数组的长度为5 数组最大索引是4
      赋值：
            格式：arr[索引]=值；
            */
            publilc class Demo03动态初始化数组的基本操作{
            public static void main(String[] agrs){
            //动态初始化一个长度为5的int类型的数组
            int []arr =new int [5];//数组的长度为5 只能存放int类型相匹配数据，他的索引是 0 1 2 3 4
            //取值：格式：数组的数据类型 变量名=数组名【索引】；
            int a=arr[0];//取出0索引对应的数值 存放到变量a中
            //打印a
            System.out.println(a);
            int b=arr[1];
             System.out.println(b);
            int c=arr[2];
              System.out.println(c);
            int d=arr3];
            System.out.println(d);
            int e=arr[4];
            System.out.println(e);
            System.out.println("-----------------------------");
            for(int i=0;i<5;i++){
            /*System.out.println(i);*/
            int f= arr[i];
            System.out.println(f);
            }
            System.out.println("------------------------------");
            //赋值：格式：arr[索引]=值；
            arr[0]=10；
            arr[1]=20;
            arr[2]=30;
            arr[3]=40;
            arr[4]=50;
            for(int i= 0;i<5;i++){
            int x=arr[i];
            System.out.println(x);
                }
            }
            }

1.4数组的静态初始化

/* 
         数组的静态初始化：
           格式1：
              数据类型【】数组名=new 数据类型【】{.............}
              int [] arr=new int[]{1,2,3,4,5,6,7,8,9,0}
            格式2：
              数据类型【】数组名={.................}；
              int []brr={1,2,3,4,5,6,7,8,9};
              提示：
                  静态初始化数组推荐使用格式2，放存储单元是已知数据是推荐使用数组的静态初始化
                  静态初始化数组有默认值，默认值是初始化是赋给的值*/
            public class Demo04数组的静态初始化{
            public static void main(String[] agrs){
                 int []brr={1,2,3,4,5,6,7,8,9};
                 int a=brr[0];
                 System.out.println(a);
                   System.out.println("--------------------------");
                       for(int i=0;i<9;i+++){
                       System.out.println(brr[i]);
                       }
                        System.out.println("--------------------------");
                        int []crr={1,2,3,4,5,6,7,8,9,0};
                        /*
                              求数组的长度 数组提供了了一个属性length用来求数组的长度
                              使用格式：
                              int l=数组名.length;
                              */
                              int l=crr.length;
                               System.out.println(l);
                               int length =brr.length;
                                 System.out.println(length);
                                 //去除数组中所有元素 打印到控制台
                                 for（ int i=0;i<crr.length;i++）{
                                   System.out.println(crr[i]);
                                 }
        }
}

1.5动态初始化数组有默认值

/*
         动态初始化数组有默认值：
         基本类型的数组有默认值：
            byte short int long数组 默认值是0
            float double 数组 默认值是0.0
            boolean 数组 默认值是false
            char 数组 默认值'\u0000'
            引用数据类型数组的默认值是：null
            */
   public  class Demo05动态初始化数组有默认值{
         public static void main( String[] agrs){
         //int 数组 默认值是0
         int[]arr= new int[3];
         for(int i=0;i<arr.length;i++){
         System.out.println(arr[i]);
              }
              System.out.println("---------------------------")
              //byte 数组 默认值是0
              byte []brr=new byte[3];
              for(int i=0;i<brr.length;i++){
              System.out.println(brr[i]);
              }
              System.out.println("----------------------");
              short[] crr=new short[3];
              for(int i=0;i<crr.length;i++){
              System.out.println(crr[i]);
              }
                System.out.println("----------------------");
                   long[] drr=new long[3];
              for(int i=0;i<drr.length;i++){
              System.out.println(drr[i]);
                  }
                System.out.println("----------------------");
                   float[] err=new float[3];
              for(int i=0;i<err.length;i++){
              System.out.println(err[i]);
                  }
                System.out.println("----------------------");
                 double[] frr=new double[3];
              for(int i=0;i<frr.length;i++){
              System.out.println(frr[i]);
                  }
                System.out.println("----------------------");
                   boolean [ ] grr=new boolean[3];
              for(int i=0;i<grr.length;i++){
              System.out.println(grr[i]);
                   }
                System.out.println("----------------------");
                  char [ ] hrr=new char[3];
              for(int i=0;i<hrr.length;i++){
              System.out.println(hrr[i]);
              }
                 System.out.println("----------------------");
                 //数组 类 接口
                 String [ ] irr=new String[3];
                 for(int i=0;i<irr.length;i++){
                  System.out.println(irr[i]);
                 }
         }
   }

1.6遍历数组

 /*
        遍历数组的通用代码：
           for ( int i=0;i<数组名.length;i++){
             System.out.println(数组名【i】);
           }
           */
           public class Demo06练习{
           public static void main(String [ ] agrs){
           int [ ] arr={11,22,33,44,55};
           //使用循环最方便 选择for循环
           for (int i=0;i<arr.length;i++){
           System.out.println(arr[i]);
           }
           }
           }

1.7求数组的最大值

/*
    1.定义最大值
          int max=arr[0];
          2.使用循环遍历数组依次获取数组中的每一个元素
          3.和最大值max比较
                 如果比最大值还要大。就更新最大值
                 */
public class Demo07求数组的最大值{
   public static void main (String[ ] agrs){
         int [ ] arr={5,44,33,55,22};
         //定义最大值
         int max =arr[0];
         //使用循环遍历数组
         for （int i=0;i<arr.lebgth;i++）{
         //和最大值比较
         if(arr[i]>max){
         //更新最大值
         max=arr[i];
         }
         }
         System.out.println("数组中元素的最大值是："+max);
   }
}

1.8求数组的最小值

        /*
             1.定义最小值
              int min=arr[0];
              2.使用循环遍历获取数组中的每一个元素 依次和最小值比较 如果比最小值还要小，就更新最小值
              */
public class Demo08求数组的最小值{
     public static void main (String [ ] agrs ){
     int [ ] arr={5,44,33,55,22};
     //1.定义最小值
     int min =arr[0];
     //2.使用for循环遍历数组
     for(int i=0;i<arr.length;i++){
     //3.比较
     if(arr[i]<min){
     //4.更新最小值
    min=arr[i];
     }
     }
     //5.打印结果
     System.out.println("数组中元素的最小值是："+min);
     }
}

1.9求数组元素和求平均值

             /*
        求和：
        1.定义求和变量 存储最终和
        int sum = 0;
        2.使用循环遍历数组，获取数组中的元素，和求和变量累加
        3.打印最终和
     求平均值：
        使用数组中元素和和长度相除
 */
 public class Demo09求数组元素和求平均值{
     public static void main(String[] args) {
        int[] arr = {5, 44, 33, 55, 22};
        //1.定义求和变量 存储最终和
        int sum = 0;
        //2.使用循环遍历数组，获取数组中的元素，和求和变量累加
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        //3.打印最终和
        System.out.println("数组中所有元素的和："+sum);

        //4.求平均值
        double avg = sum*1.0/arr.length;
        System.out.println("数组中元素的平局值："+avg);
    }

1.10冒泡排序 最初版

import  java.untl.Arrays;
/*
         冒泡排序的原理：
         1.数组中相邻两个数字比较 如果前面的数据大于后面的数据则交换位置
         2.第一轮比较完成后 获取到数组中最大值放到最大值索引位置
         3.数组有多长我们就遍历多少轮
         */
         public class Demo10冒泡排序{
         public static void main(String[] agrs){
               int []arr={5,4,3,2,1};
               /*第一轮交换 求出数组中最大值放到最大牵引位置
               for(int i=0;i<arr.length;i++){
                       int temp=arr[i];
                       arr[i]=arr[i+1];
                       arr[i+1]=temp;
               }
         }
         System.out.prinlin(Arrays.toString(arr));
         //第二轮交换 求出数组中最大值放到最大索引位置
         for (int i=0;i<arr.length-1;i++){
                if(arr[i]>arr[i+1]){
                             int temp=arr[i];
                             arr[i]=arr[i+1];
                             arr[i+1]=temp;
                }
         }
          System.out.println(Arrays.toString(arr));
        //第三轮交换 求出数组中最大值放到最大索引位置
        for (int i=0;i<arr.length-1;i++){
              if(arr[i]>arr[i+1]){
              int temp=arr[i];
              arr[i]=arr[i+1];
              arr[i+1]=temp;
              }
        }
         System.out.println(Arrays.toString(arr));
        //第四轮交换 求出数组中最大值放到最大索引位置
        for(int i=0;i<arr.length;i++){
        if(arr[i]>arr[i+1]){
       int temp=arr[i];
       arr[i]=arr[i+1];
       arr[i+1]=temp;
        }
        }
        System.out.println(Arrays.toString(arr));*/
        for (int i=0;i<arr.length;i++){
        for(int j=0;j<i;j++){
        if(arr[j]>arr[j+1]){
        int temp=arr[i];
        arr[i]=arr[i+1];
        arr[j+1]=temp;
        }
       }
    }
  //打印数组的元素
        System.out.println(Arrays.toString(arr));
    }
}

1.11数组查找

import java.util.Scanner;
/*
 需求：一直一个数组arr={19，28，37，46，50}；
 键盘录入一个数据，查找该数据在数组中的索引，在控制台输出找到的索引值。
 1.键盘录入
 2.查找键盘录入的数据在数组中的索引
 3.输出索引
  */
  public class Demo11数组查找{
  public static void main(String[] agrs){
    int []arr={19,28,37,46,50};
    //1.键盘录入
    Scanner scanner=new Scanner(System.in);
    System.out.println("请输入一个整数：")；
    int num=scanner.nextInt();
     //2.查找键盘录入的数据在数组中的索引 如果不存输出-1
        //定义一个变量用来存存数组的索引
        int index=-1;
        for (int i=0;i<arr.length;i++){
        if(num==arr[i]){
        index=i;
        }
        }
         System.out.println(num+"在数组中索引"+index);
   }
  }

1.12评委打分

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

/*
  需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
        选手的最后得分为：去掉一个最高分和一个最低分后的4个评委平均值 (不考虑小数部分)。
  1.定义长度为6的数组 存放6个评委的打分
  2.键盘录入6个成绩
  3.求最大值最小值
  4.求和 求平均值
*/
public class Demo12评委打分 {
  public static void main(String[] args) {
      //定义数组
      int [] arr = new int[6];
      //键盘录入6个成绩
      Scanner scanner = new Scanner(System.in);
      for (int i = 0; i < arr.length; i++) {
          System.out.println("请第"+(i+1)+"个评委打分：");
          int score = scanner.nextInt();
          if (score>=0&&score<=100){
              arr[i] = score;
          }else {
              System.out.println("您的打分不和法！");
              i--;
          }
      }
      System.out.println(Arrays.toString(arr));
      // 3.求最大值最小值
      int max = arr[0];
      for (int i = 0; i < arr.length; i++) {
          if (arr[i]>max){
              max = arr[i];
          }
      }
      System.out.println("max = "+max);
      int min = arr[0];
      for (int i = 0; i < arr.length; i++) {
          if (arr[i]<min){
              min = arr[i];
          }
      }
      System.out.println("min = "+min);
      //4.求和 求平均值
      int sum = 0;
      for (int i = 0; i < arr.length; i++) {
          sum+=arr[i];
      }
      System.out.println("sum = "+sum);
      //平均值
      double avg = (sum-max-min)*1.0/(arr.length-2);
      //double l = Math.round(avg * 100)*1.0 / 100;
      System.out.println("运动员的最终成绩："+avg+"分");
  }
}

2.数组的内存分配

2.1Java内存分配 以及单个数组的内存图

/*
    栈内存
        方法运行时，进入的内存
    堆内存
        new出来的内容都会进入堆内存，并且会存在地址值
    方法区
        字节码文件(.class文件)加载时进入的内存
    本地方法栈:
        调用操作系统相关资源
    寄存器
        交给CPU去使用
 */
public class Demo01Java内存分配 {
    public static void main(String[] args) {
        int [] arr = new int[3];
        System.out.println(arr);//[I@119d7047
        /*
            [I@119d7047
            [:数组
            I:int类型
            @:分隔符
            119d7047：地址值 存在堆内存中
         */
        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);//[I@119d7047
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);



        double [] brr = new double[3];
        System.out.println(brr);

        System.out.println(brr[0]);
        System.out.println(brr[1]);
        System.out.println(brr[2]);
        double [][] crr = new double[3][4];
        System.out.println(crr);

    }
}

2.2两个数组的内存图

/*
    两个数组指向各自对内存，无论谁修改自己堆内存中的数据，最后取值的时候，取得是修改后的最新值
 */
public class Demo02两个数组的内存图 {
    public static void main(String[] args) {
        int [] arr = new int[3];
        System.out.println(arr);//[I@119d7047
        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);//[I@119d7047
        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]);//0
        System.out.println(brr[1]);
        System.out.println(brr[2]);
        brr[0] = 11;
        brr[1] = 22;
        brr[2] = 33;
        System.out.println(brr);
        System.out.println(brr[0]);//11
        System.out.println(brr[1]);//22
        System.out.println(brr[2]);//33
    }
}

2.3多个数组指向同一片区内存

/*
多个数组指向同一片堆内存，无论谁修改堆内存中的值，再去取值的时候取得是修改后的最新值
 */
 public class Demo03两个数组指向同一片堆内存 {
    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[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        
         int []brr=arr;
     System.out.println(brr);
        System.out.println(brr[0]);
        System.out.println(brr[1]);
        System.out.println(brr[2]);
        brr[0]=11;
        brr[1]=22;
        brr[2]=33;
         System.out.println(brr[0]);
        System.out.println(brr[1]);
        System.out.println(brr[2]);
        }
  }

2.4数组在操作中出现问题

public class Demo04数组在操作中出现问题 {
  public static void main(String[] args) {
  //1.访问了数组不存在索引
  .ArrayIndexOutofBoundsException 数组索引越界异常
        int [] arr = new int[3];
      //System.out.println(arr[3]);//.ArrayIndexOutOfBoundsException
      //2.空指针异常 NullPointerException
      System.out.println(arr);
      arr = null;
      System.out.println(arr[0]);
  }
}