java canvas数组_java数组

数组

数组是相同类型数据的有序集合.

数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。

其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

数组的声明和创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法:

Java中使用new字符创建数组：

数组的元素是通过索引访问的，数组索引从О开始。获取数组长度:array.length

练习

//变量类型 变量名字 = 变量的值

int[] nums;//声明数组

nums = new int[4];//创建数组 数组中可以存放多少个数

nums[0] = 2;//索引从0开始

nums[1] = 3;

nums[2] = 4;

nums[3] = 6;

System.out.println(nums[3]);//输出索引数为3的数字

int sum =0;

for (int i = 0; i < nums.length; i++) {

sum = sum + nums[i];

}

System.out.println("和为:"+sum);

}

内存分析

变量的类型存放在栈中

new的对象储存在堆中

三种初始化

//静态初始化 创建+赋值

int[] a = {1,2,3,4,5,6,7,8,9};

//同上int[] ab = new int[]{1};

System.out.println(a[0]);

//动态初始化

int[] aa = new int[6];

aa[0] = 10;

System.out.println(aa[1]);

//数组的默认初始化

数组的某一个索引没有被赋值，则默认初始化为0

小结：

数组的四个基本特点：

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

其元素必须是相同类型,不允许出现混合类型。

数组中的元素可以是任何数据类型，包括基本类型和引用类型。

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

数组边界

数组下标取到规定数组长度以外

数组下标越界异常： javalang.ArrayIndexOutOfBoundsException

小结：

数组是相同数据类型(数据类型可以为任意类型)的有序集合

数组也是对象。数组元素相当于对象的成员变量

数组长度的确定的，不可变的。如果越界，则报: ArraylndexOutofBounds

数组的使用

普通的For循环

For-Each循环

数组作方法入参

数组作返回值

基本数组

//打印全部数组元素

int[] numa = {10,20,30,40,50,60};

for (int i = 0; i < numa.length; i++) {

System.out.println(numa[i]);

}

//计算总和

int sum =0;

for (int i = 0; i < numa.length; i++) {

sum+=numa[i];

}

System.out.println("和为"+sum);

//查找最大元素

int a = numa[0];

for (int i = 0; i < numa.length; i++) {

if (a

a=numa[i];

}

}

System.out.println(a);

数组增强

int[] arrays = {1, 2, 3, 4, 5,6};

// for (int i : array) {//for (循环变量类型 循环变量名称 : 要被遍历的对象) 循环体

// System.out.println(i);

// }

// printarray(arrays);

int[] reserve = reserve(arrays);//调用reserve方法,并将arrays数组中的数字保存在reserve数组中

printarray(reserve);//打印reserve数组

}

//打印数组元素

public static void printarray(int[] arrays){

for (int i = 0; i < arrays.length; i++) {

System.out.print(arrays[0]+" ");

}

}

//反转数组

public static int[] reserve(int[] arrays){

int[] result = new int[arrays.length];

for (int i = 0,j =result.length-1; i < arrays.length;j--,i++) {

result[j] = arrays[i];

}

return result;

}

二维数组

基本形式：int[][] a =new int[2][5];

//二维数组,n行,两列

int[][] a = new int[][]{{1,1},{2,3}};

System.out.println(a[0][0]);//第一行第一列的数字

System.out.println(a[0][1]);//第一行第二列的数字

System.out.println(a[1][0]);//第二行第一列的数字

System.out.println(a[1][1]);//第二行第二列的数字

printarray(a[0]);//第一行全部的数字

//多维数组

int[][][][][][] b =new int[][][][][][]{};//最多可以建多少个?

}

//打印数组元素

public static void printarray(int[] arrays){

for (int i = 0; i < arrays.length; i++) {

System.out.print(arrays[0]+" ");

}

}

Arrays类

public static void main(String[] args) {

int[] a = {1,54545,8,63,445,9,6};

System.out.println(a);

//打印数组元素 Arrays.toString()

System.out.println(Arrays.toString(a));

printArrays(a);

Arrays.sort(a);//升序

printArrays(a);

//填充数组

Arrays.fill(a,2,5,3);

printArrays(a);

}

//Arrays.toString() 方法

public static void printArrays(int[] b){

for (int i = 0; i < b.length; i++) {

if (i==0){

System.out.print("[");

}

if (i==b.length-1){

System.out.print(b[i]+"]");

}else {

System.out.print(b[i]+","+" ");

}

}

}

Arrays详解https://www.cnblogs.com/wei-jing/p/10540192.html

冒泡排序

1.原理：比较两个相邻的元素，将值大的元素交换到右边

2.思路：依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。

public static void main(String[] args) {

int[] array ={1,5,454,4,648,1,454,7,1};

int[] sort = sort(array);

System.out.println(Arrays.toString(sort));

}

public static int[] sort(int[] b){

//临时变量

int temp =0;

for (int i = 0; i < b.length-1; i++) {

boolean flag =false;//如果改数组已经排序,则跳出循环.减少没有意义的比较

//内层循环,比较两个数,如果第一个数比第二个数大则交换位置

for (int j = 0; j < b.length-1-i; j++) {

if (b[j+1]

temp= b[j];

b[j]=b[j+1];

b[j+1] =temp;

flag = true;

}

}

if (flag ==false){

break;

}

}

return b;

}

算法复杂度https://www.iteye.com/blog/univasity-1164707

稀疏数组

稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组

例如：

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();

}

System.out.println("====================");

//转换为稀疏数组保存

//1.获取有效值的个数

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

System.out.println(array2[i][0]+"\t"

+array2[i][1]+"\t"

+array2[i][2]+"\t");

}

System.out.println("====================");

System.out.println("还原:");

//1.读取稀疏数组

int[][] array3 = new int[array2[0][0]][array2[0][1]];

//2.给其中的元素还原它的值

for (int i = 1; i

array3[array2[i][0]][array2[i][1]] = array2[i][2];

}

//3.打印

System.out.println("输出还原数组:");

for (int[] ints : array1) {

for (int anInt : ints) {

System.out.print(anInt+"\t");

}

System.out.println();

}

}