三、Java数组、排序和查找

最新推荐文章于 2023-08-16 21:17:07 发布
最新推荐文章于 2023-08-16 21:17:07 发布
阅读量308 收藏
点赞数
分类专栏： Java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46048220/article/details/128218384
版权

一、数组

可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即：数组就是一组数据

1、数组的创建

（1）动态初始化：

  • 方法一：
    在这里插入图片描述
    数组的下标从0开始
public class Array02 {
    public static void main(String[] args) {
        double[] scores = new double[5];
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 5; i++) {
            System.out.println("请输入第" + (i+1) + "个元素的值");
            scores[i] = scanner.nextDouble();
        }
        // 输出（遍历数组）
        System.out.println("当前数组内容如下");
        for (int i = 0; i < scores.length; i++) {
            System.out.println("第" + (i+1) + "个元素的值为" + scores[i]);
        }
    }
}

请输入第1个元素的值
100
请输入第2个元素的值
300
请输入第3个元素的值
45
请输入第4个元素的值
99
请输入第5个元素的值
97
当前数组内容如下
第1个元素的值为100.0
第2个元素的值为300.0
第3个元素的值为45.0
第4个元素的值为99.0
第5个元素的值为97.0

  • 方法二：
    在这里插入图片描述
public class Array02 {
    public static void main(String[] args) {
        double[] scores;
        scores = new double[5];
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 5; i++) {
            System.out.println("请输入第" + (i+1) + "个元素的值");
            scores[i] = scanner.nextDouble();
        }
        // 输出（遍历数组）
        System.out.println("当前数组内容如下");
        for (int i = 0; i < scores.length; i++) {
            System.out.println("第" + (i+1) + "个元素的值为" + scores[i]);
        }
    }
}

（2）静态初始化：
在这里插入图片描述

public class ArrayDetail {
    public static void main(String[] args) {
        /*
        1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理
         */
        // int[] arr1 = {1, 2, 3, 60, 1.1}; //错误：1.1不是int类型
        double[] arr2 = {1.1, 2.2, 100};    // 正确：int可以自动转换为double

        /*
        2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
         */
        String[] arr3 = {"hi", "hello", "halo"};

        /*
        3. 数组创建之后，如果没有赋值，有默认值
            int:0, short:0, byte:0, long:0, float:0.0,
            double:0.0, char:\u0000, boolean:false, String:null.
         */
        short[] arr4 = new short[3];
        for (int i = 0; i < arr4.length; i++) {
            System.out.print(" " + arr4[i]);    // 0 0 0
        }

        /*
        4.使用数组的步骤：
            a，声明数组并开辟空间
            b，给数组各个元素赋值
            c，使用数组
        5. 数组的下标从0开始
        7. 数组属于引用类型，属性数据是对象（object）
         */

        /*
        6. 数组的下标必须在指定范围内使用，否则报：下标越界异常，比如
            int[] arr5 = new int[5]; 有效下标为[0,4]
            即数组的下标/索引 最小：0；最大：数组长度-1
            java.lang.ArrayIndexOutOfBoundsException
         */
        int[] arr5 = new int[5];
        // System.out.println(arr5[5]);
    }
}

public class ArrayExercise01 {
    public static void main(String[] args) {
        /*
        创建一个char类型的26个元素的数组，放置'A'-'Z'
        访问并打印所有元素
         */
        char[] chars = new char[26];
        for (int i = 0; i < chars.length; i++) {
            chars[i] =(char) ('A' + i); //'A'+i是int类型
        }
        for (int i = 0; i < chars.length; i++) {
            System.out.print(chars[i]);
        }
    }
}

public class ArrayExcercise02 {
    public static void main(String[] args) {
        /*
        求出一个数组int[]的最大值{ 4, -1, 9, 10, 23 }
        并得到对应下标
         */
        int[] arr = { 4, -1, 9, 10, 23 };
        int max = arr[0];
        int index = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
                index = i;
            }
        }
        System.out.println("最大值：" + max + "；下标为：" + index);
    }
}

最大值：23；下标为：4

2、数组的赋值

在这里插入图片描述

public class ArrayAssign {
    public static void main(String[] args) {
        // 基本数据类型赋值，赋值方式为值拷贝(值传递)
        // n2的变化，不会影响到n1的值
        int n1 = 10;
        int n2 = n1;
        n2 = 1;
        System.out.println("n1=" + n1); //10
        System.out.println("n2=" + n2); //80

        // 数组在默认情况下是引用传递，赋的值是地址，赋值方式为引用赋值
        // 传递的是一个地址=>arr2的变化会影响到arr1
        int[] arr1 = {1, 2, 3};
        int[] arr2 = arr1;  // 把arr1赋给了arr2
        arr2[0] = 10;
        System.out.println("arr1的值");
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
    }
}

n1=10
n2=1
arr1的值
10
2
3

在这里插入图片描述

3、数组拷贝

将int[] arr1 = {10, 20, 30};拷贝到arr2数组，要求数据空间是独立的

public class ArrayCopy {
    public static void main(String[] args) {
        int[] arr1 = {10, 20, 30};
        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr2.length; i++) {
            arr2[i] = arr1[i];
        }
        arr2[1] = 99;
        System.out.println("修改arr2后查看arr2的值");
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
        System.out.println("查看arr2的变化是否影响arr1");
        for (int i = 0; i < arr1.length; i++) {
            System.out.println(arr1[i]);
        }
    }
}

修改arr2后查看arr2的值
10
99
30
查看arr2的变化是否影响arr1
10
20
30

4、数组反转

把数组元素内容反转int[] arr = {11, 22, 33, 44, 55, 66, 77};

public class ArrayReverse {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44, 55, 66, 77};
        int temp = 0;
        int len = arr.length;
        for (int i = 0; i < len / 2; i++) {
            temp = arr[len - 1 - i];
            arr[len - 1 - i] = arr[i];
            arr[i] = temp;
        }
        for (int i = 0; i < len; i++) {
            System.out.print(" " + arr[i]);
        }
    }
}

77 66 55 44 33 22 11

5、数组添加元素

实现动态的给数组添加元素的效果，实现对数组扩容
1）原始数组使用静态分配 int[] arr = {1, 2, 3};
2）增加的元素，直接放在数组的最后 arr = {1, 2, 3, 4};

public class ArrayAdd {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int[] arrNew = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
            arrNew[i] = arr[i];
        }
        arrNew[arrNew.length - 1] = 4;
        arr = arrNew;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i] + " ");
        }
    }
}

1
2
3
4

3）用户可以通过如下方法决定是否继续添加，添加成功，是否继续？y/n。

public class ArrayAdd02 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        Scanner myScanner = new Scanner(System.in);
        do {
            int[] arrNew = new int[arr.length + 1];
            // 遍历arr数组，依次将arr元素拷贝到arrNew数组
            for (int i = 0; i < arr.length; i++) {
                arrNew[i] = arr[i];
            }
            System.out.println("请输入你要添加的元素");
            int addNum = myScanner.nextInt();
            // 将addNum赋给arrNew的最后一个元素

            arrNew[arrNew.length - 1] = addNum;
            // 让arr指向arrNew
            arr = arrNew;
            // 输出arr查看结果
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i] + " ");
            }
            // 是否继续添加
            System.out.println("是否继续添加？y/n");
            char key = myScanner.next().charAt(0);
            if ( key == 'n' ){
                break;
            }
        } while (true);
        System.out.println("已退出添加代码");
    }
}

请输入你要添加的元素
5
1
2
3
5
是否继续添加？y/n
y
请输入你要添加的元素
9
1
2
3
5
9
是否继续添加？y/n
n
已退出添加代码

6、数组的缩减

将数组 {1, 2, 3, 4, 5} 进行缩减，提示用户是否继续缩减，每次缩减最后的元素，当只剩下最后一个元素时，提示，不能再缩减

public class ArrayReduce {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        Scanner scanner = new Scanner(System.in);
        while (true){
            int[] arrNew = new int[arr.length - 1];
            for (int i = 0; i < arrNew.length; i++) {
                arrNew[i] = arr[i];
            }
            arr = arrNew;
            for (int i = 0; i < arrNew.length; i++) {
                System.out.println(arr[i]);
            }
            if (arrNew.length == 1){
                System.out.println("只剩一个元素，无法继续缩减，退出缩减循环");
                break;
            }
            System.out.println("是否继续缩减？y/n");
            char key = scanner.next().charAt(0);
            if (key == 'n'){
                System.out.println("缩减结束，退出缩减循环");
                break;
            }
        }
    }
}

1
2
3
4
是否继续缩减？y/n
y
1
2
3
是否继续缩减？y/n
y
1
2
是否继续缩减？y/n
y
1
只剩一个元素，无法继续缩减，退出缩减循环

1
2
3
4
是否继续缩减？y/n
y
1
2
3
是否继续缩减？y/n
n
缩减结束，退出缩减循环

二、排序

排序介绍：
在这里插入图片描述

1、冒泡排序

冒泡排序 (Bubble Sorting)的基本思想是: 通过对 待排序 序列从后向前 (从下标依次比较相邻元素的值，若发现逆序则交换，使值从较较大的元素开始)，大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

特点：
在这里插入图片描述

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 4, 3, 2, 1};
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // 如果前面的数大于后面的数就交换
                if( arr[j] > arr[j + 1]){
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("\n=== 第" + (i + 1) + "轮 ===");
            for (int j = 0; j < arr.length; j++) {
                System.out.print(arr[j] + "\t");
            }
        }
        System.out.println("\n" + Arrays.toString(arr));
    }
}

=== 第1轮 ===
4 3 2 1 5
=== 第2轮 ===
3 2 1 4 5
=== 第3轮 ===
2 1 3 4 5
=== 第4轮 ===
1 2 3 4 5
[1, 2, 3, 4, 5]

三、查找

在这里插入图片描述

public class SeqSearch {
    public static void main(String[] args) {
        String[] names = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入名字");
        String findName = scanner.next();
        int index = -1;
        for (int i = 0; i < names.length; i++) {
            if (names[i].equals(findName)){
                System.out.println("找到：" + findName + "，下标为：" + i);
                index = i;
                break;
            }
        }
        if (index == -1){
            System.out.println("没有找到！！！");
        }
    }
}

请输入名字
who
没有找到！！！

请输入名字
金毛狮王
找到：金毛狮王，下标为：1

四、多维数组

二维数组：数组元素为一维数组的数组

int[][] arr = {{1,1,1},{2,2,2},{100}}	//正确

int[][] arr = {{1,1,1},{2,2,2},100}		//错误，100不是数组

应用场景：五子棋等……

1、动态初始化

方法一：
在这里插入图片描述

public class TwoDimensionalArray02 {
    public static void main(String[] args) {
        int arr[][] = new int[2][3];
        arr[1][1] = 8;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

0 0 0
0 8 0

在这里插入图片描述
方法二：
在这里插入图片描述
方式二

public class TwoDimensionalArray02 {
    public static void main(String[] args) {
        int arr[][];
        arr = new int[2][3];
        arr[1][1] = 8;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

方式三

public class TwoDimensionalArray03 {
    public static void main(String[] args) {
        // 创建一个只确定一维数组个数，而未开辟一维数组空间的二维数组
        int[][] arr = new int[3][];
        for (int i = 0; i < arr.length; i++) {  //遍历arr的每个一维数组
            // 给每一个一位数组开辟空间
            // 如果没有给一维数组 new，则arr[i]就是null
            arr[i] = new int[i + 1];
            //遍历一维数组，并给一维数组每个元素赋值
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = i + 1;
            }
        }
        System.out.println("输出arr");
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

2、静态初始化

int[][] arr = {{1,1,1},{2,2,2},{100}}

3、例题

在这里插入图片描述

public class YangHui {
    public static void main(String[] args) {
        int[][] yangHui = new int[10][];
        for (int i = 0; i < yangHui.length; i++) {  //遍历yangHui的每个元素
            //给每一个一维数组(行) 开辟空间
            yangHui[i] = new int[i + 1];
            //给每一个一维数组赋值
            for (int j = 0; j < yangHui[i].length; j++) {
                if (j == 0 || j == yangHui[i].length - 1){
                    yangHui[i][j] = 1;
                } else {
                    yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
                }
            }
        }
        // 输出杨辉三角
        for (int i = 0; i < yangHui.length; i++) {
            for (int j = 0; j < yangHui[i].length; j++) {
                System.out.print(yangHui[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package array;
/*
已知有一个升序的数组，要求插入一个元素，该数组顺序仍然是升序，比如：
[10, 12, 45, 90]，插入23后，数组为[10, 12, 23, 45, 90]
 */
public class InsertArr {
    public static void main(String[] args) {
        int[] arr = {10, 12, 45, 90};
        int insertNum = 23;
        int index = -1; //要插入的位置
        int[] arrAdd = new int[arr.length + 1];
        //遍历arr数组，如果发现insertNum<=arr[i]，说明i就是要插入的位置
        //使用index保留，index = i;
        //如果遍历完后，没有发现insertNum<=arr[i]，说明index = arr.length
        //即，添加到arr的最后
        for (int i = 0; i < arr.length; i++) {
            if (insertNum <= arr[i]){
                index = i;
                break;  // 找到位置后，就退出
            }
        }
        //判端index的值
        if (index == -1){   //说明没有找到位置
            index = arr.length;
        }
        System.out.println("index = " + index);

        //将arr的元素拷贝到arrNew，并且要跳过index位置
        //j用来控制arr数组的下标
        for (int i = 0, j = 0; i < arrAdd.length; i++) {
            if (i != index){    //说明该位置拷贝的是arr中的元素
                arrAdd[i] = arr[j];
                j++;
            } else {
                arrAdd[i] = insertNum;
            }
        }

        arr = arrAdd;
        //打印扩充后的arr
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

index = 2
10 12 23 45 90

package array;

import java.util.Arrays;

/*
随机生成1-100 的10个整数到数组中，倒序打印，求：
平均值、最大值、最大值的下标、查找里面是否有8.
 */
public class Ex {
    public static void main(String[] args) {
        int[] arr = new int[10];
        double sum = arr[0];
        int max = arr[0];
        int maxIndex = 0;
        int findNum8 = 8;
        int findNum8Index = -1;
        for (int i = 0; i < 10; i++) {
            //要将"*100"也括起来，否则只强转Math.random()，结果始终为0
            arr[i] = (int)(Math.random()*100) + 1;
        }
        System.out.println("随机生成arr数组：" + Arrays.toString(arr));
        //倒序
        System.out.println("=====");
        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.print(arr[i] + "\t");
        }

        //平均值、最大值、最大值下标
        for (int i = 1; i < arr.length; i++) {
            sum += arr[i];
            if (max < arr[i]){
                max = arr[i];
                maxIndex = i;
            }
        }
        System.out.println("\nmax=" + max + "；maxIndex=" + maxIndex);
        System.out.println("平均值：" + sum/arr.length);

        //查找数组中是否有8
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == findNum8){
                System.out.println("找到了数字" + findNum8 + "，下标为：" + findNum8Index);
                findNum8Index = i;
                break;
            }
        }
        if (findNum8Index == -1){
            System.out.println("未找到数字" + findNum8);
        }
    }
}

随机生成arr数组：[79, 23, 89, 67, 90, 52, 92, 46, 25, 32]
32 25 46 92 52 90 67 89 23 79
max=92；maxIndex=6
平均值：51.6
未找到数字8

/*
冒泡排序———倒序
*/
public class Ex {
    public static void main(String[] args) {
        int[] arr = {73, 24, 66, 82, 12, 47, 87, 17, 23, 10};
        int temp = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]){
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

[10, 12, 17, 23, 24, 47, 66, 73, 82, 87]

肿么啦！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数组高级算法与Arrays类常见操作小结【排序、查找】
08-26
主要介绍了Java数组高级算法与Arrays类常见操作,结合实例形式总结分析了Java数组常见的排序算法、查找算法相关原理、实现与使用技巧,需要的朋友可以参考下
Java数组常见应用详解【创建、遍历、排序、查找】
08-25
主要介绍了Java数组常见应用,结合实例形式详细分析了java数组的基本定义、创建、遍历、排序、查找等相关操作技巧与使用注意事项,需要的朋友可以参考下
java 数组的查找方式
2302_76913357的博客
08-16 1104
因为 binarySearch(),和sort()方法都是静态方法，所以在使用的时候，用Arrays.方法名() 的形式调用方法。这样的方法效率更高，但是要查找的目标数组，必须是排序好的数组，也就是说二分法查找是基于排序的基础上的。但是在使用这个方法之前需要使用java.Util.Arrays工具类中的sort()数组排序方法。返回值为int，为目标元素的下标，需要传的参数是要查找的目标元素。二分法查找的方法：binarySearch()第一种方法：一个挨着一个找，直到找到位置。一.数组元素的查找方式。
Java数组、排序、查找
Du_xuan_qing的博客
05-12 505
数组的基本概念及作用• Java中 数组是相同数据类型元素的集合• 数组本身是引用数据类型，即对象。（下章面向对象讲）但是数组可以存储基本数据类型， 也可以存储引用数据类型。数组的声明的两种方式：•数据类型 [] 数组名字 例如：int [] a;• 数据类型 数组的名字 [] 例如： int a [];• 注意： 在Java语言中两种声明方法没有任何区别，但是建议大家用第一种， 避免混淆a的数据类型例 // int [] c,d;(建议的)
Java 数组、排序和查找（3）
周小末天天开心的博客
10-07 1320
数组查找和二维数组复习
Array扩展方法——find()
dandanmei0513的博客
08-15 1039
Array扩展方法——find()快速找到数组中符合条件的对象
用于搜索数组中元素的 Java 程序
我的博客，不一样的自我表达
07-26 599
Stream anyMatch(Predicate predicate) 返回此流的任何元素是否与提供的谓词匹配。输入： arr[] = [5, 1, 1, 9, 7, 2, 6, 10], key = 7。Java中的List contains()方法用于检查给定列表中是否存在指定元素。在 Java 中，有多种方法可以检查此数组中是否存在特定元素。输入： arr[] = [-1, 1, 5, 8], key = -2。在此，顺序遍历列表或数组，并检查每个元素。数组：[5,1,1,9,7,2,6,10]
Java数组+数组排序+数组复制+最大最小值+合并数组+数组升降序排序+数组查找
最新发布
05-09
Java数组排序：冒泡排序、选择排序 、插入排序 、快速排序、希尔排序、堆排序和归并排序 三种Java数组复制方法 Java数组最大最小值 四种合并Java数组方法 Java数组升降序排序 Java数组查找：二分查找、顺序查找、...
JAVA实现排序算法和折半查找
04-08
包括常见的排序算法，以及折半查找，首先对要查找的数据排好序，然后用递归调用的方式实现折半查找（包括了...指定一个排好序的数组和要查找的值，同时指定要查找的左边界和有边界。左右边界要位于数组长度区间范围内。
java数组二分查找
11-02
Java数组的二分查找代码，将给定数组排序，然后接收键盘键入的整形数字，并查找该数字。
JAVA 数组排序和查找
weixin_54778787的博客
03-12 295
JAVA 数组相关介绍，包含排序，查找，多维数组
Array.find（）解析
热门推荐
啊啊怪的学习日记
12-16 1万+
Array.find() 返回数组中满足提供的测试函数的第一个元素的值，若没有满足测试函数的元素，则返回undefined 1、概要 array.find(function(currentValue, index, arr),thisValue){ // 如果返回 true，则返回 item 并停止迭代 // 对于假值（falsy）的情况，则返回 undefined } 2、参数 function（必选）：在数组的元素上执行的函数，它带有三个参数 1、currentValue（必选）：元素
Java数组、排序和查找
timerring的博客
04-14 289
数组介绍 数组的使用 使用方式1-动态初始化数组的定义 使用方式2-动态初始化 使用方式3-静态初始化 数组使用注意事项和细节 数组应用案例 数组赋值机制 数组拷贝 数组添加/扩容 多维数组 二维数组 动态初始化1 动态初始化2 静态初始化 二维数组的应用案例 二维数组使用细节和注意事项
Java面试干货：关于数组查找的几个常用实现算法
finally_vince的博客
11-16 2112
假如要查找的元素在前半段，那么继续按照斐波那契数列来看，55 = 34 + 21，所以继续把前半段分成前34个数据元素的前半段和后21个元素的后半段，继续查找，如此反复，直到查找成功或失败。斐波那契查找也叫做黄金分割法查找，这种查找法其实也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。5.最后，又将mid所指向的元素(19)与待查找元素(19)进行比较，结果相等，则查找成功，返回mid指针指向的元素的位序。从折半查找中可以看出，折半查找的查找效率还是不错的。
Java Arrays类
qq_51542797的博客
12-20 1690
Java Arrays类笔记。
Java Arrays的常用操作总结
rqz__的博客
04-02 481
Java Arrays是Java语言中的一个数组类，它提供了一系列的方法用于操作数组。Arrays类包含了排序、搜索、复制、比较、填充等方法，这些方法可以使操作数组更加简单高效。它拥有很多静态方法，可以方便地对数组进行各种操作，比如查找最大值、最小值等。Arrays还支持多维数组，并且可以用于基本数据类型与对象类型数组的操作。
Java查找数组中的指定元素（顺序查找）
weixin_44436675的博客
01-02 2590
顺序查找数组中的指定元素 给定一个数组，在给定一个元素，找出该元素在数组中的位置（输出的是该元素在数组中的下标） public static void main(String[] args) { int[] array = {12, 14, 16, 18, 20, 28}; System.out.println(find(array,16)); } public static int find(int[] arr, int toFind) {
Java中数组的两种查找 / 检索方法（遍历和二分法查找）
weixin_51906670的博客
11-05 7176
Java中数组元素查找的两种方法： 1.一个一个挨着找，直到找到为止。 代码： public class Array02 { public static void main(String[] args) { // 这个数组已经排序的。 int[] arr = {100,200,230,235,600,1000,2000,9999}; // 找出arr这个数组中200所在的下标。 ...
Java 数组查找指定元素
weixin_52899638的博客
04-30 8190
binarSearch: 第一钟形式： binaySearch(object [] a , object key) 对象数组a 表示要查找的数组元素 ， 对象数组key 表示 要查找的值 其中，a 表示要搜索的数组，key 表示要搜索的值。如果 key 包含在数组中，则返回搜索值的索引；否则返回 -1 或“-插入点”。插入点指搜索键将要插入数组的位置，即第一个大于此键的元素索引。 d...
java数组查找元素
08-12
Java中可以使用线性查找和二分查找两种方法来查找数组中的元素。 线性查找是逐个遍历数组元素，直到找到目标元素或遍历完整个数组。如果找到目标元素，返回该元素在数组中的索引；如果遍历完整个数组仍未找到目标...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值