Java基础之数组

(1)数组：存储同一种数据类型的多个元素的容器（注意和集合的区别 后面的总结之中有）。

(2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。编号的专业叫法：索引。

(3)定义格式

A:数据类型[] 数组名;

B:数据类型 数组名[];

(4)数组的初始化

A:动态初始化

只给长度，系统给出默认值。

举例：int[] arr = new int[3];

B:静态初始化

给出值，系统决定长度。

举例：int[] arr = new int[]{1,2,3};

简化版：int[] arr = {1,2,3};

(5)JAVA的内存分配

A:栈 存储局部变量。

B:堆 存储所有new出来的。

C:方法区(后面面试题会详细讲，先大概了解)。

D:本地方法区(系统相关)。

E:寄存器(CPU使用)。

注意：

a:局部变量 在方法定义中或者方法声明上定义的变量。

b:栈内存和堆内存的区别。

栈：数据使用完毕，就消失。

堆：每一个new出来的东西都有地址，每一个变量都有默认值。

byte,short,int,long 0。

float,double 0.0。

char 'u0000'。

boolean false。

引用类型 null。

数据使用完毕后，在垃圾回收器空闲的时候回收。

(6)数组内存图：

(7)数组的常见操作

A:遍历。

B:最值。

(8)代码：

/*
 数组:存储同一种数据类型的多个元素的容器。
 定义格式：
 A:数据类型[] 数组名;
 B:数据类型 数组名[];
 举例：
 A:int[] a; 定义一个int类型的数组a变量
 B:int a[]; 定义一个int类型的a数组变量
 如何对数组进行初始化呢?
 A:何谓初始化呢? 就是为数组开辟内存空间，并为每个数组元素赋予值
 B:有几种方式呢?
 a:动态初始化 只指定长度，由系统给出初始化值
 b:静态初始化 给出初始化值，由系统决定长度
 动态初始化的格式：
 数据类型[] 数组名 = new 数据类型[数组长度];
 举例：
 int[] arr = new int[3]; 
 如何获取数组中的元素呢?
 通过:
 数组名[索引]
 索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1。
*/
public class ArrayDemo1 {
 public static void main(String[] args) {
 //定义一个数组 动态初始化
 int[] arr = new int[3];
 //定义一个数组 静态初始化
 int[] arr2 = {1,2,3};
 /*
 左边：
 int:说明数组中的元素的数据类型是int类型
 []:说明这是一个数组
 arr:是数组的名称
 右边：
 new:为数组分配内存空间。
 int:说明数组中的元素的数据类型是int类型
 []:说明这是一个数组
 3:数组长度，其实也就是数组中元素的个数
 */
 System.out.println(arr); //[I@c3c749 地址值。
 System.out.println(arr[0]);//0
 System.out.println(arr[1]);//0
 System.out.println(arr[2]);//0
 System.out.println("=====================");
 System.out.println(arr);//[I@c3c749
 System.out.println(arr2[0]);//1
 System.out.println(arr2[1]);//2
 System.out.println(arr2[2]);//3
 }
}

/*
 数组遍历：就是依次输出数组中的每一个元素。
 注意：数组提供了一个属性length，用于获取数组的长度。
 格式：数组名.length
*/
public class ArrayDemo2 {
 public static void main(String[] args) {
 // 定义数组
 int[] arr = { 11, 22, 33, 44, 55 };
 // 获取每一个元素
 // 如何获取呢?我们知道数组名结合编号(索引)就可以找到数据
 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 x = 0; x < 5; x++) {
 // x=0,1,2,3,4
 System.out.println(arr[x]);
 }
 System.out.println("--------------------");
 //为什么到5呢，我们是数了一下数组的个数
 // 继续看下个数组如何遍历 我们还是数吗？
 int[] arr2 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 2, 2, 3, 4, 5, 7, 8,
 5, 3, 5, 6, 8, 7, 8, 5, 3, 5, 6, 8, 7, 8, 5, 3, 5, 6, 8, 7, 8,
 5, 3, 5, 6, 8, 7, 8, 5, 3, 5, 6, 8 };
 // 这个时候，数组就给我们提供了一个属性：length专门用于获取数组的长度
 // 格式：数组名.length 返回数组的长度
 System.out.println(arr.length);//5
 System.out.println(arr2.length);//51
 System.out.println("--------------------");
 // 改进第一个程序
 for (int x = 0; x < arr.length; x++) {
 System.out.println(arr[x]);
 }
 }
}

/*
 数组获取最值(获取数组中的最大值最小值)
 分析：
 A:定义一个数组，并对数组的元素进行静态初始化。
 B:从数组中任意的找一个元素作为参照物(一般取第一个),默认它就是最大值。
 C:然后遍历其他的元素，依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
 D:最后参照物里面保存的就是最大值。
*/
public class ArrayDemo3 {
 public static void main(String[] args) {
 //定义一个数组
 int[] arr = {34,98,10,25,67};
 //调用方法
 int max = getMax(arr);
 System.out.println("max:"+max);
 //请获取数组中的最小值
 int min = getMin(arr);
 System.out.println("min:"+min);
 }
 public static int getMax(int[] arr) {
 //从数组中任意的找一个元素作为参照物
 int max = arr[0];
 //然后遍历其他的元素
 for(int x=1; x<arr.length; x++) {
 //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
 if(arr[x] > max) {
 max = arr[x];
 }
 }
 //最后参照物里面保存的就是最大值。
 return max;
 }
 public static int getMin(int[] arr) {
 //从数组中任意的找一个元素作为参照物
 int min = arr[0];
 //然后遍历其他的元素
 for(int x=1; x<arr.length; x++) {
 //依次获取和参照物进行比较，如果小就留下来，如果大，就离开。
 if(arr[x] < min) {
 min = arr[x];
 }
 }
 //最后参照物里面保存的就是最小值。
 return min;
 }
}