(八)数组(java)

最新推荐文章于 2023-03-04 17:47:43 发布
最新推荐文章于 2023-03-04 17:47:43 发布
阅读量607 收藏 2
点赞数 4
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67497868/article/details/127008383
版权

目录

        前言：

                一、一维数组

                二、二维数组

                三、数组中的常见算法

                四、java内存分配图

                五、数组使用的常见问题

前言：

        数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。

        数组是用于储存多个相同类型数据的集合。

一、一维数组

1.概述：

        数组(Array)，是多个相同类型数据按一定顺序排列的集合，并用一个名字命名，并通过编号的方式对这些数据进行统一管理

2.数组的常见概念：

                数组名

                角标、下标(或索引)

                元素

                数组的长度：元素的个数

3.数组的特点：

        ①数组是有序排列的。

        ②数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。

        ③创建数组对象会在内存中开辟一整块连续的空间。

        ④数组的长度一旦确定，就不能修改。

4.数组的分类：

        ①按照维数：一维数组、二维数组、三维........

        ②按照数组元素的类型：基本数据类型数组、引用数据类型数组。

5.一维数组的使用：

        ①一维数组的声明和初始化；

        ②如何调用数组的指定位置的元素；

        ③如何获取数组的长度；

        ④如何遍历数组；

        ⑤数组元素的默认初始化值；

        ⑥数组的内存解析；

public class Test {
   //一维数组的使用
   public static void main(String[] args) {
      //1.一维数组的声明和初始化
      int num;//声明
      num =10;//初始化
      int id = 1001;//声明＋初始化
​
      int[] ids;//声明
      //静态初始化:数组的初始化和数组元素的赋值操作同时进行。
      ids = new int[]{1001,1002,1003,1004};
      //动态初始化:数组的初始化和数组元素的赋值操作分开进行。
      String[] names = new String[4];
​
      //总结:数组一旦初始化完成，其长度就确定了。
​
      //2.如何调用数组的指定位置的元素:通过角标、索引、下标的方式调用。
      //数组的角标(索引)从0开始的，到数组的长度-1结束。
      names[0] ="张飞";
      names[1] ="张良";
      names[2] ="赵云";
      names[3] ="关羽";
      names[4] ="孙策";
      //3.如何获取数组的长度：length关键字
      System.out.println(names.length);
      System.out.println(ids.length);
​
      //4.如何遍历数组
      for (int i = 0; i < names.length; i++) {
         System.out.println(i);
      }
​
      /*5.数组元素的默认初始化值
            》数组元素是整型:0
            》数组元素是浮点型:0.0
            》数组元素是char型: 0或'\u0000',而非'0';
            》数组元素是boolean型:false
            》数组元素是引用数据类型:null
​
       */
      int[] arr = new int[5];
      for (int i = 0; i < arr.length; i++) {
         System.out.println(i);
      }
   }
}

6.数组的内存解析

上图给出java程序执行时的内存分配。图中有栈，堆，方法区，各区域分别存储的数据有：

  • 栈：存放局部变量

  • 堆：存放new实例化的对象、数组等

  • 方法区：包括常量池、静态区

6.代码演练：

打印联系电话！

public class Test {
   //
   public static void main(String[] args) {
    int[] arr = new int[] {8,2,1,0,3};
    int[] index = new int[] {2,0,3,2,4,0,2,1,3,3,4};
    String tel = "";
      for (int i = 0; i < index.length; i++) {
         tel +=arr[index[i]];
      }
      System.out.println("联系方式" + tel);
   }
}

7.例题：

        从键盘输入学生的成绩，并找出最高分，输出学生成绩的等级。

        成绩>=最高分-10 等级为'A' 成绩>=最高分-20 等级为'B' 成绩>=最高分-30 等级为'C' 其余 等级为'D' 提示:先读入学生人数，根据人数创建int数组，存放学生成绩。

public class Test {
   /*从键盘输入学生的成绩，并找出最高分，输出学生成绩的等级。
   成绩>=最高分-10   等级为'A'
   成绩>=最高分-20   等级为'B'
   成绩>=最高分-30   等级为'C'
   其余             等级为'D'
   提示:先读入学生人数，根据人数创建int数组，存放学生成绩。
    */
   public static void main(String[] args) {
    //1.使用Scanner，读取学生个数。
      Scanner scan = new Scanner(System.in);
      System.out.println("请输入学生人数:  ");
      int number = scan.nextInt();
   //2.创建数组，存储学生成绩,动态初始化。
      int[] score = new int[number];
   // 3.给数组中的元素赋值。
      System.out.println("请输入"+number+"学生成绩: ");
      for (int s = 0; s < score.length; s++) {
         score[s] =scan.nextInt();
      }
    //4.获取数组中元素的最大值:最高分
      int maxscore = 0;
      for (int i = 0; i < score.length; i++) {
         if (maxscore<score[i]){
            maxscore = score[i];
         }
      }
    //5.根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩。
      char level;
      for (int i = 0; i <score.length ; i++) {
         if (maxscore - score[i] <=10) {
            level='A';
         } else if (maxscore-score[i] <=20) {
            level = 'B';
         } else if (maxscore-score[i] <=30) {
            level = 'C';
         }else {
            level= 'D';
         }
         System.out.println("学生 "+i + "成绩为:"+score[i] + "评分为:"+level);
      }
   }
}

二、二维数组

1.二维数组的使用：        

        ①一维数组的声明和初始化；

        ②如何调用数组的指定位置的元素；

        ③如何获取数组的长度；

        ④如何遍历数组；

        ⑤数组元素的默认初始化值；

        ⑥数组的内存解析；

2.规定：二维数组分为外层数组的元素，内层数组的元素。

        外层元素：arr[0]、arr[1]等

        内层元素：arr[0] [1]、arr[2] [1]等

public static void main(String[] args) {
   //1.一维数组的声明和初始化
   int[] arr = new int[]{1,2,3};//二维数组
   //静态初始化
   int[][] arr1 = new int[][]{{1,2},{1,4,3},{2,4}};
   //动态初始化
   String[][] arr2 = new String[3][2];
   String[][] arr3 = new String[3][];
​
   //2.如何调用数组的指定位置的元素.
   System.out.println(arr1[0][1]);
   System.out.println(arr2[0][1]);
​
   //3.如何获取数组的长度：length关键字
   System.out.println(arr.length);
   System.out.println(arr1.length);
   System.out.println(arr2.length);
   System.out.println(arr3.length);
​
   //4.如何遍历数组
   for (int i = 0; i < arr.length; i++) {
      System.out.println(i);
   }
  /*5.数组元素的默认初始化值
      针对初始化方式一,比如:int [][] arr = new int[4] [3];
         外层元素初始化值为:地址值
         内层元素的初始化值:与一维数组初始化情况相同。
     针对初始化方式二,比如:int [][] arr = new int[4] [];
         外层元素的初始化值为:null
         内层元素的初始化值为:不能调用，否则报错。
    */
   int[] arr = new int[5];
   for (int i = 0; i < arr.length; i++) {
      System.out.println(i);
   }
}
​

3.代码演练：

                获取arr数组中的元素的和。

                提示：使用for循环嵌套

public class Test {
   public static void main(String[] args) {
      int[] [] arr = new int[][]{{3,5,8,4},{1,24,65},{3,2}};
​
      int sum =0;//记录总和
      for (int i = 0; i < arr.length; i++) {
         for (int j = 0; j < arr[i].length; j++) {
            System.out.println(sum);
         }
      }
   }
}

4.例题：

        使用二维数组打印一个10行杨辉三角。

        提示：

                1.第一行有1个元素，第n行有n个元素。

                2.第一行的第一个元素和最后一个元素都是1.

                3.从第三行开始，对于非第一个元素和最后一个元素的元素。即：

                        yuansu[i] [j] = yuansu[i-1] [j-1] +yuansu[i-1] [j];

public class Test {
   /*使用二维数组打印一个10行的杨辉三角。
   提示
   1.第一行有1个元素，第n行有n个元素。
   2.第一行的第一个元素和最后一个元素都是1.
   3.从第三行开始，对于非第一个元素和最后一个元素的元素。
   即:yuansu[i] [j] = yuansu[i-1] [j-1] +yuansu[i-1] [j];
    */
   public static void main(String[] args) {
      //1.声明并初始化二维数组。
      int[][] yuansu = new int[10][];
      //2.给数组的元素赋值
      for (int i = 0; i < yuansu.length; i++) {
         yuansu[i] = new int[i+1];
         //2.1给首末元素赋值
         yuansu[i][0] = yuansu[i][i] =1;
         //2.2给每行的非首末元素赋值。
         if (i >1) {
            for (int j = 1; j < yuansu[i].length-1; j++) {
               yuansu[i][j] = yuansu[i-1][j-1] + yuansu[i-1][j];
            }
         }
      }
      //3.遍历二维数组
      for (int i = 0; i < yuansu.length; i++) {
         for (int j = 0; j < yuansu[i].length; j++) {
            System.out.println(yuansu[i][j] + "   ");
         }
         System.out.println();
      }
   }
}

三、数组中的常见算法

1.数组元素的赋值(杨辉三角、回形数等)。

public class Test {
   /*使用二维数组打印一个10行的杨辉三角。
    */
   public static void main(String[] args) {
      //1.声明并初始化二维数组。
      int[][] yuansu = new int[10][];
      //2.给数组的元素赋值
      for (int i = 0; i < yuansu.length; i++) {
         yuansu[i] = new int[i+1];
         //2.1给首末元素赋值
         yuansu[i][0] = yuansu[i][i] =1;
         //2.2给每行的非首末元素赋值。
         if (i >1) {
            for (int j = 1; j < yuansu[i].length-1; j++) {
               yuansu[i][j] = yuansu[i-1][j-1] + yuansu[i-1][j];
            }
         }
      }
      //3.遍历二维数组
      for (int i = 0; i < yuansu.length; i++) {
         for (int j = 0; j < yuansu[i].length; j++) {
            System.out.println(yuansu[i][j] + "   ");
         }
         System.out.println();
      }
   }
}

2.求数值型数组中元素的最大值、最小值、平均数、总和等。

public class Test {
   /*定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值、最小值、和值。
   要求：所有随机整数都是两位数。
   公式:(int) (Math.random()*(99 -10+1)+10)//[10，99]的公式。
    */
   public static void main(String[] args) {
      int[] arr = new int[10];
​
      for (int i = 0; i < arr.length; i++) {
         arr[i] =(int) (Math.random()*(99 -10+1)+10);
      }
      //遍历
      for (int i = 0; i < arr.length; i++) {
         System.out.println(arr[i] + "\t");
      }
      System.out.println();
      //求数组元素的最大值
      int maxvalue =arr[0];
      for (int i = 0; i < arr.length; i++) {
         if (maxvalue <arr[i]){
            maxvalue = arr[i];
         }
      }
      System.out.println("最大值为:"+ maxvalue);
      //求数组元素的最小值
      int minvalue =arr[0];
      for (int i = 0; i < arr.length; i++) {
         if (minvalue >arr[i]){
            minvalue = arr[i];
         }
      }
      System.out.println("最小值为:"+ minvalue);
      //求数组元素的总和
      int sum = 0;
      for (int i = 0; i < arr.length; i++) {
         sum +=arr[i];
      }
      System.out.println("总和为: "+sum);
      //求数组元素的平均数
      int avg = sum/arr.length;
      System.out.println("平均数:"+avg);
   }
}

3.数组的复制、反转、查找(线性查找、二分法查找)。

public class Test {
   /*算法的考查:数组的复制、反转、查找(线性查找、二分法查找)
    */
   public static void main(String[] args) {
      String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
​
      //数组的复制(区别于数组变量的赋值:arr1 = arr)
      String[] arr1 = new String[arr.length];
      for (int i = 0; i < arr1.length; i++) {
         arr1[i] = arr[i];
      }
​
      //数组的反转
      //方法一
      for (int i = 0; i < arr1.length/2; i++) {
         String temp =arr[i];
         arr[i] = arr[arr.length-i-1];
         arr[arr.length-i-1] = temp;
      }
      //方法二
      for (int i = 0 ,j=arr.length-1; i < j; i++,j--) {
         String temp =arr[i];
         arr[i] = arr[j];
         arr[j] = temp;
      }
      //遍历
      for (int i = 0; i < arr.length; i++) {
         System.out.println(arr[i]+" \t");
      }
      //数组的查找
      //线性查找
      String dest = "BB";
​
      boolean ifFlag = true;
      for (int i = 0; i < arr.length; i++) {
         if (dest.equals(arr[i])) {
            System.out.println("找到了指定元素，位置为: " + i);
            ifFlag = false;
            break;
         }
      }
      if (ifFlag) {
         System.out.println("很遗憾，没有找到!");
      }
      //二分法查找:查找速度快
      //前提：所要查找的数据必须有序
      int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,333};
​
      int dest1 = -34;
      int head = 0;//初始的首索引
      int end = arr2.length -1;//初始的末索引
      boolean isFlag1 = true;
      while (head <= end){
         int middle = (head + end )/2;
​
         if (dest1 == arr2[middle]){
            System.out.println("找到了指定元素，位置为: "+ middle);
         } else if (arr2[middle] > dest1) {
            end = middle -1;
         }else {//arr2[middle] < dest1
            head = middle + 1;
         }
      }
      if (isFlag1) {
         System.out.println("很遗憾，没有找到!");
      }
   }
}

4.数组元素的排序算法。

(1)排序思想：

        1.比较相邻的元素，如果第一个比第二个大(升序)，就交换他们两个。

        2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

        3.针对所有的元素重复以上的步骤，除了最后一个。

        4.持续每次对越来越少的的元素重复上面的操作，知道没有任何一对数字需要比较为止。

(2)衡量排序算法的优劣：

        1.时间复杂度：分析关键字的比较次数和记录的移动次数。

        2.空间复杂度：分析排序算法中需要多少辅助内存。

        3.稳定性：若两个记录A和B的关键字值相等，但排序后A，B的先后次序保持不变，则称这种排序算法是稳定的。

(3)排序分类

        选择排序：直接选择排序，堆排序

        交换排序：冒泡排序，快速排序

        插入排序：直接插入排序，折半插入排序，shell排序

        归并排序

        桶式排序

        基数排序

(4)排序特征

 

(5)冒泡排序

        冒泡排序的原理非常简单，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

public class Test {
   /*冒泡排序
   每次从数组中找出最大值放到数组的后面去。
    */
   public static void main(String[] args) {
      //1.定义一个数组，存储一些数据。
      int[] arr = {43,32,12,45,37,27,86,87,57};
      //2.定义一个循环控制比较的轮数
      for (int i = 0; i < arr.length-1; i++) {
         //3.定义一个循环控制每轮比较的次数
         for (int j = 0; j < arr.length-i-1; j++) {
            //判断j当前位置的元素值是否大于后一个位置，若大，则交换。
            if (arr[j] >arr[j+1]){
               int temp = arr[j];
               arr[j] =arr[j+1];
               arr[j+1] = temp;
            }
         }
      }
      //遍历数组内容输出
      for (int i = 0; i < arr.length; i++) {
         System.out.println(arr[i] + "\t");
      }
   }
}

例题1：

        猜数字: 后台随机生成1-20之间的5个数，然后让大家猜数字.

         》未猜中提示：“未命中”，并继续猜测；

         》猜中提示:“运气不错，猜中了”，并输出该数据第一次出现的位置，且输出全部5个数据，最终结束本游戏。

public class CSZ {
    /*后台随机生成1-20之间的5个数，然后让大家猜数字
    》未猜中提示：“未命中”，并继续猜测；
    》猜中提示:“运气不错，猜中了”，并输出该数据第一次出现的位置，且输出全部5个数据，最终结束本游戏。
     */
    public static void main(String[] args) {
        //1.定义一个动态初始化的数组存储5个随机的1-20之间的数据。
        int[] data = new int[5];
​
        //2.动态的生成5个1-20之间的随机数并存入数组中去。
        Random r = new Random();
        for (int i = 0; i < data.length; i++) {
            data[i] = r.nextInt(20)+1;
        }
        //3.使用一个死循环，让用户进行猜测
        Scanner sc = new Scanner(System.in);
        OUT:
        while (true){
            System.out.println("请您输入一个1-20之间的整数进行猜测: ");
            int guessData = sc.nextInt();
​
            //4.遍历数组中的每个数据，看是否有数据与猜测的数据相同，相同代表中了，给出提示。
            for (int i = 0; i < data.length; i++) {
                if (data[i] == guessData){
                    System.out.println("您猜中了该数据，运气不错！该数据的位置是:"+i);
                    break OUT; //结束死循环
                }
            }
            System.out.println("当前猜测的数据在数组中不存在，请重新猜测！");
        }
        //5.输出数据的全部元素，让用户看到自己确实是猜中了某个数据。
        for (int i = 0; i < data.length; i++) {
            System.out.println(data[i] +"\t");
        }
    }
}

例题2：

        随机选取人排序。 键盘录入一组工号，最终要随机输出一组作为排名

public class SJPM {
    /*随机排名选取
    键盘录入一组工号，最终要随机输出一组作为排名
     */

    public static void main(String[] args) {
        //1.动态初始化一个数组，存储5个工号
        int[] codes = new int[5];

        //2.定义一个循环，循环5次，依次录入一个工号存入对应的位置。
        Scanner sc= new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            //录入工号
            System.out.println("请您输入第"+(i+1)+"个员工的工号: ");
            int code = sc.nextInt();
            //存入到数组中去
            codes[i] = code;
        }
        //3.遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机索引位置处的元素值进行交换
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            //当前遍历的元素值:codes[i]
            //随机一个索引位置出来:codes[index]
            int index = r.nextInt(codes.length);

            //定义一个临时变量存储index位置处的值
            int temp = codes[index];
            codes[index] = codes[i];
            codes[i] = temp;
        }
        //4.遍历数组元素输出就是随机排名的结果。
        for (int i = 0; i < codes.length; i++) {
            System.out.println("");
            System.out.println(codes[i] +"\t");
        }
    }
}

四、java内存分配图

五、数组使用的常见问题

        1.如果访问的元素位置超过最大索引，执行时会出现：ArrayIndexOutOfBoundsException(数组索引越界异常)。

        2.如果数组变量中没有存储数组的地址，而是null，在访问数组信息时会出现NullPointerException(空指针异常)。

public class Test {
​
   public static void main(String[] args) {
      //1.数组索引越界异常
      int[] arr = {11,22,33};
      System.out.println(arr[0]);
      System.out.println(arr[1]);
      System.out.println(arr[2]);
      System.out.println(arr[3]);//出现异常
​
      //2.空指针异常
      arr = null;
      System.out.println(arr);
      System.out.println(arr.length);
      System.out.println("程序结束。。。");
   }
}

晚风残照
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Java有序数组
萌萌程序员的博客
12-20 4540
1：有序数组简介，以及优缺点 2：构建有序数组 在数组增删改查功能里，我们是如何让数组有序的呢？肯定是添加方法 1：我们在添加的时候可以进行一个判断 2：判断我们这个新添加的数据到底是添加在哪个地方在哪个位置 //接下来插入数据     public void insert(int values){         int i;//先声明一个i         for (i = 0
有序数组实现
12-10
很好的代码哟!增加,删除元素,二分查找元素
java二分查找算法字符串数组_详解Java数据结构和算法（有序数组和二分查找）...
weixin_36480977的博客
02-13 270
一、概述有序数组中常常用到二分查找，能提高查找的速度。今天，我们用顺序查找和二分查找实现数组的增删改查。二、有序数组的优缺点优点：查找速度比无序数组快多了缺点：插入时要按排序方式把后面的数据进行移动三、有序数组和无序数组共同优缺点删除数据时必须把后面的数据向前移动来填补删除项的漏洞四、代码实现public class OrderArray {private int nElemes; //记录数组长...
java 有序数组 频率_Java有序数组的实现
weixin_36479263的博客
02-13 128
package 有序数组;public class OrdArray {private long[]array;private int nElems;//初始化public OrdArray(int max){array = new long[max];nElems = 0;}//返回数组中的大小public int size(){return nElems;}//查找的方法的实现public i...
java有序数组
CherishL_的专栏
07-25 2777
public class SortArray { private long[] a;//ref to array a private int nElems;//number of data items public SortArray(int max){ a = new long[max]; nElems = 0; } publ
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
初识JAVA数组
09-04
【初识JAVA数组】 在Java语言中，数组是一种基本的复合数据类型，它代表了有序数据的集合。数组的关键特性是其元素具有相同的类型，并且可以通过一个数组名称和下标来唯一地确定每个元素的位置。Java支持一维数组和...
对象数组 java
03-16
在Java编程语言中，对象数组是一种特殊的数组，它允许我们存储多个对象实例，而不是基本数据类型。对象数组的创建和操作是Java编程中常见的任务，特别是在处理一组具有相同类实例时。下面我们将深入探讨对象数组的...
Java数组讲解
06-02
//在定义数组时,如果确定数组的各个元素,可以进行静态初始化 ,在创建数组时,给数组元素赋初值 int [] data2 = new int[] {34,56,765,78}; //注意静态初始化时,不需要指定数组的长度 //通过foreach循环遍历, 增强的...
java数组_java_java数组_
09-30
Java数组是Java编程语言中的基本数据结构之一，它允许我们存储多个同类型的元素在一个单一的变量中。数组的使用在程序设计中至关重要，因为它提供了一种高效、有序的方式来管理和访问数据。下面将深入探讨Java数组的...
Java数组
HuangChunLei_的博客
07-09 140
Java数组 1. 数组概述 数组是相同类型数据的有序集合。 数组是将同一类型的若干个数据，按照一定的顺序排列组合而成。 其中，每个数据称为数组元素，每个数组元素可以通过下标访问它们。 2. 数组声明创建 首先必须先声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法： dataType[] arrayRefVar; //首选方法 dataType arrayRefVar[]; //效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下： dataType[
Java有序数组的相关操作
Restfulq的博客
12-07 844
Java有序数组的相关操作
java实现有序数组
dadeiji的博客
05-16 1057
java实现有序数组最近看到一篇文章，大概就是说程序员如果想要提升，就应该写博客。受到了一定启发，所以来此创建账号，准备写点什么。 注意:本文章只适合初学者阅读。其中很多代码参考源码所写，仅供自娱自乐
java 数组有序_Java有序数组
weixin_33925126的博客
02-20 2432
1：有序数组简介，以及优缺点2：构建有序数组在数组增删改查功能里，我们是如何让数组有序的呢？肯定是添加方法1：我们在添加的时候可以进行一个判断2：判断我们这个新添加的数据到底是添加在哪个地方在哪个位置//接下来插入数据public void insert(int values){int i;//先声明一个ifor (i = 0; i < elements; i++) {//然后进行判断if ...
Java有序数组的实现
weixin_30723433的博客
01-14 248
package 有序数组; public class OrdArray { private long[]array; private int nElems; //初始化 public OrdArray(int max){ array = new long[max]; nElems = 0; } //返回数组中的大小 public int siz...
数据结构 有序数组java篇
11-16 687
一：有序数组特点： 1：有序数组特点：查询快，插入，删除慢，适合查询多，修改少的环境 2：查询时间复杂度O(log(n))，插入,删除时间复杂度O(n) 3 : 插入平均需要比较n/2 次，移动n/2个元素 4 : 删除是先查找，然后移动n/2个元素二：二分查找思想 假设有n个元素的有序数组，取数组中间位置的值与检索值比较，如果小于中间值，则利用二分查找在前半部分的有序数组中查找，如
数组案例题
秋雨绵绵
07-28 852
   有一个数组，其中有十个元素从小到大依次排列 {12,14,23,45,66,68,70,77,90,91}。再通过键盘录入一个整数数字。要求：把数字放入数组序列中，生成一个新的数组，并且数组的元素依旧是从小到大排列的。执行效果如下： 请输入一个整数数字： 50 生成的新数组是：12 14 23 45 50 66 68 70 77 90 91 //导包 import java.util.Scanner; public class Rank { public static void main
java中数组是否有序,在Java中的有序集的任何实现？
weixin_29284201的博客
03-13 234
import java.util.ArrayList; import java.util.HashMap; import java.util.Set; import java.util.Collection; import java.util.Comparator; import java.util.function.Predicate; import java.util.function.Una...
数组--java--动态数组--有序数组--底层
余的日常学习
03-04 1396
数组--java--动态数组--有序数组 数组底层
字节数组 java
最新发布
10-10
字节数组是指由若干个字节构成的数组，在Java中可以用byte类型的数组来实现。字节数组在处理二进制数据或者网络传输数据时非常常见。 可以通过以下代码创建一个长度为10的字节数组： ``` byte[] byteArray = new ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

晚风残照

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值