目 录第1章 List接口 1.1 List接口介绍 1.2 List接口常用方法 1.2.1 List集合的遍历方式 1.2.2 Iterator的并发修改异常 1.3 List集合存储数据的结构 1.4 ArrayList集合 1.5 LinkedList集合 1.6 Vector集合 第2章 Set接口 2.1 Set接口介绍 2.2 HashSet集合介绍 2.2.1 哈希表存储数据的结构 2.2.2 哈希表的存储过程 2.3 HashSet存储JavaAPI中的类型元素 2.3.1 对象的哈希值 2.3.2 字符串对象的哈希值 2.4 HashSet存储自定义类型元素 2.5 LinkedHashSet介绍 第3章 判断集合元素唯一的原理 3.1 ArrayList的contains方法判断元素是否重复原理 3.2 HashSet的add/contains等方法判断元素是否重复原理 第4章 思考题 第5章 总结第1章 List接口有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复的元素。1.1 List接口介绍 1）List接口的特点：它是一个元素存取有序的集合。存储的顺序与取出的顺序相同。它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。2） List接口的常用子类有：ArrayList集合LinkedList集合1.2 List接口常用方法List接口中的抽象方法，有一部分方法和他的父类接口Collection是一样的，另一部分是List特有的方法（与父类方法区分：带索引的方法都是List特有的）List接口的特有方法(带索引的方法)1）增加元素方法add(Object e)：向集合末尾处，添加指定的元素 add(int index, Object e) 向集合指定索引处，添加指定的元素，原有元素依次后移public class ListDemo {
public static void main(String[] args) {
function();
}
/*
*
add(int index, E)
*
将元素插入到列表的指定索引上
*
带有索引的操作,都要做到防止越界问题
*
java.lang.IndexOutOfBoundsException：集合中的越界异常
*
ArrayIndexOutOfBoundsException：数组的越界异常
*
StringIndexOutOfBoundsException：字符串越界异常
*/
public static void function(){
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
System.out.println(list);//输出结果为：[abc1, abc2, abc3, abc4]
list.add(1, "itcast");
System.out.println(list);//输出结果为：[abc1, itcast, abc2, abc3, abc4]
list.add(6, "itcast");
//目前集合为，有五个元素，索引数1-4，所以可以添加到索引5上，而索引6则越界
System.out.println(list);
//输出结果为：java.lang.IndexOutOfBoundsException: Index: 6, Size: 5
}
} 2）删除元素删除remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素public class ListDemo {
public static void main(String[] args) {
function_1();
}
/*
*
E remove(int index)
*
移除指定索引上的元素
*
返回被删除之前的元素
*/
public static void function_1(){
List<Double> list = new ArrayList<Double>();
list.add(1.1);
list.add(1.2);
list.add(1.3);
list.add(1.4);
Double d = list.remove(0);//如果此处写的索引不存在发生越界异常，则以下代码不会执行
System.out.println(d);//输出结果为：1.1
System.out.println(list);//输出结果为：[1.2, 1.3, 1.4]
}
}
3）替换元素方法set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素public class ListDemo {
public static void main(String[] args) {
function_2();
}
/*
*
E set(int index, E)
*
修改指定索引上的元素
*
返回被修改之前的元素
*/
public static void function_2(){
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Integer i = list.set(0, 5);//如果此处写的索引不存在发生越界异常
System.out.println(i);//输出结果为：1
System.out.println(list);//输出结果为：[5, 2, 3, 4]
}
}4）查询元素方法get(int index)：获取指定索引处的元素，并返回该元素1.2.1 List集合的遍历方式1）迭代器遍历： 2）for循环，利用索引查找的方式 3）增强for循环，代码简单，day18学习过。1.2.2 Iterator的并发修改异常/*
*
迭代器的并发修改异常 java.util.ConcurrentModificationException
*
就是在遍历的过程中,使用了集合方法修改了集合的长度,不允许的
*/
public class ListDemo1 {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
//对集合使用迭代器进行获取,获取时候判断集合中是否存在 "abc3"对象
//如果有,添加一个元素 "ABC3"
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
//对获取出的元素s,进行判断,是不是有"abc3"
if(s.equals("abc3")){//字符串的全等，不可以用==表示！
list.add("ABC3");
}
System.out.println(s);//输出结果为：abc1
//
abc2
//
abc3
//
Exception in thread "main" java.util.ConcurrentModificationException
//
遍历到abc3的时候发生修改元素长度的情况，则会报错
//
并发修改异常，不可以在迭代器运行的时候修改集合中的元素
}
}
}在迭代过程中，使用了集合的方法对元素进行操作。导致迭代器并不知道集合中的变化，容易引发数据的不确定性。并发修改异常解决办法：在迭代时，不要使用集合的方法操作元素。 那么想要在迭代时对元素操作怎么办？通过ListIterator迭代器操作元素是可以的，ListIterator的出现，解决了使用Iterator迭代过程中可能会发生的错误情况。1.3 List集合存储数据的结构 List接口下有很多个集合，它们存储元素所采用的结构方式是不同的，这样就导致了这些集合有它们各自的特点，供给我们在不同的环境下进行使用。数据存储的常用结构有：堆栈、队列、数组、链表。 1）堆栈，采用该结构的集合，对元素的存取有如下的特点：先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。栈的入口、出口的都是栈的顶端位置压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。2）队列，采用该结构的集合，对元素的存取有如下的特点：先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，安检。排成一列，每个人依次检查，只有前面的人全部检查完毕后，才能排到当前的人进行检查。队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。3）数组，采用该结构的集合，对元素的存取有如下的特点：查找元素快：通过索引，可以快速访问指定位置的元素增删元素慢： 指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。如下图指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图4）链表，采用该结构的集合，对元素的存取有如下的特点：多个节点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素增删元素快：增加元素：操作如左图，只需要修改连接下个元素的地址即可。删除元素：操作如右图，只需要修改连接下个元素的地址即可。1.4 ArrayList集合 ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。1.5 LinkedList集合 LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。 代码示例如下：import java.util.LinkedList;
/*
*
LinkedList 链表集合的特有功能
*
自身特点: 链表底层实现,查询慢,增删快
*
*
子类的特有功能,不能多态调用
*
所以必须写成： LinkedList<String> link = new LinkedList<String>();
*
不能写成： List<String> link = new LinkedList<String>(); 否则 下面调用方法时就会报错
*/
public class LinkedListDemo {
public static void main(String[] args) {
function_3();
}
/*
*
addFirst(E) 添加到链表的开头
*
addLast(E) 添加到链表的结尾
*/
public static void function(){
LinkedList<String> link = new LinkedList<String>();
link.addLast("heima");
link.add("abc");
link.add("bcd");
link.addFirst("itcast");
System.out.println(link);//输出结果为：[itcast, heima, abc, bcd]
}
public static void function_1(){
LinkedList<String> link = new LinkedList<String>();
link.addLast("a");
link.addLast("b");
link.addLast("c");
link.addLast("d");
link.addFirst("1");
link.addFirst("2");
link.addFirst("3");
System.out.println(link);//输出结果为：[3, 2, 1, a, b, c, d]
}
/*
* E getFirst() 获取链表的开头
* E getLast() 获取链表的结尾
*/
public static void function_2(){
LinkedList<String> link = new LinkedList<String>();
link.add("1");
link.add("2");
link.add("3");
link.add("4");
//如果加上link.clear();再执行就会报错，因为已经清空了
//为了防止上述情况，获取时进行判断，
if(link.size()!=0){
String first = link.getFirst();
String last = link.getLast();
System.out.println(first);//输出结果为：1
System.out.println(last);//输出结果为：4
}
//下列代码效果相同
if(!link.isEmpty()){
String first = link.getFirst();
String last = link.getLast();
System.out.println(first);//输出结果为：1
System.out.println(last);//输出结果为：4
}
}
/*
*
E removeFirst() 移除并返回链表的开头
*
E removeLast() 移除并返回链表的结尾
*/
public static void function_3(){
LinkedList<String> link = new LinkedList<String>();
link.add("1");
link.add("2");
link.add("3");
link.add("4");
String first = link.removeFirst();
String last = link.removeLast();
System.out.println(first);//输出结果为：1
System.out.println(last);//输出结果为：4
System.out.println(link);//输出结果为：[2, 3]
}
}1.6 Vector集合Vector集合数据存储的结构是数组结构，为JDK中最早提供的集合。Vector中提供了一个独特的取出方式，就是枚举Enumeration，它其实就是早期的迭代器。此接口Enumeration的功能与 Iterator 接口的功能是类似的。Vector集合已被ArrayList替代。枚举Enumeration已被迭代器Iterator替代。第2章 Set接口2.1 Set接口介绍 Set接口的特点 它是个不包含重复元素的集合。Set集合取出元素的方式可以采用：迭代器、增强for。Set集合有多个子类，这里我们介绍其中的HashSet、LinkedHashSet这两个集合。import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/*
*
Set接口,特点不重复元素,没索引
*
*
Set接口的实现类,HashSet (哈希表)
*
特点: 无序集合,存储和取出的顺序不同,没有索引,不存储重复元素
*
代码的编写上,和ArrayList完全一致
*/
public class HashSetDemo {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
set.add("cn");
set.add("heima");
set.add("java");
set.add("java");
set.add("itcast");
Iterator<String> it = set.iterator();
while(it.hasNext()){
System.out.println(it.next());//输出结果为：java
不允许存储重复元素，所以只有一个
//
itcast
//
heima
//
cn
}
System.out.println("==============");
for(String s : set){
System.out.println(s);//输出结果为：java
不允许存储重复元素，所以只有一个
//
itcast
//
heima
//
cn
}
}
}2.2 HashSet集合介绍 查阅HashSet集合的API介绍：此类实现Set接口，由哈希表支持（实际上是一个 HashMap集合）。HashSet集合不能保证的迭代顺序与元素存储顺序相同。 HashSet集合，采用哈希表结构存储数据，保证元素唯一性的方式依赖于：hashCode()与equals()方法。2.2.1 哈希表存储数据的结构 加载因子:表中填入的记录数/哈希表的长度 例如: 加载因子是0.75 代表: 数组中的16个位置,其中存入16*0.75=12个元素如果在存入第十三个(>12)元素,导致存储链子过长,会降低哈希表的性能,那么此时会扩充哈希表(在哈希),底层会开辟一个长度为原长度2倍的数组,把老元素拷贝到新数组中,再把新元素添加数组中当存入元素数量>哈希表长度*加载因子,就要扩容,因此加载因子决定扩容时机2.2.2 哈希表的存储过程 哈希表的存储过程中，不允许有重复数据，具体的执行依据是哈希值hashCode()与equals()方法。import java.util.HashSet;
/*
* HashSet集合的自身特点
*
底层数据结构，哈希表
*
存储和取出都比较快
*
线程不安全，运行速度快
*/
public class HashSetDemo1 {
public static void main(String[] args) {
HashSet<String> set = new HashSet<String>();
set.add(new String("abc"));
set.add(new String("abc"));
set.add(new String("bbc"));
set.add(new String("bbc"));
System.out.println(set); //输出结果为：[bbc, abc]
}
}存储过程的图解：存取原理: 每存入一个新的元素都要走以下三步: 1.首先调用本类的hashCode()方法算出哈希值 2.在容器中找是否与新元素哈希值相同的老元素, 如果没有直接存入 如果有转到第三步 3.新元素会与该索引位置下的老元素利用equals方法一一对比： 一旦新元素.equals(老元素)返回true,停止对比,说明重复,不再存入（注意String类重写过equals(）方法） 如果与该索引位置下的老元素都通过equals方法对比返回false,说明没有重复,存入2.3 HashSet存储JavaAPI中的类型元素2.3.1 对象的哈希值① hashCode()方法/*
*对象的哈希值，普通的十进制整数
*父类Object，方法public int hashCode()计算结果是int整数
*
*/
public class HashDemo {
public static void main(String[] args) {
Person p = new Person();
int i = p.hashCode();
System.out.println(i);//输出结果为不可预知的整数
}
}
public class Person {
}
② 重写 hashCode()方法,自定义哈希值/*
*对象的哈希值，普通的十进制整数
*父类Object，方法public int hashCode()计算结果是int整数
*
*/
public class HashDemo {
public static void main(String[] args) {
Person p = new Person();
int i = p.hashCode();
System.out.println(i);//输出结果为:1
}
}
public class Person {
/*
* 没有重写父类hashCode方法，每次运行结果都是不同的整数
* 重写父类hashCode方法，哈希值就是自定义的数值
* 哈希值是存储到HashSet集合的依据
*/
public int hashCode() {
return 1;
}
}
2.3.2 字符串对象的哈希值给HashSet中存储JavaAPI中提供的类型元素时，不需要重写元素的hashCode和equals方法，因为这两个方法，在JavaAPI的每个类中已经重写完毕，如String类、Integer类等。1）代码示例如下：/*
*String类的哈希值
*
*/
public class HashDemo {
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("abc");
System.out.println(s1.hashCode());//输出结果为：96354
System.out.println(s2.hashCode());//输出结果为：96354
}
}
2）String类哈希值计算方式的图解：2.4 HashSet存储自定义类型元素 给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一。代码示例如下：1） 原版public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person(){}
public String toString(){
return name+".."+age;
}
}import java.util.HashSet;
public class HashSetDemo1 {
public static void main(String[] args) {
HashSet<Person> setPerson = new HashSet<Person>();
setPerson.add(new Person("a",11));
setPerson.add(new Person("b",10));
setPerson.add(new Person("b",10));
setPerson.add(new Person("c",25));
setPerson.add(new Person("d",19));
setPerson.add(new Person("e",17));
System.out.println(setPerson);
//输出结果为：[a..11, c..25, d..19, b..10, b..10, e..17]
//new出来的两个Person("b",10)不同，所以不能判断为重复
}
}
2） 对比组:自定义对象重写hashCode和equals方法public class Person {
private String name;
private int age;
public int hashCode() {
return
name.hashCode()+age*55;//name.hashCode()+age;的返回值为十进制数
}
/*
*尽可能让不同的属性值产生不同的哈希值,这样就不用再调用equals方法去比较属性
*所以age →→ age*55
*/
//方法equals重写父类,保证和父类相同
//public boolean equals(Object obj){}
public boolean equals(Object obj) {
if(this==obj)
return true;
if(obj==null)
return false;
if(obj instanceof Person) {
Person p = (Person)obj;
return name.equals(p.name) && age==p.age;
}
return false;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person(){}
public String toString(){
return name+".."+age;
}
}
import java.util.HashSet;
public class HashSetDemo1 {
public static void main(String[] args) {
//将Person对象中的姓名,年龄,相同数据,看作同一个对象
//判断对象是否重复,依赖对象自己的方法 hashCode,equals
HashSet<Person> setPerson = new HashSet<Person>();
setPerson.add(new Person("a",11));
setPerson.add(new Person("b",10));
setPerson.add(new Person("b",10));
setPerson.add(new Person("c",25));
setPerson.add(new Person("d",19));
setPerson.add(new Person("e",17));
System.out.println(setPerson);
//输出结果为：[e..17, d..19, a..11, b..10, c..25]
}
}
//经过重写hashCode方法，("a",11)、("b",10)、("b",10)的哈希值是相同的，但("a",11)、("b",10)的equals方法返回值不同，所以判定不是重复元素
//每个对象的地址值都不同,所以需要重写equals方法比较具体属性。("b",10)、("b",10)调用Obejct类的hashCode方法返回相同的哈希值,且equals返回true，判断为重复元素，所以结果只存一次 1） 图解2.5 LinkedHashSet介绍 我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？在HashSet下面有一个子类LinkedHashSet，它是链表和哈希表组合的一个数据存储结构，LinkedHashSet集合保证元素的存入和取出的顺序一致。代码示例：
import java.util.LinkedHashSet;
/*
*
LinkedHashSet 基于链表的哈希表实现
*
继承自HashSet
实现Set接口
*
*
LinkedHashSet自身特性：具有顺序,存储和取出的顺序相同的
*
线程不安全的集合,运行速度块
*/
public class LinkedHashSetDemo {
public static void main(String[] args) {
LinkedHashSet<Integer> link = new LinkedHashSet<Integer>();
link.add(123);
link.add(44);
link.add(33);
link.add(33);
link.add(66);
link.add(11);
System.out.println(link);//输出结果为：[123, 44, 33, 66, 11]
即不重复且有序
}
}第3章 第3章 判断集合元素唯一的原理3.1 ArrayList的contains方法判断元素是否重复原理ArrayList的contains方法会使用调用方法时，传入的元素的equals方法依次与集合中的旧元素所比较，从而根据返回的布尔值判断是否有重复元素。此时，当ArrayList存放自定义类型时，由于自定义类型在未重写equals方法前，判断是否重复的依据是地址值，所以如果想根据内容判断是否为重复元素，需要重写元素的equals方法。3.2 HashSet的add/contains等方法判断元素是否重复原理 第4章 思考题1） 问题:① 如果两个对象的哈希值相同 p1.hashCode()==p2.hashCode() 两个对象的equals一定返回true吗 p1.equals(p2) 一定是true吗正确答案:不一定② 如果两个对象的equals方法返回true,p1.equals(p2)==true 两个对象的哈希值一定相同吗正确答案: 一定2）分析：实际上可以通过编译，令hashCode方法return1，即固定数字，也可以令equals方法return true，或者定义静态变量static int a;hashCode中return a++;都可以推翻上述答案，虽然编译运行没有问题，但是不符合hashCode常规协定。第5 章 总结1）List与Set集合的区别？List: 它是一个有序的集合(元素存与取的顺序相同) 它可以存储重复的元素 Set: 它是一个无序的集合(元素存与取的顺序可能不同) 它不能存储重复的元素2）List集合中的特有方法void add(int index, Object element) 将指定的元素，添加到该集合中的指定位置上Object get(int index)返回集合中指定位置的元素。Object remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素Object set(int index, Object element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素3）ArrayList:底层数据结构是数组，查询快，增删慢4）LinkedList:底层数据结构是链表，查询慢，增删快5）HashSet:元素唯一，不能重复底层结构是哈希表结构元素的存与取的顺序不能保证一致如何保证元素的唯一的？ 重写hashCode() 与 equals()方法6）LinkedHashSet:元素唯一不能重复底层结构是 哈希表结构 + 链表结构元素的存与取的顺序一致

数组是 js 中最常用到的数据集合，其内置的方法有很多，熟练掌握这些方法，可以有效的提高我们的工作效率，同时对我们的代码质量也是有很大影响。
1.使用数组字面量表示法var arr4 = [];
//创建一个空数组
var arr5 = [20];
// 创建一个包含1项数据为20的数组
var arr6 = ["lily","lucy","Tom"];
// 创建一个包含3个字符串的数组
2.使用 Array 构造函数无参构造var arr1 = new Array();
//创建一个空数组
带参构造如果只传一个数值参数，则表示创建一个初始长度为指定数值的空数组var arr2 = new Array(20);
// 创建一个包含20项的数组
如果传入一个非数值的参数或者参数个数大于 1，则表示创建一个包含指定元素的数组var arr3 = new Array("lily","lucy","Tom");
// 创建一个包含3个字符串的数组
var array4 = new Array('23'); // ["23"]
3. Array.of 方法创建数组(es6 新增)Array.of()方法总会创建一个包含所有传入参数的数组，而不管参数的数量与类型。let arr = Array.of(1, 2);
console.log(arr.length);//2
let arr1 = Array.of(3);
console.log(arr1.length);//1
console.log(arr1[0]);//3
let arr2 = Array.of('2');
console.log(arr2.length);//1
console.log(arr2[0]);//'2'
4.Array.from 方法创建数组(es6 新增)在 js 中将非数组对象转换为真正的数组是非常麻烦的。在 ES6 中，将可迭代对象或者类数组对象作为第一个参数传入，Array.from()就能返回一个数组。function arga(...args) {
//...args剩余参数数组,由传递给函数的实际参数提供
let arg = Array.from(args);
console.log(arg);
}
arga('arr1', 26, 'from'); // ['arr1',26,'from']
1.join()join()方法用于把数组中的所有元素转换一个字符串。元素是通过指定的分隔符进行分隔的。默认使用逗号作为分隔符var arr = [1,2,3];
console.log(arr.join());
// 1,2,3
console.log(arr.join("-"));
// 1-2-3
console.log(arr);
// [1, 2, 3]（原数组不变）
通过join()方法可以实现重复字符串，只需传入字符串以及重复的次数，就能返回重复后的字符串，函数如下：function repeatString(str, n) {
//一个长度为n+1的空数组用string去拼接成字符串,就成了n个string的重复
return new Array(n + 1).join(str);
}
console.log(repeatString("abc", 3));
// abcabcabc
console.log(repeatString("Hi", 5));
// HiHiHiHiHi
2.push()和 pop()push() 方法从数组末尾向数组添加元素，可以添加一个或多个元素。pop() 方法用于删除数组的最后一个元素并返回删除的元素。var arr = ["Lily","lucy","Tom"];
var count = arr.push("Jack","Sean");
console.log(count);
// 5
console.log(arr);
// ["Lily", "lucy", "Tom", "Jack", "Sean"]
var item = arr.pop();
console.log(item);
// Sean
console.log(arr);
// ["Lily", "lucy", "Tom", "Jack"]
3.shift() 和 unshift()shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。var arr = ["Lily","lucy","Tom"];
var count = arr.unshift("Jack","Sean");
console.log(count);
// 5
console.log(arr);
//["Jack", "Sean", "Lily", "lucy", "Tom"]
var item = arr.shift();
console.log(item);
// Jack
console.log(arr);
// ["Sean", "Lily", "lucy", "Tom"]
4.sort()sort() 方法用于对数组的元素进行排序。排序顺序可以是字母或数字，并按升序或降序。默认排序顺序为按字母升序。var arr1 = ["a", "d", "c", "b"];
console.log(arr1.sort());
// ["a", "b", "c", "d"]
arr2 = [13, 24, 51, 3];
console.log(arr2.sort());
// [13, 24, 3, 51]
console.log(arr2);
// [13, 24, 3, 51](元数组被改变)
为了解决上述问题，sort()方法可以接收一个比较函数作为参数，以便我们指定哪个值位于哪个值的前面。比较函数接收两个参数，如果第一个参数应该位于第二个之前则返回一个负数，如果两个参数相等则返回 0，如果第一个参数应该位于第二个之后则返回一个正数。以下就是一个简单的比较函数：function compare(value1, value2) {
if (value1 < value2) {
return -1;
} else if (value1 > value2) {
return 1;
} else {
return 0;
}
}
arr2 = [13, 24, 51, 3];
console.log(arr2.sort(compare));
// [3, 13, 24, 51]
如果需要通过比较函数产生降序排序的结果，只要交换比较函数返回的值即可：function compare(value1, value2) {
if (value1 < value2) {
return 1;
} else if (value1 > value2) {
return -1;
} else {
return 0;
}
}
arr2 = [13, 24, 51, 3];
console.log(arr2.sort(compare));
// [51, 24, 13, 3]
5.reverse()reverse() 方法用于颠倒数组中元素的顺序。var arr = [13, 24, 51, 3];
console.log(arr.reverse());
//[3, 51, 24, 13]
console.log(arr);
//[3, 51, 24, 13](原数组改变)
6.concat()concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。var arr = [1,3,5,7];
var arrCopy = arr.concat(9,[11,13]);
console.log(arrCopy);
//[1, 3, 5, 7, 9, 11, 13]
console.log(arr);
// [1, 3, 5, 7](原数组未被修改)
从上面测试结果可以发现：传入的不是数组，则直接把参数添加到数组后面，如果传入的是数组，则将数组中的各个项添加到数组中。但是如果传入的是一个二维数组呢？var arrCopy2 = arr.concat([9,[11,13]]);
console.log(arrCopy2);
//[1, 3, 5, 7, 9, Array[2]]
console.log(arrCopy2[5]);
//[11, 13]
7.slice()slice()：返回从原数组中指定开始下标到结束下标之间的项组成的新数组。slice()方法可以接受一或两个参数，即要返回项的起始和结束位置。在只有一个参数的情况下， slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数，该方法返回起始和结束位置之间的项，但不包括结束位置的项。当出现负数时，将负数加上数组长度的值（6）来替换该位置的数var arr = [1,3,5,7,9,11];
var arrCopy = arr.slice(1);
var arrCopy2 = arr.slice(1,4);
var arrCopy3 = arr.slice(1,-2);//相当于arr.slice(1,4)
var arrCopy4 = arr.slice(-4,-1);//相当于arr.slice(2,5)
console.log(arr);
//[1, 3, 5, 7, 9, 11](原数组没变)
console.log(arrCopy);
//[3, 5, 7, 9, 11]
console.log(arrCopy2);
//[3, 5, 7]
console.log(arrCopy3);
//[3, 5, 7]
console.log(arrCopy4);
//[5, 7, 9]
8.splice()splice()：很强大的数组方法，它有很多种用法，可以实现删除、插入和替换。1.删除元素,并返回删除的元素可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。例如， splice(0,2)会删除数组中的前两项。var arr = [1,3,5,7,9,11];
var arrRemoved = arr.splice(0,2);
console.log(arr);
//[5, 7, 9, 11]
console.log(arrRemoved);
//[1, 3]
2.向指定索引处添加元素可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。例如，splice(2,0,4,6)会从当前数组的位置 2 开始插入 4 和 6。var array1 = [22, 3, 31, 12];
array1.splice(1, 0, 12, 35);
//[]
console.log(array1); // [22, 12, 35, 3, 31, 12]
3.替换指定索引位置的元素可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如，splice (2,1,4,6)会删除当前数组位置 2 的项，然后再从位置 2 开始插入 4 和 6。const array1 = [22, 3, 31, 12];
array1.splice(1, 1, 8);
//[3]
console.log(array1);
// [22, 8, 31, 12]
9.indexOf()和 lastIndexOf()接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。indexOf()： 从数组的开头（位置 0）开始向后查找。lastIndexOf： 从数组的末尾开始向前查找。这两个方法都返回要查找的项在数组中的位置，或者在没找到的情况下返回-1。在比较第一个参数与数组中的每一项时，会使用全等操作符。var arr = [1,3,5,7,7,5,3,1];
console.log(arr.indexOf(5));
//2
console.log(arr.lastIndexOf(5));
//5
console.log(arr.indexOf(5,2));
//2
console.log(arr.lastIndexOf(5,4));
//2
console.log(arr.indexOf("5"));
//-1
10.forEach()forEach()：对数组进行遍历循环，对数组中的每一项运行给定函数。参数都是 function 类型，有三个参分别为：当前元素；当前元素的索引值，数组本身；this:回调函数中this的指向，没传参数的时候，this指向window，如果传了参数，this指向参数本身；无返回值，为undefined，该方法会改变原数组。语法：arr.forEach(callbackFun(item, index, arr) { },this)
或者
arr.forEach((item, index, arr) => { });
例子：
var arr = [10, 20, 30, 40, 50];
arr.forEach(function(item, index, data) {
item = item + 1;
});
console.log(arr);
结果为： var arr = [10, 20, 30, 40, 50];
arr.forEach(function(item, index, data) {
data[index] = data[index] + 1;
});
console.log(arr);
结果为：由此可见直接操作index，它是一个基本类型，是无法影响到原数组的。在forEach里面是不支持break的。11.map()map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。map() 方法按照原始数组元素顺序依次处理元素。该方法不会改变原数组var arr = [1, 2, 3, 4, 5];
var arr2 = arr.map(function(item){
return item*item;
});
console.log(arr2);
//[1, 4, 9, 16, 25]
12.filter()filter()：“过滤”功能，数组中的每一项运行给定函数，返回满足过滤条件组成的数组。var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var arr2 = arr.filter(function(x, index) {
return index % 3 === 0
x >= 8;
});
console.log(arr2);
//[1, 4, 7, 8, 9, 10]
13.fill() es6 新增fill()方法能使用特定值填充数组中的一个或多个元素。当只是用一个参数时，该方法会用该参数的值填充整个数组。let arr = [1, 2, 3, 'cc', 5];
arr.fill(1);
console.log(arr);//[1,1,1,1,1];
如果不想改变数组中的所有元素，而只是想改变其中一部分，那么可以使用可选的起始位置参数与结束位置参数（不包括结束位置的那个元素）3 个参数： 填充数值，起始位置参数，结束位置参数（不包括结束位置的那个元素）let arr = [1, 2, 3, 'arr', 5];
arr.fill(1, 2);
console.log(arr);//[1,2,1,1,1]
arr.fill(0, 1, 3);
console.log(arr);//[1,0,0,1,1];
14.every()every()：判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回 true。var arr = [1, 2, 3, 4, 5];
var arr2 = arr.every(function(x) {
return x < 10;
});
console.log(arr2);
//true
var arr3 = arr.every(function(x) {
return x < 3;
});
console.log(arr3);
// false
15.some()some()：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回 true。var arr = [1, 2, 3, 4, 5];
var arr2 = arr.some(function(x) {
return x < 3;
});
console.log(arr2);
//true
var arr3 = arr.some(function(x) {
return x < 1;
});
console.log(arr3);
// false
16.includes() es7 新增includes() 方法用来判断一个数组是否包含一个指定的值，如果是返回 true，否则 false。参数有两个，其中第一个是（必填）需要查找的元素值，第二个是（可选）开始查找元素的位置const array1 = [22, 3, 31, 12, 'arr'];
const includes = array1.includes(31);
console.log(includes); // true
const includes1 = array1.includes(31, 3); // 从索引3开始查找31是否存在
console.log(includes1); // false
需要注意的是：includes使用===运算符来进行值比较，仅有一个例外：NaN 被认为与自身相等。let values = [1, NaN, 2];
console.log(values.indexOf(NaN));//-1
console.log(values.includes(NaN));//true
17.reduce()和 reduceRight()这两个方法都会实现迭代数组的所有项(即累加器)，然后构建一个最终返回的值。reduce()方法从数组的第一项开始，逐个遍历到最后。reduceRight()则从数组的最后一项开始，向前遍历到第一项。4 个参数：前一个值、当前值、项的索引和数组对象var values = [1,2,3,4,5];
var sum = values.reduceRight(function(prev, cur, index, array){
return prev + cur;
},10);
//数组一开始加了一个初始值10,可以不设默认0
console.log(sum);
//25
18.toLocaleString() 和 toString()将数组转换为字符串const array1 = [22, 3, 31, 12];
const str = array1.toLocaleString();
const str1 = array1.toString();
console.log(str); // 22,3,31,12
console.log(str1); // 22,3,31,12
19. find()和 findIndex()find()与 findIndex()方法均接受两个参数：一个回调函数，一个可选值用于指定回调函数内部的 this。该回调函数可接受三个参数：数组的某个元素，该元素对应的索引位置，以及该数组本身。该回调函数应当在给定的元素满足你定义的条件时返回 true，而 find()和 findIndex()方法均会在回调函数第一次返回 true 时停止查找。二者的区别是：find()方法返回匹配的值，而 findIndex()返回匹配位置的索引。let arr = [1, 2, 3, 'arr', 5, 1, 9];
console.log(arr.find((value, keys, arr) => {
return value > 2;
})); // 3 返回匹配的值
console.log(arr.findIndex((value, keys, arr) => {
return value > 2;
})); // 2 返回匹配位置的索引
20.copyWithin() [es6 新增]copyWithin() 方法用于从数组的指定位置拷贝元素到数组的另一个指定位置中。该方法会改变现有数组//将数组的前两个元素复制到数组的最后两个位置
let arr = [1, 2, 3, 'arr', 5];
arr.copyWithin(3, 0);
console.log(arr);//[1,2,3,1,2]
默认情况下，copyWithin()方法总是会一直复制到数组末尾，不过你还可以提供一个可选参数来限制到底有多少元素会被覆盖。这第三个参数指定了复制停止的位置（不包含该位置本身）。let arr = [1, 2, 3, 'arr', 5, 9, 17];
//从索引3的位置开始粘贴
//从索引0的位置开始复制
//遇到索引3时停止复制
arr.copyWithin(3, 0, 3);
console.log(arr);//[1,2,3,1,2,3,17]
21.flat() 和 flatMap() es6 新增flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。该方法返回一个新数组，对原数据没有影响。参数： 指定要提取嵌套数组的结构深度，默认值为 1。const arr1 = [0, 1, 2, [3, 4]];
console.log(arr1.flat());
// expected output: [0, 1, 2, 3, 4]
const arr2 = [0, 1, 2, [[[3, 4]]]];
console.log(arr2.flat(2));
// expected output: [0, 1, 2, [3, 4]]
//使用 Infinity，可展开任意深度的嵌套数组
var arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// 扁平化数组空项,如果原数组有空位，flat()方法会跳过空位
var arr4 = [1, 2, , 4, 5];
arr4.flat();
// [1, 2, 4, 5]
flatMap()方法对原数组的每个成员执行一个函数，相当于执行Array.prototype.map(),然后对返回值组成的数组执行flat()方法。该方法返回一个新数组，不改变原数组。// 相当于 [[2, 4], [3, 6], [4, 8]].flat()
[2, 3, 4].flatMap((x) => [x, x * 2])
// [2, 4, 3, 6, 4, 8]
22. entries(),keys() 和 values() 【ES6】entries()，keys()和values() —— 用于遍历数组。它们都返回一个遍历器对象，可以用for…of循环进行遍历区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历
for (let index of ['a', 'b'].keys()) {
console.log(index);
}
// 0
// 1
for (let elem of ['a', 'b'].values()) {
console.log(elem);
}
// 'a'
// 'b'
for (let [index, elem] of ['a', 'b'].entries()) {
console.log(index, elem);
}
// 0 "a"
// 1 "b"
如果不使用for…of循环，可以手动调用遍历器对象的next方法，进行遍历。let letter = ['a', 'b', 'c'];
let entries = letter.entries();
console.log(entries.next().value); // [0, 'a']
console.log(entries.next().value); // [1, 'b']
console.log(entries.next().value); // [2, 'c']
join()：用指定的分隔符将数组每一项拼接为字符串push() ：向数组的末尾添加新元素pop()：删除数组的最后一项shift()：删除数组的第一项unshift()：向数组首位添加新元素slice()：按照条件查找出其中的部分元素splice()：对数组进行增删改fill(): 方法能使用特定值填充数组中的一个或多个元素filter():“过滤”功能concat()：用于连接两个或多个数组indexOf()：检测当前值在数组中第一次出现的位置索引lastIndexOf()：检测当前值在数组中最后一次出现的位置索引every()：判断数组中每一项都是否满足条件some()：判断数组中是否存在满足条件的项includes()：判断一个数组是否包含一个指定的值sort()：对数组的元素进行排序reverse()：对数组进行倒序forEach()：ES5 及以下循环遍历数组每一项map()：ES6 循环遍历数组每一项copyWithin():用于从数组的指定位置拷贝元素到数组的另一个指定位置中find():返回匹配的值findIndex():返回匹配位置的索引toLocaleString()、toString():将数组转换为字符串flat()、flatMap()：扁平化数组entries() 、keys() 、values():遍历数组