java 一维数组的基本用法【详解篇6】

最新推荐文章于 2022-11-06 08:23:45 发布
最新推荐文章于 2022-11-06 08:23:45 发布
阅读量520 收藏 6
点赞数 3
分类专栏： 编程语言基础 java篇 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59157222/article/details/119723642
版权

文章目录

什么是数组？

数组本质上就是让我们能 “批量” 创建相同类型的变量.它是一块连续的内存，它存放的是一组相同数据类型的集合。

  • 例如:
    如果需要表示两个数据, 那么直接创建两个变量即可 int a; int b
    如果需要表示五个数据, 那么可以创建五个变量 int a1; int a2; int a3; int a4; int a5;
    但是如果需要表示一万个数据, 那么就不能创建一万个变量了. 这时候就需要使用数组, 帮我们批量创建.
  • 注意： 在 Java 中, 数组中包含的变量必须是相同类型

如何创建数组？

基本语法

  • 定义数组的第一种方式：静态初始化（这种方式用的最多）

数据类型[] 数组名称 = { 初始化数据 };

如：int[] array1 = {1, 2, 3};

注意事项:

int后的[]里面不能写东西，数据也不可以

静态初始化的时候, 数组元素个数和初始化数据的格式是一致的.

  • 定义数组的第二种方式 ：动态初始化

数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };

如：int[] array2 = new int[]{1, 2, 3};

注意：等号前面的int后的[]里面不能写东西，数据也不可以.

  • 定义数组的第三种方式：初始化数组长度

如：int[] array2 = new int[10];

注意：[10]表示初始化数组长度为10，默认元素为0

  • 其实数组也可以写成int arr[] = {1, 2, 3};
    这样就和 C 语言更相似了. 但是我们还是更推荐写成 int[] arr 的形式. 因为int和 [] 是一个整体.

数组的使用

代码示例1：获取长度（数组名.length） 和 访问元素

public class TestArray1 {
    public static void main1(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        //1.获取数组长度:arr.length
        System.out.println("length=" + arr.length);//6
        //2.打印数组中的每个元素：
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //3.访问数组中下标为几元素
        System.out.println("arr[0]=" + arr[0]);//1
        System.out.println("arr[4]=" + arr[4]);//5
        arr[4] = 100;
        System.out.println("修改后的arr[4]=" + arr[4]);//100

打印结果：image-20210815205900661

注意事项：

  1. 使用 数组名.length 能够获取到数组的长度; . 这个操作为成员访问操作符. 后面在面向对象中会经常用到.
  2. 使用 [] 按下标取数组元素. 需要注意, 下标从 0 开始计数
  3. 使用 [] 操作既能读取数据, 也能修改数据.
  4. 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常。

代码示例2:测试下标越界

  public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        System.out.println(arr[4]);

打印结果：使用数组一定要谨防下标越界。image-20210815210528165

Java中打印数组的方式

方式1：使用for循环 遍历数组

所谓 “遍历” 是指将数组中的所有元素都访问一遍, 不重不漏. 通常需要搭配循环语句.

代码示例：

 public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");//打印结果:1 2 3 4 5 6
        }

    }

方式2：使用for-each循环遍历数组，也叫增强for循环

代码示例：

public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        for (int x : arr) {
            System.out.print(x+" ");//打印结果:1 2 3 4 5 6
        }
  • for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错.
  • 冒号左边放的是这个数组里面存放的元素的类型所定义的变量，如上面的数组是int类型，给他一个变量x,代表每一个元素都是整型的，每一个元素都保存到x里面，通过遍历数组打印，保存一个就打印一个;
  • 冒号的右边放的是数组名称，它里面放的是一组元素。

讨论：for循环和for-each循环的区别是什么？

答：用for循环可以拿到数组的下标，但for-each循环不可以，因此如果只是打印数组元素，此时不需要使用下标，所以二者都可以使用，但如果跟下标扯上关系就是只能使用for循环，如：将下标为4的元素乘2，arr[4]*2。

方式3：使用Arrays.toString()方法

Arrays：是一个帮助我们操作数组的工具类，它的包是import java.util.Arrays;
它通过调用toString方法，将当前的数组转换为字符串的形式进行输出，toString可以将任意类型的数组都转化为字符串的形式，它的返回值是string因此需要用String 来接收。

image-20210815211754438

image-20210815211833051

代码示例：

public static void main5(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        String ret = Arrays.toString(arr);//用String 来接收
        System.out.println(ret);
        //也可写成一行的形式打印
        System.out.println(Arrays.toString(arr));
    }

打印结果：但方式3只是用在打印数组，如若要操作数组还得使用方式1和方式2

image-20210815212023214

初识 JVM 内存区域划分

image-20210815215215877

JVM 的内存被划分成了几个区域, 如图所示:

image-20210815215853098

  • 程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址.

  • 虚拟机栈(JVM Stack): 重点是存储局部变量表(当然也有其他信息). 我们刚才创建的 int[] arr 这样的存储地址的引用就是在这里保存.

  • 本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是一起的.

  • 堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} )

  • 方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据. 方法编译出的的字节码就是保存在这个区域.

  • 运行时常量池(Runtime Constant Pool): 是方法区的一部分, 存放字面量(字符串常量)与符号引用. (注意 从 JDK1.7 开始, 运行时常量池在堆上).

Native 方法:

  • JVM 是一个基于 C++ 实现的程序. 在 Java 程序执行过程中, 本质上也需要调用 C++ 提供的一些函数进行和操作系统底层进行一些交互. 因此在 Java 开发中也会调用到一些 C++ 实现的函数.
  • 这里的 Native 方法就是指这些 C++ 实现的, 再由 Java 来调用的函数.
  • 我们发现, 在上面的图中, 程序计数器, 虚拟机栈, 本地方法栈被很多个原谅色的, 名叫 Thread(线程) 的方框圈起来了,

并且存在很多份. 而 堆, 方法区, 运行时常量池, 只有一份. (关于线程, 这是我们后面重点讲解的内容).

关于上面的划分方式, 我们随着后面的学习慢慢理解. 此处我们重点理解 虚拟机栈 和 堆.

局部变量和引用保存在栈上, new 出的对象保存在堆上.

堆的空间非常大, 栈的空间比较小.

堆是整个 JVM 共享一个, 而栈每个线程具有一份(一个 Java 程序中可能存在多个栈).

数组作为方法的参数

基本用法

代码示例: 打印数组内容

 public static void printArray(int[] array1) {
        for (int x : array1) {
            System.out.print(x+" ");//打印结果：1 2 3 4 5
        }
    }
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        printArray(array);
    }

  • 在这个代码中int[] a 是函数的形参, int[] arr 是函数实参.

  • 如果需要获取到数组长度, 同样可以使用 a.length。

理解引用类型

代码示例: 参数传内置类型

 public static void func(int x) {
        x = 10;
        System.out.println("x=" + x);//x=10
    }
    public static void main7(String[] args) {
        int num = 0;
        func(num);
        System.out.println("num=" + num);//num=0
    }

执行结果：x=10 num=0;
我们发现, 修改形参 x 的值, 不影响实参的num的值。

代码示例: 参数传数组类型

  public static void func(int[] a) {
        a[1] = 10;
        System.out.println("a[1]=" + a[1]);//a[1]=10
    }
    public static void main(String[] args) {
        int[] arr = {2, 3, 4, 5};
        func(arr);
        System.out.println("arr[1]=" + arr[1]);//arr[1]=10
    }

运行结果：a[1]=10 arr[1]=10
我们发现, 在函数内部修改数组内容, 函数外部也发生改变.
此时数组名 arr 是一个 “引用” . 当传参的时候, 是按照引用传参。

这里我们要先从内存开始说起.
如何理解内存?
内存就是指我们熟悉的 "内存". 内存可以直观的理解成一个宿舍楼. 有一个长长的大走廊, 上面有很多房间.
每个房间的大小是 1 Byte (如果计算机有 8G 内存, 则相当于有 80亿 个这样的房间).
每个房间上面又有一个门牌号, 这个门牌号就称为 地址
那么啥又是引用?
什么是引用?
引用相当于一个 "别名", 也可以理解成一个指针.
创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址.
总结: 所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实
只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大)


   public static void main06(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5, 6};
        int[] array2 = new int[10];
        int[] array3 = new int[]{1, 2, 3, 4, 5, 6};
    }

看图理解引用image-20210815214032060

什么是对象？对象是真正意义上存在的实体。

画图理解引用二

image-20210815214255436

代码示例:交换数组的0号下标和1号下标

 public static void swap(int[] array) {
        int tmp = array[0];
        array[0] = array[1];
        array[1] = tmp;
    }
    public static void main006(String[] args) {
        int a = 10;
        int b = 11;
        int[] array = {a, b};
        System.out.println("交换前：" + array[0] + " " + array[1]);
        swap(array);
        System.out.println("交换后：" + array[0] + " " + array[1]);
    }

打印结果：image-20210815214504128

探讨一个问题：
    public static void main07(String[] args) {
        int[] array1 = {1, 2, 3, 4, 5, 6};
        int[] array2 = array1;//这样写是不是代表array2这个引用指向array1这个引用呢？不是
        //这样写的意思是array2这个引用指向了array1这个引用所指的对象
        //总结：引用不能指向引用，引用只能指向另外一个引用所指的对象
    }

认识null

代码示例：null在java中表示”空引用“，也就是一个无效的引用,代表他不指向任何对象。

public static void main9(String[] args) {
        int[] arr = null;
        System.out.println(arr[0]);

打印结果：image-20210815214802642

注意：

  • null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作. 一旦尝试读写, 就会抛出 NullPointerException.（空指针异常）；

  • Java 中并没有约定null和0号地址的内存有任何关联。

  • 如果以后通过null访问尝试访问属性的时候就会报出空指针异常的错误。

  • 引用类型如果不知道它将来指向哪个对象，那么初始化的时候就把它初始化为null

数组作为方法的返回值

在C语言里面数组是不能作为返回值的而在java里面数组是可以作为返回值的
让数组扩大两倍的两种方式

代码示例: 写一个方法, 将数组中的每个元素都*2 ( 直接修改原数组的方式)

  public static void printArray1(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");

        }
    }
    public static void tranform(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] * 2;
        }
    }

    public static void main10(String[] args) {
        int[] arr = {1, 2, 4, 6};
        tranform(arr);
        printArray1(arr);
    }

打印结果：image-20210815220746988

提示：这个代码固然可行, 但是破坏了原有数组. 有时候我们不希望破坏原数组, 就需要在方法内部创建一个新的数组, 并由方法返回出来.

代码示例：写一个方法, 将数组中的每个元素都*2 (返回一个新的数组)(第五个：2:56:00画图讲解)

 public static void printArray3(int[] arr1) {
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] *= 2;
        }
    }
    public static int[] tranform1(int[] arr2) {//进入这个函数,返回值是一个数组
        int[] ret = new int[arr2.length];//new一个新的数组
        for (int i = 0; i < arr2.length; i++) {
            ret[i] = arr2[i] * 2;
        }
        return ret;
    }
    public static void main(String[] args) {
        int[] arr = {1, 2, 4, 6};
        System.out.println("执行 printArray3之前arr数组" + Arrays.toString(arr));
        printArray3(arr);
        System.out.println("执行 printArray3之后arr数组" + Arrays.toString(arr));

        System.out.println("执行 tranform1之前arr数组" + Arrays.toString(arr));
        int[] ret = tranform1(arr);
        printArray3(ret);
        System.out.println("执行 tranform1之后arr数组" + Arrays.toString(arr));
        System.out.println("执行 tranform1之后，返回的数组" + Arrays.toString(ret));
    }

打印结果：image-20210815220952784

注意：由于数组是引用类型, 返回的时候只是将这个数组的首地址返回给函数调用者, 没有拷贝数组内容, 从而比较高效.
在java当中数组就是一个对象，只要是一个对象，它的内存就在堆上

数组练习

练习1：数组转字符串
  public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        String newArr = Arrays.toString
  }

打印结果：image-20210815221342957

接练习1：实现一个自己版本的数组转字符串
public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        String ret = toString(arr);
        System.out.println(ret);//打印方式1
        System.out.println(toString(arr));//打印方式2
    }
    public static String toString(int[] arr) {
        if (arr == null) {
            return null;
        }
        if (arr.length == 0) {
            return "";
        }
        String ret = "[";
        for (int i = 0; i < arr.length; i++) {
            ret += arr[i];  //借助string+=进行拼接字符串
            if (i != arr.length - 1) {//除了最后一个元素之外，其他元素后面都要加上”,“
                ret += ",";//在拼上一个逗号
            }
        }
        ret += "]";
        return ret;
    }

打印结果：image-20210815221549993

练习2:数组的四种拷贝方式（遍历数组元素，拷贝到另外一个新的数组）
方式1：使用for循环进实现数组拷贝
//不使用函数的方法进行数组拷贝
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8};
        int[] newArray = new int[array.length];
        System.out.println(Arrays.toString(newArray));//拷贝之前打印一下，拷贝之前默认都为0
        for (int i = 0; i < array.length; i++) {//遍历原来的数组
            newArray[i] = array[i];
        }
        System.out.println(Arrays.toString(newArray));//拷贝之后打印一下
    }

打印结果：image-20210815221757815

 //使用函数的方法通过for循环进行数组拷贝
    public static int[] copyArray(int[] array) {
        int[] newArray = new int[array.length];
        for (int i = 0; i < array.length; i++) {//遍历原来的数组
            newArray[i] = array[i];
        }
        return newArray;//函数有返回值
    }
    public static void main(String[] args) {
        int[] array1={1,2,3,4,5,6,7,8};
        int[] ret=copyArray(array1);//返回值是int[] ,所以要用它来接收
        System.out.println(Arrays.toString(ret));//拷贝之后
    }
    //注意：建议不要在子函数进行打印

打印结果：image-20210815221859341

方式2：使用数组工具类Arrays.copyOf()实现数组拷贝
 public static void main(String[] args) {
        int[] array={1,2,3,4,5,6,7,8};
        int[] newArray=Arrays.copyOf(array,array.length);
        System.out.println("newArr:"+Arrays.toString(newArray));

       array[0]=10;
       System.out.println("arr:"+Arrays.toString(array));
       System.out.println("newArr:"+Arrays.toString(newArray));

        //拷贝数组某个区间范围使用Arrays.copyOfRange
        int[] newArr2=Arrays.copyOfRange(array,2,4);//[2,4)
        System.out.println("newArr2："+Arrays.toString(newArr2));
    }

打印结果：image-20210815222230887

注意：java当中看到有from to这样一个范围，一般情况都是左闭右开的。

方式3：借助System.arraycopy()进行拷贝
 /*  源码： public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
     源码的意思是：从src（源头）的srcPos开始拷贝，拷贝到dest（目的地）的destPos位置，拷贝的长度是 length*/

    /*源码中的native表示本地方法，它的特点是
    * 1.是由C/C++代码实现的
    * 2.速度很快
    * 3.运行是在本地方法栈*/

public static void main15(String[] args) {
    int[] array={1,2,3,4,5};
    int[] copy=new int[array.length];//自己定义一个copy数组
    System.arraycopy(array,0,copy,0,array.length);//进行拷贝
    System.out.println(Arrays.toString(copy));//打印结果：[1,2,3,4,5]
}
方式4：调用对象的clone克隆方法
public static void main015(String[] args) {
    int[] array={1,2,3,4,5,6};
    int[] ret=array.clone();//调用克隆，就会产生array的对象的副本，然后给ret
    System.out.println(Arrays.toString(ret));
}

注意一个问题：

public static void main016(String[] args) {
    int[] array={2,4,6,8,10};
    int[] ret=array;//这样写是不是拷贝？不是，它只是代表赋值
    System.out.println(Arrays.toString(ret));

注意事项: 相比于 ret=array 这样的赋值, copyOf 是将数组进行了 深拷贝, 即又创建了一个数组对象, 拷贝原有数组中的所有元素到新数组中. 因此, 修改原数组, 不会影响到新数组.

画图理解是深拷贝、浅拷贝？

image-20210816011954822

image-20210816012023116

image-20210816012103959

练习3： 找数组中的最大元素

要求：给定一个整型数组, 找到其中的最大元素 (找最小元素同理)

public static void main16(String[] args) {
       int[] arr={1,2,3,4,5,6};
       int ret=max(arr);
       System.out.println(ret);

       System.out.println("max="+max(arr));
    }
    public static int max(int[] arr){
       int max=arr[0];//从1下标开始
       for(int i=1;i<arr.length;i++){
           if(arr[i]>max){//从1下标开始，跟max进行比较
               max=arr[i];
           }
       }
       return max;
       //类似于 "打擂台" 这样的过程. 其中 max 变量作为 擂台, 比擂台上的元素大, 就替换上去, 否则就下一个对
    }

打印结果：image-20210815223024527

练习4：求数组中元素的平均值

要求：给定一个整型数组, 求平均值

 public static void main17(String[] args) {
        int[] arr={2,4,6,8,9};
        System.out.println(avg(arr));
    }
    public static double avg(int[] arr){//求平均值可能结果为小数，注意返回值为double类型
       int sum=0;
       for (int x:arr){
           sum+=x;
       }
       return (double)sum/(double)arr.length;
    }

打印结果：image-20210815223121922

练习5： 查找数组中指定元素(顺序查找)

要求：给定一个数组, 再给定一个元素, 找出该元素在数组中的位置.

 public static void main18(String[] args) {
        int[] arr={2,4,6,8,9};
        System.out.println(find(arr,9));
    }
    public static int find(int[] arr,int key){//在数组当中找关键字key,找到返回下标，找不到返回-1
       for(int i=0;i< arr.length;i++){
           if(arr[i]==key){
               return i;
           }
       }
       return -1;//表示没找到
    }

打印结果：image-20210815223256970

练习6：查找数组中指定元素(二分查找）
针对有序数组, 可以使用更高效的二分查找.
啥叫有序数组?
有序分为 "升序" 和 "降序" 如 1 2 3 4 , 依次递增即为升序. 如 4 3 2 1 , 依次递减即为降序.
以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否则就去右边找.

image-20210815223841078

 public static void main19(String[] args) {
        int[] arr={1,2,3,4,5,6,7,8,9};
        System.out.println(binarySearch(arr,6));
    }
    public static int binarySearch(int[]arr,int toFind){
        int left=0;
        int right=arr.length-1;
        while(left<=right){
            int mid=(left+right)/2;
            if(toFind<arr[mid]){
                //去左侧区间找
                right=mid-1;
            }else if(toFind>arr[mid]){
                //去右侧区间找
                left=mid+1;
            }else{
                //相等，说明找到了
                return mid;
            }
        }
        return -1;//循环结束，没找到
    }

打印结果：image-20210815223952993

接练习6：感受二分查找的效率
 static int count=0;//创建一个成员变量，记录二分查找循环次数
    public static void main(String[] args) {
        int[] arr=makeBigArray();
        int ret=binarySearch1(arr,9999);
        System.out.println("ret="+ret+","+"count="+count);
    }
    public static int[] makeBigArray(){
        int[] arr=new int[10000];
        for(int i=0;i<10000;i++) {
            arr[i]=i;
        }
        return arr;
    }
    public static int binarySearch1(int[] arr,int toFind){
        int left=0;
        int right=arr.length-1;
        while(left<=right){
            count++;//使用一个变量来记录循环执行次数
            int mid=(left+right)/2;
            if(toFind<arr[mid]){
                right=mid-1;
            }else if(toFind>arr[mid]){
                left=mid+1;
            }else{
                return mid;
            }
        }
        return -1;
    }

打印结果：image-20210815224111287

**结论：**可以看到, 针对一个长度为 10000 个元素的数组查找, 二分查找只需要循环 14 次就能完成查找. 随着数组元素个数
越多, 二分的优势就越大.

练习7： 检查数组的有序性
给定一个整型数组, 判断是否该数组是有序的(升序)
    public static void main21(String[] args) {
        int[] arr={1,2,3,10,9,7};
        System.out.println(isSoretd(arr));//打印结果：false
    }
    public static boolean isSoretd(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            if(arr[i]>arr[i+1]){
                    return false;
            }
        }
        return true;
    }
给数组排序使用 Arrays.sort()方法
    public static void main022(String[] args) {
        int[] array={2,1,5,6,10,23,29};
        System.out.println("排序之前的数组："+Arrays.toString(array));
        Arrays.sort(array);//数组排序
        System.out.println("排序之后的数组："+Arrays.toString(array));
    }

打印结果：image-20210815224402850

练习8：数组排序(冒泡排序)
给定一个数组, 让数组升序 (降序) 排序
每次尝试找到当前待排序区间中最小(或最大)的元素, 放到数组最前面(或最后面)

image-20210815224615476

代码示例：

 public static void bubbleSort1(int[] array){
        for(int i=0;i<array.length-1;i++){//确定趟数
            boolean flg=false;//定义一个布尔类型初始值为false，每一趟都要把flg=false
            //长度是5，array.length-1表示5-1=4，j<4,所以第一趟j的取值是0,1,2,3
            //array.length-1-i表示下一趟比上一趟少1
            for(int j=0;j<array.length-1-i;j++){//每一趟j都是从0开始，
                if(array[j]>array[j+1]){//上面那个数如果比下面那个数大，就交换
                    int tmp=array[j+1];
                    array[j]=array[j+1];
                    array[j+1]=tmp;
                    flg=true;//如果交换了就把flg置为true
                }
            }//第二个for循环里面是一趟冒泡排序

            if(flg==false){//flg==false说明从0开始比较没有发生交换,表明此时已经在上一次有序，就可以跳出了，没必要在进行比较了
                break;
            }
        }
    }
    public static void main023(String[] args) {
        int[] array={4,10,6,2,8};
        System.out.println("排序之前："+Arrays.toString(array));
        bubbleSort(array);
        System.out.println("排序之后："+Arrays.toString(array));
    }

打印结果：image-20210815224742039

接练习8：更高效的排序算法
 public static void main23(String[] args) {
        int[] arr={9,7,4,8,3};
        Arrays.sort(arr); //这里是用 Arrays.sort方法实现算法的。
        System.out.println(Arrays.toString(arr));
    }

打印结果：image-20210815224929936

练习9：数组逆序
要求：给定一个数组, 将里面的元素逆序排列
思路
 设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
 然后让前一个下标自增, 后一个下标自减, 循环继续即可.

数组逆序算法思想

image-20210815225229511

 public static void main24(String[] args) {
        int[] arr={1,2,3,4,5,6,7};
        reverse(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void reverse(int[] arr){
        int left=0;
        int right=arr.length-1;
        while(left<right){
            int tmp=arr[left];
            arr[left]=arr[right];
            arr[right]=tmp;
            left++;
            right--;
        }
    }

打印结果：image-20210815225334829

练习10：数组数字排列
要求：给定一个整型数组, 将所有的偶数放在前半部分, 将所有的奇数放在数组后半部分
例如
 {1, 2, 3, 4}
 调整后得到
 {4, 2, 3, 1}
基本思路
设定两个下标分别指向第一个元素和最后一个元素.
用前一个下标从左往右找到第一个奇数, 用后一个下标从右往左找到第一个偶数, 然后交换两个位置的元素.依次循环即可.

 public static void main26(String[] args) {
        int[] arr={1,2,3,4,5,6,7,8,9};
        transform(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void transform(int[] arr){
        int left=0;//left找奇数
        int right=arr.length-1;//right找偶数
        while(left<right){//
            while(left<right && arr[left]%2==0){ //该循环结束left就指向了一个奇数
                left++;
            }
            while(left<right && arr[right]%2!=0){ //该循环结束right就指向了一个偶数
                right--;
            }
            // 交换两个位置的元素
            int tmp=arr[left];
            arr[left]=arr[right];
            arr[right]=tmp;
        }
    }
}

打印结果：image-20210815225537870

思路

设定两个下标分别指向第一个元素和最后一个元素.
用前一个下标从左往右找到第一个奇数, 用后一个下标从右往左找到第一个偶数, 然后交换两个位置的元素.依次循环即可.

 public static void main26(String[] args) {
        int[] arr={1,2,3,4,5,6,7,8,9};
        transform(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void transform(int[] arr){
        int left=0;//left找奇数
        int right=arr.length-1;//right找偶数
        while(left<right){//
            while(left<right && arr[left]%2==0){ //该循环结束left就指向了一个奇数
                left++;
            }
            while(left<right && arr[right]%2!=0){ //该循环结束right就指向了一个偶数
                right--;
            }
            // 交换两个位置的元素
            int tmp=arr[left];
            arr[left]=arr[right];
            arr[right]=tmp;
        }
    }
}
打印结果：[8,2,6,4,5,3,7,1,9]
测试小姐姐~
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java一维数组 例题
weixin_70890083的博客
08-07 535
i++) {l++;r--;i++) {4。
java实现二维数组转json的方法示例
10-19
例如，使用Gson库，你可以创建一个`Blog`类来表示博客信息，然后将二维数组转换为`List<Blog>`，再使用Gson的`toJson`方法生成JSON字符串： ```java import com.google.gson.Gson; public class Blog { private ...
Java当中的数组的定义与简单使用
weixin_64308540的博客
11-06 696
Java当中的数组的定义与简单使用
JAVA范例　五）数组---一维数组
A+
07-21 359
一维数组 实例55  一维数组的创建与使用 import java.util.Random; public class OneArray_01 { public static void main(String[] args) { Random rd = new Random(); // 创建Random对象 int array[] = new int[10]; ...
Java小白自学11：一维数组应用
m0_66650460的博客
08-03 470
1.思路：可以看到这里定义了一个长度为7的int类型数组，目的是求最大值，既然是最大值，肯定是需要比较的，两两比较才能其中一个最大值，然后再将得到的最大值与第三个值比较，这样一直比到数组的最后一位，就可以得到最大值。由此可以看出第一轮需要进行四次比较，一旦前面的数比后面的数大，就要交换数据，第一轮选择完一个最大数据在最后之后，我们进行第二轮比较，第二轮由于只有4个数，因此只要比较三次，第三轮比较2次，第四轮比较1次，可以得出5个元素需要4轮。根据使用区别，一般在知道循环范围的情况下，用for循环最好。...
一维数组的使用
xiaotai1234的博客
08-09 1239
一维数组的使用 1.一维数组的声明方式 type var[] 或 type[] var； 例： nt a[]; int[] a1; double b[]; String[] c; //引用类型变量数组 注意 Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法 2.一维数组的初始化 动态初始化 数组声明且为数组元素分配空间与赋值的操作分开进行 int[] arr = new int[3]; arr[0] = 3; arr[1] = 9; arr[2] = 8;
用递归查找有序二维数组的方法详解
09-05
在本文中，我们将深入探讨如何使用递归方法在一个有序的二维数组中查找特定的整数。有序二维数组是指每行从左到右递增，每列从上到下递增的数组。这样的结构使得我们可以采用一种高效的方式来搜索目标值，而无需遍历...
详解Java合并数组的两种实现方式
08-26
System.arraycopy()方法是Java提供的一种本地方法，用于将源数组的元素复制到目标数组中。该方法的原型如下： ```java public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int...
Java软件开发实战 Java基础与案例开发详解 4-1 一维数组 共14页.pdf
最新发布
07-07
4-1 一维数组 4-2 数组应用 4-3 多维数组 4-4 排序算法 4-5 增强for循环 4-6 数组和排序算法章节练习 5-0 抽象和封装 5-1 面向过程的设计思想 5-2 面向对象的设计思想 5-3 抽象 5-4 封装 5-5 属性 5-6 方法的定义 5-...
java数组知识点详解带你快速掌握数组的使用
02-18
这个例子创建了一个3行4列的二维数组。访问多维数组元素的方式是`matrix[row][column]`。 除了基本操作，Java还支持数组的复制、排序和查找等高级功能。`System.arraycopy()`方法可以实现数组的部分或全部复制；`...
Java的一维数组详解
saoang的博客
05-15 3445
Java数组的概述： 1、 数组（Array），是多个相同类型数据按照一定的顺序排列集合，并且使用一个名字来命名，通过编号的方式来对这些数据来进行管理。 2、 数组的相关概念： 1、 数组名：数组的名称，用于区分不同的数组，数组只有一个名称，即标识符，要符合标识符规范。 2、 元素类型：数组要存储的元素的数据类型。 3、 数组元素：向数组中存放的数据/元素。 4、 元素下标：对数组元素进行编号，元素下标标明了元素在数组中的位置，从0开始；数组中的每个元素都可以通过下标来访问。 5、 数组长度：数组长度固定不
Java一维数组及常见操作
小仙女的博客
05-22 7540
1，如何排序数组并搜索某个元素，找到返回下标   调用java中的Arrays.sort()方法进行排序    使用冒泡排序进行排序 2，如何排序数组并插入某个元素   3，如何确定二维数组的上限 所以，可以通过第三个输出语句来确定二维数组的上限a.length 是代表二维数组的行数a[0].length是代表二维数组的列数a代表的是整个二维数组的首地址              4，如何反转数组...
Java定义一个一维数组有哪几种方法
WenDong1997的博客
10-21 7533
1⃣️  int a[]; int[] a; 2⃣️int abc[] = new int [10];3⃣️int a[] = {1, 2, 3};如果分开写错误 4⃣️int abc[] = new int[] = {1, 2, 3};此方法是2⃣️3⃣️两种方法的结合，但new int[]括号中不能有数字 2⃣️3⃣️4⃣️方法同时初始化了一维数组。
JAVA_一维数组的小例子
qq_16246279的博客
12-11 372
import java.util.Scanner; public class Main {     public static void main(String[] args) {         Scanner s = new Scanner(System.in);         System.out.println("请输入学生个数：");         int count = s.ne...
Java初学语法（9）之一维数组
kuu_ga的博客
08-05 312
一维数组 一维数组 概念：一组相同类型数据的线性集合。 用途：在程序中需要处理一组相同的数据，或者传递一组数据时可以应用。 创建一维数组： 分为以下四个步骤： 定义数组变量所属类型。 使用new关键字分配内存 初始化 调用一维数组 首先，我们要如何定义数组呢？ 有两种语法可以定义，分别是: 1. 数字元素类型 数组名[]； 2. 数字元素类型[] 数组名； 举个例子，定义一个整形数组ace，使用如上方法需写成： int[] ace; 或者 int ace[];
java一维数组的使用
qq_51694024的博客
11-22 465
Java一维数组的使用 多个相同类型的数据按照一定的顺序排列的集合并需要一个名字命名，且通过编写的方式对这些数据进行统一管理，这就是数组。数组的组成有1.数组名，2.下标，3.元素，4.数组长度（切记：数组中元素有顺序，不同于集合，顺序不同，数组不同） 一.用前声明（了解下就ok）： 1.数组本身为引用数据类型（还有类和接口），数组中的元素可以基本数据和引用数据。 2.数组其实就是在内存中开辟一整块新的连续空间（不连续为链表），而数组名中引用的是这块连续空间的首地址上。 3.数组长度一旦确定就别修改，也不可
Java数组和字符串：一维数组的常用操作
汝嫣兮的博客
05-24 507
学习了一维数组的声明、创建、初始化及引用，那接下来看一下一维数组有那些常用的操作： 文章目录输入使用输入值初始化数组使用随机数初始化数组输出（打印）打印数组中的元素处理对所有元素求和找出最大的元素移动元素（排序）匿名数组 输入 使用输入值初始化数组 Scanner sc new Scanner(System.in); System.out.print("Enter"+myList.length+"walues:"); for(int i = 0;i < myList.length;i++)
一维数组的简单操作
qq_40333693的博客
07-14 285
一维数组的声明 一维数组有以下两种声明方式 int[] a; int a[]; 分配空间： 定义数组a，并初始化数组长度为5； 使用new关键字来分配空间，new关键字是java中优先级最高的 a=new int[5]; 声明的同时分配空间： 定义数组d，并赋值1,2,3 int[] d=new int[]{1,2,3}; 一维数组的简单应用 1.计算30位学生的平均分，同时打印每一个数 代码实现如下 2.判断元素是否在数组中 3.数组增加 首先查找位置，然后进行添加 4.从数组中删除元素 首先找到删
一维数组和二维数组的定义及用法
热门推荐
qq_40955824的博客
06-08 2万+
一维数组的定义 类型说明符 数组名 [常量表达式]； 在此说明：常量表达式必须是常量和常量符号。常量表达式定义了数组的长度。在宏定义中#define定义一个符号常量，则这个符号常量可以用来声明数组的个数 #define n=9 ..... int arr[n]; 一维数组的引用 数组必须先定义在使用，可以通过引用数组元素方式使用该数组中的元素，如arr[0]就是访问的数组的第...
Java语言程序设计课件：数组.ppt
05-07
一维数组和多维数组都被介绍了，以及数组的基本操作和应用举例。 数组是用一个变量名表示一组数据，每个数据称为数组元素，每个元素通过下标来区分。如果用一个下标能确定数组中的不同元素，这种数组称为一维数组。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值