javascript中的数组

数组的创建

直接创建方式  var str = ['java', 'js'];

使用new创建方式： var a = new Array(10);  //  定义长度为10的数组(可变)

另类new创建方式：var a = new Array(1, 2, 3, 4, 5);var b = [1, 2, 3, 4, 5];

二维数组(多维)创建方式：var a = new Array([1,2,3], [4,5,6], [7,8,9]);  var b = [[1,2,3], [4,5,6], [7,8,9]];

创建数组注意事项：js中的数组长度、类型都是“动态性”的。即长度可变、类型多样。

数组的判别

面试的时候经常会被问道：js中怎么判断一个变量是数组类型？

答案有很多，这里我列举一下我所知道的一些判断方法

1 //千万别犯这种错误

2 console.log(typeof []) //object

3 //方法一

4 var arr = [1,2,3];5 console.log(arr.constructor === Array)//true

6 //方法二

7 console.log(arr instanceof Array) //true

8 //方法三

9 console.log(Object.prototype.toString.call(arr) === '[object Array]')//true

10 //方法四

11 Array.isArray(arr) //es5 新方法

数组的常用方法

arr. push();// 将一个或多个新元素添加到数组结尾，并返回数组新长度

arr.unshift();// 将一个或多个新元素添加到数组开始，返回数组新长度

arr.splice(arg1,arg2,arg3); //增删改都可以，非常强大

arr.pop();//移除最后一个元素并返回该元素值

arr.shift(); //移除最前一个元素并返回该元素值，数组中元素自动前移

arr.slice(start, [end]);//以数组的形式返回数组的一部分，注意不包括 end 对应的元素

arrayObj.reverse(); //反转元素(最前的排到最后、最后的排到最前)

arrayObj.sort(); //对数组元素排序，返回数组地址

es5 新增的数组方法，详情见下面代码

1 //代码来自网络，大致能表达我的意思2 //定义一个数组，存储不同数据类型的元素

3 var array = [8, 2, 1, 5],4 array2 =[5 [0, 1],6 [1, 2],7 [2, 3]8 ],9 value;10

11 ///Array.prototype.reduce = function(callback,initialValue) {};

12 //化解数组：13 //调用reduce 方法提供的回调函数，14 //总共调用 数组的lenght - 1次 回调函数15 //第一次时 previousValue 为 initialValue16 //此后 reduce方法的返回值 作为 previousValue17

18 //reduceRight 则从数组最右边开始，进行上述操作19

20 //数组中元素累加

21 value =array.reduce(function (previousValue, currentValue, index, array) {22 return previousValue +currentValue;23 }24 );25 console.log(value); //1626

27 //数组扁平化

28 value =array2.reduce(function (previousValue, currentValue, index, array) {29 returnpreviousValue.concat(currentValue);30 }31 );32 console.log(value); //[ 0, 1, 1, 2, 2, 3 ]

33

34 ///Array.prototype.indexOf = function(searchElement,fromIndex) {};

35 //从fromIndex索引处 向后寻找searchElement元素 找到并返回其索引，否则返回-136 //fromIndex 默认为 0

37 console.log(array.indexOf(1)); //2

38 console.log(array.indexOf(3)); //-1

39

40 ///Array.prototype.lastIndexOf = function(searchElement,fromIndex) {};

41 //从fromIndex索引处 向前寻找searchElement元素 找到并返回其索引，否则返回-1

42 console.log(array.lastIndexOf(1)); //2

43 console.log(array.lastIndexOf(3)); //-1

44

45 ///Array.prototype.every = function(callback,thisObject) {};

46 //测试数组的所有元素是否都通过了指定函数的测试

47 value =array.every(function (element, index, array) {48 return element > 1;49 });50 console.log(value); //false

51

52

53 ///Array.prototype.filter = function(callback,thisObject) {};

54 //数组过滤：55 //返回通过函数测试的 元素(当回调函数的返回true，表明元素通过测试 )，生成新的数组

56 value =array.filter(function (element, index, array) {57 return element > 1;58 });59 console.log(value);//[ 8, 2, 5 ]

60

61

62 ///Array.prototype.forEach = function(callback,thisObject) {};

63 //为每个数组元素执行一次回调函数。

64 array.forEach(function (element, index, array) {65 console.log(element);66 });67

68

69 ///Array.prototype.map = function(callback,thisObject) {};

70 //数组映射：71 //返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组。

72 value =array.map(function (element, index, array) {73 return element *element;74 });75 console.log(value); //[ 64, 4, 1, 25 ]

76

77

78 ///Array.prototype.some = function(callback,thisObject) {};

79 //测试数组中的某些元素是否通过了指定函数的测试。

80 value =array.some(function (element, index, array) {81 return element > 1;82 });83 console.log(value); //true

84

85

86 ///Array.prototype.isArray = function(object) {};

87 //判断元素是否为数组类型

88 console.log(Array.isArray(array)); //true

View Code

这是我在谷歌浏览器查找的数组全部方法属性 截图如下

数组的重要知识点

数组是传递引用的

1 var x = [1, 9, 8];2 var y =x;3 x[0] = 2;4 console.log(y[0]);//2

2. 联合数组

1 var arr=[];2 arr['a']=1;3 arr['b']=2;4 console.log(a.length);//0 数组是对象类型，当然js中一切皆为对象！！！

3.类数组。

JavaScript和DOM中有很多类数组对象，它们只是类似数组，而不是数组，并不能使用数组的特有方法，如slice、push、pop等。

arguments

getElementsByName(name)

getElementsByClassName(className)

getElementsByTagName(tagName)

document.forms //所有form元素

document.images //所有img元素

document.links //所有带href属性的a元素和area元素

.......

类数组转为真正的数组方法：Array.prototype.slice.call(arguments);

4.稀疏数组。

稀疏数字就是包含从0开始的不连续索引的数组。

稀疏数组的length属性值大于元素的个数. 代码如下

var a=[];

a[100]=23;

console.log(a.length);//101

5.作为数组的字符串

个人理解是：可索引的字符串。

var s="javascript";

console.log(s[1]);//a 标准的字符串方法应该是s.charAt(1)//数组和字符串方法可以灵活的相互利用

Array.prototype.join.call(s,"+");//j+a+v+a+s+c+r+i+p+t

备注：push()、sort()、reverse()、splice()等数组方法会修改数组，但是在字符串上是无效的。因为字符串是不可变值！！！

java中的数组

前言：JAVA数组与容器类主要有三方面的区别：效率、类型和保存基本类型的能力。在JAVA中，数组是一种效率最高的存储和随机访问对象引用序列的方式。数组就是一个简单的线性数列，这使得元素访问非常快速。但是为此付出的代价却是数组的大小被固定，并且在其生命周期中不可改变。

数组的创建

type[] 变量名 = new type[数组中元素的个数];

type[] 变量名 = {"a","b"}

java中数组长度不可变，类型一致

个人觉得java中直接用数组的机会不是很大，大多数都是用集合(很多方法都是基于数组)

为什么需要数组

当我们定义一个变量时可以使用一个变量名表示，但是如果出现很多的变量我们分别起变量名代替表示存储就比较麻烦了，为了解决这样的问题我们采用数组的形式表示存储，使用下标        表示每个变量。

声明一个变量就是在内存中划出一块合适的空间；声明一个数组就是在内存中划出一串连续打的空间

数组方法

1、打印数组

int[] intArray = { 1, 2, 3, 4, 5};

String intArrayString=Arrays.toString(intArray);//print directly will print reference value

System.out.println(intArray);//[I@7150bd4d

System.out.println(intArrayString);//[1, 2, 3, 4, 5]

2、检查一个数组是否包含某个值

String[] stringArray = { "a", "b", "c", "d", "e"};boolean b = Arrays.asList(stringArray).contains("a");

System.out.println(b);//true

3、移除数组中的元素

int[] intArray = { 1, 2, 3, 4, 5};int[] removed = ArrayUtils.removeElement(intArray, 3);

System.out.println(Arrays.toString(removed));

4、数组转为list

String[] stringArray = { "a", "b", "c", "d", "e"};

ArrayList arrayList = new ArrayList(Arrays.asList(stringArray));

System.out.println(arrayList);//[a, b, c, d, e]

5、数组转为set

Set set = new HashSet(Arrays.asList(stringArray));

System.out.println(set);//[d, e, b, c, a]

6、数组比较

Arrays提供了重载后的equals()方法，针对所有类型和Object类型都做了重载，用来比较整个数组。数组相等的条件是元素个数必须相等，并且对应位置的元素也相等。而多维数组的比较用deepEquals()方法。Array.equals()方法比较的两个数组必须是同类型的数组。

import java.util.Arrays;

public class javaArrayEquals{

public staticvoidmain(String args[]){int[] arrayA = {1,2,3};int[] arrayB = {1,2,3,};int[] arrayC = new int[4]; //if int[] arrayC = new int[3],return true

arrayC[0] = 1;

arrayC[1] = 2;

arrayC[2] = 3;

System.out.println(Arrays.equals(arrayA, arrayB));

System.out.println(Arrays.equals(arrayA, arrayC));

String[][] arrayD= {{"a","b"},{"c","d"}};

String[][] arrayE= {{"a","b"},{"c","d"}};

System.out.println(Arrays.deepEquals(arrayD, arrayE));

}

}

View Code

7、集合更加强大。在开发中我们尽量用集合，而不是直接用数组解决问题

接下来的一个月，我要整天rhino、ps、手绘，应该不会过多的碰代码。因为不管怎么样，我必须得要顺利毕业吧！