文章目录
- [一 数组的基本概念](#一 数组的基本概念)
-
- [1.1 什么是数组](#1.1 什么是数组)
- [1.2 数组的创建及初始化](#1.2 数组的创建及初始化)
- [1.3 数组的基本使用](#1.3 数组的基本使用)
- [二 数组是引用类型](#二 数组是引用类型)
-
- [2.1 初识JVM的内存分布](#2.1 初识JVM的内存分布)
- [2.2 基本类型变量和引用类型变量](#2.2 基本类型变量和引用类型变量)
- [2.3 再谈引用变量](#2.3 再谈引用变量)
- [2.4 认识null](#2.4 认识null)
- [三 数组的应用场景](#三 数组的应用场景)
-
- [3.1 保留数据](#3.1 保留数据)
- [3.2 作为函数的参数](#3.2 作为函数的参数)
- [3.3 作为函数的返回值](#3.3 作为函数的返回值)
- [四 数组数据工具类Arrays与数组练习](#四 数组数据工具类Arrays与数组练习)
-
- [4.1 数组转字符串](#4.1 数组转字符串)
- [4.2 数组拷贝](#4.2 数组拷贝)
- [4.3 查找数组中的指定元素(顺序查找)](#4.3 查找数组中的指定元素(顺序查找))
- [4.4 查找数组中指定元素(二分查找)](#4.4 查找数组中指定元素(二分查找))
- [4.5 数组排序(冒泡排序)](#4.5 数组排序(冒泡排序))
- [4.6 数组逆序](#4.6 数组逆序)
- [五 精选题目](#五 精选题目)
-
- [1 实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素乘以 2 , 并设置到对应的数组元素上.](#1 实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素乘以 2 , 并设置到对应的数组元素上.)
- [2 奇数位于偶数之前](#2 奇数位于偶数之前)
- [3 两数之和](#3 两数之和)
- [4 只出现一次的数字](#4 只出现一次的数字)
- [5 多数元素](#5 多数元素)
- [6 存在连续三个奇数的数组](#6 存在连续三个奇数的数组)
- [六 二维数组](#六 二维数组)
-
- [6.1 普通二维数组](#6.1 普通二维数组)
- [6.2 不规则的二维数组](#6.2 不规则的二维数组)
一 数组的基本概念
1.1 什么是数组
数组可以看成是相同类型元素的一个集合。在内存中是一个连续的空间
注意:
1· 数组的空间是连在一起的
2.每个空间都有自己的编号,起始位置的编号为0,即数组的下标。
1.2 数组的创建及初始化
java
T[] 数组名 = new T[N];
T:表示数组中存放元素的类型
T[]表示数组的类型
N:表示数组的长度
java
int[] arr1 = new int[10];//创建一个容纳10个int类型元素的数组
double[] arr2 = new double[5]//创建一个可以容纳5个double类型元素的数组
String[] arr 3 = new String[3]//创建一个可以容纳3个字符串元素的数组
数组的初始化
数组的初始化主要分为动态初始化 以及静态初始化
1 动态初始化:在创建数组时,直接指定数组元素的个数
java
int[] arr = new int[10];
2 静态初始化:在创建数组时不直接指定数组元素的个数,而直接将具体的数据内容进行指定
语法格式:T[]数组名称={data1,data2,data3,...,datan};
java
int[] arr1 = new int[]{1,2,3,4,5};
double[] arr2 = new double[]{1.0,2.0,3.0,4.0,5.0};
String[] arr3 = new String[]{"hello","Java","!!!"};
注意事项:
1 静态初始化虽然没有指定数组的长度 ,编译器在编译时会根据{}中元数的个数来确定数组的长度;
2 静态初始化时,{}中的数据类型必须与{}前的数据类型一致;
3 静态初始化可以简写,省去后面的new T[];
java
int[] arr1 = {1,2,3,4,5};
double[] arr2 = {1.0,2.0,3.0,4.0,5.0};
String[] arr3 = {"hello","Java","!!!"}
静态和动态初始化也可以分成两步
java
int[] arr1;
arr1 = new int[10];
int[] = arr2;
arr2 = new int[]{10,20,30};
//注意省略格式不可以拆分,否则编译失败,这种方式只能在定义的同时初始化
//int[] arr3;
//arr3 = {1,2,3};
如果数组完成初始化后,未显式赋值的元素会有默认值
如果数组中存储元素类型为基型类型,默认值为基型类型对应的默认值,比如:
类型 | 默认值 |
---|---|
byte | 0 |
short | 0 |
int | 0 |
long | 0 |
float | 0.0f |
double | 0.0 |
char | /u0000 |
boolean | false |
如果数组存储元素类型为引用类型,默认值为null;
java
String[] words = new String[3];
1.3 数组的基本使用
数组在内存中是一段连续的空间,空间的编号都是从0开始的,依次递增,该编号称为数组的下标,数组可以通过下标访问其任意位置的元素。比如:
java
public class Test {
public static void main(String[] args) {
int[] arr = new int[]{1, 2, 3, 4, 5};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[3]);
System.out.println(arr[4]);
//也可以通过{}对数组中的元素进行修改
arr[0] = 100;
System.out.println(arr[0]);
}
}
注意事项:
1 数组是一段连续的内存空间,因此支持随机访问,即通过下标访问快速访问数组中任意位置的元素
2 下标从0开始,介于[0,N)之间不包含N,N为元素个数,不能越界,否则会报出下标越界异常
java
public class Test {
public static void main(String[] args) {
int[] arr = {1,2,3,4};
System.out.println(arr[4]);
}
}

遍历数组
所谓遍历是指将数组中的所有元素都访问一遍,访问是指对数组中的元素进行某种操作。比如:打印
java
public class Test {
public static void main(String[] args) {
int[] arr = new int[]{1, 2, 3, 4, 5};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[3]);
System.out.println(arr[4]);
}
}
上述代码可以起到对数组中元素遍历的⽬的,但问题是:
1 如果数组中增加了⼀个元素,就需要增加⼀条打印语句如果输⼊中有100个元素,就需要写100个打印语句
2 如果现在要把打印修改为给数组中每个元素加1,修改起来⾮常⿇烦。
3 通过观察代码可以发现,对数组中每个元素的操作都是相同的,则可以使⽤循环来进⾏打印。
java
public class Test {
public static void main(String[] args) {
int[] arr = {1,2,3,4};
//数组名+点号+length获取数组的长度
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i] + " ");
}
}
}
也可以用for-each遍历数组
java
public class Test {
public static void main(String[] args) {
//for-each 增强for循环
for(int x : arr){
System.out.print(x + " ");
}
}
也可以以用
java
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
//把数组以字符串的形式进行进行输出[1,2,3,4]
String ret = Arrays.toString(arr);//返回值是String,所以要用String类型接收
System.out.println(ret);
}
}
二 数组是引用类型
2.1 初识JVM的内存分布
内存是一段连续的内存空间,主要用来存储程序运行时数据的。比如:
1 程序运行时代码需要加载到内存;
2 程序运行产生的中间数据要存放在内存;
3 程序中的常量也要保存;
4 有些数据可能需要长时间存储,而有些数据当方法运行结束后就要销毁;
如果对内存中存储的数据不加区分的随意存储,那些内存管理起来将会非常麻烦;
因此JVM也对所使用的内存按照功能的不同进行了划分

1 程序计数器 :(PC Register):只是一个很小的空间,保存下一条执行的指令的地址 ;
2 虚拟机栈 (JVM Stack):与方法调用相关的一些信息,每个方法在执行时,都会先创建一个栈帧 ,栈帧中包含有:局部变量表,操作数栈,动态链接,返回地址 以及其他的一些信息,保存的都是与方法执行时相关的一些信息。比如:当方法运行结束后。栈帧就被销毁了,即栈帧中保存的数据也被销毁了 。
3 本地方法栈 :(Native Method Stack):本地方法栈与虚拟机栈的作用类似,只不过保存的内容是Native方法的局部变量。在有些版本的JVM实现中(例如Hotspot),本地方法栈与虚拟栈是一起的
4 堆(Heap):JVM所管理的最大内存区域,使用new创建对象都是在堆上保存 (例如前面的new int[]{1,2,3,4}),堆是随着程序开始运行而创建,随着程序的退出而销毁,堆中的数据开始运行而创建,随着程序的退出而销毁,堆中的数据只要还在使用,就不会被销毁 。
5 方法区 (Method Area):用于存储已被虚拟机加载的类信息,常量,静态变量,即时编译器编译后的代码等数据。方法编译出的字节码保存在这个区域
2.2 基本类型变量和引用类型变量
基本数据类型创建的变量,称为基本变量,该变量空间中直接存放的是其所对应的值。
而引用类型数据创建的变量,一般称为对象的引用,其空间存储的是对象所在空间的地址
java
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 20;
int[] array = {1,2,3,4,5};
}
}
在上述代码中,a,b,array,都是函数内部的变量。因此其空间都在main方法对应的栈帧中分配。
a,b是基本类型变量(内置类型)的变量,因此其空间中保存的就是该变量初始化的值。
array是数组类型的引用变量,其内部保存的内容可以简单理解成是数组在堆空间中的首地址

从上图可以看到,引用类型变量并不直接存储对象本身,可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址,引用类型变量便可以去操作对象。有点类似C语言中的指针,但是Java中引用要比指针的操作更简单。
2.3 再谈引用变量
java
public class Test {
public static void main(String[] args) {
int[] array1 = new int[3];
array1[0] = 10;
array1[1] = 20;
array1[2] = 30;
int[] array2 = new int[]{1,2,3,4,5};
array2[0] = 100;
array2[1] = 200;
array1 = arr2;//意味着array1这个引用指向了array2这个引用所指向的对象
array1[2] = 300;
array2[3] = 400;
array2[4] = 500;
for(int i = 0;i < array2.length;i++){
System.out.println(array2[i]);//打印100~500
}
}
}
2.4 认识null
java
public static void main(String[] args) {
int[] array1 = null;//array1这个引用不指向任何对象
System.out.println(array1);//打印null
}
java
public static void main(String[] args) {
int[] array1 = null;//array1这个引用不指向任何对象
System.out.println(array1.length);//会抛出空指针异常
}

null的作用类似于C语言中的NULL(空指针),都是表示一个无效的内存位置,因此不能对这个内存进行任何读写操作。一旦尝试读写,就会抛出NullpointerException
注意:Java中并没有约定null和0号地址的内存有任何关联。
三 数组的应用场景
3.1 保留数据
java
public static void main(String[] args) {
int[] array = {1, 2, 3};
for(int i = 0; i < array.length; ++i){
System.out.println(array[i] + " ");
}
}
3.2 作为函数的参数
java
public class Test {
public static void func(int x){
x = 10;
System.out.println("x= " + x);
}
public static void main(String[] args) {
int num = 0;
func(num);
System.out.println("num= " + num);
}
}
//执行结果
x=10
num=0
发现在func方法中修改形参x的值,不影响实参num的值。
参数传递数组类型(引用数据类型)
java
import java.util.Arrays;
public class Test {
public static void test1(int[] array) {
array = new int[]{10, 20, 30, 40, 50};
}
public static void test2(int[] array){
array[0] = 99;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
test1(array);
//test2(array);
System.out.println(Arrays.toString(array));
}
}
因为test2方法内部修改数组的内容,方法外部的数组内容也发生改变
因为数组是引用类型,按照引用类型来进行传递,是可以修改其中的内容的
总结:所谓的"引用"本质上只是存了一个地址,Java将数组设定为引用类型,这样的话后续进行数组参数传参。其实只是将数组的地址传入函数形参中,这样可以避免对整个数组的拷贝(数组可能比较长,那么拷贝开销就会很大)
3.3 作为函数的返回值
java
public class Test {
public static int[] func2(){
return new int[]{1,2,3,4,5};
}
public static void print(int[] array){
for(int i = 0;i < array.length;i++){
System.out.print(array[i] + " ");
}
}
public static void main(String[] args) {
int[] r = func2();
print(r);
}
}
四 数组数据工具类Arrays与数组练习
4.1 数组转字符串
java
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
}
}
//运行结果
[1, 2, 3, 4, 5]
使用这个方法后续打印数组就更方便些。
Java中提供来java.util.Arrays包,其中包括了一些操作数组的常用方法。
自己也可以按照这个数组数据工具类Arrays代码来写出一个函数和这个函数的执行结果相同
java
public class Test {
public static String myToString(int[] array){
String ret = "[";
for(int i = 0;i < array.length;i++) {
ret += array[i];
if(i != array.length-1){
ret += ",";
}
}
ret += "]";
return ret;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
String ret = myToString(array);
System.out.println(ret);
}
}
4.2 数组拷贝
java
(1)public static void main1(String[] args) {
int[] array = {1,2,3,4,5};
int[] copy = new int[array.length];
for(int i = 0;i < array.length;i++){
copy[i] = array[i];
}
for(int x : copy) {
System.out.print(x + " ");
}
System.out.println();
}
public static void main2(String[] args) {
//这个代码不是拷贝,只是指向array引用所指向的对象.
int[] array = {1,2,3,4,5};
int[] array2 = array;
}
(2)public static void main3(String[] args) {
int[] array = {1,2,3,4,5};
int[] copy = Arrays.copyOf(array,array.length);//参数是拷贝哪个数组,拷贝多长.
for(int x : copy) {
System.out.print(x + " ");
}
System.out.println();
}
(3)public static void main4(String[] args) {
int[] array = {1,2,3,4,5};
int[] copy = new int[array.length];
//帮我们完成了拷贝
System.arraycopy(array, 0, copy, 0,array.length);/*参数是你要拷贝的数组,从被拷贝的数组的哪开始,拷贝数组,拷贝数组的哪
开始,被拷贝数组长度和拷贝数组长度的最小值*/
for(int x : copy) {
System.out.print(x + " ");
}
System.out.println();
}
public static void main5(String[] args) {
int[] array = {1,2,3,4,5};
int[] copy = Arrays.copyOf(array,array.length*2);//相当于扩容
array = copy;
for(int x : copy) {
System.out.print(x + " ");
}
System.out.println();
System.out.println(Arrays.toString(array));
}
public class Test {
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
//Java当中,一般下标给定范围的时候[1,3)
int[] copy = Arrays.copyOfRange(array,1,3);//你要拷贝的数组,从哪开始,到哪结束
System.out.println(Arrays.toString(copy));//输出[2,3]
}
}
注意 :数组当中存储的是基本类型数据时,不论怎么拷⻉基本都不会出现什么问题,但如果存储的是
引⽤数据类型,拷⻉时需要考虑深浅拷⻉的问题,关于深浅拷⻉在后续详细给⼤家介绍。
4.3 查找数组中的指定元素(顺序查找)
给定一个数组,在给定一个元素,找出该元素在数组中的位置
java
public class Test {
public static int find(int[] array,int key){
for(int i = 0;i < array.length;i++){
if(array[i] == key){
return i;
}
}
return -1;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
int index = find(array,3);
if(index == -1){
System.out.println("没有找到你要找的数字");
}else{
System.out.println("找到你要找的数字!"+"该下标为 "+index);
}
}
}
4.4 查找数组中指定元素(二分查找)
针对有序数组,可以使用更高效的⼆分查找.
java
public class Test {
public static int binarySearch(int[] array,int key){
int left = 0;
int right = array.length-1;
while(left <= right){
int mid = left + (right - left) / 2;
if(array[mid] < key){
left = mid+1;
} else if (array[mid] == key) {
return mid;
}else{
right = mid-1;
}
}
return -1;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
int index = binarySearch(array,5);
if(index == -1){
System.out.println("未找到你要找的数字");
}else{
System.out.println("找到你要找的数字!"+"该下标是"+index);
}
}
}
也可以用Arrays.binarySearch来完成二分查找
java
public static void main(String[] args) {
int[]array = {1,2,3,4,5};
int index = Arrays.binarySearch(array,3);//可以整体二分查找,也可以局部二分查找
if(inde < 0){
System.out.println("未找到你要找的数字");
}else{
System.out.println("找到你要找的数字!"+"该下标是"+index);
}
}
4.5 数组排序(冒泡排序)
给定⼀个数组,让数组升序(降序)排序
算法思路
假设排升序:
1.将数组中相邻元素从前往后依次进行比较,如果前⼀个元素⽐后⼀个元素大,则交换,⼀趟下来后 最大元素就在数组的末尾
2.依次从上上述过程,直到数组中所有的元素都排列好
java
import java.util.Arrays;
public class Test {
public static void bubbleSort(int[] array){
for (int i = 0;i < array.length-1;i++){//5个数据,比较4趟就有序了
boolean flg = false;
for(int j = 0;j < array.length-1-i;j++){//每一趟比较的时候,j从0下标开始
if(array[j] > array[j+1]){ //每一趟比较比上一趟少1
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flg = true;
}
}
if(flg == false){
break;
}
}
}
public static void main(String[] args) {
int[] array = {1,23,45,54,22};
bubbleSort(array);
System.out.println("排序之后的数组"+ Arrays.toString(array));
}
//执行结果
排序之后的数组[1, 22, 23, 45, 54]
冒泡排序性能较低.Java中内置了更⾼效的排序算法
java
public static void main(String[] args){
int[] array = {1,23,45,54,22};
Arrays.sort(array,1,5);//可以局部也可以整体排序
System.out.println("排序之后的数组"+ Arrays.toString(array));
}
关于Arrays.sort 的具体实现算法,到时候我们会介绍很多种常见排序算法
4.6 数组逆序
给定⼀个数组,将⾥⾯的元素逆序排列. 思路 设定两个下标,分别指向第⼀个元素和最后⼀个元素.交换两个位置的元素. 然后让前⼀个下标⾃增,后⼀个下标⾃减,循环继续即可.
java
import java.util.Arrays;
public class Test {
public static String myToString(int[] array){
String ret = "[";
for(int i = 0;i < array.length;i++) {
ret += array[i];
if(i != array.length-1){
ret += ",";
}
}
ret += "]";
return ret;
}
public static void reverse(int[] array){
int i = 0;
int j = array.length-1;
while(i < j){
swap(array,i,j);
i++;
j--;
}
}
public static void swap(int[] array,int i,int j){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
reverse(array);
String ret = myToString(array);
System.out.println(ret);
}
}
补充Arrays.equals和Arrays.fill
java
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] array1 = {1,2,3,4,5};
int[] array2 = {2,3,4,5,6};
boolean flg = Arrays.equals(array1,array2);//判断两个数组是不是一样,返回值是boolean类型
System.out.println(flg);//false
System.out.println("==========fill========");
int[] array3 = new int[10];
//Arrays.fill(array3,9);//全部弄为9
Arrays.fill(array3,2,5,8);//部分弄为8,参数是你要填充的数组,fromIndex,toIndex,val
System.out.println(Arrays.toString(array3));
}
}
五 精选题目
1 实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素乘以 2 , 并设置到对应的数组元素上.
例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
java
import java.util.Arrays;
public class Main {
public static void transform(int[] array){
for(int i = 0;i < array.length;i++){
array[i] = array[i] * 2;
}
}
public static void print(int[] array){
System.out.println(Arrays.toString(array));
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
transform(array);
print(array);
}
}
2 奇数位于偶数之前
调整数组顺序使得奇数位于偶数之前。调整之后,不关心大小顺序。
如数组:[1,2,3,4,5,6]
调整后可能是:[1, 5, 3, 4, 2, 6]
思路:
1.定义i下标和j下标从头和尾开始查找
-
i遇到偶数停下来,j遇到奇数停下来
-
此时i下标和j下标进行交换,i++ j- -
-
直到i和j相遇
java
import java.util.Arrays;
public class Test {
//调整数组顺序使得奇数位于偶数之前。调整之后,不关心大小顺序。
//如数组:[1,2,3,4,5,6]
//调整后可能是:[1, 5, 3, 4, 2, 6]
public static void func(int[] array){
int i = 0;
int j = array.length-1;
while(i < j){
while(i < j && array[i] % 2 != 0){//遇到偶数停下来,要加上i < j的判断,不然全是奇数会数组越界
i++;
}
while(i < j && array[j] % 2 == 0){//遇到奇数停下来,,要加上i < j的判断,不然全是偶数会数组越界
j--;
}
swap(array,i,j);
}
}
public static void swap(int[] array,int i,int j){
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
func(array);
System.out.println(Arrays.toString(array));
}
}
3 两数之和
给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出和为目标值 target 的那两个整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1:
输入:nums = [2,7,11,15], target = 9
输出:[0,1]
解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。
java
import java.util.Arrays;
public class Test {
public static int[] twoIndex(int[] array,int target){
int[] temp = {-1,-1};//因为可能找不到相加为指定值两个数,没有哪个数组的下标为负数,初始化为-1,如果返回[-1,-1],那就说明没找到
for(int i = 0;i < array.length;i++){
for(int j = i + 1;j < array.length;j++){
if(array[i] + array[j] == target){
temp[0] = i;
temp[1] = j;
}
}
}
return temp;
}
public static void main(String[] args) {
int[] array = {2,7,11,15};
int[] ret = twoIndex(array,18);
System.out.println(Arrays.toString(ret));
}
}
4 只出现一次的数字
给定一个非空整数数组,除了某个元素只出现一次以外,其余每个元素均出现两次。找出那个只出现了一次的元素。
输入: [2,2,1]
输出: 1
输入: [4,1,2,1,2]输出: 4
思路
n ^ 0 = n
n ^ n = 0
java
public class Test {
public static int singleNum(int[] array){
int ret = 0;
for(int i = 0;i < array.length;i++){
ret ^= array[i];
}
return ret;
}
public static void main(String[] args) {
int[] array = {2,2,3,4,4};
int n = singleNum(array);
System.out.println(n);
}
}
5 多数元素
给定一个大小为 n 的数组,找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的,并且给定的数组总是存在多数元素。
示例 1:
输入:[3,2,3]
输出:3
示例 2:
java
输入:[2,2,1,1,1,2,2]
输出:2
工作原理
这段代码利用了多数元素的一个重要性质:如果一个元素在数组中出现的次数超过一半,那么在排序后的数组中,中间位置的元素一定是这个多数元素。
java
import java.util.Arrays;
public class Test {
public static int moreNum(int[] array){
Arrays.sort(array);
return array[array.length / 2];
}
public static void main(String[] args) {
int[] array = {2,2,2,5,4};
int ret = moreNum(array);
System.out.println(ret);
}
}
//运行结果为2
6 存在连续三个奇数的数组
给你一个整数数组 arr
,请你判断数组中是否存在连续三个元素都是奇数的情况:如果存在,请返回 true
;否则,返回 false
示例 1:
输入:arr = [2,6,4,1]
输出:false
解释:不存在连续三个元素都是奇数的情况。
示例 2:
输入:arr = [1,2,34,3,4,5,7,23,12]
输出:true
解释:存在连续三个元素都是奇数的情况,即 [5,7,23]
java
public class Test {
public static boolean function(int[] array){
int count = 0;
for(int i = 0;i < array.length;i++){
if(array[i] % 2 != 0) {
//遇到奇数了
count++;
if (count == 3) {
return true;
}
}else {
//遇到偶数了
count = 0;
}
}
return false;
}
public static void main(String[] args) {
int[] array = {2,7,2,1,2,3,5,7,10,2};
boolean flg = function(array);
System.out.println(flg);
}
}
六 二维数组
6.1 普通二维数组
二维数组本质上也就是一维数组,只不过每个元素又是一个一维数组。
基本语法
java
数据类型[][] 数组名称 = new 数据类型[行数][列数]{初始化数据};
行不可以省略,列可以省略
代码示例
java
public class Test {
public static void main(String[] args) {
int[][] array = {{1,2,3},{4,5,6}};//二维数组定义的第一种方式(省略)
int[][] array2 = new int[][]{{1,2,3},{4,5,6}};//数组定义的第二种方式
int[][] array3 = new int[2][3];//数组定义的第三种方式
// System.out.println(array[1][1]);//打印5
for(int i = 0;i < array.length;i++){
for (int j = 0;j < array[i].length;j++){
System.out.print(array[i][j] + " ");
}
System.out.println();
}
System.out.println("=====================");
for(int[] tempArray : array){
for(int x : tempArray){
System.out.print(x + " ");
}
System.out.println();
}
System.out.println("================");
System.out.println(Arrays.deepToString(array));//注意打印二维数组用Arrays.deepToString()
}
}

6.2 不规则的二维数组
不规则的二维数组指的是,二维数组的列在定义的时候,没有确定。(二维数组列可以省略)
java
int[][] array = new int[2][];
array[0] = new int[3];
array[1] = new int[5];
上述二维数组就不是一个规则的二维数组,第一行有3列,第二行有5列