java 不带下标数组名_第二十二讲——JAVA数组

第二十二讲——JAVA数组

数组就是相同类型(比如int，byte...)数据的有序集合

每一个数据是整个数组中的一个组成元素

调用元素，要通过下标来调用(10，11，12，13，14(下标是从0开始第几个就是第n个标))

01—数组创建和声明

和所有数据一样都需要声明datatype

//变量类型 变量名 = 变量值;

//int num01 = 1;

1—声明datatype

//int(long,byte,short...)[](数组类型) 数组名字;

int[] numbers;

2—创建datatype

适用new来创建datatype

int[] numbers;

numbers = new int[10];//创建了一个数组，里面能放十个int的数据

创建数组后默认值为0

package Method;

public class Demo03 {

public static void main(String[]ages){

int[] numbers;//1.声明了一组int数组

numbers =new int[10];//2.创建了一个数组，里面能放十个int的数据

}

}

//可以把声明和创建放在一起

int[] numbers = new int[10];

数组类型[] 数组名字 = new 数组类型[长度]

3—给数组赋值

数组的元素是通过索引访问的，从0开始索引；

package Method;

public class Demo03 {

public static void main(String[]ages){

int[] numbers;//1.定义

numbers =new int[10];//2.创建

// 3. 给创建的数组赋值

numbers[0] = 1;

numbers[1] = 2;

numbers[2] = 3;

numbers[3] = 4;

numbers[4] = 5;

numbers[5] = 6;

numbers[6] = 7;

numbers[7] = 8;

numbers[8] = 9;

numbers[9] = 10;

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

//打印出名为numbers数组中第一个元素，也就是2

}

}

计算所有datatype下元素的合

datatype.length

该数组的长度即多少个数据

package Method;

public class Demo03 {

public static void main(String[]ages){

int[] numbers;//1.定义

numbers =new int[10];//2.创建

// 3. 给创建的数组赋值

numbers[0] = 1;

numbers[1] = 2;

numbers[2] = 3;

numbers[3] = 4;

numbers[4] = 5;

numbers[5] = 6;

numbers[6] = 7;

numbers[7] = 8;

numbers[8] = 9;

numbers[9] = 10;

int 合 = 0;

for(int num = 0;num<=numbers.length;num++){

合 = 合+num;

}

System.out.println(合);

}

}

02—两种常用初始化数组的方法

即从声明到赋值三合一的操作

package Method;

public class Demo03 {

public static void main(String[] args){

//第一种;

// 静态初始化;声明+创建+赋值

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

//要注意的是值从0开始排序所以注意提取序列

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

//第二种;

// 动态初始化; 声明+创建+自己手动一一赋值

int[] b = new int[5];

b[0] =1;

b[1] =2;

b[2] =3;

b[3] =4;

b[4] =5;

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

}

}

数组边界

提取元素，要在下标的合法区间内；(0，length-1),否则越界会报错！！！

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

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

03—数组使用

打印出所有元素

计算所有元素的总和

查找最大元素

package Arrays;

public class Arrays01 {

public static void main(String[]args){

//======打印出所有数组的元素========

//第一种创建数组的方法

int[] arrays01 = {1,2,3};

//打印出所有元素

int sum = 0;

for(int I = 0;I

System.out.println(arrays01[I]);

sum = sum+arrays01[I];

}

//计算所有元素的总和

System.out.println("该数组的总和为;"+"\t"+sum);

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

//计算数组中的最大值

int Max = 0;

for(int A= 0;A

if(Max

Max = arrays01[A];

}

}

System.out.println("该数组的最大值为;"+Max);

}

}

显示

C:\Users\夏天的风\Desktop\DEMO-XXZ\out\production\DEMO-XXZ Arrays.Arrays01

1

2

3

该数组的总和为;6

============================

该数组的最大值为;3

Process finished with exit code 0

数组进阶用法

用于打印数组

增强型的for循环 ; 多用于打印输出没有下标

package Arrays;

public class Arrays01 {

public static void main(String[]args){

int[] arrays01 = {1,2,3};

//格式为

//数组名称.for

//其中()中会把arrays01中的每一项都赋值给了I，I就是默认arrays中的每一个元素，每一次循环就取一个值

for (int I : arrays01) {

//调用时用array(数组)

System.out.println(I);

}

}

}

显示

C:\Users\夏天的风\Desktop\DEMO-XXZ\out\production\DEMO-XXZ Arrays.Arrays01

1

2

3

Process finished with exit code 0

用建立方法来打印数组

package Arrays;

public class Arrays01 {

public static void main(String[]args){

int[] arrays01 = {1,2,3};

printArrays(arrays01);

}

//建立打印数组元素的方法

public static void printArrays(int[] arrays){

for(int I = 0; I

System.out.print(arrays[I]+"\t");

}

}

}

反转数组

package Work;

public class Work06{

//============反转数组元素内容==========

public static void main(String[]args){

//第一步 先定义变量

int[] array ={1,2,3};

//第五步 先声明反转后数组的名称

//反转数组 = 反转方法

int[] reverse = reverse(array);

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

//第六步 用打印数组方法打印反转数组

printArray(reverse);

}

//第二步 先创建reverse数组方法

public static int[] reverse(int[] array){

//反转的结果长度 = 被反转数组长度

//int [] 结果 =new int[长度]

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

//I就是原数组的初始值，J是反转后初始值；I>原长度;

for(int I =0,J= (array.length)-1;I

//每循环一次就把值赋值给反转数组一次

result[J] = array[I];

}

//返回到结果就是反转数组的结果

return result;

}

//第四步 建立打印数组元素的方法

//===打印出数组元素的方法====================

public static void printArray(int[] array){

for(int I = 0;I

System.out.println(array[I]);

}

}

}

显示

C:\Users\夏天的风\Desktop\DEMO-XXZ\out\production\DEMO-XXZ Work.Work06

1

2

3

=====================

3

2

1

Process finished with exit code 0

04—二维数组

多维数组是数组中的数组

格式

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

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

//array中第0个数组中第0个元素

/*

1,2

2,3

4,5

*/

//============遍历二维数组===========

package Test;

public class Test04 {

public static void main(String[]args){

int[][] array = {{1,2},{10,20},{100,200}};

printarray(array);

}

//建立遍历二维数组的方法

public static void printarray(int[][] array){

for(int I = 0;I

for(int J = 0;J

System.out.print(array[I][J]);

if(J==0){

System.out.print(",");

}

}

System.out.println();

}

}

}

05—Arrays类讲解

package Test;

//重点！！！ 先生成Arrays类方法

// 输入(Arrays;) 然后按住alt+回车 就能调出Arrays类，后删除Arrays

import java.util.Arrays;

public class Test01 {

public static void main(String[]args){

int[] a = {1,2,315,656,615,29,37,54};

System.out.println(a);//会输出对象; [I@75412c2f

//======打印数组元素======

System.out.println(Arrays.toString(a));//打印数组元素的方法，仅用于一维数组

//=======数组排序==========

Arrays.sort(a);//数组进行排序 升序

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

//=======给赋值填充fill方法==========

//数组名称，从下标0开始到下标4，填充为0

//默认填充为0

Arrays.fill(a,0,4,0);

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

//Arrays类中还有很多功能待开发

}

}

06—冒泡排序

冒泡排序的实质就是把最大的元素放在右边，直到提取全部元素

两两比较，如果前面大就交换位置，直到大小排序正确

两层循环，外层冒泡轮数(轮数就是数组长度-1)，里层依次比较

//冒泡排序 步骤;

//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换他们位置。

//2.每一次比较都会产生一个最大，或者最小的数字。

//3.下一轮就可以少一次排序。

//4.依次循环，直到结束。

package Test;

import java.util.Arrays;

public class Test02{

public static void main(String[]args){

//用冒泡排序 从小到大{5,6,2,7,9,1,4}

//第一步 创建array

int[] array = {5,6,2,7,9,1,4};

//第五步 创建新的数组用于接受排序后的数组

int[] sort = sort(array);

//第六步 打印

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

}

//第二步 创建方法

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

//第三步 设置临时变量用来交换变量

int temp = 0;

//第四步 设置外循环;全部元素数量-1，就是需要冒泡的次数，遍历一次是一次，每遍历一次，会比较出一个最大值，需要遍历的元素是长度-1

for(int I = 0; I

//=========重点===========

//通过falg标识位减少没有意义的比较

boolean flag = false;

for(int J = 0; J

if(array[J]>array[J+1]){

temp = array[J];

array[J] = array[J+1];

array[J+1] = temp;

//这里的falg表示如果走了这个程序那么标志是true，因为通过了修正一定是true的

falg = true;

}

}

//falg等于false说明没有走中间修正程序，说明该数组不需要排序，直接break提出，从而达到优化的目的，本来还得跑，一直跑array。length-1才退出

if(falg==false){

break;

}

}

return array;

}

}

显示

C:\Users\夏天的风\Desktop\DEMO-XXZ\out\production\DEMO-XXZ Test.Test02

[1, 2, 4, 5, 6, 7, 9]

Process finished with exit code 0

07—稀疏数组

什么是稀疏数组？

需求；在编写五子棋游戏中，有存盘和续上盘的功能

​ 分析；在程序中是用数字来记录数据的，然而在很多场景中都存在各种各样的”默认值“，那么就—>

推出; 稀疏数组

用来解决过多杂而没有意义的数据

什么场景用及原理

​ 当一个数组大部分的元素为0；或者为同一数值时，可以使用稀疏数组来保存该数组。

稀疏数组二点处理方式是：

记录数组共有几行几列，有多少不同的数值

把具有不同值的元素记录在一个小规模的数组中，从而缩小程序的规模(达到一个压缩的作用)和提高可读性

如下图：左原始数组，右稀疏数组

稀疏数组

这里学会使用PS来拼接图片

Demo01

先学习一个增强性for循环的二维数组的应用

//定义了一个11*11的二维数组

int[][] array = new int[11][11];

//设置有效值，其他默认为0

array[1][2] = 1;

array[2][3] = 2;

//增强性for循环的二维数组应用

//输入数组名称+for

for (int[] ints : array) {

//输入ints.for

for (int anInt : ints) {

//此时把所有的元素已经赋值给了anInt所以打印anInt就可以了

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

}

System.out.println();

输出结果

C:\Users\夏天的风\Desktop\DEMO-XXZ\out\production\DEMO-XXZ Test.Test06

00000000000

00100000000

00020000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

Process finished with exit code 0

到目前为止打印二维数组的方法大致有二

package Test;

public class Test {

public static void main(String[]args){

//打印数组的两种方法

//打印表格

/*

* 1 2 3

* 4 5 6

* 0 0 0

* */

//===第一种===普通for循环遍历法

//动态初始化

int[][] array = new int[3][3];

array[0][0] = 1;

array[0][1] = 2;

array[0][2] = 3;

array[1][0] = 4;

array[1][1] = 5;

array[1][2] = 6;

for(int i = 0;i

for(int j = 0;j

System.out.print(array[i][j]+"\t");

}

System.out.println();

}

//===也可写做增强型for循环的二维数组写法

System.out.println("=========第一种====增强型for循环=======");

for (int[] ints : array) {

for (int anInt : ints) {

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

}

System.out.println();

}

//===第二种===

System.out.println("=========第二种====固定列=======");

for(int i = 0;i

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

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

+array[i][2]);

}

}

}

显示

C:\Users\夏天的风\Desktop\DEMO-XXZ\out\production\DEMO-XXZ Test.Test

123

456

000

=========第一种====增强型for循环=======

123

456

000

=========第二种===========

123

456

000

Process finished with exit code 0

Demo02

从数组—>稀疏数组—>数组

package Test;

public class Test03 {

public static void main(String[]args){

//这里就不能用动态初始化一一赋值的方式，因为数据多，用静态初始化可以默认值为0，效率高

//创建一个二维数组棋盘 11*11 0:没有棋子 1:黑棋 2:白棋

int[][] array = new int[11][11];

//这里要注意:[第几个数组][下标]

array[1][2] = 1;

array[2][3] = 2;

//输出原始数据:

System.out.println("输出原始的数组：");

//使用增强型for循环来遍历二维数组

//语法:数组名称.for

for (int[] ints : array) {

//二维数组还要添加

//ints.for

for (int anInt : ints) {

//到这一步已经把array数组的元素赋值给了anInt，所以打印anInt即可

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

}

System.out.println();

}

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

//=========转换为稀疏数组========

//===第一步=== 获取有效值

int sum = 0;

//输入for i

for (int i = 0; i < 11; i++) {

for (int j = 0; j < 11; j++) {

if(array[i][j]!=0){

sum++;

}

}

}

System.out.println("获取的有效值为:"+sum);

//===第二步=== 创建稀疏数组

//创建的稀疏数组的 [几行][几列] //这里创建了一个(2+1)*3的表格来准备存放稀疏数组

int[][] array1 = new int[sum+1][3];//声明几个有效值再加1行写总的行列和总有效值

/*默认值为:0

*

* 0 0 0

* 0 0 0

* 0 0 0

* */

array1[0][0] = 11;//所要稀疏的数组的几行

array1[0][1] = 11;//所要稀疏的数组的几列

array1[0][2] = sum;//有效值

//到这里表格的头部(即第一行)就出来了

/* 总行 总列 总的有效值 这行是不打印的做参考

* 11 11 2

* 0 0 0

* 0 0 0

* */

//===第三步=== 遍历数组，将非0的值，存放在稀疏数组中

int count = 0;

for (int i = 0;i

for (int j = 0;j

//这里循环就能将稀疏数组填好

if(array[i][j]!=0){

//如果遍历到的值非0，那么把count赋值再自增

count++;

array1[count][0] = i;

//遍历到第count++个有效值时 :把有效值行的位置i赋值给稀疏数组中的(count，0)位置

/*

* 11 11 2

* i 0 0

* 0 0 0

* */

array1[count][1] = j;

//遍历到第count++个有效值时 :把有效值列的位置i赋值给稀疏数组中的(count，1)位置

/*

* 11 11 2

* i j 0

* 0 0 0

* */

array1[count][2] = array[i][j];

//遍历到第count++个有效值时 :把有效值,赋值给稀疏数组中的(count，2)位置

/*

* 11 11 2

* i j array1[i][j]

* i j array1[i][j]

* */

}

}

}

//第四步 输出稀疏数组

System.out.println("输出稀疏数组:");

for (int[] ints : array1) {

for (int anInt : ints) {

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

}

System.out.println();

}

/*

* 11 11 2

* 1 2 1

* 2 3 2

* */

//======还原数组======

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

System.out.println("稀疏数组还原为数组");

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

//====第一步====创建一个还原数组

//这里创建了一个数组，行为稀疏数组中的(0,0)，列为(0，1)，即new int[11][11]

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

//====第二步====进行赋值

for(int i = 1;i

//i初始值为1，是因为0是头部文件的一行，所以不用取0

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

}

//====第三步====打印还原数组

System.out.println("打印还原数组:");

for(int i = 0;i

for(int j = 0;j

System.out.print(array2[i][j]+"\t");

}

System.out.println();

}

}

}

显示

C:\Users\夏天的风\Desktop\DEMO-XXZ\out\production\DEMO-XXZ Test.Test03

输出原始的数组：

00000000000

00100000000

00020000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

============================

获取的有效值为:2

输出稀疏数组:

11112

121

232

===========================

稀疏数组还原为数组

===========================

打印还原数组:

00000000000

00100000000

00020000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

00000000000

Process finished with exit code 0

数组篇完结

😃

新增单词

1

team

团队

Tm~

数组比作—>足球团队，(即组成元素)数据—>队员

2

data

数据

达塔~

datatype[]定义一个数组

3

length

长度

楞夫~

(数据名称).length | 可以获取该数组的长度即多少个数据

4

arrays

数组

额瑞兹~

5

reverse

反转

瑞沃丝~

reverse(int[] array)

6

result

结果

瑞肉t~

return result

7

sort

排序

索T~

Arrays.sort(a);//数组进行排序 升序||打印数组；Arrays.toString(a)；||填充数组；Arrays.fill(a,0,0,0)

8

temp

临时|变量

time噗~

9

falg

标记

弗莱戈~

通过falg标识位减少没有意义的比较 boolean flag = false;

10

row

行

肉~

11

col

列

扣~

12

value

值

VLU~

13

count

数

炕T~

int count = 0;

14

Fill

填充

菲尔

Arrays.fill(a,0,4,0);