精华内容
下载资源
问答
  • 2、数组的声明和赋值 2.1 声明 2.2 赋值 3、数组的组成 3.1 组成 3.2 如何使用 4、数组的遍历 4.1 for循环 4.2 foreach循环(增强for循环) 5、可变参数 6、二维数组 6.1 概念、创建 6.2 遍历 6.3 案例(杨辉三角) ...

    1、数组概念

    1.1 数组概念

    • 1.存储多个相同数据类型的数据
    • 2.长度固定

    2、数组的声明和赋值

    2.1 声明

    声明语法:数据类型[] 数组名称 = new int[长度]
    示例:int[] nums = new int[5];

    2.2 赋值

    int [] nums = new int[3];
    nums[0] =1;
    nums[1] =2;
    nums[2] =3;

    3、数组的组成

    3.1 组成

    • 数组中的每个数据被称为“数组元素”。
    • 对元素的访问和取值被称为“元素访问”。
    • 访问元素时,需要使用数组的下标,下标从0开始,一次+1,自动生成
    • 访问语法:数组名[下标];//例如:存:a[0]=1;取:a[0]

    3.2 如何使用

    如何存储100名学生的成绩?

    • 办法:使用变量存储,重复声明100个double类型变量即可
    • 缺点:麻烦,重复操作过多。

    如何让100名学生成绩全部+1?

    • 办法:100个变量重复相同操作,直至全部完毕。
    • 缺点:无法进行统一的操作

    解决上边两个问题,使用数组就很简单!

    4、数组的遍历

    4.1 for循环

    遍历:从头至尾,逐一对数组的每一个元素进行访问。
    遍历示例:

    package Day06_Array;
    
    import java.util.Arrays;
    import java.util.Random;
    
    /**
     * @author wzy
     * @version 1.0
     * @date 0021 2020-11-21 11:24
     */
    public class  Demo04 {
        public static void main(String[] args){
    
            // 定义存储名字的数组names
            String[] names = {"码云","麻花头","马赛克","马保国"};
            // 定义存储点名次数的数组nums
            int[] nums = new int[names.length];
    
            Random random = new Random();  // 生成随机数
    
            // 随机点名数字
            for(int i=0;i<10;i++){
                //生成随机数 0~3
                int ranNum = random.nextInt(names.length);
                System.out.println(names[ranNum]+"被点名");
                // 次数+1
                nums[ranNum]++;
            }
            System.out.println("------------");
    
            // 遍历数组,打印每个人被点名的次数
            for (int i=0;i<names.length;i++){
                System.out.println(names[i]+":"+nums[i]);
            }
        }
    }
    

    4.2 foreach循环(增强for循环)

    foreach遍历示例:

    package Day06_Array;
    
    /**
     * @author wzy
     * @version 1.0
     * @date 0023 2020-11-23 19:21
     */
    public class Foreach {
        public static void main(String[] args) {
            String[] names = {"码云","麻花头","马赛克","马保国"};
            for (String str:names) {
                System.out.println(str);
    
            }
        }
    }
    
    

    5、可变长参数

    概念:

    • 可以接收多个同类型的实参
    • 个数不限
    • 使用方式和数组相同

    语法:

    • 数据类型…形参名(必须定义在形参列表后边,且只能有一个)

    使用场景:

    • 使用场景:当传递的参数都是相同类型但是数量不定的时候

    6、二维数组

    6.1 概念、语法

    概念: 一维数组里存储y一维数组,二维数组中的元素是一维数组

    语法:

    • int[][] 数组名=new 数据类型[行数][列数];
    • 示例:int[][] = new int[3][3];

    使用双下标访问二维数组中的元素:

    • 第一个下标代表:行号(高维下标)。
    • 第二个下标代表:列号(低维下标)。

    6.2 遍历

    package com.qf.ran.array;
    
    /**
     * @author Ran
     * @since JDK 1.8
     *      二维数组
     *          一维数组里面存储一维数组
     *
     *      静态初始化和动态初始化的区别:
     *          静态初始化的一维数组长度可不一致
     *          动态初始化的一维数组长度必须一致
     *
     *      foreach的使用只能用来遍历打印数据,不能修改数据
     *
     */
    public class Demo05 {
        public static void main(String[] args) {
            //动态初始化 3代表的是二维数组的长度  4代表的是1维数组的长度
            //String[][] books = new String[3][4];
            //String[][] books;
            //books = new String[3][4];
            //books[0][0] = "西游记";
    
            //静态初始化
            String[][] books = new String[][]{{"马宝国","马赛克"},{"雷军","雷公","雷震子"},{"昌老师"}};
            //System.out.println(books[1][2]);
    
            //一维数组
            int[] nums = {1,3,5,7};
    
            //一维数组的遍历
            System.out.println("---------一维数组的for循环遍历-------------");
            for (int i = 0; i < nums.length; i++) {
                System.out.println(nums[i]);
            }
            System.out.println("----------一维数组的foreach遍历------------");
            //num在foreach中称为循环值,每次循环自动接收数组中的元素
            //for(元素类型 循环值:数组)
            for(int num:nums){
                System.out.println(num);
            }
    
            //二维数组的遍历
            System.out.println("---------二维数组的for循环遍历-------------");
            for (int i = 0;i <books.length;i++){
                for (int j = 0;j < books[i].length;j++){
                    System.out.println(books[i][j]);
                }
            }
    
            System.out.println("----------二维数组的foreach遍历------------");
            for(String[] str:books){
                for (String book:str){
                    System.out.println(book);
                }
            }
        }
    }
    

    6.3 案例(杨辉三角)

    代码示例:

    package com.qf.ran.array;
    
    /**
     * @author wzy
     * @since JDK 1.8
     *          杨辉三角
     *          1.列数与行数相等
     *          2.每一行的第一个数与最后一个数为1
     *          3.除了首尾的其他数字,等于他上一行的数与上一行前一列的数相加。
     *
     *          1
     *          1   1
     *          1   2   1
     *          1   3   3   1
     *          1   4   6   4   1
     *          1   5   10  10  5   1
     */
    public class Demo06 {
        public static void main(String[] args) {
            print(9);
        }
    
        //打印杨辉三角
        public static void print(int num){
            //行数与列数一样
            int[][] nums = new int[num][num];
            //控制的是行数
            for (int i = 0; i < nums.length; i++) {
                //控制列数
                for (int j = 0; j <= i; j++) {
                    //第一列或者每列与行数相同的数设为1
                    if(j == 0 || i == j){
                        nums[i][j] = 1;
                    }else{
                        //其他数则等于上一行同列的数加上一行前一列的数
                        nums[i][j] = nums[i-1][j]+nums[i-1][j-1];
                    }
    
                    //打印
                    System.out.print(nums[i][j]+"\t");
                }
                System.out.println();
            }
        }
    }
    
    

    7、数组排序

    7.1 冒泡排序

    冒泡排序:相邻的两个数值比较大小,互换位置。
    代码示例:

    package com.qf.ran.sort;
    
    import java.util.Arrays;
    
    /**
     * @author Ran
     * @since JDK 1.8
     *
     *          排序算法:
     *              冒泡排序
     *                  相邻的两个数进行两两对比,符合条件的数进行交换
     *              快速排序
     *              插入排序
     *              归并排序
     *              希尔排序
     *              选择排序
     *                   一轮比较中多次比较选出最小值或者最大值,进行一次交换
     *              桶排序
     *              堆排序
     *              计数排序
     *              基数排序
     */
    public class Demo01 {
        public static void main(String[] args) {
            int[] nums = {3, 1, 5, 2};
    
            //外层for循环控制的是轮数     nums.length-1的原因是因为最后一个数不需要进行位置确定
            for(int j = 0;j < nums.length-1;j++){
                //内层for循环控制的是每轮对比的次数
                // nums.length-j的原因是因为每轮会少一个需要比较的值
                //减一的原因是因为轮数是由j控制,j从0开始
                for (int i = 0; i < nums.length-j-1; i++) {
                    if (nums[i] > nums[i + 1]) {
                        int temp = nums[i];
                        nums[i] = nums[i + 1];
                        nums[i + 1] = temp;
                    }
                }
            }
            System.out.println(Arrays.toString(nums));
    
    
            //-------------第一轮-------------
            /*for (int i = 0; i < 3; i++) {
                if (nums[i] > nums[i + 1]) {
                    int temp = nums[i];
                    nums[i] = nums[i + 1];
                    nums[i + 1] = temp;
                }
            }
    
            //-------------第二轮-------------
            for (int i = 0;i < 2;i++){
                if (nums[i] > nums[i + 1]) {
                    int temp = nums[i];
                    nums[i] = nums[i + 1];
                    nums[i + 1] = temp;
                }
            }
    
            //-------------第三轮-------------
            for(int i = 0;i < 1;i++){
                if (nums[i] > nums[i + 1]) {
                    int temp = nums[i];
                    nums[i] = nums[i + 1];
                    nums[i + 1] = temp;
                }
            }*/
    
            //-------------第一轮-------------
            //第一次   --  第一个数与第二个数进行比较
            /*if(nums[0] > nums[1]){
                int temp = nums[0];
                nums[0] = nums[1];
                nums[1] = temp;
            }
            //第二次   --  第二个数与第三个数进行比较
            if(nums[1] > nums[2]){
                int temp = nums[1];
                nums[1] = nums[2];
                nums[2] = temp;
            }
            //第三次   --  第三个数与第四个数进行比较
            if(nums[2] >nums[3]){
                int temp = nums[2];
                nums[2] = nums[3];
                nums[3] = temp;
            }*/
    
            //-------------第二轮-------------
            //第一次   --  第一个数与第二个数进行比较
            /*if(nums[0] > nums[1]){
                int temp = nums[0];
                nums[0] = nums[1];
                nums[1] = temp;
            }
            //第二次   --  第二个数与第三个数进行比较
            if(nums[1] > nums[2]){
                int temp = nums[1];
                nums[1] = nums[2];
                nums[2] = temp;
            } */
    
            //---------------第三轮------------
            //第一次   --  第一个数与第二个数进行比较
            /*if(nums[0] > nums[1]){
                int temp = nums[0];
                nums[0] = nums[1];
                nums[1] = temp;
            }*/
        }
    }
    
    
    

    7.2 选择排序

    选择排序:一轮比较中多次比较选出最小值或者最大值,进行一次交换
    代码示例:

    package com.qf.ran.sort;
    
    /**
     * @author Ran
     * @since JDK 1.8
     */
    public class Demo02 {
        public static void main(String[] args) {
            int[] nums = {3,1,5,2};
            //外层for循环控制轮数
            for(int i = 0;i <nums.length - 1;i++){
                //1.定义min的初始值
                int min = i;
                //2.j为被对比数的索引
                for(int j = i+1;j < nums.length;j++){
                    //nums[min]为对比数,nums[j]为被对比数
                    if(nums[min] > nums[j]){
                        //改变min的索引为被对比数的索引
                        min = j;
                    }
                }
                //3.判断min是否为初始值
                if(min != i){
                    int temp = nums[min];
                    nums[min] = nums[i];
                    nums[i] = temp;
                }
            }
        }
    }
    
    
    展开全文
  • 所谓二维数组,可以简单的理解为是一种“特殊”的一维数组,它的每个数组空间中保存的是一个一维数组。 那么如何使用二维数组呢,步骤如下: 1、 声明数组并分配空间 或者 如: 2、 赋值 二维数组的赋值,...

    Java 中的二维数组

    所谓二维数组,可以简单的理解为是一种“特殊”的一维数组,它的每个数组空间中保存的是一个一维数组。

    那么如何使用二维数组呢,步骤如下:

    1、 声明数组并分配空间

    或者

    如:

    2、 赋值

    二维数组的赋值,和一维数组类似,可以通过下标来逐个赋值,注意索引从 0 开始

    也可以在声明数组的同时为其赋值

    如:

    3、 处理数组

    二维数组的访问和输出同一维数组一样,只是多了一个下标而已。在循环输出时,需要里面再内嵌一个循环,即使用二重循环来输出二维数组中的每一个元素。如:

    运行结果:

     

    需要了解的:在定义二维数组时也可以只指定行的个数,然后再为每一行分别指定列的个数。如果每行的列数不同,则创建的是不规则的二维数组,如下所示:

    运行结果为:

     

    4、使用 foreach 操作二维数组
     

    int[][] arrs2 = new int[4][];//定义一个4行的二维数组
    arrs2[0] = new int[] { 1, 2 };
    arrs2[1] = new int[] { 3 };
    arrs2[2] = new int[] { 4, 5, 6, 7 };
    arrs2[3] = new int[] { 11, 22, 33, 4, 5, 6, 7 };
    
    	for (int[] is : arrs2) { //第一个foreach 遍历的是二维数组中所有行的一维数组
    		for (int i : is) {//第二个 foreach 遍历出 每行一维数组中所有的元素
    			System.out.print(i + "\t");
    		}
    		System.out.println();
    	}
    		

     


    运行结果是:
     

    1	2	
    3	
    4	5	6	7	
    11	22	33	4	5	6	7	

     



    提示:    如果要声明三维数组,就是在类型关键词旁使用[][][],四维就是[][][][],以此类推。
                不过不建议以三维数组以上方式记录数据,因为不容易撰写,阅读与理解,自定义类来解决这类需求会是较好的方式。

     

     

     

     

     

     

     

    注:文中部分内容摘自 慕课网,《Java学习笔记》

    转载于:https://my.oschina.net/u/3421709/blog/881302

    展开全文
  • 维数组

    2020-02-20 18:11:31
    如何创建一个维数组如何访问二维数组中的元素? 声明维数组变置并创建二维数组 下面是声明维数组的语法: 数据类型[] []数组名 : 或者 数据类型数组名[] [] ; //允许这种方式 ,但并不推荐使用它 ...

    二维数组

     二维数组的基础知识

    要点提示:二维數组中的元素通过行和列的下标来访问。

    如何声明一个二维数组变量?如何创建一个二维数组?如何访问二维数组中的元素?

    声明二维数组变置并创建二维数组

    下面是声明二维数组的语法:

    数据类型[] []数组名 :

    或者

    数据类型数组名[] [] ; //允许这种方式 ,但并不推荐使用它

    作为例子,

    下面演示如何声明 int 型的二维数组变量 matrix:
    int[] [] matrix;

    或者

    int matrix[][];// 允许这种方式 ,但并不推荐使用它

    可以使用这个语法创建 5 x 5 的 int 型二维数组,并将它陚值给 matHx:
    matrix = new int[5] [5];

    也可以这样获取一个数组:(例如:创建一个3行4列的二维数组)创建个指定元素的二维数组

    int[][] matrix=new int[][]{                   int[][] matrix={
        {1,2,3,4} ,                                              {1,2,3,4} ,
        {5,6,7,8} ,                                              {5,6,7,8} ,
        {9,10,11,12}                                          {9,10,11,12}
    };                                                         };

    锯齿矩阵/二维数组
    int[][] matrix={
        {1,2,3,4} ,
        {5,6,7} ,
        {8,9},
        {10}
    };

    特别的,如果一个二维数组的行和列相等的话,也称之为是方阵

    二维数组中使用两个下标,一个表示行,另一个表示列。同一维数组一样,每个下标索 引值都是 int 型的,从 0 开始,如图 8-la 所示。

    如图 8-1b所示,要将 7 賦值给行下标为2、列下标为1的特定元素,可以使用下面的语句:

    matrix[2] [l]= 7;

    瞥告:使用 matrix[2,l]访问行下标为 2、列下标为丨的元素是一种常见错误。在 Java 中, 每个下标必须放在一对方括号中。

    也可以使用数组初始化来声明、创建和初始化一个二维数组。例如:下图 a 中的代码创 建一个具有特定初值的数组,如图 8-1c 所示。它和图 b中的代码是等价的。

    获取二维数组的长度

            二维数组实际上是一个数组,它的每个元素都是一个一维数组。数组 X 的长度是数组中 元素的个数,可以用 x.length 获取该值。元素 x[0], x[l],…,x[x.length-l]也是数组。 可以使用 x[0].length, x[l].length,…, x[x.length-1].length 获取它们的长度。

             例如:假设 x = new int[3][4], 那么 x[0]、x[l] 和 X[2]都是一维数组,每个数组都 包含 4 个元素,如图 8-2 所示。x.length 为 3, x[0].length、x[l].length 和 x[2].length 都是 4。

    锯齿数组

    二维数组中的每一行本身就是一个数组,因此,各行的长度就可以不同。这样的数组称 为锯齿数组(ragged array)。下面就是一个创建锯齿数组的例子:

    从上图中可以看到,triangleArray[0].length 的值为 5,triangleArray[l].length 的值为 4,triangleArray[2].length的值为 3,triangleArray[3].length 的值为 2, triangleArray[4]. length 的值为1。

    如果事先不知道锯齿数组的值,但知道它的长度,正如前面讲到的,可以使用如下所示 的语法创建锯齿数组:

    int[][] triangleArray = new int[5][]; 
    triangleArray[0] = new int[5]; 
    triangleArray[l] = new int[4]; 
    triangleArray[2] = new int[3]; 
    triangleArray[3] = new int[2]; 
    triangleArray[4] = new int[l]; 

    现在可以给数组賦值,例如:

    triangleArray[0][3] - 50;

    triangleArray[4][0] * 45;

    注意:使用语法 new in‘ t[5][]创建数组时,必须指定第一个下标。语法 new int[]□ 是 错误的

    处理二维数组

    要点提示:嵌套的 for 循环常用于处理二维数组。

    假设如下创建数组 matrix:

    int[][] matrix = new int[10][10];

    下面是一些处理二维数组的例子:

    1 )(使用输入值初始化数组)下面的循环使用用户输人值初始化数组:

    java.util.Scanner input = new Scanner(System.in);
    System.out.println("Enter + matrix.length + " rows and " + matrix[0].length + "columns:); 
        for (int row=0; row < matrix.length; row++){ 
            for (int column = 0; column < matr1x[row].length; column++){ 
                matrix[row][column] = input.nextlnt(); 
        }
    }

    2)(使用随机值初始化数组)下面的循环使用 0 到 99 之间的随机值初始化数组:

    for (int row = 0; row < matrix.length; row++){ 
        for (int column = 0; column < matrix[row].length; column++){ 
            matrix[row][column] = (int) (Math.random() * 100);
        }
    }

    3 )(打印數组)为打印一个二维数组,必须使用如下所示的循环打印数组中的每个元素:

    for (int row = 0; row < matrix.length; row++){ 
        for (int column = 0; column < matrix[row].length; column++){ 
            System.out.print(matrix[row][column] + " " );
        }
        System.out.println();
    }
    

    4)(求所有元素的‘ 和)使用名为 total 的变量存储和。将 total 初始化为 0。利用类似 下面的循环,把数组中的每一个元素都加到 total 上:

    int total = 0; 
        for(int row = 0; row < matrix.length; row++){ 
            for(int column = 0; column < matrix[row] .length; column++){ 
                total +-matrix[row] [column]; 
        }
    }

    5 )(对数组按列求和)对于每一列,使用名为 total 的变量存储它的和。利用类似下面 的循环,将该列中的每个元素加到 total 上

    for(int column = 0; column < matrix[0].length; column—){
        int total-0;
        for (int row = 0; row < matrix.length; row++) 
            total += matrix[row] [column] ; 
        System.out.println("Sum for column " + column + " is ’’ + total);
    } 

    6) (哪一行的和最大?)使用变量 maxRow 和 indexOfMaxRow 分别跟踪和的最大值 以及该行的索引值。计算每一行的和,如果计算出的新行的和更大,就更新 maxRow 和 indexOfMaxRow。

    int maxRow = 0; 
    int indexOfMaxRow * 0; 
    // Get sum of the first row in maxRow 
    for(int column = o; column < matrix[0].length; column++){ 
        maxRow += matrix[0] [column] ;
    }
    for(int row = 1; row < matrix.length; row++){ 
        int totalOfThisRow = 0; 
    for(int column = 0; column < matrix[row].length; column++) 
        totalOfThisRow += matrix[row] [column] ; 
    if(totalOfThisRow > maxRow){ 
        maxRow = totalOfThisRow; 
        indexOfMaxRow = row; 
        }
    } 
    System.out.println("Row " + indexOfMaxRow + " has the maximum sum of •• + maxRow) ; 

    7)(随意打乱)在 7.2. 6 节中已经介绍了如何打乱一维数组的元素,那么如何打乱二维 数组中的所有元素呢?为了实现这个功能,对每个元素 Hiatrix[i] [j] , 随机产生下标 il 和 jl, 然后互换 matrix[ i] [j]和 matrix[il] [jl] , 如下所示:

    for(int i = 0; i < matrix.length; i++){ 
        for(int j = 0; j < matrix[ i].length; j++){ 
            int i1 = (int) (Math.random() = matrix.length) ; 
            int j1 = (int) (Math.random() = matrix[i] .length) ; 
            // Swap matrix[i] [j] with matrix[i1][j1] 
            int temp = matrix[i][j] ; 
            matrix[i] [j] = matrix[i1][j1] ; 
            matrix[i1][j] =  temp; 
        }
    }

     将二维数组传递给方法

    要点提示:将一个二维数组传递给方法的时候,数组的引用传递给了方法

    可以像传递一维数组一样,给方法传递二维数组。也可以从一个方法返回一个数组。

    第一个方法:  getArray( ), 返回一个二维数组

    import java.util.Scanner; 
    class PassTwoDimensionalArray { 
        Scanner input = new Scanner(System.in); 
        public static void main(String[] args) { 
            int[][] m = getArray(); // Get an array 
            // Display sum of elements
            System.out.println("\nSum of all elements is " + sum(m)); 
        } 
        //第一个方法,getArray(), 返回一个二维数组; 
        public static int[][] getArray() { 
         
            // Enter array values 
            int[][] m = new int[3][4]; 
            System.out.println("Enter " + m.length + " rows and " + m[0].length +"columns:"); 
            for (int i = 0; i < m.length; i++)         //从键盘获取一个二维数组的循环
                for (int j = 0; j < m[i].length;j++) 
                    m[i][j] = input.nextlnt(); 
            return m;                                 //返回一个数组
        } 
        //第二个方法,sum(int[][] m), 返回一个矩阵中所有元素的和。 
         public static 1nt sum(1nt[][] m) { 
             int total = 0; 
            for (int row = 0; row < m.length; row++) { 
                for (int column = 0; column < m[row].length; column++) { 
                    total += m[row][column];     //累加,计算所有数据的和
                } 
            } 
            return total ;                       //返回一个数字,数组所有数据之和
        }
    }

    运行结果:

     

    展开全文
  • Java —— 一维数组

    2019-11-30 20:01:37
    文章目录第六章-一维数组1、什么是数组2、数组的基本要素3、如何定义使用数组4、数组长度5、数组求最大值最小值6、向数组中插入元素 第六章-一维数组 1、什么是数组 数组是一个变量,存储的是相同数据类型的...

    第六章-一维数组

    1、什么是数组

    数组是一个变量,存储的是相同数据类型的一组数据,声明数组,就是在内存中划分一串连续的空间
    注意:
    数组一经定义,大小就确定了,不可以在此基础上再增加空间(重新创建除外),即:不可以动态扩展空间


    2、数组的基本要素

    数据类型:指定数组中存放的数据类型
    标识符:数组名称
    数组元素:存放在数组中的数据
    下标:从0开始,最大不能大于 数组的长度-1
    注意:
    数组长度固定,应避免地址下标越界获取元素


    3、如何定义和使用数组

    1)声明数组
    方式1:数据类型[] 数组名; – 推荐写法
    方式2:数据类型 数组名[];

    2)分配空间 使用 new 关键字
    数组名 = new 数据类型[数组长度];
    注意:
    长度必须要定义,代表数组可以存放的元素个数

    备注:
    数组元素,根据不同的数据类型,会有不同的初始值(数组定义后,不初始化赋值,仍然可以直接访问元素,不会报错,比如:int–0,String–null…)

    3)赋值
    实际是向分配的内存空间存放数据(实际是地址的引用)
    语法:
    数组名[下标] = 定义数据类型的值;

    声明数组同时赋值:
    方式1:
    数据类型[] 数组名 = {元素1,元素2…};
    方式2:
    数据类型[] 数组名 = new 数据类型[]{元素1,元素2…};

    注意:
    由于初始化值,已经确定了数组的元素个数,所以,不可以再指定长度
    边声明边赋值:必须定义在一条语句内,不能分开
    比如:

    //常见错误
      int[] scores = new int[5];
                scores = {1,2,3,4,5};
    

    4)数组的使用
    数组元素赋值之后,可以重复获取,并使用


    4、数组长度

    语法:数组名.length
    注意:数组长度,使用的length数组,有别于字符串,字符串长度使用的是length()方法

    示例:

         for(int i = 0; i < scores.length; i++){
                System.out.println(scores[i]);
            }
    

    5、数组求最大值和最小值

    原理:
    类似打擂台,借助中间表变量,依次比较,保留最大或者最小值


    6、向数组中插入元素

    示例:

      // 初始化数组
            int[] scores = { 83, 63, 68, 78, 99, 90 };
            // 定义新的数组,长度为初始数组长度加1,用来移位
            int[] newScores = new int[scores.length + 1];
    
            System.out.println("排序前:");
            System.out.println(Arrays.toString(scores));
    
            // 给数组排序,使用sort方法,默认规则为升序,方法调用后,数组中元素的顺序是排序的
            Arrays.sort(scores);
            System.out.println("排序后:");
            System.out.println(Arrays.toString(scores));
    
            // 将排序数组拷贝到新的数组中
            for (int i = 0; i < scores.length; i++) {
                newScores[i] = scores[i];
            }
    
            System.out.println("新的数组:");
            System.out.println(Arrays.toString(newScores));
    
            // 定义要插入的元素值
            int score = 88;
    
            // 定义变量接收要插入的位置
            int index = -1;
            
            // 循环查找,找到要插入的数的位置,升序数列,找到哪个数,比插入的数值大,这个数就要放在该位置
            for (int i = 0; i < newScores.length; i++) {
                if(newScores[i] > score){
                    index = i;
                    break;
                }
            }
            System.out.println("需要插入的位置下标为:" + index);
            
            // 在插入数据之前,需要先把该下标位置空出来(实际上原有值还在),否则直接复制,会丢失原有的值
            for (int i = newScores.length - 1; i > index; i--) {
                newScores[i] = newScores[i-1];
            }
            
            System.out.println("新的数组移位后:");
            System.out.println(Arrays.toString(newScores));
            
            // 将要插入的值,直接放到对应的位置上,即可
            newScores[index] = score;
            
            System.out.println("最终插入数据后,新的数组为:");
            System.out.println(Arrays.toString(newScores));
    
    展开全文
  • 如何获取数组

    千次阅读 2018-12-07 03:15:34
    Dim a(x, y)将声明创建一个维数组,在VBA中并没有提供可以直接获取数组维数的函数方法。 在VBA(VB)中数组最大维数为60,因此可以使用捕获错误的方法来获取数组的维数。 Sub ArrayDimension() Dim i, b Dim a...
  • 数组

    2020-06-08 10:00:41
    创建和使用一维数组创建和使用二维数组 了解如何遍历数组 了解如何填充替换数组中的元素 了解如何对数组进行排序 了解如何复制数组 了解查询数组的方法 6.1 数组概述 数组中的每元素具有相同的数据类型。 ...
  • 数据结构——二维数组

    千次阅读 2019-01-25 17:38:35
    维数组可以理解为数组的数组。...如何声明维数组 int arr[max_rows][max_columns]; 元素以行列的形式组织。 第一行的第一个元素由[0][0]表示,其中第一个索引中显示的数字是行的数字,而第二...
  • 一维数组声明方式: type var[]; 或type[] var; 声明数组时不能指定其长度(数组中元素的个数), Java中使用关键字new创建数组对象,格式为: 数组名 = new 数组元素的类型 [数组元素的...
  • 最近,项目中需要实现:提取组数据,每个数组都有自己的属性,这组数据的长度又未知,还可能变长,变短,我考虑一会,实现如下; 1.在oncreate前面,我声明个数组 String data1[ ][ ];//使用的时候,比如...
  • 使用数组、文件图表、 了解数组及其使用二、二维数组三、文件操作读取文本文件读取 Excel 文件输入文本文件四、如何创建图表 、 了解数组及其使用 数组是具有类似类型的数据集合。通过使用数组,可以存储大量...
  • Java学习——数组

    2020-07-06 17:14:08
    Java学习——数组 数组的关键元素 ...1.一维数组声明和初始化 2.如何调用数组指定位置的元素 3.如何遍历数组 4.如何获取数组长度 5.数组元素的默认初始化值 6.数组的内存解析 一维数组的声明: //1.1静
  • Go-15 多维数组的使用

    2019-11-04 11:27:41
    下面通过实例来演示一下如何声明一个维数组。 【示例 1】声明二维数组 // 声明一个二维整型数组,两个维度的长度分别是 4 2 var array [4][2]int // 使用数组字面量来声明并初始化一个二维整型数组 arra...
  • C#学习笔记--数组

    2008-05-27 23:56:00
    2.如何创建和引用一维数组 C#里面的数组是一个类,我们声明一个数组的时候实际上是声明一个Array类型的对象,所以在实例化的时候会使用new关键字,因为是对象所 以数组本身就是引用类型的了。数组一般分为一维...
  • 数组长度二、一维数组1.默认值2.循环赋值3.循环输出4.数组下标越界异常三、应用1.求整数数组的累加2.求数组元素最大值四、增强型for循环1.增强型for循环2.foreach循环应用五、冒泡排序1.如何对变量a,b进行交换2....
  • c#多维数组的建立及操作 总结

    万次阅读 2016-12-05 15:04:17
    1C#如何定义使用多维数组 不建议使用ArrayList,当数组里的元素是值类型在操作的时候会出现大量的装箱与拆箱步骤性能会损失许多,...例如,下列声明创建一个四行两列的二维数组: C# int[,]array = new int[4, 2];
  • c#多维数组的建立及操作

    千次阅读 2015-04-03 22:23:02
    1C#如何定义使用多维数组 不建议使用ArrayList,当数组里的元素是值类型在操作的时候会出现大量的装箱与拆箱步骤性能会损失许多,...例如,下列声明创建一个四行两列的二维数组: C# int[,]array = new int[4, 2];
  • 3.2.3 创建一个变量变量名的规范 37 3.2.4 Java中的基本运算符表达式 39 3.2.5 Java中的布尔运算符 43 3.3 基本数据类型运算的难点 47 3.3.1 强制类型转换——小数哪里去了 48 3.3.2 类型的转换在运算中...
  • 3.2.3 创建一个变量变量名的规范 37 3.2.4 Java中的基本运算符表达式 39 3.2.5 Java中的布尔运算符 43 3.3 基本数据类型运算的难点 47 3.3.1 强制类型转换——小数哪里去了 48 3.3.2 类型的转换在运算中...
  • 3.2.3 创建一个变量变量名的规范 37 3.2.4 Java中的基本运算符表达式 39 3.2.5 Java中的布尔运算符 43 3.3 基本数据类型运算的难点 47 3.3.1 强制类型转换——小数哪里去了 48 3.3.2 类型的转换在运算中...
  • 声明,实例化,初始化使用一维数组 声明,实例化,初始化使用多维数组 使用Java运算符; 使用括号覆盖运算符优先级 使用==equals()测试字符串其他对象之间的相等性 创建ifif / else三元构造 使用...
  • java基础学习笔记 06

    2020-12-17 15:11:45
    第六章-一维数组 1、什么是数组: 数组是一个变量,存储是相同数据类型的一组数据,声明数组,就是在内存中划分一串连续的空间 注意: 数组一经定义,大小就确定了,不可以在此基础上再增加空间(重新创建除外),...
  • 1.24 我在一个文件中定义了一个extern数组,然后在另一个文件中使用,为什么sizeof取不到数组的大小? 42 声明问题 43 1.25 函数只定义了一次,调用了一次,但编译器提示非法重声明了。 43 *1.26 main的正确定义...
  • 1.24 我在一个文件中定义了一个extern数组,然后在另一个文件中使用,为什么sizeof取不到数组的大小? 声明问题 1.25 函数只定义了一次,调用了一次,但编译器提示非法重声明了。 1.26 main的正确定义是什么?void ...
  • 6.18 当我向一个接受指针的指针的函数传入二维数组的时候,编译器报错了。 6.19 我怎样编写接受编译时宽度未知的二维数组的函数? 6.20 我怎样在函数参数传递时混用静态动态多维数组? 数组的大小 6.21 当数组...
  • 6.18 当我向一个接受指针的指针的函数传入二维数组的时候,编译器报错了。  6.19 我怎样编写接受编译时宽度未知的二维数组的函数?  6.20 我怎样在函数参数传递时混用静态动态多维数组?  数组的大小  6.21...
  •  1.24 我在一个文件中定义了一个extern数组,然后在另一个文件中使用,为什么sizeof取不到数组的大小? 声明问题 1.25 函数只定义了一次,调用了一次,但编译器提示非法重声明了。 *1.26 main的正确定义是...
  • 1.24 我在一个文件中定义了一个extern数组,然后在另一个文件中使用,为什么sizeof取不到数组的大小? 声明问题 1.25 函数只定义了一次,调用了一次,但编译器提示非法重声明了。 1.26 main的正确定义是什么?void ...

空空如也

空空如也

1 2 3 4
收藏数 80
精华内容 32
关键字:

如何声明和创建一个一维数组