Java三大集合框架

定义：java中集合类：是一种工具类，就像是容器，储存任意数量的具有共同属性的对象

一.List集合

   1.List实现的超级父类接口：Collection

   2.了解ArrayList类

    A）：定义的格式：Array<具体类型>集合名=new Array<具体类型>();

    B）：数据的储存方式：底层还是用数组储存

    C）：对象的类型： 在List集合中，如果定义集合对象时没有定义定义对象的类型，就表示什么类型的对象都可以直接存储到List集合中，如果想要运用里面的元素，则需要用instanceof来判断元素的类型。格式 ：元素 instanceof 所判断的类型;返回true或false。后续需要强转。

     D）：集合的设计：泛型的方式进行类型指定，ArrayList<具体类型>

               特点：元素有序、可重复，可变大小的容器

               遍历：for循环即可

     E)：基本操作：

                              增加：集合名.add(元素); 加在集合最后，

                              集合名.add(数字，元素); 加载指定的位置

                              集合名.addAll(另一个集合名);  加在最后

                              集合名.addAll(数字，另一个集合名);   加载指定位置

                              删除：集合名.remove(数字);   移去指定位置的元素

                              集合名.remove(元素);   移去集合中第一次出现的指定元素（如果存在）

                              集合名.removeALL(另一个集合名);  移去另一个集合中的所有元素

                              集合名.retaintALL(另一个集合名);   仅保留另一个集合中的所有元素

                              集合名.clear();  清空集合

                              判断/获得：集合名.get(数字);   获得指定位置的元素

                              集合名.contains(元素);   判断集合是否包含该元素，是则返回true

                              集合名.contains(另一个集合名); 判断是否包含另一个集合的所有元素

                              集合名.indexOf(元素);   返回该元素的索引，无则返回-1

                              集合名.equals(元素); 判断该元素是否与集合的元素一致  返回true或false

                              改：集合名.set(数字，元素); 用该元素替换指定位置的元素

                              其它：集合名.size(); 获取集合的大小

LinkedList：

同样实现List接口的LinkedList与ArrayList不同，ArrayList是一个动态数组，而LinkedList是一个双向链表。所以它除了有ArrayList的基本操作方法外还额外提供了get，remove，insert方法在LinkedList的首部或尾部。

      由于实现的方式不同，LinkedList不能随机访问，它所有的操作都是要按照双重链表的需要执行。在列表中索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。这样做的好处就是可以通过较低的代价在List中进行插入和删除操作。

addFirst：在列表的首部添加元素

addLast：在列表末尾添加元素

getFirst：返回列表中的第一个元素

getLast：返回列表中最后一个元素

removeFirst：删除并返回列表中的第一个元素

removeLast：删除并返回列表中的最后一个元素

Java集合框架的体系结构：

二.Set接口：

                         1、Set实现的超级父类接口：Collection                           

                          2、了解HashSet类

                                A)：定义的格式:  HashSet<具体类型> 集合名 =  HashSet<具体类型>();

                                B):数据的存储方式:遵循Hash算法来存储数据

                                C)：对象的类型：必须要定义集合对象类型，否则会影响后续的使用

                                D)：集合的设计：泛型的方式进行类型指定：HashSet<具体类型>

                                                             特点：元素无序、不可重复，可变大小的容器

                                                             注意：底层并非真正的无序，遵循Hash算法来保证数据的存储，但是我们作为使用者，就理解为无序

                                                             遍历：需要使用迭代器:Iterator<类型> 名称 = 集合名.iterator();

                                E)：基本操作：

                                      增加：集合名.add(元素);   添加指定元素（之前集合不过包含的）

                                      删除：集合名.remove(元素);  移去指定的元素

                                      集合名.clear();    清空集合

                                      判断：集合名.containts(元素);  如果集合包含此元素，返回true

                                      其它：集合名.size();   获得集合的大小

                                     Iterator<类型> 名称 = 集合名.iterator();  用于集合的遍历

Set和List的区别

• 1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。

• 2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。

• 3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

三、Map集合

1、Map没有实现的超级父类接口，不是Collection的直接接口子类

2、了解HashMap类

A)：定义的格式：HashMap<类型,类型> 集合名 = new HashMap<类型,类型>();

B)：数据的存储方法：key+value的存储方式

C)：对象的类型：必须要定义集合对象类型，否则会影响后续的使用

D)集合的设计：泛型的方式进行类型的指定：HashMap<具体类型>

                      特点：一条数据，是由两部分组成：键和值，元素无序、不可重复， 可变大小的容器

      遍历：需要使用键的迭代器   Set<类型> 名称1 = 集合名.keySet();

Iterator<类型> 名称 = 名称1.iterator();

E)：基本操作

增加：集合名.put(键，值);  在此映射中关联指定值与指定键（是put，不是add）

删除：集合名.remove(键);  从映射中移除指定键的映射关系（如果存在）

判断：集合名.containsKey(键);  如果此映射包含对于指定键的映射关系，返回true

  集合名.containsValue(值); 如果此映射将一个或多个键映射到指定值，返回true

其它：集合名.size();  获得集合的大小

注意：在Map集合中，一个键只能对应有一个值，但一个值可以有多个键对应，如果说放（put）了一个相同的键到map中，则新元素会替换原来的元素，会把替换掉的元素返回出来，你可以接收到，并做后续处理

hasNext和next方法：

boolean hasNext()：判断集合是否还有元素可以遍历

E next():返回迭代的下一个元素

Iterator：   

iterator是一个接口，集合再覆盖Collection的方法时提供迭代器的实现

import java.util.*;
 
public class Test{
 public static void main(String[] args) {
     List<String> list=new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add("HAHAHAHA");
     //第一种遍历方法使用foreach遍历List
     for (String str : list) {            //也可以改写for(int i=0;i<list.size();i++)这种形式
        System.out.println(str);
     }
 
     //第二种遍历，把链表变为数组相关的内容进行遍历
     String[] strArray=new String[list.size()];
     list.toArray(strArray);
     for(int i=0;i<strArray.length;i++) //这里也可以改写为  foreach(String str:strArray)这种形式
     {
        System.out.println(strArray[i]);
     }
     
    //第三种遍历 使用迭代器进行相关遍历
     
     Iterator<String> ite=list.iterator();
     while(ite.hasNext())//判断下一个元素之后有值
     {
         System.out.println(ite.next());
     }
 }
}