目录
- 数组概述
- 数组声明创建
- 数组的使用
- 多维数组
- Arrays类
- 稀疏数组
数组概述
数组就是相同型数据的有序集合
数组的描述是相同类型的若干个数据,按照一定的先后次序排列组合而成
每一个数组称作一个数组元素，每个数组元素可以通过一个下标来访问他们.
数组的声明创建
像Java中的众多语法一样，变量一定要先声明然后才能使用
语法:
dataType[] arrayRefVar / dataType arrayRefVar[]
Java语言使用new操作符来创建数组，语法如下:
dataType[] arrayRefVar = new dataType[arraySize];
数组的元素是通过索引来访问的，数组的索引是从0开始的。
获取数组的长度: arrays.length
数组的使用
public static void main(String[] args) {
int [] arr = new int[10];
arr[0]=1;
arr[1]=2;
arr[2]=3;
arr[3]=4;
arr[4]=5;
arr[5]=6;
arr[6]=7;
arr[7]=8;
arr[8]=9;
arr[9]=10;
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
System.out.println("sum: "+sum);
}
/*
* result: 55;
*/
使用数组遍历得到数组内所有的元素想加得来的结果.
针对于Java中的内存分析：
- Java内存
- 堆
- 存放new的对象和数组
- 可以被所有的线程共享，不会存放别的对象引用
- 栈
- 存放基本的变量类型
- 引用对象的变量(其实存放的是引用堆里面的地址)
- 方法区
- 可以被所有的线程共享
- 包含所有的class和static变量
- 堆
如果你取了一个超越下标的数组元素就会报异常:
java.lang.ArrayIndexOutOfBoundsException
//数组下标超出异常
Java数组的3种初始化
-
静态初始化
int[] arr = {1,2,3}; Man[] mans = {new Man(1,1),new Man(2,2)}; -
动态初始化
int [] a = new int[2]; a[0]=1; a[1]=2; -
数组默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化；
以int变量来举例说明:
int [] arr = new int[5];
/*
*创建了一个int类型的数组arr，里面有6个元素
*/
//这里面的所有子元素都被隐式初始化，arr[1],arr[2],arr[3]...结果都是0;
同样如果式string
String [] str = new String[5];
/*
* str[0],str[1],str[2]...,str[5] => 初始默认都是null
*/
数组的基本特定
- 长度是确定的，一旦被创建以后，它的大小就是不可以改变的
- 元素必须是相同的类型，不允许出现混合类型
- 元素可以是任何数据类型，包含基本类型和引用类型
- 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量
- 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身就是在堆中
数组的使用
-
foreach循环
-
数组作方法入参
-
数组返回值
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (int item : array) {
System.out.print("item: "+item+"; ");
}
/*result*/
item: 1; item: 2; item: 3; item: 4; item: 5; item: 6; item: 7; item: 8; item: 9; item: 10;
数组作为方法传参
/*数组作为参数传入打印数组元素*/
public static void printArray(int[] arr) {
for (int item : arr) {
System.out.println("item: "+item);
}
}
/*反转数组并且返回*/
public static int [] reverseArray(int[] arr){
int [] result= new int[arr.length];
for (int i = 0,j =arr.length-1;i <arr.length ; i++,j--) {
result[i] = arr[j];
}
return result;
}
多维数组
- 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组
格式: int a[][] = new int[2][5];
int[][] arr = {{1,2},{2,3},{3,4}};
demo
int[][] arr = {{1,2},{2,3}};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j <arr[i].length ; j++) {
System.out.println(arr[i][j]);
}
}
Arrays类
- 数组的工具类:java.util.Arrays
- 因为数组对象本身没有什么方法可以供给我们调用，但是API中提供了一个工具类Arrays供我们使用，从而可以对数据进行一些基本操作
- Arrays类中的方法是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不是使用对象来调用
常用功能:
- 赋值：fil
- 排序：sort
- 比较数组：equals
- 查找数组元素：binarySearch进行对排序号的数组进行二分法查找
冒泡排序
- 冒泡排序是两层循环，外层冒泡轮数，里层依次比较
- 我们看到嵌套循环，时间复杂度为O(n2)
思想:
- 比较数组中，两个相邻的元素，如果第一个比第二个大，我们就交换它们的位置
- 每一次比较，都会产生出一个最大或者最小的数字
- 下一轮则，可以少一次排序
- 依次循环，直到结束
public static void main(String[] args) {
int[] arr = {2, 5, 8, 4, 9, 0};
demoSort demoSort = new demoSort();
System.out.println(Arrays.toString(demoSort.sortArray(arr)));
}
public static int[] sortArray(int[] array) {
//外层循环循环的次数，两两比较
int temp = 0;
for (int i = 0; i < array.length - 1; i++) {
//内层循环，比较次数
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j+1] > array[j]) {
temp = array[j];
array[j] = array[j+1];
array[j + 1] = temp;
}
}
}
return array;
}
reuslt: [0,2,4,5,8,9]
稀疏数组
当一个数组中大部分元素为0，或者同一个值的时候，可以使用稀疏数组来保存该数组
稀疏数组的出力方式：
-
记录数组一共有几行几列，有多少个不同的值
-
把具有不同的元素的和行列及值记录在一个小规模的数组中，从而缩小程序的规模
左边是原始数组，右边是稀疏数组