数组的常用方法

1. js数组几种常见的操作方法

关于js数组的用法有很多，下面主要针对一些简单的操作，比如合并，反转，添加删除等简单的操作总结一下。

关于js数组的用法有很多，下面主要针对一些简单的操作，比如合并，反转，添加删除等简单的操作总结一下。

第一：读取数组 for循环

方法如下：

var ay=[1,"sdsd","sdsd"]
for (var i=0;i<ay.length;i++) {

console.log("index:"+i+" "+ay[i]) //index：0 1 index：1 sdsd index：2 sdsd

}

第二：合并数组 concat

方法如下：

var arr1=['w','e','s'];

var arr2=['e','y','u'];
var arr3=arr1.concat(arr2);
console.log(arr3) //['w','e','s''e','y','u'];
第三：数组变为字符串格式 join

方法如下：

var arr1=['w','e','s'];

var arr4=arr1.join()
console.log(arr4) //w,e,s

第四：删除最后一个元素,针对老数组是删除最后一个,针对新数组是返回最后一个 pop

var arr6=["d","s","t"];
var arr7=arr6.pop();
console.log(arr6) //["d","s"];
console.log(arr7);// t

第五：添加最后一个元素，针对老数组最后一个元素后面添加一个元素，新数组返回元素个数 push

var arr8=["i","u","t"];

var arr9=arr8.push("k");

console.log(arr8); //["i","u","t","k"];

console.log(arr9); // 4

第六：shift() 和pop()一样，不同的是操作的是开头删除的元素shift（）；具体操作不在展示
第七：unshiift()和push一样，不同的是操作的是开头添加的元素unshift（）；具体操作不再展示

第八：反转数组 reverse

方法如下：

var arr1=['w','e','s'];

var arr10=arr1.reverse()

console.log(arr10) //['s','e','w'];

第九：数组排序 sort a-b正向 b-a 反向

正向

var arr11=[3,1,5,8,28]
var arr12=arr11.sort(function (a,b) {
return a-b;
})
console.log(arr12) //[1,3,5,8,28];

反向

var arr13=arr11.sort(function (a,b) {
return b-a;
})
console.log(arr13) //[28,8,5,3,1]

第十：数组截取 数组截取的方法主要有slice 和splice，另外说到截取我这里随便也把字符串截取带上，字符串截取的方法主要有substr 和substring

（1）slice 使用方法arr.slice(m,n);其中arr为数组，m，n为两个参数，意思是从已有数组中返回选定的元素，截取位置均为下标，其中m必须，为起始位置，可以为负值，n为结束位置（截取位置并不包含）。

示例如下：

①只有起起始值，并且为正，默认的从起始位置一直到整个数组结束，起始下标从0开始

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(1)
console.log(arr) //[2,3,5,6,8,9] 老数组是没有变化的，下面不在列举，都是一样的
console.log(arr1) //[3,5,6,8,9] 只有起始参数，并且为正值，返回新数组从下标1开始截取

②只有起始值，并且为负，默认的是从起始位置一直到整个数组结束，此处没有起始值，数组的最后一个下标是-1，比如此例，如果从-6开始取，必定是整个数组

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-1)
console.log(arr1) //[9] 只有起始参数，并且为负值，从数组尾部截取元素

③有起始值和结束值，并且为正，此处需注意下标是从小到大，比如你（3，1）肯定是取不到值的，另外截取的下标个数并不包含最后一个下标

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(1,4)
console.log(arr1) //[3,5,6] 此时是从下标1开始到下标4，但是需要注意的是并不包含下标4，准确的说是1-3的下标

④有起始值和结束值，并且为负，此处需注意下秒也是从小到大，同理，比如（-1，-6）也是肯定取不到值的，另外截取的下标个数也并不包含最后一个下标

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-6,-1)
console.log(arr1) //[2,3,5,6,8]

⑤有起始值和结束值，并且正负都有

负值到0

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-1,0)

//刚刚都看到了，数组下标都是从小到大的，所以说如果正负都有的情况下，理论上应该可以取值的，比如这个例子，-1为9的小标，0为2的下标，所以取值应该为 [9]，但是结果并不是这样的
console.log(arr1) //[ ] 从这里可以看出他的结果是为空的，所以从负值到0结果是取不到的

负值到正直

var arr=[2,3,5,6,8,9]

var arr1=arr.slice(-1,2)

//那从负值到正值呢，同样也是取不到值的

console.log(arr1) //[ ]

正直到负值

var arr=[2,3,5,6,8,9]

var arr1=arr.slice(2,-1)

//那从正直到负值，这个理论上是取不到的，但是看下结果

console.log(arr1) //[ 5，6，8] 从结果可以看出是可以取的 原理是2的下标为5，-1的下标为9，不包含结束位置下标

总结：这个方法看着可能会麻烦些（也可能被我写的麻烦啦），比如正到负等，不知道大家都是怎么操作，我一般用这个取值都是只截取正的，所以这个实际操作还是非常简单的。

（2）splice 像数组中添加或者删除元素
arr.splice(m,n,index,index1,...,indexx)
m是起始位置，n是删除元素的个数，index是要添加的元素，在不添加元素的前提下，只有第一个参数是必须的，后面两个都不是必须的，在需要添加元素的情况下，三个元素都是必须的，此方法和slice是不一样的，这个返回的是被删除的元素

示例如下：

只删除不添加

注意看此例，是（1，2）删除两个，如果是（1，0），则表示删除零个，也就是不删除的意思，如果只有一个参数则表示从这里开始删除，比如是（1）则为[2]，当然这个也是可以取负值，但是这个和slice是不一样的，只能起始位置取负值，因为删除的个数不可能为负值，slice可以取（2，-1），这个就截然不同啦，但是刚刚也说啦，slice是不可以起始位置取负值，结束位置取正的，但是这个是可以的，比如（-1，0）则表示从-1开始删除零个，结果为[2,3,5,6,8,9]，（-6，2),结果为[5,6,8,9]，另外这个删除的第二个值如果写的过大，也只是删除从本下标到最后一个，比如（2，78）为[2,3]

var arr=[2,3,5,6,8,9]
var arr1=arr.splice(1,2)
console.log(arr) // [2,6,8,9] 注意看此处才是我们要的数组，从下标1开始删除删除两个
console.log(arr1) //[3,5] 此处是我们删除掉的数组

删除加添加 具体的和上面的差不多，主要添加了添加元素的效果，这个也可以添加多个元素

var arr=[2,3,5,6,8,9]
var arr1=arr.splice(1,2,"il")
console.log(arr) //[2,"li",6,8,9]
console.log(arr1) //[3,5]

总结：此方法用的时候，一般也都是只取正值

（3）substr 这个是字符串的用法 用法arr.substr(m,n) m必选也可以负值 n选填，注意看这个并不是结束为止而是截取的个数

示例如下：

只有一个参数 默认从此下标开始，取后面所有的

正值

var arr="sdhgfhf"
var arr1=arr.substr(1)
console.log(arr)// "sdhgfhf"这个是不变的，下面不再列举
console.log(arr1)//"dhgfhf" 从下标1开始取后面所有的

负值

var arr="sdhgfhf"
var arr1=arr.substr(-2)
console.log(arr1)//"hf" 从下标-2开始取后面所有的

两个参数，从第一个下标开始，截取到下标2的长度

var arr="sdhgfhf"
var arr1=arr.substr(1，3)
console.log(arr1)//"dhg" 从下标1开始取后面所有的 同理如果为负值，比如（-6，3）则为"hjf";后面的始终为长度

总结：此方法需注意不要和数组的混淆，这个是截取长度的

（4）substring 用法arr.substring(m,n) 两个参数，m必须，起始位置 ，n选填，截取下标的结束位置，此用法和上面slice有点类似，但是需要注意的是此方法是不支持负值的

示例如下：

只有一个参数

var arr="sdhgfhf"
var arr1=arr.substring(1)
console.log(arr1)//"dhgfhf"从下标1开始取后面所有的

两个参数

var arr="sdhgfhf"
var arr1=arr.substring(1,3)
console.log(arr1)// "dh"从下标1开始截取到下标3，但是不包含3

总结：此方法不支持负值，只针对下标来截取的

最后，以上主要是总结的数组的一些简单的操作方法，学无止境，继续努力。

2. Java数组的几种常用操作方法

int[] num = {5,4,3,2,1};
for(int i = 0; i < num.length - 1; i++) {
for (int j = i + 1; j < num.length; j++) {
if (num[i] > num[j]) {
int tmp = num[i];
num[i] = num[j];
num[j] = tmp;
}
}
System.out.print("排序后：" + num[i]);
}

3. js中操作数组的几个常用方法

1. Array.shift()------删除并返回第一个元素
作用：从数组中删除第一个元素（即下标为0的元素），并返回该元素。
注意：1）删除元素之后，数组的长度-1。2）如果数组是空的，那么 shift() 方法将不进行任何操作，返回 undefined 值。

4. 数组的使用步骤

数组的创建
数组的创建有三步：
l 1 、定义“类型 [] ” ：指定数组里保存的值都是什么类型的
l 2 、定义大小 ：指定数组只能保存多少个元素
l 3 、填充元素：每个元素的值是什么

一、定义类型 :
l 变量的定义大家都知道：类型 变量名
l 数组的定义也是很简单：类型 [] 变量名
l 就是在变量的定义以后，在类型后加一“ [] ”即可。
l 也可以这样定义：“类型 变量名 [] ”，但显示不直观。因为只看类型时，并不能一目也然地看到这是一个数组。
l 示例：
n int[] age ：定义一个 int 类型的 age 数组
n Student[] allStu ：定义一个 Student 类型数组
二、定义大小 (2/3):
l 类型 数组名称 = new 类型 [ 大小 ];
或者在“数组名称”创建以后，也可以这样：
l 数组名称 = new 类型 [ 大小 ];
l 示例：
n int[] age = new age[5] ： age 数组中只能保存 5 个元素
n int[] age ；
age = new age[5]
n Student stu = new Student[3];

三、填充元素
l 一次性填充：
n age = {10,11,12,13,14,15};
n allStu = {stu1,stu2,stu3}
l 逐个填充：
n age[0] = 10; age[1]=20;
n allStu[0]= new Student( );allStu[1] = new Student( );

数组使用要点：
l 两个下标的区别
n 类型名称 [5] ：表示该数组的元素一共有 5 个。如： age = new int[5]
n 数组名称 [5] ：表示该数组的第 6 个元素。如： age[5]
l 数组的循环
n 普通的 for 循环即可：
for(int i=0,i<age.length;i++){ …… }
l 什么时候用数组
n 同一个类型的变量有很多个时，而且对每个变量的处理方法相同，这个时候就要用数组。
n 一维数组最常用。
n 二维数组使用的关键是：类型 [R][C] 。 R 代表行号， C 代表列号。

陷井提醒：数组 [ 数字 ] ：数组的第一个元素为“数组 [0] ”。所以数组元素的是这样数的：第 0 个、第 1 个……。而创建数组“ new 类型 [5] ”，表示的是该数组一共有 5 个元素，不要混淆了。

5. 常用的几个操作数组的方法

concat()连接两个或更多的数组，并返回结果。
join()把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。
pop()删除并返回数组的最后一个元素
push()向数组的末尾添加一个或更多元素，并返回新的长度。
reverse()颠倒数组中元素的顺序。
shift()删除并返回数组的第一个元素
slice()从某个已有的数组返回选定的元素
sort()对数组的元素进行排序
splice()删除元素，并向数组添加新元素。
toSource()返回该对象的源代码
toString()把数组转换为字符串，并返回结果。
toLocaleString()把数组转换为本地数组，并返回结果。
unshift()向数组的开头添加一个或更多元素，并返回新的长度。
valueOf()返回数组对象的原始值

6. 数组遍历常见的方式有

数组遍历常见的方式有：

一、forEach方法

forEach是最简单、最常用的数组遍历方法，它提供一个回调函数，可用于处理数组的每一个元素，默认没有返回值。

二、map方法

map，从字面上理解，是映射，即数组元素的映射。它提供一个回调函数，参数依次为处于当前循环的元素、该元素下标、数组本身，三者均可选。默认返回一个数组，这个新数组的每一个元素都是原数组元素执行了回调函数之后的返回值。

map方法不改变原数组。

三、filter方法

filter，过滤，即对数组元素的一个条件筛选。它提供一个回调函数，参数依次为处于当前循环的元素、该元素下标、数组本身，三者均可选。默认返回一个数组，原数组的元素执行了回调函数之后返回值若为true，则会将这个元素放入返回的数组中。

filter方法不改变原数组。

四、some、every方法

some方法和every的用法非常类似，提供一个回调函数，参数依次为处于当前循环的元素、该元素下标、数组本身，三者均可选。

数组的每一个元素都会执行回调函数，当返回值全部为true时，every方法会返回true，只要有一个为false，every方法返回false。当有一个为true时，some方法返回true，当全部为false时，every方法返回false。

some、every方法不改变原数组。

五、rece方法

rece方法有两个参数，第一个参数是一个回调函数（必须），第二个参数是初始值（可选）。回调函数有四个参数，依次为本轮循环的累计值、当前循环的元素（必须），该元素的下标（可选），数组本身（可选）。

rece方法，会让数组的每一个元素都执行一次回调函数，并将上一次循环时回调函数的返回值作为下一次循环的初始值，最后将这个结果返回。

如果没有初始值，则rece会将数组的第一个元素作为循环开始的初始值，第二个元素开始执行回调函数。

最常用、最简单的场景，是数组元素的累加、累乘。

rece方法不改变原数组。

六、for of方法

es6新增了interator接口的概念，目的是对于所有数据结构提供一种统一的访问机制，这种访问机制就是for of。

即：所有有interator接口的数据，都能用for of遍历。常见的包括数组、类数组、Set、Map等都有interator接口。

(6)数组的常用方法扩展阅读：

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

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

在C语言中， 数组属于构造数据类型。一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。

7. String数组常用的几种遍历方法

list集合的遍历3种方法：

[java] view plain
package com.sort;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
* list的三种遍历
* @author Owner
*
*/
public class ListTest {

public static void main(String[] args) {

List<String> list = new ArrayList<String>();

list.add("a");
list.add("b");
list.add("c");
list.add("c");//可添加重复数据

//遍历方法一
for(Iterator<String> iterator = list.iterator();iterator.hasNext();){
String value = iterator.next();

System.out.println(value);
}

//遍历方法二
for(String value : list){
System.out.println(value);
}

//遍历方法三
for(int i=0;i<list.size();i++){
System.out.println(list.get(i));
}

}
}

三种遍历的比较分析：

方法一遍历：
执行过程中会进行数据锁定, 性能稍差, 同时,如果你想在循环过程中去掉某个元素,只能调用it.remove方法。

方法二遍历：
内部调用第一种

方法三遍历：
内部不锁定, 效率最高, 但是当写多线程时要考虑并发操作的问题

List接口的两种主要实现类ArrayList和LinkedList都可以采用这样的方法遍历

关于ArrayList与LinkedList的比较分析
a) ArrayList底层采用数组实现，LinkedList底层采用双向链表实现。
b) 当执行插入或者删除操作时，采用LinkedList比较好。
c) 当执行搜索操作时，采用ArrayList比较好。

8. 数组中有哪些常用的方法

Array 类是支持数组的语言实现的基类，Array的常用方法有很多，比如GetLength--获取一个 32 位整数，该整数表示 Array 的指定维中的元素数，IndexOf --已重载。 返回一维 Array 或部分 Array 中某个值第一个匹配项的索引，LastIndexOf --返回一维 Array 或部分 Array 中某个值的最后一个匹配项的索引，Resize -- 将数组的大小更改为指定的新大小，Reverse -- 反转一维 Array 或部分 Array 中元素的顺序 ，Sort -- 对一维 Array 对象中的元素进行排序。
Array的一个属性也用的非常频繁，那就是：Length -- 获得一个 32 位整数，该整数表示 Array 的所有维数中元素的总数 。

9. 数组的方法有哪些

数组中常用的方法有：
1、给数组末尾添加新内容的push方法；
2、删除数组最后一项的pop方法；
3、删除数组第一项的shift方法；
4、向数组首位添加新内容unshift方法；
5、按照条件查找出其中的部分内容。

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

在C语言中， 数组[2]属于构造数据类型。一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。
关于可变长数组（VLA）的问题：原来的C89标准中是不允许可变长数组出现的，但是在C99标准中，加入了对VLA的支持，但是支持的编译器不多，而且由于栈溢出的安全问题，没有太多的人敢用这个可变长数组，所以在C11标准中又把它规定为可选实现的功能了。

如果有过用其它语言编程的经历，那么想必会熟悉数组的概念。由于有了数组，可以用相同名字引用一系列变量，并用数字（索引）来识别它们。在许多场合，使用数组可以缩短和简化程序，因为可以利用索引值设计一个循环，高效处理多种情况。数组有上界和下界，数组的元素在上下界内是连续的。因为 Visual Basic对每一个索引值都分配空间，所以不要不切实际声明一个太大的数组。

此处数组是程序中声明的变量数组。它们不同于控件数组，控件数组是在设计时通过设置控件的 Index 属性规定的。变量数组总是连续的；与控件数组不同的是，不能从一个数组的中部加载或卸载数组元素。

10. c#中Array类中的常用方法的功能

Array 类是支持数组的语言实现的基类，Array的常用方法有很多，比如GetLength--获取一个 32 位整数，该整数表示 Array 的指定维中的元素数，IndexOf --已重载。 返回一维 Array 或部分 Array 中某个值第一个匹配项的索引，LastIndexOf --返回一维 Array 或部分 Array 中某个值的最后一个匹配项的索引，Resize -- 将数组的大小更改为指定的新大小，Reverse -- 反转一维 Array 或部分 Array 中元素的顺序 ，Sort -- 对一维 Array 对象中的元素进行排序。
Array的一个属性也用的非常频繁，那就是：Length -- 获得一个 32 位整数，该整数表示 Array 的所有维数中元素的总数 。
Array还有其它的一些方法、属性和成员变量，这些需要在实际的项目中慢慢体会……