1.Collection接口

Collection接口是List，Set，Queue接口的父接口，里面提供了子类的常用方法；

List储存的是可以重复的，有序的数据，子类是arrayList（数组结构）和linkedList（双向链表）

我们主要研究一下Collection接口中封装的方法

//使用多态的向上造型创建一个子类型对象Collection<String> c1 = new ArrayList<>();//1.E add(E e)  向集合中添加元素c1.add("A");c1.add("B");c1.add("C");//2.Boolean isEmpty()boolean b1 = c1.isEmpty();System.out.println(b1);

首先利用多态的向上造型创建一个子类型对象c1，并向集合中添加元素，利用对象.add( )的方法，该类型的返回值是泛型变量；

之后判断一个集合是否为空，返回值是一个boolean类型的变量；同样是使用对象名.isEmpty（）的方法

 //3.int size()  返回的是集合元素的个数System.out.println(c1.size());//4.String toString()   将集合转换为字符串形式System.out.println(c1.toString());Collection<String> c2 = new ArrayList<>();c2.add("B");c2.add("C");c2.add("D");//5. addAll(Collection c)c1.addAll(c2);System.out.println(c1);

想要返回集合中元素的个数，需要调用方法对象名.size( )，该方法的返回值是一个int类型的变量；如果需要将集合转换为字符串形式，需要调用对象名.toString( ),该方法的返回值是String类型；如果想将B集合的所有元素添加到A集合中，需要调用方法 A.addAll(B);该方法的返回值是对象的类型

//6.boolean contains(Object o)//查看是否包含字符串Bboolean contains = c1.contains("B");System.out.println("contains: "+contains);//7.boolean  containsAll(Collection c)boolean containsAll = c1.containsAll(c2);System.out.println("c1是否包含集合c2: "+containsAll);//8.boolean  equals(Object o)//测试：  创建一个新的集合c3，添加元素“A” "B" "C" "B" "D" "D"  判断两个集合是否相等Collection<String> c3 = new ArrayList<>();c3.add("A");c3.add("B");c3.add("C");c3.add("B");c3.add("C");c3.add("D");c1.equals(c3);System.out.println("c1和c3相同么：" + c1.equals(c3));

contains(Ojbect obj)  该方法的作用是判断集合中是否包含某一部分元素，使用对象名调用方法，返回值是boolean类型

containsAll（Collection c）该方法的作用是判断某一集合中是否包含其他集合，形参需要传入一个集合

equals（）该方法的作用是判断两个集合是否相等，可以使用A.equals（B）的方式来判断，A,B都是集合对象,返回值是一个布尔类型

//9. boolean remove(Object o)  移除c1集合里的元素D，并查看剩余元素boolean remove = c1.remove("D");System.out.println("remove: "+remove);System.out.println("移除c1集合中的元素D："+c1);//10.boolean removeAll(Collection <?> c)  新建一个集合c4，添加元素"B" "C"//从集合中删除另一个集合中所具有的元素，符合自己的元素都会删除//测试c1移除c4Collection<String> c4 = new ArrayList<>();c4.add("B");c4.add("C");System.out.println("c4: "+c4);c1.removeAll(c4);System.out.println("c1移除c4："+c1);//11.boolean retainAll(Collection c )//作用：保留集合中符合另一个集合中的所有元素，不符合的删除//测试：向c1添加"E","F","G",然后保留子集c5，c5里的元素有"A","E"c1.add("E");c1.add("F");c1.add("G");Collection<String> c5 = new ArrayList<>();c5.add("A");c5.add("E");c1.retainAll(c5);System.out.println(c1);//12. void clear():  清空c1c1.clear();System.out.println(c1);System.out.println(c1.size());

remove(Ogject obj)

作用从集合中移除某个元素，返回值是一个布尔类型，查看移除操作是否成功，形参是需要移除的元素，用对象来调用；

removeAll（Collection <?> c）

作用从原集合中移除另一个集合中所具有的元素，符合条件的元素都会被移除，返回值是布尔类型，查看移除操作是否成功，形参是条件集合，用原集合对象来调用该方法；

retainAll （Collection c）

作用保留原集合中符合另一个集合中的所有元素，不符合条件的会被删除；返回值布尔类型，形参是条件集合，用对象名来调用

clear()

作用，清空集合中的所有元素，用集合对象来调用；

2.集合的迭代

集合的迭代就是指集合的遍历操作；几乎所有的集合子接口都实现了迭代接口Iterable;

迭代接口中提供了多个方法，用于迭代操作；-boolean hasNext(): 用于判断集合中是否有下一个元素。可以形象的理解为指针；指针的最初位置在第一个元素的前面，

-E next(): 用于返回指针指向的那个元素,然后指针向后移动，为下一次的判断做准备

-E remove(): 用于删除指针所指向的那个元素

需要注意的是，在使用迭代器时，不可以调用集合自己的remove（）方法

public static void main(String[] args) {Collection<Integer> c1 = new ArrayList();c1.add(1);c1.add(2);c1.add(3);c1.add(4);c1.add(5);/*** 使用增强for循环（foreach）遍历：底层原理就是迭代器*/for (Integer i : c1) {System.out.print(i + " ");}System.out.println();

在main方法中我们创建了一个集合并赋值1，2，3，4，5，首先使用增强for循环对集合进行遍历，定义一个Integer的对象来接收便利的结果，并将结果打印

之后我们使用迭代器的方式来对集合进行遍历；增强for循环的底层逻辑也是迭代器

//第一步：获取要遍历的集合对象的迭代器对象Iterator<Integer> it = c1.iterator();//第二步：问是否有下一个元素while (it.hasNext()) {//第三步：取元素Integer a = it.next();//此时指针向后移动System.out.println("a: " + a);}

首先需要定义一个迭代器对象，通过集合对象名.iterator()的方法来创建

3.List接口

List接口的特点：

1.元素有序并且可以重复

2.两个实现类：ArrayList  和  LinkedList    -ArrayList 动态数组和基本方法  -LinkedList 双向链表和各种方法

3.两个实现类在元素特别多的时候效率不同：

  -对于随机访问来说，ArrayList的效率高于LinkedList  -对于进行增删改来说，LinkedList的效率高于ArrayList。

4.这两个类都是基于List接口的，所以实现类的方法基本一致。

 //创建一个ArrayList集合对象List<String> names = new ArrayList<>();//创建一个linkedList集合对象List<String> adds = new LinkedList<>();

首先是创建集合的对象，都可以使用向上造型

 /*** 添加元素* boolean add(E e):  添加元素，默认向集合尾部添加* void add(int index, E  element) 插入元素，下标范围[0,size()]* boolean addAll(int index, Collection c)* boolean addAll(Collection  c )*/names.add("micheal");names.add(0,"bob");names.add("aaa");names.add("bbb");names.add("ccc");System.out.println(names);//地址集合添加两个元素adds.add("beijing ");adds.add("shanghai ");//将地址集合添加到名字集合中names.addAll(adds);System.out.println(names);

添加元素与之前的方法基本一致，依旧是add( ), 和其重载的方法，addAll( )，和其重载的方法，在上述代码中，我们在names集合中添加了5个元素，在adds集合中添加了两个元素，并把adds集合的元素添加到names集合的元素尾部。

/*** E  get(int index) 获取元素*/String s1 = adds.get(1);//得到上海System.out.println(s1);/*** 查找元素  int indexOf(Object obj)  返回指定元素的第一个下标，如果没有返回-1* 查找元素最后出现的位置  int lastIndexOf(Object obj)  返回指定元素的最后一个下标，没有返回-1*/int i = names.indexOf("micheal");System.out.println(i);int i1 = names.lastIndexOf("bob");System.out.println(i1);/*** 移除元素  E  remove(int index)*/adds.remove(1);System.out.println(adds);/*** 修改元素  E  set(int  index, E  element)*/String add1 =  adds.set(0, "changchun");System.out.println("add1 "+add1);System.out.println(adds);

上述代码中的四个方法是比较基础的移除，修改，查找的方法，首先是get( )方法，形参是int类型的，需要传入集合的下标，返回值就是集合中的元素；如果需要查找元素所在的位置，需要使用indexOf方法，传入的参数是需要查找位置的元素，返回值类型是int，返回集合的下标，当然也可以使用lastIndexOf方法，返回的结果是该元素出现的最后一个下标，如果没有查找到该元素，就会返回-1；如果需要移除元素，可以使用remove( )方法，形参是元素的索引位置，返回值是被移除的元素，如果要修改集合中的内容，我们可以使用set( )方法，形参是索引位置和需要修改的元素；返回值是被替换的元素；

 /*** 截取子集 List subList(int fromIndex, int toIndex)* 用于截取子集，包前不包后*/List n1 = names.subList(2,5);System.out.println(n1);List<Integer> nums = new ArrayList<>();for (int j = 1; j <11 ; j++) {nums.add(j);}System.out.println(nums);List<Integer> sub =  nums.subList(3,7);System.out.println(sub);//对子集里的每一个元素扩大10倍for (int j = 0;j<sub.size();j++) {//取出元素*10，然后替换掉原有的元素
//            int r = sub.get(j)*10;sub.set(j,sub.get(j)*10);}System.out.println(sub);System.out.println(nums);

截取子集的方法是 subList( ) 返回值是被截取的自己，需要传入两个形参，开始截取的索引和结束截取的索引，注意：包前不包后；

在创建集合的时候，我们还可以使用循环的方法来达到减少代码量的操作；比如需要创建一个都是数字的集合，就可以使用for循环创建一个长度为10的泛型为Integer的List集合；集合内容是从1到10的数字，之后对该集合进行截取，截取范围是3，7，会截取到4，5，6，7四个元素的集合，如果我们需要集合中的每个元素都扩大10倍的化，可以先获取到结婚中的每个元素并对其*10操作；然后再将将其放回到原集合中的每个索引位置；

4.队列Queue

队列Queue，也是Collection的子接口，用来描述一种先进先出的数据结构，可以理解为一种特殊的线性表，只能从一头进，另一头出，对应的方法：

-boolean offer(E e)  从队列的尾部插入元素；

-E  poll( ) 将队首的元素取出并移除这个元素；

-E  peek( ) 查看队首的元素；（只能查看，不能做其他操作）

//创建一个名字队列Queue<String> names = new LinkedList<>();//调用offer方法，入队names.offer("Micheal");names.offer("张三");names.offer("李四");//查看队列的样子System.out.println(names);//查看队列的头部对象String head = names.peek();System.out.println(head);System.out.println("=============================");

首先我们可以创建一个队列，泛型是String,调用offer方法，来添加元素；之后可以查看队列的头部元素，使用对象名.peek（ ）的方法

//如果想移除头部元素，最后先查看是否有头部元素，如果有再移除while (names.peek() != null) {String oldHead = names.poll();System.out.println(oldHead);System.out.println(names);}

如果我们想利用循环移除队列的头部元素；可以使用如上述代码的方法，循环条件是队列的头部元素不是空，就可以使用poll(  )方法，来移除队首的元素，并将其打印出来，之后再打印队列剩余的元素；

双端队列Deque：即可以从队列的两头添加元素,是Queue的子接口；对应的实现类，还是LinkedList

对应的方法： -offerFirst( ):   向队首添加元素    -offerLast( ) :  向队尾添加元素

                       -pollFirst( ) :   移除队首的元素     -pollLast（ ）：移除队尾的元素

 //创建一个双端队列Deque<String> names = new LinkedList<String>();//添加第一个元素names.offer("小明");//第二个元素从队列的头部进入names.offerFirst("小红");//第三个元素从队尾进入names.offerLast("小芳");System.out.println(names);

首先创建一个双端队列；，并向队列中添加元素，可以从队头添加，也可以从队尾添加

小红是从队首添加的所以再前面，小芳是从队尾添加的，所以在最后面

//移除元素//移除队列// 的头部元素String head = names.poll();System.out.println("head: "+head);//移除队列的尾部元素String tail = names.pollLast();System.out.println("tail: "+tail);System.out.println(names);

我们可以选择移除头部或者尾部的元素，默认是移除头部的元素

使用Deque来模拟栈结构；

 Deque <String> stack = new LinkedList<String>();//从栈的出口进入，方法是push，表示将元素推进去stack.push("micheal");//推入到栈的底部stack.push("lucy");//推入到最底层的上一层stack.push("lily");//推入到最底层的上一层的上一层stack.push("tom");//推入到最底层的上一层的上一层的上一层System.out.println(stack);

首先创建一个储存结构，储存类型是字符串类型的；从出口进入，使用push方法，将元素推入栈；需要注意：元素都应该是先进后出；之后出栈也应该是tom先出，之后是lily。。。

//出栈(弹出)：对应的方法pop()，将元素弹出栈结构while(stack.size() > 0){String el = stack.pop();System.out.println(el);}

需要注意的是：在出栈的时候，需要调pop方法，可以使元素弹出栈；

5.Set接口

set接口，是collection的子接口；用来储存不重复的元素，元素的顺序是无序的，（取出的顺序和存入的顺序无关）（一旦存入，在结构中的顺序就固定了，和存入的先后顺序无关）

Set接口里的方法都是Collection接口中的方法，      -HashSet : 是实现了Set接口最最经典的子类型；  底层的储存方式就是Hash表

//创建一个Set接口的对象Set<String> names = new HashSet<String>();//存入micheal,lucy,john,tomnames.add("michael");names.add("lucy");names.add("john");names.add("tom");System.out.println(names);/*** 打印一下四个元素的hash值*/System.out.println("michael".hashCode()%16);System.out.println("tom".hashCode()%16);System.out.println("john".hashCode()%16);System.out.println("lucy".hashCode()%16);

首先创建一个Set接口的对象；存入四个元素，并打印这四个元素，然后分别打印这四个元素的hash值，发现这四个元素的哈希值不同，我们就是按照哈希值来排出他们的顺序的；

Set接口的去重原理： 先计算需要添加元素的哈希值，然后确定哈希表中该值的位置上是否存在元素，如果不存在，可以添加进集合中，如果存在，就需要使用equals方法进行比较，如果equals返回true，则不能添加，如果equals返回false，则可以添加，  需要注意：每一个哈希值的位置上，都维护了一个单向链表，可以储存进哈希值相同，但equals判断不同的元素；

boolean michael = names.add("michael");System.out.println(michael);System.out.println(names.size());System.out.println(names);

因为存入的元素与之前放入集合的元素哈希值和equals判断都相同，所以返回的结果肯定是false，无法添加；

hashSet的遍历

Set<Integer> set = new HashSet<Integer>();set.add(10);set.add(20);set.add(30);set.add(40);set.add(50);System.out.println(set);

首先创建一个集合，储存五个元素；因为Set集合中的元素是无序的，没有下标的意义，所以不能使用for循环来遍历，但是可以使用迭代器和增强for循环来遍历；

for (Integer i : set) {System.out.println(i);}System.out.println("=======");Iterator<Integer> it = set.iterator();while (it.hasNext()) {System.out.println(it.next());}

第一个方法是增强for循环，创建一个变量来接受set中的每一个值，并打印，  第二种方法是使用迭代器，创建一个迭代器对象  it，然后询问it是否有下一个值，如果有就打印出下一个值。

这两种方式是等效的，因为增强for的底层就是迭代器。

public static void main(String[] args) {Set<String> set = new LinkedHashSet<>();set.add("A");set.add("B");set.add("C");set.add("bob");System.out.println(set);/*** 使用迭代器遍历*/Iterator<String> it = set.iterator();while (it.hasNext()) {System.out.println(it.next());}}

上述代码也是使用迭代器对set集合进行遍历；

TreeSet接口

TreeSet接口是SortSet接口的实现类，TreeSet集合内部存储的元素是有序的，并且不重复的，即内部维护了一个二叉树算法的排序方式，

默认的排序方式是升序，如果想用别的，需要使用比较器，重写比较方式

Set<String> set = new TreeSet<>();set.add("a");set.add("h");set.add("b");set.add("f");set.add("d");set.add("bob");set.add("bab");System.out.println(set);

先创建了一个TreeSet集合，向上造型，添加了元素，并打印出来，之前使用LinkedHashSet内容是无序的，这次是有序的，默认是升序，按照abcde的方式排列

Comparator c1=new Comparator<Integer>() {//创建比较器对象需要使用匿名内部类，重写里面的compare方法@Overridepublic int compare(Integer o1, Integer o2) {return o2-o1; //降序排序}};Set<Integer> nums = new TreeSet<>(c1);nums.add(10);nums.add(1);nums.add(20);nums.add(2);System.out.println(nums);}

上述代码中我i们创建了一个TreeSet集合向上造型并传入了比较器对象c1，传入的元素就变成降序排列的了；

Set <Person> ps = new HashSet<>();//存入集合四个Person对象ps.add(new Person("michael",18));ps.add(new Person("john",18));ps.add(new Person("tom",18));ps.add(new Person("michael",18));System.out.println("ps : "+ ps);//需求：查看有没有一个叫Michael并且是18的人Person p1 = new Person("michael",18);Person p2 = new Person("michael",18);System.out.println(p1.hashCode());System.out.println(p2.hashCode());

在上述代码中，我们使用了自己定义的类来创建一个HashSet集合，添加了4个元素，并将其都打印出来，之后定义两个对象，来查看有没有叫michael的元素，然后查看hashCode值

因为对象的成员变量是固定的，所以hashCode值也相同。

之后我们再通过contains方法来判断集合中是否有p1元素

 /***  调用contains方法，判断是否包含p1*  1.通过输出语句发现，返回的是false*    先调用hashCode，如果值不相同。就认为不存在*    如果值相同，还会调用equals方法进行比较，equals返回true，表示存在，否则表示不存在**  2.结论：*    --在自定义类的时候，如果这个类的对象要存入Set集合中，需要重写hashCode和equals方法*    --基于上述需求，我们自定义的类就必须重写这两个方法。因为我们也不知道未来如何使用*/boolean b = ps.contains(p1);System.out.println("集合中是否包含p1 ："+b);

在判断时，会先判断hashCode值，如果值不相同，则认为不存在，如果值相同，会调用equals方法来继续判断，返回true则表示存在，返回false则表示不存在

在自定义类的时候，如果这个类的对象需要储存在集合中，则需要重写hashCode( )和equals( )方法

Set接口中的删除操作

public static void main(String[] args) {Set<Person> set = new HashSet<Person>();Person p1 = new Person("小明",18);Person p2 = new Person("小张",19);Person p3 = new Person("小王",18);//存储进入集合set.add(p1);set.add(p2);set.add(p3);

首先创建一个新集合，并创建三个Person类对象，并把这三个对象储存进集合中；

 Person p4 = new Person("小王",18);set.add(p4);System.out.println(set);

因为我们重写了equals方法和hashCode方法，所以p4无法添加进集合中

 //修改p3的年龄为20岁p3.setAge(20);//Person p5 = new Person("小王",20);set.add(p5);System.out.println(set);

此时我们修改p3的年龄为20；然后发现可以继续添加一个元素p5和p3一样；

 set.remove(p3);//从结果上看，想删除p3，有一个和p3长得一样的元素没被干掉，把p5删除了System.out.println(set);

我们想要删除掉p3，但是无法删除p3,会在结果中把p5删除

这是因为我们在集合中修改了元素的属性后，会导致hashCode值不会发生改变，但是元素的属性的确改变了，我们在添加p5时，会有一个新的hashcode值存入，但是在进行删除p3的时候，会访问p3的属性，得到hashcode值，这个值是p5的值，所以会把p5删除，但是p3删除不掉了。

Sort排序

在我们自定义的类中，如果想实现排序，就要求元素必须是Comparable的子类型，因为底层需要调用Comparable的compareTo方法，所以，我们自定义的类，如果像排序，就必须实现Comparable接口，并重写里面的compareTo方法

在上述的基础上，如果我们想要重新定义比较规则，不应该修改compareTo方法的源代码，应该使用Comparator比较器来定义一个新规则，调用集合或者数组的方法来传入一个比较器的方法，从而进行一个新的排序。

集合工具类：Collections   数组工具类： Arrays

- void sort (List <E> list)

 - void sort(List<E> list,Comparator<E> c ): 可以使用比较器来重新制定比较规则

public static void main(String[] args) {List<Integer> list = new ArrayList<Integer>();for (int i = 0; i < 10; i++) {list.add((int)(Math.random() * 100));}System.out.println(list);/*** 利用工具类里的排序方法*/Collections.sort(list);System.out.println(list);

在上述代码中，我们创建了一个集合，存入了一百以内的10个随机数，然后打印出来，并利用集合工具类的排序方法来直接排序

数组工具类的排序方法默认是升序排列，如果想使用降序排列，就需要使用比较器，采用匿名内部类的方式；

 Comparator c1 = new Comparator<Integer>() {public int compare(Integer o1, Integer o2) {return o2 - o1;}};Collections.sort(list, c1);System.out.println(list);

创建一个比较器对象c1，在里面重写compare方法，返回值是一个负数，然后使用集合工具类的sort方法把比较器对象传进去，对集合进行重新排序

集合中的其他工具类

 public static  void main(String[] args) {List<String> names = new LinkedList<String>();names.add ("michael");names.add("peter");names.add("mark");names.add("john");names.add("jane");

首先创建一个都是姓名的集合这个集合是LinkedList，是有序的

  1.打印集合，顺序为添加时的顺序System.out.println("初始结果"+names);//1.调用集合工具类里的反转方法Collections.reverse(names);System.out.println("反转后的结果："+names);//2.调用工具类里的打乱方法Collections.shuffle(names);System.out.println("打乱后的结果："+names);

之后我们可以打印集合，顺序就是添加元素的顺序，可以调用工具类的反转方法，reverse,集合元素的顺序会改变

可以调用打乱方法，让集合中的元素打乱；

//3.将第二个和倒数第二个元素交换Collections.swap(names,1,names.size()-2);System.out.println("交换后的结果"+names);//4.调用max方法：底层使用的自然排序，找到最大的String ele = Collections.max(names);System.out.println("最大的结果"+ele);//5.调用min方法：底层使用自然排序，找到最小的String ele2 =  Collections.min(names);System.out.println("最小的结果"+ele2);

可以调用swap方法，交换集合总的元素，形参是索引，调用max方法，根据自然排序得到最大的，也可以调用min方法，得到最小的元素；

 names.add("michael");names.add("michael");names.add("michael");System.out.println("集合："+names);System.out.println("集合长度："+names.size());//调用工具类找到michael出现的次数int count  = Collections.frequency(names,"michael");System.out.println("michael出现的次数："+count);

我们可以在集合中继续添加三个Michael，并打印集合的长度和现在的集合，之后调用工具类的frequency方法来查看某一个元素出现的次数；形参是集合名，和需要查看的元素

//将集合中的所有Michael替换为张三Collections.replaceAll(names,"michael","张三");System.out.println("替换后的样子："+names);

工具类中还有一个替换方法，将集合中某一元素替换为指定的元素

.

集合与数组之间的相互转换

集合转数组

 List<String> names = new ArrayList<>();names.add("michael");names.add("peter");names.add("mark");

首先创建一个List集合，泛型是String

 String[] arr = new String[0];String[] arr2 = names.toArray(arr);System.out.println(arr2.length);System.out.println(Arrays.toString(arr2));//判断第一个元素是不是以el结尾的String str2 = arr2[0];boolean el = str2.endsWith("el");System.out.println(el);

然后可以先创建一个String类型的空数组，之后调用集合名.toArray(T[ ]  t )的方法来将集合转变为某一类型的数组，该方法有返回值，就是一个该类型的数组，需要接收变量，之后我们可以打印新数组的长度，并展示一下里面的内容

之后我们可以判断第一个元素是不是以el结尾的，首先需要拿到数组中的第一个元素，然后调用字符串的方法.endsWith("el")来判断；返回的结果是true。

数组转集合

public static void main(String[] args) {String[] names = new String[5];names[0] = "michael";names[1] = "tom";names[2] = "lucy";names[3] = "lily";names[4] = "john";

首先创建一个长度为5的String类型的数组，并传入元素；

 List<String> list = Arrays.asList(names);System.out.println(list);
//        将集合的第二个元素替换为张三list.set(1,"张三");System.out.println(list);names[1] = "李四";
//        add和remove都属于修改集合的长度，会报错list.add("王五");list.remove(1);

然后我们使用集合工具类中的Arrays.asList方法将集合转换为数组；我们需要将集合中的第二个元素替换为张三，可以使用集合的set方法，将索引和张三传入即可，也可以选择直接使用索引来修改；但是，当我们使用add和remove方法时，程序会报错，因为我们不能对集合的长度进行修改，集合是由数组转换过来的，数组是不允许修改长度的。

如果想要添加新的元素，就必须将原集合中的元素拷贝到新集合中，再对其进行操作

ArrayList<String> list2 =new ArrayList<>(list);list2.add("张三");list2.add("李四");

创建一个新的数组，传入参数是list；向新数组添加张三和李四

//获取张三的位置int index = list2.indexOf("张三");Collections.swap(list2,0,index);System.out.println(list2);

之后我们可以获取张三的位置，使用indexOf方法，然后调用集合工具类中的swap方法调换张三和第一个元素的位置。

6.Map接口

Map接口是集合的另一大父接口

Map集合在储存数据时，一对一映射，是一个双列集合，内部是键值对（Entry）

Map接口的子类有HashMap和TreeMap:

HashMap底层使用的是Hash表和红黑树结构， TreeMap底层使用的是二叉树结构

Map的键是不可以重复的，但是值可以重复，我们可以通过键来找到具体对应的值，

Map中的元素也是无序的（在结构中的储存顺序和存入顺序无关）

 //创建一个Map集合（散列表）Map<String,Integer> map = new HashMap<>();//1.存储元素调用put方法map.put("张三",100);map.put("李四",98);map.put("王五",97);map.put("赵六",99);//输出打印一下System.out.println(map);

首先我们创建一个Map集合,调用集合的添加方法put 存入元素，在创建集合的时候，因为是键值对，我们需要传入两个泛型；

 //2.获取一个人的成绩  调用get(K k)Integer score = map.get("张三");System.out.println("张三的成绩"+score);//存入张三和60分     put方法，如果key相同，会覆盖掉原来的valuemap.put("张三",60);System.out.println(map);//取出小花的成绩    get(K k)方法  如果key不存在，返回nullInteger score1 = map.get("小八");System.out.println("小八的成绩："+score1);map.put(null,null);map.put(null,10);System.out.println(map);

之后我们可以获取键对应的值，调用get方法，输入的形参是键，返回值是值。如果我们在使用get方法时，输入的键不存你在，那么返回的值就是null,我们还可以调用put方法来修改键对应的值，如果输入的键和值都为null也可以储存进集合；如果put方法传入的键是集合中存在的，则是覆盖操作，会将原有的值覆盖，返回值是被覆盖的值。

Map的其他方法

 HashMap<String, String> course = new HashMap<>();course.put("王老师","语文");course.put("李老师","数学");course.put("张老师","化学");course.put("赵老师","生物");System.out.println(course);

首先创建一个Map集合；两个泛型都是String；并添加元素。

/*** 1. boolean isEmpty()*/System.out.println("course集合是否为空 "+course.isEmpty());/*** 2. containsKey(Object obj)*/System.out.println("是否包含张老师这个key "+course.containsKey("张老师"));/*** 3. containsValue(Object obj)*/System.out.println("是否包含数学这个value "+course.containsValue("数学"));/**

判断集合是否为空可以使用  isEmpty（）方法，返回值是布尔类型；

判断集合中是否包含某个键可以使用  containsKey（K k ），返回值是布尔类型

判断集合中是否包含某个值可以使用  containsValue(V v ) ，返回值是布尔类型

 /*** 4. V remove(K k)  移除一个键值对*/course.remove("赵老师");System.out.println(course);/*** 5.  int size()*/System.out.println(course.size());/*** 6.clear():  清空所有键值对*/course.clear();System.out.println(course.size());System.out.println(course);

移除集合中某个键值对可以使用remove（ ）方法，传入的形参是键；

获取集合的长度可以使用  size（ ） 方法，返回值类型是int

清空所有键值对可以使用  clear（ ）方法

Map集合的遍历

集合遍历的第一种方式（键找值）

遍历所有的键，通过键来找到对应的值，达到遍历整个集合的目的；

Map<String, Integer> scores = new HashMap<>();scores.put("michael", 100);scores.put("lucy", 98);scores.put("tom", 97);scores.put("john", 99);

 /*** 第一种方式：使用keySet():  返回所有key的set集合方式*/Set<String> keys = scores.keySet();for (String key : keys) {//通过key获取valueInteger value = scores.get(key);System.out.println(key + "--" + value);}System.out.println("===================");

首先创建一个只有键的单列集合遍历这个集合，通过调用每个键的value获得键值对；

集合遍历的第二种方式（entry键值对）

/*** 第二种方式： 使用entrySet(): 返回entry对象的set集合*     Entry: 是Map的内部类，Entry对象就是封装了一个键值对*/Set<Map.Entry<String,Integer>>  es = scores.entrySet();for(Map.Entry<String,Integer> Entry :es){//每一个Entry都是键值对
//            System.out.println(Entry);/*** Entry类型提供了getKey()和getValue()方法*/System.out.println(Entry.getKey()+"--"+Entry.getValue());System.out.println("=============");}

可以使用scores.entry();的方式创建一个集合对象，泛型是Map的内部类Entry<>,传入键和值的泛型，然后使用增强for循环对集合进行遍历；然后打印出键和值

使用第三种方式对集合进行遍历（获得每个值）

 Collection<Integer> values = scores.values();for(Integer value : values){System.out.println(value);}

直接调用scores.values()获得所有值，然后对这些值进行遍历；就可以得到所有的值的遍历结果；

LinkedHashMap

是hashMap的子类型，使用链表维护了元素的插入顺序，确保集合是有序的；

public static void main(String[] args) {Map<String, String> map = new LinkedHashMap<>();map.put("张三","北京");map.put("李四","上海");map.put("王五","北京");map.put("赵六","长春");System.out.println(map);}

TreeMap

使用二叉树对key进行排序，默认是升序，可以通过比较器来自定义比较规则；

public static void main(String[] args) {Comparator c1 = new Comparator<String>() {public int compare(String o1, String o2) {return -o1.compareTo(o2);}};Map<String,Integer> map = new TreeMap<>(c1);map.put("A", 100);map.put("a", 90);map.put("b", 80);map.put("C", 90);System.out.println(map);}

首先创建一个比较器对象，重写比较方法；之后创建集合，输入集合中的元素