数组
数组概述
- 数组是相同类型数据的有序集合。
- 数组中的元素可以是任意数据类型，包括基本类型和引用类型
- 数组描述是相同类型的若干个数据，按照一定的先后顺序排列组合而成。
- 数组下标从0开始。
数组声明与创建
数组的声明
int[] nums;//声明一个数组（建议）
int nums2[];//也是声明数组,C，C++也是这样用的
创建数组
int[] nums;//声明数组（建议）
nums=new int[5]; //数组的创建，分配了空间
获取数组长度
数组名.length
为数组元素赋值
方式1
nums[0]=1;
nums[1]=1;
nums[2]=1;
nums[3]=1;
nums[4]=1;
方式2
int [] number={1,2,3,4,5};
内存分析
堆
- 存放new的对象跟数组
- 可以被所有的线程共享，不会存放别的对象引用。
栈
- 存放基本变量类型（会包含这个基本类型的具体数值）
- 引用对象的变量（会存放这个引用在堆里面的具体地址）
数组三种初始化
静态初始化
//静态初始化: 创建+赋值
int [] a={1,2,3,4,5};
动态初始化
//动态初始化,默认初始化了b[3]=0,b[4]=0;
int[] b=new int [5];
b[0]=1;
b[1]=2;
默认初始化
int[] b=new int [5];//默认初始化为0
下标越界及小结
下标合法区间在[0~length-1]
数组的使用
打印所有的元素
public static void main(String[] args) {
int[] arrays={1,2,3,4,5};
//打印所有的元素
for (int i : arrays){
System.out.println(i);
}
System.out.println("===============");
printarray(arrays);
}
数组作为方法参数
public static void printarray(int[] arrays){
for (int i : arrays){
System.out.println(i);
}
}
数组作为方法返回值
public static int[] reverse(int[] arrays){
int[] b=new int[arrays.length];
for (int i = 0; i < arrays.length; i++) {
b[i]=arrays[arrays.length-1-i];
}
return b;
}
多维数组
int[][] array={{1,2,3},{4,5,6},{7,8,9}};
public static void main(String[] args) {
int[][] array = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
//printarray(array[0]);
System.out.println("=======================");
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
Arrays类
toString打印数组
package com.xie.array;
import java.util.Arrays;
public class Demo6 {
public static void main(String[] args) {
int[] a={1,3333,4,2,6};
System.out.println(a);//[I@14ae5a5
//打印数组元素
System.out.println(Arrays.toString(a));//[1, 3333, 4, 2, 6]
}
}
sort排序数组
package com.xie.array;
import java.util.Arrays;
public class Demo7 {
public static void main(String[] args) {
int[] a={1,3333,4,2,6};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
}
fill方法
将指定的数覆盖指定数组中的每个数
package com.xie.array;
import java.util.Arrays;
public class Demo8 {
public static void main(String[] args) {
int[] a={1,3333,4,2,6};
Arrays.fill(a,0);
System.out.println(Arrays.toString(a));//[0, 0, 0, 0, 0]
}
}
冒泡排序算法
public class Demo9 {
public static void main(String[] args) {
int[] a={2,6,4,5,8};
boolean flag=false;
for (int i = 0; i < a.length-1; i++) {
for (int j = 0; j < a.length-1-i; j++) {
int temp=0;
if (a[j+1]>a[j]){
temp=a[j+1];
a[j+1]=a[j];
a[j]=temp;
flag=true;
}
}
if (flag==false){
break;
}
}
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
}
稀疏数组
当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组。
package com.xie.array;
import java.util.Arrays;
public class Demo10 {
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];
}
}
}
//输出稀疏数组
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("========================");
//还原稀疏数组
System.out.println("还原");
int[][] arrays3=new int[array2[0][0]][array2[0][1]];
for (int i = 1; i < array2.length; i++) {
arrays3[array2[i][0]][array2[i][1]]=array2[i][2];
}
System.out.println("输出还原的数组");
for (int[] ints : arrays3){
for (int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
