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