Java-数组
- 一个类型所有数据的有序集合
- 每个数据称作一个数组元素，通过每个组的元素可以用下标访问它
数组是声明与创建
- 首先必须声明数组变量，才能在程序种使用数组。
dataType[] arrayRefVar; //首选声明方法
// 或
dataType arrayRefVar[]; //效果相同，但非首选
- 使用new操作符来创建数组
dataType[] arrayRefVar = new dataType[arraySize];
public class ArrayDemo01 {
//变量类型 变量名字 = 变量的值
public static void main(String[] args) {
// 声明了一个数组，名为nums
int[] nums; //定义 Java // 创建了一个nums数组，赋值10个空间
nums = new int[10]; //创建了一个数组
// 给数组赋值
for (int i = 0; i < 10; i++) {
nums[i] = i;
System.out.print(nums[i]+" ");
}
}
}
内存机制
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
没有被初始化的空间都是0
public class ArrayDemo02 {
public static void main(String[] args) {
// 静态初始化: 创建+赋值
int[] a = {1,2,3,4,5,6,7,8};
System.out.println(a[0]);
// 对对象也可以数组 引用类型
Man[] mans = {new Man(),new Man()};
// 动态初始化
int[] b = new int[10];
b[0] = 10;
System.out.println(b[0]);
}
}
数组四个基本特点
- 数组一旦被创建，它的大小不可改变
- 元素必须是相同类型，不许混合类型
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型
- 数组变量属引用类型，数组本身就是对象，每个元素相当于该对象的成员变量。java中对象是在堆中的，因此数组对象本身是在堆中。
数组边界
数组使用
For循环
public class ArrayDemo03 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
// 打印全部数组元素
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
System.out.println("============");
// 计算所有元素的和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum += arrays[i];
}
System.out.println("sum="+sum);
System.out.println("==============");
// 查找最大元素
int max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
if (max > arrays[i]) {
continue;
}else {
max = arrays[i];
}
}
System.out.println("max="+max);
}
}
For Each
public class ArrayDemo04 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
// for each arrays代表数组，array代表数组中的每一个元素,适合打印
// 遍历
for (int array:arrays) {
System.out.println(array);
}
System.out.println("=======");
// 这里arrays就相当于参数，对象，传入进去后依然可以打印
printArray(arrays);
System.out.println("\n===========");
// 反转数组,返回的也是一个数组
int[] reverse = reverse(arrays);
printArray(reverse);
}
// 打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+"");
}
}
// 反转数组
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
// 反转的操作
for (int i = 0, j = result.length-1; i < arrays.length; i++,j--) {
result[j] = arrays[i];
}
return result;
}
}
二维数组
public class ArrayDemo05 {
public static void main(String[] args) {
// 二维数组 [4][2] /* 1,2 array[0] 2,3 array[1] 3,4 array[2] 4,5 array[3] */ int[][] array = {{1,2},{2,3},{3,4},{4,5}};
// 查看 array[0] 输出 [I@77459877 ，这是一个对象（可以理解为是一个地址）
System.out.println(array[0]);
System.out.println(array[0][0]); //1
System.out.println(array[3][0]); //4
System.out.println("==========");
System.out.println(array[0].length); // 长度为2
printArray(array[0]); //将array[0]送进，相当于一个一维数组
}
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] + "");
}
}
}
Arrays类
- java给我们提供了一个数组的工具类，
java.util.Arrays - 该类给我们提供了API，可以使用其对数据对象进行一些基本的操作
- 由于Arrays类中的方法都是static修饰的静态方法，在使用时，我们可以直接使用类名进行调用
- 具有以下常用功能
- 给数组赋值：fill
- 给数组排序：sort
- 比较数组：equals比较数组中元素值是否相等
- 查找数组元素：binarySearch（排序好的数组进行二分查找）
import java.util.Arrays;
public class ArrayDemo06 {
public static void main(String[] args) {
int[] a = {1,2,3,4,897,987,34,98,453,798,324,7,564};
System.out.println(a);
// 打印元素 Arrays.toString 打印数组，变成了字符串
System.out.println(Arrays.toString(a));
// 排序类
Arrays.sort(a); //在当前地址进行排序-从小到大
System.out.println(Arrays.toString(a));
// 填充方法
Arrays.fill(a,2,4,0); //将a的 2-4之间的值 赋值为0
System.out.println(Arrays.toString(a));;
}
}
冒泡排序
比较每两个数，大的数上浮或者下层，时间复杂的\(O(n^2)\)
import java.util.Arrays;
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a = {1,3,7,63,2,4,67,32,3};
int[] sort = sort(a);
System.out.println(Arrays.toString(sort));
}
// 冒泡排序
public static int[] sort(int[] array) {
// 外层循环，判断我们走多少次
int temp = 0;
for (int i = 0; i < array.length-1; i++) {
// 内层循环
// 如果是顺序的，提前跳出循环
boolean flag = false; //标志位
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;
flag = true;
}
}
if (flag == false) {
break;
}
}
return array;
}
}
稀疏数组
当大多数数值都为同一值时，我们可以用稀疏数组来保存值。记录有用值坐标与数值。
稀疏数组的处理方式：
- 记录数组一共有几行几列，多少不同数值
- 把具有不同数值的元素的行和列记录在一个小规模的数组中
public class ArrayDemo08 {
public static void main(String[] args) {
//1. 创建一个二维数组 11*11 0：无棋子，1：黑， 2：白
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
// 输出原始数组
System.out.println("原始数组");
for (int[] ints: array1) {
for (int anInt:ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
// 转换为稀疏数组
// 获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (array1[i][j] != 0) {
sum++;
}
}
}
System.out.println("有效值个数:"+sum);
// 创建一个稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组，将非0值存放在稀疏数组中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j] != 0) {
count ++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
// 输出稀疏数组
// 二维数组，array2.length 输出的是行数（也就是栈里的长度）
System.out.println("稀疏数组");
for (int i = 0; i < array2.length; i++) {
System.out.println(array2[i][0] + "\t"
+ array2[i][1] + "\t"
+ array2[i][2] + "\t");
}
// 读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
for (int i = 1; i < array2.length; i++){
array3[array2[i][0]][array2[i][0]] = array2[i][2];
}
// 还原数组
System.out.println("还原数组");
for (int[] ints: array3) {
for (int anInt:ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}