java的数组

数组的概述

• 数组是相同类型数据的有序集合。数组就是一个数据容器
• 数组描述的是相同的如干个数据，按照一定的先后次序排列组合而成。
• 其中，每个数据称作为一个数组元素，每个数组元素可以通过一个下标来访问他们，下标从0开始

数组的定义

• 数组名 下标 (脚标 / 索引)(index) 元素(element) 数组的长度(length)
• 首先必须声明数组变量，才能在程序中使用数组；

数组的特点

• 数组的长度一旦确定就不能修改（重要）

• 存储的元素为相同的数据类型，可以是基本数据类型或引用数据类型

• 有索引，创建数组时会在内存中开辟一整块连续的空间。

• 存取元素的速度快，因为可以通过[下标]，直接定位到任意一个元素。

• 获取数据长度: (数组名+ . +length)

• 数组在使用之前需要先进行声明并初始化

数组的声明

//推荐
元素的数据类型[] 数组的名称;
int[] age;
//不推荐
元素的数据类型  数组名[];
int age[];

数组的初始化

静态初始化

 定义数组的同时为数组分配内存空间，并赋值。程序员只给定数组元素的初始值，不指定数组长度，由系统决定数组的长度

 	// 方式一: 声明和赋值不能分开
 
 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
 
 	int[] arr = new int[]{1,2,3,4,5};
 
 	// 方式二:声明和赋值可以分开
 
数据类型[] 数组名;
数组名 = new 数据类型[]{元素1,元素2,元素3...};

	int[] arr;
	arr = new int[]{1,2,3,4,5};

	// 简化方式：
数据类型[] 数组名 = {元素1,元素2,元素3...};

	 int [] arr = {1,2,3,4,5};
	//必须在一个语句中完成，不能分开两个语句写

动态初始化

 程序员只给定数组的长度，后期再给给元素赋值（实际系统会先给出元素的默认值）

 数据类型[] 数组名字 = new 数据类型[长度];
 
 int[] arr = new int[5];
 
  或
  
 数据类型[] 数组名字;
 数组名字 = new 数据类型[长度];
 
 int[] arr;
 arr = new int[5];
 

• 注意:

1. 数组名[下标]
   String s = sArr[0];
   sArr[0]=“甄姬”;
2. 数组的长度:数组内元素的数量
   数组名.length
   数组一旦完成初始化长度不可变
3. 数组下标的范围[0,长度-1]
4. 动态初始化后数组先存储默认值
   byte short int long ----> 0
   float double ----> 0.0
   boolean ----> false
   char ----> \u0000 也就是0
   引用数据类型创建的数组默认值都是null
   String ----> null

格式详解

1. 数据类型： 指定创建的数组容器可以存储什么数据类型的数据。
2. [] : 表示数组。
3. 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
4. new：关键字，理解为开辟内存空间。因为数组本身是引用数据类型，所以要用new创建数组对象。
5. [长度]：数组的长度，表示数组容器中可以存储多少个元素。(length)
6. 数组有定长特性,长度一旦指定,不可更改.

堆和栈

数组的使用

遍历:展示数组中的元素

1. 使用下标遍历 普通for

	int arr = {1,2,3,4,5};
	for (int i = 0; i < arr.length; i++) {
	System.out.println("arr[i] = " + arr[i]);

2. 增强for 底层本质也是普通for
   for(数组元素类型 变量名:数组名){
   变量名:数组内的数据

	int[] arr = {1,2,3,4,5};
	for(int ele:arr){
	System.out.println("ele = " + ele);
     }

• 注意
  如果条件需要下标
  采用方式一 普通for
  否则使用方式二 增强for

二维数组 : 存储一维数组的数组

声明

1. 数据类型[ ][ ]数组名;
2. 数据类型[ ]数组名[ ];
3. 数据类型 数组名[ ][ ];

静态初始化

• 定义: 完成初始化后 就确定了数组内的元素是什么

1. 声明和赋值必须放到一起
   数据类型[][]数组名 = {{值1,值2…},{值1,值2…}};
2. 声明和赋值可以分开
   数据类型[][]数组名 = new 数据类型[][]{{值1,值2…},{值1,值2…}};

动态初始化

1. 数据类型[ ][ ]数组名 =new 数据类型[数值1][数值2];
   数值1 : 二维数组内一维数组的数量
   数值2 : 一维数组内元素的数量
2. 数据类型[ ][ ]数组名 =new 数据类型[数值1][ ];
   数值1:二维数组内一维数组的数量

注意

注意:

1. 二维数组的长度 数组内一维数组的个数
2. 获取二维数组内一维数组的元素
   arr[二维数组内一维数组的下标][一维数组的元素下标]
   //获取dArr数组内第2个一维数组的第3个元素
   dArr[1][2]

Arrays类

• 定义
  数组的工具类 java.util.Arrays

• 功能

  1. 给数组赋值 : 通过 fill 方法
  2. 对数组排序 : 通过 sort 方法.从小到大排
  3. 比较数组 : 通过 equals 方法比较数组中元素值是否相等
  4. 查找数组元素 : 通过 binarySearch 方法堆排序好的数组进行二分查找法寻找

冒泡排序

冒泡排序是最出名的排序算法之一,一共有八大排序算法!
冒泡排序的时间复杂度为 O(n2)

1. 比较数组中两个相邻元素 若第一个比第二个数字大 则互换位置
2. 每一次比较 都会产生一个最大值(或 最小值)
3. 下一轮则可以少排序一次
4. 依次循环 直到排序完成

• 例如:

public static void main(String[] args) {
	int[] a = {6, 8, 1, 5, 9, 3, 4, 7, 2};
	//外层循环,判断要循环多少次
	for (int i = 0; i < a.length - 1; i++) {
	//内层循环,判断两个数的大小,按照升降序的要求,进行交换位置
	for (int j = 0; j < a.length - 1 - i; j++) {
		if (a[j + 1] > a[j]) {
		//这里<就是升序  >就是降序
			int temp = a[j];
			a[j] = a[j + 1];
			a[j + 1] = temp;
                }
            }
        }
        for (int i : a) {
            System.out.print(i + " ");
	}
}