day 05

最新推荐文章于 2024-09-06 20:43:28 发布

牛奶c

最新推荐文章于 2024-09-06 20:43:28 发布

阅读量124

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/weixin_43439493/article/details/84317611

版权

笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

01 数组概括和定义格式 02 数组的初始化动态初始化 03 Java的内存分配以及栈和堆的区别 04 数组的静态初始化 05 数组索引越界异常和空指针异常 06 数组遍历 07 数组获取最值 08 数组操作反转 09 数组查表法 10 数组基本查找 11 二维数组的概括和格式

01 数组概括和定义格式

数组(容器):为了存储同种数据类型多个值
概念:数组时存储同一种数据类型多个元素的集合。也可看成一个容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。

===
02 数组的初始化动态初始化 //Array 数组

数组的初始化:就是为数组开辟连续的内存空间，并为每个数组元素赋予值
   对数组进行初始化:
   动态初始化只指定长度，由系统给出初始化值
   静态初始化给出初始化值，由系统决定长度
   //数据类型[] 数组名 = new 数据类型[数组长度];
   int[] arr = new int[5];//动态初始化，在内存中开辟连续的五块空间
   //系统给出的默认初始值，整数类型都为0
   //整数类型:byte,short,int,long默认初始化值都是0
   //浮点类型:float,double默认初始化值都是0.0
   //布尔类型:boolean默认初始化值false
   //字符类型:char默认初始值'\u0000'
   //   [I@15db9742   [代表数组，几个就代表几维
   //   I代表int类型
   //   @是固定的
   //    15db9742代表的时十六进制的地址值
   System.out.println(arr);// [I@15db9742 数组的地址值

===
03 Java的内存分配以及栈和堆的区别

   栈:存储局部变量       局部变量:定义在方法声明上和方法中的变量
   栈:先进后出
   堆:存储new出来的数组和对象

===
04 数组的静态初始化

   格式:数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
   简化格式:数据类型[] 数组名 = {元素1,元素2,...};
   //简写形式声明和赋值在同一行
   //不允许动静结合

===
05 数组索引越界异常和空指针异常

       //a:ArrayIndexOutOfBoundsException:数组索引越界异常
       //原因:你访问了不存在的索引，会出现索引越界
       //b:NullPointerException:空指针异常
       //原因:数组已经不再指向堆内存了，而你还用数组名去访问元素,
       int[] arr = new int[5];
       //System.out.println(arr[-1]);   //a
       arr = null;
       System.out.println(arr[0]);
       //b:当数组引用辅助位null,再去调用数组中元素就会出现空指针异常

===
06 数组遍历

   public static void main(String[] args){
       int[] arr = {11,22,33,44,55};
       for(int i = 0;i < 5;i++){
           System.out.println(arr[i]);
       }
       System.out.println(arr.length);   //arr.length代表的是数组的长度
       for(int i = 0;i < arr.length ;i++){
           System.out.println(arr[i]);
       }
       int[] arr2 = {3,4,5};
       print(arr2);
   }
   //数组的遍历
   //1，返回值类型
   //2，参数列表int[] arr
   public static void print(int[] arr){
       for(int i = 0;i < arr.length ;i++){
           System.out.print(arr[i] + " ");
       }
   }

===
07 数组获取最值

   public static void main(String[] args){
       int[] arr = {-11,-22,-33,-44,-55};
       int max = getMax(arr);
       System.out.println(max);
   }
   //获取数组中最大值
   //1，返回值类型int
   //2，参数列表int[] arr
   public static int getMax(int[] arr){
       int max = arr[0];
       for(int i = 1;i < arr.length ;i++){   //从数组的第二个元素开始遍历
           if(max < arr[i]){               //如果max记录的值小于的数组中的元素
               max = arr[i];               //max记录住较大的
           }
       }
       return max;
   }

===
08 数组操作反转

   public static void main(String[] args){
       int[] arr = {11,22,33,44,55};
       reverseArray(arr);   //反转
       print(arr);           //打印
   }
   /*
   * 数组元素反转
   * 1，明确返回值类型void
   * 2，明确参数列表int[] arr;
   */
   public static void reverseArray(int[] arr){
       for(int i = 0;i < arr.length / 2;i++){
           // arr[0]和arr[arr.length-1-0]交换
           // arr[1]和arr[arr.length-1-1]交换
           // arr[2]和arr[arr.length-1-2]交换
           int temp = arr[0];
           arr[0] = arr[arr.length-1-i];
           arr[arr.length-1-i] = temp;
       }
   }
   /*
   * 数组遍历
   * 1，明确返回值类型
   * 明确参数列表int[] arr
   */
   public static void print(int[] arr){
       for(int i = 0;i < arr.length;i++){
           System.out.print(arr[i]+" ");
       }
   }

===
09 数组查表法

/*
* 数据查表法(根据键盘录入索引，查找对应星期)
*/
import java.util.Scanner;
public class Demo5_Array {
   public static void main(String[] args){
       Scanner sc = new Scanner(System.in);
       System.out.println("请输入对应的星期范围在1-7:");
       int week = sc.nextInt();
       System.out.println("星期"+getWeek(week));
   }
   /*
   * 根据索引返回相应日期
   * 1，返回值类型char
   * 2，参数列表int week
   */
   public static char getWeek(int week){
       //定义一张星期表
       char[] arr = {' ','一','二','三','四','五','六','日',};
       //通过索引获取表中元素
       return arr[week];
   }
}

===
10 数组基本查找

   数组元素查找(查找指定元素第一次在数组中出现的索引)
public class Demo6_Array {
   public static void main(String[] args){
       int[] arr = {11,22,33,44,55};
       int index = getIndex(arr,22);
       System.out.println(index);
   }
   /*
   * 查找元素索引
   * 1，返回值类型 int
   * 2，明确参数列表，int[] arr,int value
   */
   public static int getIndex(int[] arr,int value){
       for(int i = 0;i < arr.length;i++){   //数组的遍历
           if(arr[i] == value){           //如果数组中的元素与查找的元素匹配
               return i;
           }
       }
       return -1;
   }
}

===
11 二维数组的概括和格式

    二维数组格式   int[][] arr = new int[3][2];
//定义二维数组，输出二维数组名称，一维数组名称，一个元素
public class Demo1_Array {
   public static void main(String[] args){
       int[][] arr = new int[3][2];
       /*
       * 这是一个二维数组
       * 这是二维数组中有3个以为数组
       * 每一个数组中有2个元素
       */
       /*
       [[I@15db9742   //二维数组
       [I@6d06d69c   //一维数组
       0
       */
       System.out.println(arr);       //二维数组
       System.out.println(arr[0]);       //二维数组中第一个一维数组
       System.out.println(arr[0][0]);   //二维数组中第一个一维数组中第一个元素6
   }
}
//格式: int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
public class Demo2_Array {
   public static void main(String[] args){
       int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
       System.out.println(arr);       //[[I@15db9742 二维数组的地址值
       System.out.println(arr[0]);       //[I@6d06d69c 一维数组的地址值
       System.out.println(arr[0][0]);   //1二维数组第一个一维数组的第一个数字
   }
}
//test   //二维数组遍历
       int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
       for(int i = 0;i < arr.length;i++){   //获取到每个二维数组中的一维数组
           for(int j = 0;j < arr[i].length;j++){//获取每个一维数组中的元素
               System.out.print(arr[i][j] + " ");
           }
           System.out.println();
       }
       //求和
       int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
       int sum = 0;   //定义变量，记录每次相加的结果
       for(int i = 0;i < arr.length;i++){
           for(int j = 0;j < arr[0].length;j++){
               sum = sum + arr[i][j];
           }
       }
       System.out.println(sum);
   }
//基本数据类型的值传递，不改变原值，因为调用后就会弹栈，局部变量随之消失
//引用数据类型的值传递，改变原值，因为即使方法弹栈，但是堆内存数组对象还在，可以通过地址继续访问
//Java中既是传值也是传地址，基本数据类型传递的值，引用数据类型传递的地址
//Java中只有传值，因为地址值也是值