Array.isArray() 用于确定传递的值是否是一个 Array。
//例如：
Array.isArray([1,2,3,])
//返回true
Array.isArray({foo: 123});
//返回false
//假如不存在 Array.isArray()，则在其他代码之前运行下面的代码将创建该方法。
if (!Array.isArray) {
Array.isArray = function(arg) {
return Object.prototype.toString.call(arg) === '[object Array]';
};
}
Array.of() 返回一个由参数组成的数组
Array.of() 可以把一组参数转换为数组。这个方法用于替代在ES6之前常用的Array.prototype.slice.call(arguments)。
//这个方法的主要目的，是弥补数组构造函数Array()的不足。因为参数个数的不同，会导致Array()的行为有差异
//可以将一组数值转换为数组
Array.of(1,2,3)//转换为[1,2,3]
//Array方法没有参数、一个参数、三个参数时，返回结果都不一样。只有当参数个数不少于 2 个时，Array()才会返回由参数组成的新数组。参数个数只有一个时，实际上是指定数组的长度。
Array() // []
Array(2) // [, , ]
Array(2, 10, 9) // [2, 10, 9]
//Array.of()方法基本上可以用来替代Array()或new Array()，并且不存在由于参数不同而导致的重载。它的行为非常统一。
Array.from() 将数组对象转换为数组 不改变原对象 返回新数组
第一个参数是一个类数组对象，即任何可迭代的结构，或者有一个 length 属性和可索引元素的结构。
// 字符串会被拆分为单字符数组
console.log(Array.from("Matt")); // ["M", "a", "t", "t"]
// 可以使用from()将集合和映射转换为一个新数组
const s = new Set().add(1).add(2).add(3).add(4);
console.log(Array.from(s)); // [1, 2, 3, 4]
// Array.from()对现有数组执行浅复制
const a1 = [1, 2, 3, 4];
const a2 = Array.from(a1);
console.log(a1); // [1, 2, 3, 4]
a1 === a2; // false
a2.push(5);
a1.length; //?
// arguments对象可以被轻松地转换为数组
function getArgsArray() {
return Array.from(arguments);
}
console.log(getArgsArray(1, 2, 3, 4)); // [1, 2, 3, 4]
// from()也能转换带有必要属性的自定义对象
const arrayLikeObject = { 0: 1, 1: 2, 2: 3, 3: 4, length: 4 };
console.log(Array.from(arrayLikeObject)); // [1, 2, 3, 4]
//没有length的对象不行，因为会将0,1,2,3当做对象的key，而不当做是下标
const arrayLikeObject = { 0: 1, 1: 2, 2: 3, 3: 4 };
console.log(Array.from(arrayLikeObject)); // []
pop() 删除数组最后一个元素（改变原数组） 返回被删除的元素
let arr = [1,2,3,4,5,6]
let brr = arr.pop()
console.log(brr)
//打印结果[1,2,3,4,5]
//pop是将数组中的最后一个元素删除
shift() 删除数组的第一个元素 (改变原数组) 返回被删除的元素
let arr =[1,2,3,4,5,6]
let brr = arr .shift()
console.log(brr)
//打印结果[2,3,4,5,6]
push() 向末尾添加元素（改变原数组） 返回添加后的length
let arr = [1,2,3,4,5]
let drr=arr.push(6)
console.log(drr)//[1,2,3,4,5,6]
unshift() 向数组开头添加元素（改变原数组） 返回添加后数组的length
let numbers = [1, 2, 3, 4, 5];
let length = numbers.unshift(7, 8, 9);
console.log(length); // 8
console.log(numbers); // [7, 8, 9, 1, 2, 3, 4, 5]
reverse() 反转数组 改变原数组
// 书中的例子，只是作为反向排序讲解，不够全面
let values = [1, 2, 3, 4, 5];
values.reverse();
console.log(values); // [5,4,3,2,1]
let numbers = [5,1,2,6,3];
numbers.reverse();
console.log(numbers); // [3, 6, 2, 1, 5]
let chars = ['c','b','d','a','w'];
chars.reverse();
console.log(chars); // ["w", "a", "d", "b", "c"]
let objs = [{a:1}, {a:5}, {a:3}];
objs.reverse();
console.log(objs); // [{a:3},{a:5},{a:1}]
splice() 添加/删除/替换 当前数组改变
- 删除
需要给splice()传2个参数：要删除的第一个元素的位置和要删除的元素数量。从原数组中删除任意多个元素，并返回一个数组，返回的数组包含删除的项。比如splice(0, 2)会删除原数组前两个元素，并返回一个数组，数组中包含前两个已删除的项。
let colors = ["red", "green", "blue"];
let removed = colors.splice(0,1); // 删除第一项，并将第一项返回
console.log(colors); // ["green", "blue"]
console.log(removed); // ["red"]
let colors = ["red", "green", "blue"];
let removed = colors.splice(-3);
console.log(colors); // []
console.log(removed); // ["red", "green", "blue"]
let colors = ["red", "green", "blue"];
let removed = colors.splice(-3,2);
console.log(colors); // ["blue"]
console.log(removed); // ["red", "green"]
- 插入
需要给 splice() 传3个参数：开始位置、0（要删除的元素数量）和要插入的元素，可以在数组中指定的位置插入元素。第三个参数之后还可以传第四个、第五个参数，乃至任意多个要插入的元素。比如，splice(2, 0, "red", "green") 会从数组位置2开始插入字符串 “red” 和 “green” 。
let colors = ["red", "green", "blue"];
let removed = colors.splice(1, 0, "yellow", "orange"); // 在位置1插入两个元素
console.log(colors); // ["red", "yellow", "orange", "green", "blue"]
console.log(removed); // []
- 替换
splice() 在删除元素的同时可以在指定位置插入新元素，样要传入3个参数：开始位置、要删除元素的数量和要插入的任意多个元素。要插入的元素数量不一定跟删除的元素数量一致。比如，splice(2, 1, "red", "green") 会在位置2删除一个元素，然后从该位置开始向数组中插入 “red” 和 “green”。
let colors = ["red", "green", "blue"];
let removed = colors.splice(1, 1, "red", "purple"); // 插入两个值，删除一个元素
console.log(colors); // ["red", "red", "purple", "blue"]
console.log(removed); // ["green"]
sort() 数组排序 (改变原数组) 参数为规定排序的比较函数(非必填)
sort()方法可以接收一个比较函数，用于判断哪个值应该排在前面。比较函数接收两个参数，如果第一个参数应该排在第二个参数前面，就返回负值；如果两个参数相等，就返回0；如果第一个参数应该排在第二个参数后面，就返回正值。
let values = [0, 1, 5, 10, 15];
values.sort(); // 不传比较函数出来的结果是不正常的
console.log(values); // 0,1,10,15,5
let values = [15, 1, 10, 5, 0];
values.sort(function (value1, value2) {
if (value1 < value2) {
return -1;
}
else if (value1 > value2) {
return 1;
}
return 0;
});
console.log(values); // 0,1,5,10,15
//使用箭头函数简写
let values = [15, 1, 10, 5, 0];
values.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
console.log(values); // 0,1,5,10,15
//最简单的方法
let values = [15, 1, 10, 5, 0];
values.sort((a, b) => a - b);
console.log(values); // 0,1,5,10,15
copyWithin(target，start(可选)，end(可选)) 数组的指定位置复制[改变原数组、ES6]
- target：从该位置开始替换数据；
- start：从该位置开始读取数据，默认为0；
- end：到该位置停止数据的读取，默认为数组的长度
copyWithin()会按照指定范围浅复制数组中的部分内容，然后将它们插入到指定索引开始的位置。开始索引和结束索引则与fill()使用同样的计算方法。
let ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
// 从ints中复制索引0开始的内容，插入到索引5开始的位置
// 在源索引或目标索引到达数组边界时停止
ints.copyWithin(5);
console.log(ints); // [0, 1, 2, 3, 4, 0, 1, 2, 3,4]
let ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
// 从ints中复制索引5开始的内容，插入到索引0开始的位置
ints.copyWithin(0, 5);
console.log(ints); // [5, 6, 7, 8, 9, 5, 6, 7, 8, 9]
let ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
// 从ints中复制索引大于0并且小于3的内容
// 插入到索引4开始的位置
ints.copyWithin(4, 0, 3);
console.log(ints); // [0, 1, 2, 3, 0, 1, 2, 7, 8, 9]
let ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
ints.copyWithin(2, 0, 6);
console.log(ints); // [0, 1, 0, 1, 2, 3, 4, 5, 8, 9]
// 支持负索引值，与fill()相对于数组末尾计算正向索引的过程是一样的
let ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
ints.copyWithin(-4, -7, -3);
console.log(ints); // [0, 1, 2, 3, 4, 5, 3, 4, 5, 6]
fill(value，start，end)数组的填充 [改变原数组、ES6]
- value：填充的值；
- start：开始填充的位置；
- end：填充结束的位置。
使用fill()方法可以向一个已有的数组中插入全部或部分相同的值。开始索引用于指定开始填充的位置，它是可选的。如果不提供结束索引，则一直填充到数组末尾。
数组的所有的方法，只要涉及到开始下标和结束下标，那么开始下标就是>=的关系，结束下标就是<的关系。如果结束下标没有，那么就一直到数组的末尾了。
const zeroes = [0, 0, 0, 0, 0]; // 用5填充整个数组
zeroes.fill(5);
console.log(zeroes); // [5, 5, 5, 5, 5]
// 用6填充索引大于等于3的元素
zeroes.fill(0); // 重置
zeroes.fill(6, 3);
console.log(zeroes); // [0, 0, 0, 6, 6]
// 用7填充索引大于等于1且小于3的元素
zeroes.fill(0); // 重置
zeroes.fill(7, 1, 3);
console.log(zeroes); // [0, 7, 7, 0, 0];
// 用8填充索引大于等于1且小于4的元素
// (-4 + zeroes.length = 1)
// (-1 + zeroes.length = 4)
zeroes.fill(8, -4, -1);
console.log(zeroes); // [0, 8, 8, 8, 0];
fill()静默忽略超出数组边界、零长度及方向相反的索引范围
const zeroes = [0, 0, 0, 0, 0];
zeroes.fill(1, -10, -6); // 索引过低，忽略
console.log(zeroes); // [0, 0, 0, 0, 0]
zeroes.fill(1, 10, 15); // 索引过高，忽略
console.log(zeroes); // [0, 0, 0, 0, 0]
zeroes.fill(2, 4, 2); // 索引反向，忽略
console.log(zeroes); // [0, 0, 0, 0, 0]
zeroes.fill(4, 3, 10); // 索引部分可用，填充可用部分
console.log(zeroes); // [0, 0, 0, 4, 4]
slice() 拷贝数组元素 [不改变原数组]
slice()用于创建一个包含原有数组中一个或多个元素的新数组。slice()方法可以接收一个或两个参数：返回元素的开始索引和结束索引。如果只有一个参数，则 slice()会返回该索引到数组末尾的所有元素。如果有两个参数，则slice() 返回从开始索引到结束索引对应的所有元素，其中不包含结束索引对应的元素。
let colors = ["red", "green", "blue", "yellow", "purple"];
let colors2 = colors.slice(1);
let colors3 = colors.slice(1, 4);
console.log(colors2); // ["green", "blue", "yellow", "purple"
console.log(colors3); // ["green", "blue", "yellow"]
console.log(colors); // ["red", "green", "blue", "yellow", "purple"]
slice()的（负值索引从数组末尾开始计算，也可以将负索引想象成数组长度加上它得到的一个正索引（如果长度减去负索引还是得到负数，索引则从0开始）。）跟fill()负值索引计算方式一样。- 静默忽略超出数组边界、零长度及方向相反的索引范围也跟[^fill()]方法的一样。
join()将数组转换为字符串[不改变原数组]
数组拼接成字符串方法，方法传入拼接关键字
[{ a: 1 }, { a: 2 }].join('$'); // ?
let persons = [{ age: 50 }$ { age: 12 }$ { age: 30 }];
concat() 连接合并多个数组，返回新数组。[不改变原数组]
concat()方法可以在现有数组全部元素基础上创建一个新数组。它首先会创建一个当前数组的副本，然后再把它的参数添加到副本末尾，最后返回这个新构建的数组。
let colors = ["red", "green", "blue"];
let colors2 = colors.concat("yellow", ["black", "brown"]);
console.log(colors); // ["red", "green","blue"]
console.log(colors2); // ["red", "green", "blue", "yellow", "black", "brown"]
//不能添加第二层的数据
let colors = ["red", "green", "blue"];
let colors2 = colors.concat("yellow", ["black", "brown"],"aaa",["bbb",'ccc', ['a','b',['c']]]);
console.log(colors2); //["red", "green", "blue", "yellow", "black", "brown", "aaa", "bbb", "ccc", Array(3)]
toString() 方法可把数组转换为字符串，并返回结果。[不改变原数组]
let arr = [1,2,3]
arr.toString()//返回值是'1,2,3'
indexOf() 查找数组中某元素的第一个索引值。[不改变原数组] 如果没有就返回-1
let arr = [1,2,3]
arr.indexOf(1)//返回值是0
arr.indexOf(4)//返回值是-1
lastIndexOf() 逆向查找指定元素在数组中的第一个位置。[不改变原数组]
let arr =[1,2,3,1,2,4,5,]
arr.lastIndexOf(1)//显示的是最后一个1的下标为3
includes() 查找数组是否包含某个元素。[不改变原数组,]
let arr =[1,2,3,1,2,4,5,]
arr.includes(1)//返回的是一个布尔值判断这个数组中是否包含括号里的元素，现在返回为true
flat( )：用于数组扁平，数组去除未定义。
flat( )：用于数组扁平，数组去除未定义。
let ary = [1, [2, [3, [4, 5]]], 6];
console.log(ary.flat(1)); // [1, 2, Array(2), 6]
console.log(ary.flat()); // [1, 2, Array(2), 6]，不传参默认为1
console.log(ary.flat(2)); // [1, 2, 3, Array(2), 6]
console.log(ary.flat(3)); // [1, 2, 3, 4, 5, 6]
console.log(ary.flat(100)); // [1, 2, 3, 4, 5, 6]，可以超过维度深度，超过则会扁平化所有维度
console.log(ary.flat(Infinity)); //无限大的层数，表示可以扁平化所有维度
console.log(ary); // [1, Array(2), 6]
flatMap( )：对原数组的每个成员执行一个函数.
List<Integer> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
List<String> list3 = new ArrayList<>();
List<User> list4 = new ArrayList<>();
List<User> list5 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
list2.add("aa");
list2.add("bb");
list2.add("cc");
list3.add("a");
list3.add("b");
list3.add("c");
list4.add(new User(1,"小红a"));
list4.add(new User(2,"小明a"));
list5.add(new User(3,"小红B"));
list5.add(new User(4,"小明B"));
//1。将三个list合为一个
final List<? extends Serializable> collect = Stream.of(list1, list2, list3).flatMap(s -> s.stream()).collect(Collectors.toList());
System.out.println(collect.toString());
//2.将两个List<Integer>合2为一
List<String> list = Stream.of(list2, list3).flatMap(s -> s.stream()).collect(Collectors.toList());
System.out.println(list.toString());
//3.获取两个List<User>中得所有名字name集合
List<String> collect1 = Stream.of(list4, list5).flatMap(s -> s.stream().map(User::getName)).collect(Collectors.toList());
System.out.println(collect1.toString())
结果：
[1, 2, 3, aa, bb, cc, a, b, c]
[aa, bb, cc, a, b, c]
[小红a, 小明a, 小红B, 小明B]
第三种可能我们会用得比较多得场景，取出多个list里得某个元素，然后都放到一个大list里，最后返回这个新的并集list
5034
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
