数组的定义与使用

文章目录

  • [一 数组的基本概念](#一 数组的基本概念)
    • [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下标从头和尾开始查找

  1. i遇到偶数停下来,j遇到奇数停下来

  2. 此时i下标和j下标进行交换,i++ j- -

  3. 直到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列

相关推荐
三角叶蕨5 小时前
Redis极简入门 整合springboot
java·redis
稻草猫.5 小时前
Java网络编程套接字
java·后端·java-ee·idea
云泽8087 小时前
函数模板与类模板:C++泛型编程核心解析
java·开发语言·c++
缺点内向11 小时前
Java:创建、读取或更新 Excel 文档
java·excel
带刺的坐椅11 小时前
Solon v3.4.7, v3.5.6, v3.6.1 发布(国产优秀应用开发框架)
java·spring·solon
四谎真好看13 小时前
Java 黑马程序员学习笔记(进阶篇18)
java·笔记·学习·学习笔记
桦说编程13 小时前
深入解析CompletableFuture源码实现(2)———双源输入
java·后端·源码
java_t_t13 小时前
ZIP工具类
java·zip
lang2015092813 小时前
Spring Boot优雅关闭全解析
java·spring boot·后端