数组概述
数组是相同类型数据的有序集合,按一定的先后次序组合而成。
每一个数据称为一个数组元素,每个数组元素可以通过一个下标来访问。
数组声明创建
定义数组
变量类型 变量名字 = 变量的值
int[] nums;//首选
int nums[];//次选
//未赋值默认为空 即 int[] array = null;
初始化数组
nums = new int[10]
定义并初始化数组
int[] a = {1,2,3,4,5};`
int[] array = new int[10];
int[] arr = new int[]{3,5,1,7};
赋值
int[0] = 0;
//省略1~8
int[9] = 9;
获取数组长度
array.length
内存分析(堆和栈)
堆:存放new的对象和数组,可以被所有的线程共享,不会存放别的对象引用。
栈:存放基本变量类型(包含具体数值)、引用对象的变量(堆的具体地址)
三种初始化
静态初始化:创建+赋值
int[] a = {1,2,3,4,5};
动态初始化:包含默认初始化
int[] b = new int[10];//默认值为0
默认初始化(默认赋值)
数组是引用类型,它的元素相当于类的实例变量,因此数组一经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。
运用
//使用循环赋值
public static void main(String[] args) {
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
arr[i] = i;
System.out.println(arr[i]);
}
}
基本特点
- 长度确定。定义完不可改变。
- 类型固定。不存在混合类型数组。
- 元素任意。数组中的元素可以是基本类型,可以是引用类型。
- 数组也是对象。数组保存在堆中,数组元素相当于对象的成员变量。
- 不可越界。数组[0, n],越界报错"ArrayIndexOutOfBoundsException:数组下标越界异常!"
数组使用
For循环
int[] arrays = {1, 2, 3, 4};
for(int i=0; i<arrays.length;i++){
System.out.println(arrays[i]);
}
For-Each循环
//idea输入array.for->
//增强型for循环:只能访问不可改变,没有下标
int[] arrays = {1, 2, 3, 4};
for(int array : arrays){
System.out.println(arrays);
}
数组作为方法入参及返回值
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4};
printArray(arrays);
int[] result = reverse(arrays);
printArray(result);
}
//打印数组元素
public static void printArray(int[] arrays){
System.out.println("数组元素为:"+Arrays.toString(arrays));
}
//反转数组
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;
}
多维数组
二维数组
int[][] arr = {{1, 2},{3, 4}};
int[][] arr = new int[10][10]
三维数组
//必须输入数据成为一个完整的数组,否则会报错
int[][][] arr1 = {{{0, 1},{2, 3}},{{4, 5}, {6, 7}}};
int[][][] arr2 = new int[10][10][5];
示例:二维遍历输出
int[][] array ={{1, 2}, {2, 3}, {3, 4}, {4, 5}};
for (int i = 0; i < array.length ; i++) {
for (int j = 0; j <array[i].length ; j++) {
System.out.println(array[i][j]);
}
}
拓展
Arrays类
使用:Array.方法名(数组名)//Array.sort(arr)
常见功能:
-
给数组赋值:通过fill方法。
arr 数组名,[min, max) 区间,x是填充值
Array.fill(arr, x); Array.fill(arr, min, max, x);
-
对数组排序:通过sort方法,按升序。
Array.sort(arr)
-
比较数组:通过equals方法比较数组中元素值是否相等。
Array.equals(arr1, arr2)
-
查找数组元素:通过 binarySearch方法能对排序好的数组进行二分查找法操作。
arr 数组名,[min, max) 区间,x是搜索值
Array.binarySearch(arr, x);Array.binarySearch(arr, min, max, x)
-
打印数组:通过toString方法,以字符串的形式打印。
System.out.println(Array.toString(arr));
冒泡排序
两层循环,外层冒泡轮数,内层依次比较。
时间复杂度O(n2)
public static void main(String[] args) {
int[] ints = {1,24,53,42,5};
int[] sort = sort(ints);
System.out.println(Arrays.toString(sort));
}
//增加了flag优化
public static int[] sort(int[] array){
//临时变量
int temp = 0;
//外层循环,判断我们这个要走多少次;
for (int i = 0; i < array.length-1; i++) {
boolean flag=false;//通过fLag标识位减少没有意义的比较
//内层循环,比价判断两个数,如果第一个数,比第二个数大,则交换位置
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;
}
稀疏数组
当数组中存在大量的相同的数据,记录下不同的数据的信息,压缩数组。
定义:array[count+1] [3]
array[0] 存放 [总行] [总列] [个数]
从下标为一开始记录数据:
array[x] [行] [列] [数据]
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);
//2.创建一个稀疏数组的数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组,将非零的值,存放稀疏数组中
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];
}
}
}
//输出稀疏数组
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");
}
System.out.println("还原");
//1.读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//3.打印
System.out.println("输出还原的数组");
for (int[] ints : array3) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
标签:arr,JAVA,int,array2,System,数组,out
From: https://www.cnblogs.com/CLB-BB/p/18316073