数组方法与使用。

已于 2022-05-16 12:15:12 修改
阅读量898 收藏 2
点赞数 1
分类专栏： JavaSE 文章标签： java
于 2022-04-10 22:54:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/k1159/article/details/124086783
版权

1、什么是数组：

本质上让我们可以”批量“创建相同类型的变量
也是一种数据结构–顺序表
【注】数据结构即把一堆数据保存起来的结构，关心的是如何高效的读写数据，

2、数组的创建与初始化：

①数组的动态初始化

语法：数据类型[] 数组名称 = new 数组类型[]{}
数据类型[] 数组名称 = new 数组类型[number]

//eg
int[] arr = new int[]{1,2,3,4,5};
int[] arr = new int[5];
//创建数组时，若没有使用{}来初始化每个元素值，那么每个元素都是该数据类型的默认值

②数组的静态初始化

语法： 数据类型[] 数组名称 = {初始化数据}；
【注】静态初始化时Java的语法糖，javac编译之后，就是动态初始化
语法糖：只存在编译期之前

//eg
int[] arr = {1,2,3,4,5};

3、数组的使用

3.1 获取一个数组的长度，使用数组名称.length
3.2 访问数组元素，使用数组名称[元素的索引]，数组的索引从0开始，数组名.lengtg-1 结束。
【注】注意数组越界

4、数组的遍历

①for循环
②增强型for循环

public class Array{
	public static void main (String[] args){
		int[] arr1 = new int[]{1,2,3,4,5};
			for(int i= 0;i < arr1.length;i++){
				System.out.println(arr[i]+" ");
			}
			//增强型for循环
			//此处的i指从数组的第一个元素开始取值，第一次把第一个元素复制一份给i，第二次循环把第二个元素的值复制一份给i，以此类推，直到把整个数组遍历结束。
			//只能读取数组的元素值，无法修改，i是每个元素值的拷贝，并不是实实在在的数组元素。
			for（int i ： arr1）{
				System.out.println(i +" ");
			}
	}
}
//输出结果：1 2 3 4 5

5、数组和方法之间的关系：
①数组作为方法的参数
创建一个方法接受一个任意的整型数组并打印

public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        printArr(arr);
    }
    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

②关于引用数据类型的理解问题
实参：位于主方法的临时变量；形参：位于方法中的临时变量。
栈

方法的调用就是在栈区进行的，每个方法的调用过程，就是一个栈帧的入栈以及出栈过程，是一种先进后出的结构（LIFO），方法的局部变量和形参都在其中存储。当方法调用结束出栈时，临时变量都是被销毁。

堆：

所有对象都在堆中存储，数组对象，类的实例化对象，接口的对象。
引用就是起了个”别名“。数组的引用实际上就是保存数组的首元素地址。

在这里插入图片描述

public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2};
        printArr(arr);
        System.out.println(arr[0] + " "+arr[1]);
    }

    private static void printArr(int[] arr) {
        int temp = arr[0];
        arr[0] = arr[1];
        arr[1] = temp;
    }
}

内存图：
在这里插入图片描述

public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2};
        printArr(arr);
        System.out.println(arr[0] + " "+arr[1]);
    }

    private static void printArr(int[] arr) {
        arr = new int[]{10,20};
        int temp = arr[0];
        arr[0] = arr[1];
        arr[1] = temp;
    }
}

内存图：
在这里插入图片描述
数组对象：
实实在在在堆中存储，所有new出来的都在堆中
数组的引用：
给这块数组起了个名字，保存这个数组对象的首地址。

数组练习：

1、数组对象转为字符串对象
Arrays.toString（）方法
【注】dk中某些类后+s，这些是工具类，提供了大量有用的方法，直接调用即可。

import java.util.Arrays;
public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3};
        //JDK内置工具类
        String str = Arrays.toString(arr);
        System.out.println(str);
    }
}
//输出结果
//[1, 2, 3]

2、数组的复制
①Arrays.copyOf（）方法

import java.util.Arrays;
public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3};
        //新数组长度小于原数组
        int[] arr1 = Arrays.copyOf(arr, 2);
        //新数组长度等于原数组
        int[] arr2 = Arrays.copyOf(arr, 3);
        //新数组长度大于原数组
        int[] arr3 = Arrays.copyOf(arr, 4);
        System.out.println(Arrays.toString(arr1));
        System.out.println(Arrays.toString(arr2));
        System.out.println(Arrays.toString(arr3));
    }
}
//输出结果
//[1, 2]
//[1, 2]
//[1, 2, 3, 0]

②Arrays.copyOfRange（）方法

public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6};
        //Arrays.copyOfRange方法复制从索引2到索引5的数组元素值
        int[] arr1 = Arrays.copyOfRange(arr, 2, 5);
        System.out.println(Arrays.toString(arr1));
    }
}
//输出结果
//[3, 4, 5]

3、给定一个数组找出这个数组的最大值

public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6};
        //假定数组第一个元素值为最大值，遍历比大小。
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        System.out.println("数组最大值为：" + max);
    }
}
//输出结果
//数组最大值为：6

4、二分查找（仅升序或者降序）

public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5,6,7,8,9};
        System.out.println(binarySearch(arr,4));
        System.out.println(binarySearch(arr,8));
        System.out.println(binarySearch(arr,11));
    }

    //找到返回索引没找到返回-1；
    public static int binarySearch(int[] arr, int toFind) {
        //开始位置
        int left = 0;
        //结束位置
        int rigth = arr.length - 1;
        //终止循环条件：left>right;
        while (left <= rigth) {
            int mid = (left + rigth) / 2;
            if (toFind < arr[mid]) {
                rigth = mid - 1;
            } else if (toFind > arr[mid]) {
                left = mid + 1;
            } else {
                //arr[mid]  =  toFind;
                System.out.print("找到该元素！");
                return mid;
            }
        }
        System.out.println("没有找到！");
        return -1;
    }
}
//输出结果
//找到该元素！3
//找到该元素！7
//没有找到！
//-1

递归写法：

public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
        System.out.println(binarySearch(arr,3,0, arr.length-1));
        System.out.println(binarySearch(arr,6,0, arr.length-1));
        System.out.println(binarySearch(arr,11,0, arr.length-1));
    }
        
    public static int binarySearch(int[] arr, int toFind, int left, int right) {
        if (left > right) {
            return -1;
        }
        //还有元素，我只知道中间元素
        int mid = (left + right) / 2;
        if (arr[mid] == toFind) {
            return mid;
        } else if (toFind < arr[mid]) {
            return binarySearch(arr, toFind, left, mid - 1);
        }
         return binarySearch(arr, toFind, mid + 1, right);
    }
//输出结果
//2
//5
//-1

【注】当面对乱序时，可先将数组排序，后使用二分查找某元素，效率较遍历仍然很快。

5、判断数组是否是一个顺序数组

public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 4};
        System.out.println(isSorteArray(arr));
    }

    public static boolean isSorteArray(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                return false;
            }
        }
        return true;
    }
}
//输出结果
//false

6、数组排序
①冒泡排序
在这里插入图片描述
核心思想：假设现在数组有n个元素，每遍历一次就将数组中最大值放在数组末尾，每进行一次遍历，就有一个元素到达了最终位置。
将整个数组分为两个子数组：
1、待排序的数组[0…n]
2、已经排好序的数组[]
每进行一次遍历，待排序的数组元素-1已排序好的数组元素+1。

public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 2, 5, 6, 9, 7, 8, 4};
        System.out.println(Arrays.toString(bubbleSorting(arr)));
    }

    public static int[] bubbleSorting(int[] arr) {
        int[] arr1 = null;
        //表示遍历的次数，每进行一次就有一个较大值到达位置
        for (int i = 0; i < arr.length; i++) {
            //待排序的数组[0--i-1]，已排序[]
            //j+1<arr.length
            //-i表示已经排列好的元素个数
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    //交换数据
                    int temp = 0;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }
}
//输出结果
//[1, 2, 3, 4, 5, 6, 7, 8, 9]

优化：
①最后一个元素已经有序不需要排序
②若本来就是升序就不需要排序

public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7};
        System.out.println(Arrays.toString(bubbleSorting(arr)));
    }

    public static int[] bubbleSorting(int[] arr) {
        //表示遍历的次数，每进行一次就有一个较大值到达位置
        //i<arr.length-1;表示剩最后一个元素就已经有序，不需要遍历
        for (int i = 0; i < arr.length - 1; i++) {
            boolean isWsaped = false;
            //待排序的数组[0--i-1]，已排序[]
            //j+1<arr.length
            //-i表示已经排列好的元素个数
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    isWsaped = true;
                    int temp = 0;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if (!isWsaped) {
                //内存循环没有元素交换，整个数组已经有序，提前退出循环
                break;
            }
        }
        return arr;
    }
}
//输出结果
//[1, 2, 3, 4, 5, 6, 7]

7、升序或者降序的数组输出逆序

import java.util.Arrays;
public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
        reverse(arr);
    }

    public static void reverse(int[] arr) {
        int i = 0;
        int j = arr.length - 1;
        while (i < j) {
            int temp = 0;
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
        System.out.println(Arrays.toString(arr));
    }
}
//输出结果
//[8, 7, 6, 5, 4, 3, 2, 1]

8、数组的数字排列问题

题目：给定一个整型数组，将所有的偶数放在前半部分，将所有的奇数放在数组的后半部分
例{1，2，3，4，5，6}输出{6，2，4，3，5，1}

思路：
分别定义i，j从前从后找奇数和偶数，找到第一个奇数和第一个偶数，交换他们的值。

public class Thinking {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
        transform(arr);
    }

    public static void transform(int[] arr) {
        int i = 0;
        int j = arr.length - 1;
        while (i < j) {
            //i从前向后找到第一个奇数为止
            while (i < j && arr[i] % 2 == 0) {
                i++;
            }
            //此时i一定是落在了第一个奇数的位置
            //j从后向前找到第一个偶数位置
            while (i < j && arr[j] % 2 != 0) {
                j--;
            }

            //此时j一定是落在了第一个偶数的为位置
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
        System.out.println(Arrays.toString(arr));
    }
}
//输出结果
//[8, 2, 6, 4, 5, 3, 7, 1, 9]

9、给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标，你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
返回：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

import java.util.Arrays;
public class ClassPractic {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        System.out.println(Arrays.toString(twoSum(arr, 6)));
        System.out.println(Arrays.toString(twoSum(arr, 9)));
        System.out.println(Arrays.toString(twoSum(arr, 5)));
    }

    //双引用法--双指针
    public static int[] twoSum(int[] arr, int target) {
        int[] arr1=new int[2];
        for (int i = 0; i < arr.length; i++) {
            for (int j = arr.length - 1; j > i; j--) {
                if (arr[i] + arr[j] == target) {
                    arr1[0] = i;
                    arr1[1] = j;
                    return arr1;
                }
            }
        }
        return arr1;
    }
}
//输出结果
//[0, 4]
//[0, 4]
//[0, 3]

10、给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
在这里插入图片描述

//方法一：双指针、计数器法
public class ClassPractic {
    public static void main(String[] args) {
        int[] arr = new int[]{2, 2, 1};
        int[] arr1 = new int[]{4, 1, 2, 1, 2};
        System.out.println("只出现一次的元素是：");
        System.out.println(findNum(arr));
        System.out.println(findNum(arr1));
    }

    //给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。
    // 找出那个只出现了一次的元素。
    public static int findNum(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            //定义一个计数器，由题可知只有一个元素出现了一次，那么出现相同的次数就是1
            // 只有它符合这个计数，所以当计数出现就返回它的元素值。
            int count = 0;
            for (int j = 0; j < arr.length; j++) {
                if (arr[i] == arr[j]) {
                    count++;
                }
            }
            if (count == 1) {
                return arr[i];
            }
        }
        return -1;
    }
}
//输出结果
//只出现一次的元素是：
//1
//4

//方法二：异或：同0异1
public class ClassPractic {
    public static void main(String[] args) {
        int[] arr = new int[]{2, 2, 1};
        int[] arr1 = new int[]{4, 1, 2, 1, 2};
        System.out.println("只出现一次的元素是：");
        System.out.println(findNum(arr));
        System.out.println(findNum(arr1));
    }

    //给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。
    // 找出那个只出现了一次的元素。
    public static int findNum(int[] arr) {
        int num = 0;
        for (int i : arr) {
            num ^= i;
        }
        return num;
    }
}
//输出结果
//只出现一次的元素是：
//1
//4

11、【注】：向下取整的运算称为Floor，用数学符号⌊⌋表示；向上取整的运算称为Ceiling，用数学符号⌈⌉表示。在这里插入图片描述

//方法一：双指针计数器
public class ClassPractic {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 2, 3};
        int[] arr1 = new int[]{2, 2, 1, 1, 1, 2, 2};
        System.out.println(majorityElement(arr));
        System.out.println(majorityElement(arr1));
    }

    public static int majorityElement(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            //设置一个计数器，由题目可只，当一个数出现次数大于n/2时它是多数元素
            //此时返回该元素值
            int count = 0;
            for (int j = 0; j < arr.length; j++) {
                if (arr[i] == arr[j]) {
                    count++;
                }
            }
            if (count > arr.length / 2) {
                return arr[i];
            }
        }
        return -1;
    }
}
//输出结果
//3
//2

//方法二：排序最中间的数必是最多元素。
public class ClassPractic {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 2, 3};
        int[] arr1 = new int[]{2, 2, 1, 1, 1, 2, 2};
        System.out.println(majorityElement(arr));
        System.out.println(majorityElement(arr1));
    }

    public static int majorityElement(int[] arr) {
       //排序
        Arrays.sort(arr);
        //位运算。  >>右移，同意于除2
        return arr[arr.length >> 1];
    }
}
//输出结果
//3
//2

//摩尔投票法
//假设第一个元素为第一个候选人，相同则投赞成票，不同则投反对票，
//赞成票+1反对票-1，当票数为0时，换候选人为当前投票人。
public class ClassPractic {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 2, 3};
        int[] arr1 = new int[]{2, 2, 1, 1, 1, 2, 2};
        System.out.println(majorityElement(arr));
        System.out.println(majorityElement(arr1));
    }

    public static int majorityElement(int[] arr) {
        int num = arr[0];
        //票数
        int count = 1;
        for (int i = 1; i < arr.length; i++) {
            if (num == arr[i]) {
                count++;
            } else {
                count--;
                if (count == 0) {
                    num = arr[i];
                    count =1;
                }
            }
        }
        return num;
    }
}
//输出结果
//3
//2

在这里插入图片描述
若在一组数中，至多选择m个元素，则该元素的得票数 >⌊ n/(m+1) ⌋
核心步骤：
1、选侯选人，票数为0更换候选人，直到整个数组扫描完毕
2、统计候选人的票数，看他是否满足 >⌊ n/(m+1) ⌋
摩尔投票法之选两个人

二维数组：

1、语法：

数据类型[][] 数组名称 = new 数据类型[行数][列数]{可选的初始化数据}；

public class Thinking {
    public static void main(String[] args) {
        int[][] arr = new int[][]{
                {1, 2, 3},
                {2, 3, 4},
        };
        //行
        for (int i = 0; i < arr.length; i++) {
            //列
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }
}
//输出
//1	 2	3	
//2  3	4
蕾姆的48六
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数组的使用（调用）
qdyones的博客
12-10 2752
package base.Array; public class Demo04 { public static void main(String[] args) { int[] i={1,2,3}; aaa(i); //这里相当于就是调用了aaa方法的i模型 } public static void aaa(int[] i) { for (int i1 = 0; i1 < i.length; i1++) { System.out.println(i[i1]
数组方式调用
zhanglong200211的博客
04-04 2010
public static void main(String[] args) { int num=9; //数组:一次性生成多个连续同类型的数据，使用【数组名+索引号】方式调用 //声明方式一:声明即赋值，不用指定空间大小,不能拆分 int[] nums1={1,2,3,4,5}; //声明方式二:声明确定空间大小 int[] nums2=new int[]{1,2,3,4,5}; ...
C#存储过程调用通用类(改进)
wyaspnet的专栏
12-02 869
C#存储过程调用通用类(改进) Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->// ==============================// Author:  ZhiQiao// Date:    2008/09/16// File:
数组方法的调用
2301_76394512的博客
02-18 686
//定义一个方法,求长方形的周长 public class MethodTest { public static void main(String[] args) { //调用方法格式: 方法名(数值); perimeter(13.14, 5.2);//结果为36.68 int[] array1 = {11, 22, 33, 44, 55}; //数组调用方法格式:方法名(数组); method1(arra
javascript中数组的几种调用方法
xiongmaoren_v的博客
06-10 1629
1.join() 将所有元素zhuan'hu 2.toString() 3.push() 4.pop() 5.reverse()
javascript数组使用调用方法汇总
10-30
JavaScript 数组使用调用方法汇总 JavaScript 数组是一种重要的数据结构，用于存储和操作多个值。数组提供了多种方法来操作和处理数组元素，这些方法可以分为以下几类：添加元素、删除元素、排序、查找、转换等。 ...
JS数组的高级使用方法示例小结
10-15
在本文中，我们将深入探讨JavaScript数组的高级使用方法，包括增删改查、排序以及生成随机数。 首先，让我们从数组的基本操作开始。`length`属性可以帮助我们获取数组的长度，例如： ```javascript var array = ...
ORACLE数组使用方法
01-08
ORACLE 数组使用方法 Oracle 数组是一种复杂的数据类型，可以存储多个元素，数组可以分为固定数组和可变数组两种类型。在 Oracle 中，数组可以用来存储大量的数据，并且可以通过索引来访问数组中的元素。 固定数组...
JavaScript数组push方法使用注意事项
01-21
js 数组的push方法，想必大家都知道是向数组末尾添加元素，但是有一个很关键的点需注意： 引自 MDN 返回值 当调用该方法时，新的 length 属性值将被返回。 var sports = [soccer, baseball]; var total = sports....
Ruby创建数组方法总结
12-31
程序经常需要管理变量...在下面的示例程序中，使用array命令和赋值运算符创建一个空数组。从键盘上读取三个字符串(字符的有序序列)并“pushed”或添加到数组的末尾。 #!/usr/bin/env ruby array = Array.new 3.time
数组元素的调用
weixin_44548893的博客
07-08 1339
访问数组元素的格式： 数组名称[索引值] num [1] 索引值就是一个int数字，代表数组当中元素的编号 【注意】索引值从0开始，一直到“数组的长度-1"为止 使用动态初始化数组的时候，其中的元素会有一个默认值 整数型 默认 0 浮点型 默认0.0 字符型 默认’\u0000’ 布尔型 默认 false 引用型 默认 null。 数组中存放数据 num[1]=123; //把123赋值给变量中的索引值为1的元素 注意事项 1、静态初始化也有默认值的过程，只不过系统马上将默认值替换成为了大括号当中的具体数值
数组基础知识及调用方式
丶无题灬景恒的博客
07-08 1562
数组 是一种容器,可以同时存放多个数据值. 特点 1.是引用类型 (引用类型----->导包,调关键字,调方法) ​2.数据类型必须统一 3.长度在运行过程中不可改变 数组的初始化:在内存中创建一个数组,并且向其中赋予一些默认值 两种常见初始化格式 : 1.动态初始化 (指定长度)----->直接指定数组中的数据元素个数 格式 :数据类型[ ] + 数组名称 = new + 数组类型[数组长度]; int[] a = new int[5]; 5为数组长度 2.静态
Javascript -- 数组方法学习
aina0674的博客
06-01 201
1、Array.from() 参考文献 这个方法比较有意思，可以将一个类似数组或可迭代对象分割，然后将值返回为一个新数组 伪数组对象（拥有一个 length 属性和若干索引属性的任意对象） 可迭代对象](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/iterable)（可以获取对象中的元素,如 Map和 Set...
数组的用函数调用-基础
qq_31779439的博客
09-12 922
package Demo03; public class demo01Param { public static void main(String[] args) { int []arrayA={1,2,3,4,5,6,7,8,9}; System.out.println(arrayA);//地址值 PrintArray(arrayA); System.out.println("-------------"); PrintArray(arrayA); System.out.println("--------
数组的使用方法
qq_43174912的博客
03-22 3399
title: 数组 tags: JavaScript notebook: 2022年3月22日笔记 indexOf/lastIndexOf 作用： 参数： 返回值： 是否改变原数组： indexOf(第一次出现) 第一个参数 你要检索的项 第二个参数 从哪里开始检索 var ary = [1,2,3,1,1,2,3]; var returnVlue = ary.indexOf(1,2); console.log(returnVlue,ary);//3,原数组 lastInde.
数组方法的使用
最新发布
weixin_71110616的博客
02-28 132
数组方法的使用
js中在数组中调用方法
Hualihenhao的博客
03-15 2928
关于在js中，在数组中调用方法时，必须使用this，而不能使用arr[i]，因为函数是只加载函数名，不加载函数体。当循环执行时，传给方法内的i的值，始终是最后一个值。...
数组的引用
dizuo的专栏
04-08 2294
数组 引用
关于在类数组中使用数组方法
weixin_33810006的博客
12-04 1791
类数组是指具有数字索引下标并且有length属性的对象 {'1': 'a', '2': 'b', length: 3} 复制代码由于它们并不是真正的数组并不能使用数组的方法；那么有什么方法可以让他们用上方便的数组方法呢？ 借助call和apply (function() { Array.prototype.push.call(arguments, 4) console.log(ar...
C#面向对象设计：掌握数组、方法与数据结构
《C_面向对象程序设计》的第4章主要聚焦于数组与方法的深入理解和实践。本章内容涵盖了以下几个核心知识点： 1. 数组基础： - 数组是相同类型变量的集合，通过索引或下标进行访问，如存储每月降雨量的数据，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值