java_day07

Java基础

Java数组

数组的定义

• 数组是相同类型数据的有序集合
  
• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
  
• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问
  

数组的声明创建

• 数组变量必须需要声明才能够 在程序中使用
  dateType[] arrayRefVar; //建议这样声明创出
  dateType arrayRefVar[]; //也可以这样效果相同，但不建议首选
  
• Java语言使用new操作符来创建数组，语法如下：
  dateType[] arrayRefVar = new dataType[arraySize];
  
• 数组的元素是通过索引访问的，数组索引从0开始。
  
• 数组长度用arrays.length获取
  1. public class ArrayDemo1 {
  3.     //变量的类型 变量的名字 = 变量的值；
  4.     //数组类型
  5.     public static void main(String[] args) {
  7.         int[] nums; // 1.声明变量是数组类型
  8.         nums = new int[10];//2.为数组变量创建一个10个空间的大小的数组
  10.         //3.为数组中的每一个元素赋值
  11.         nums[0] = 1;
  12.         nums[1] = 2;
  13.         nums[2] = 3;
  14.         nums[3] = 4;
  15.         nums[4] = 5;
  16.         nums[5] = 6;
  17.         nums[6] = 7;
  18.         nums[7] = 8;
  19.         nums[8] = 9;
  20.         nums[9] = 10;
  22.         //计算所有元素的和
  23.         int sum = 0;
  24.         int sum2 = 0;
  26.         //可以使用arrays.length获取数组长度
  27.         for (int i = 0; i < nums.length; i++) {
  28.             sum = sum + nums[i];
  29.         }
  30.         System.out.println(sum);
  32.         for (int x : nums) {
  33.            sum2 = sum2 + x;
  34.         }
  36.         System.out.println(sum2);
  38.     }
  39. }

  复制代码

内存分析

• Java内存分析
  

<img alt="" loading="lazy">
数组的3种初始化

• 静态初始化
  
• 动态初始化
  
• 数组的默认初始化
  
  
  
  • 数组是引用类型，它的元素相当于类的实例变量，因此数据一旦被分配空间，其中的元素就会被按照实例变量同样的方式被隐式初始化 默认0或null
    
  1. public class ArrayDemo2 {
  3.     public static void main(String[] args) {
  4.         //静态初始化 创建+赋值
  5.         int[] a = {1,2,3,4,5,6};
  6.         System.out.println(a[0]);
  8.         //动态初始化 包含默认初始化
  9.         int[] b = new int[10];
  10.         b[0] = 1;
  11.         System.out.println(b[0]);
  12.         System.out.println(b[1]);
  14.     }
  15. }

  复制代码

数组的四个基本特点

• 其长度是确定。数组一旦被创建，它的大小就是不可以改变的。
  
• 其元素必须是相同类型，不允许出现混合类型。
  
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
  
• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量
  
• 数组本身就是对象，Java对象存放在堆中，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的
  

数组边界

• 下标的合法区间 是从0到数组本身的长度-1
  
• 在调用数组元素时 如果下标超过范围如 int[] a = new int[3]
  System.out.println(a[3])
  会出现ArrayIndexOutOfBoundsException:数组下标越界异常
  

总结

• 数组时相同数据类型（可以为任何类型）的有序集合
  
• 数据也是对象，数组元素相当于对象的成员变量
  
• 数组长度一旦确定，不可变。越界抛出异常
  

数组使用

• 一般for循环        用来数组操作 赋值
  
• foreach               适合用来打印数组
  
• 数组作方法入参
  
• 数组作返回值
  1. public class ArrayDemo4 {
  3.     public static void main(String[] args) {
  4.         int[] array = {1,2,3,4,5};
  6.         //JDK1.5引入，不需要下标
  7. //        for (int x : array) {
  8. //            System.out.println(x);
  9. //        }
  10.         //for循环增强型 也叫foreach 适合打印数组元素，但是不易操作数组
  12.         printArray(array);
  14.         int[] res = reverse(array);
  15.         printArray(res);
  16.     }
  17.    
  18.     //打印数组元素
  19.     public static void printArray(int[] array){
  20.         for (int i = 0; i < array.length; i++) {
  21.             System.out.print(array[i]+" ");
  22.         }
  23.     }
  25.     //反转数组
  26.     public static int[] reverse(int[] array){
  27.         int[] result = new int[array.length];
  28.         for (int i = 0,j=result.length-1; i < array.length; i++,j--) {
  29.             result[j] = array[i];
  30.         }
  32.         return result;
  33.     }
  34. }

  复制代码

多维数组

• 即数组的元素类型时数组
  1. public class ArrayDemo5 {
  2. //    二维数组
  4.     public static void main(String[] args) {
  6. //        int[][] array = new int[4][2];  一个四行两列的数组
  7.         int[][] array = {{1,2},{3,4},{5,6},{7,8}};
  9.         for (int i = 0; i < array.length; i++) {
  10.             for (int j = 0; j < array[i].length; j++) {
  11.                 System.out.print(array[i][j]+" ");
  12.             }
  13.         }
  15.     }
  16. }

  复制代码

Arrays类

• 数据的工具类java.util.Arrays
  
• 数组对象本身没有方法可以调用，所以另提供了一个工具类Arrays供我们调用，可以对数据对象进行一些操作
  
• Arrays类中的方法都是static修饰的静态方法，可以不用使用对象直接调用
  
• 具有以下几个方法
  
  
  
  • 数组赋值：fill方法
    
  • 数组排序：sort方法，默认升序
    
  • 比较数组：equals方法比较数组的元素是否相等
    
  • 查找数组元素：binarySearch方法对排好序的数组进行二分法查找
    
  
  

1. public class ArrayDemo6 {
2. //Arrays工具类
3.     public static void main(String[] args) {
4.         int[] a = {23432,456,234,56,234,21,5};
6.         //打印数据元素toString
7.         String str = Arrays.toString(a);
8.         System.out.println(str);
10.         //对数组元素进行排序sort
11.         Arrays.sort(a);
12.         System.out.println(Arrays.toString(a)); //默认升序
14.         //数组填充fill
15.         Arrays.fill(a,3,5,66); //<=3 >5
16.         System.out.println(Arrays.toString(a));//[5, 21, 56, 66, 66, 456, 23432]
18.     }
19. }

复制代码