框架集合

Collection

1：单列集合，每个元素（数据）只包含一个值
2：一个Collection代表一组Object，不提供实现类，只提供子接口（如List 接口和Set 接口）
3：Collection接口存储一组可以重复的无序对象
4：Collection是单列集合的祖宗，它规定的方法（功能）是全部单列集合都会继承的；
5：方法：

 java.util.Collection c =new ArrayList(); // 多态与这// 1.public boolean add(E e): 添圳元素，流加成功返回true
        c.add("java1");
        c.add("java1");
        c.add("java2");
        c.add("java2");
        c.add("java3");
        System.out.println(c);

        //public boolean add();//添加元素`

        //public woid clear();
        c.clear();
        System.out.println(c);//清空集合的元素

        //public boolean isEmpty(): //判断集合是否为空 是窄返回
        System.out.println(c.isEmpty()); // false

        //public int size(): 获取集合的大小。
        System.out.println(c.size());

        //public boolean contains(Object obj):判断集合中是
        System.out.println(c.contains("java1")); //true
        System.out.println(c.contains("Javal")); // false

        //public boolean remove(E e);//删除某个元素:如果有多个元素默认删除前面的第一个!
        System.out.println(c.remove( "java1"));
        System.out.println(c);

        //public Object[] toArray();//把集合转换成数细
        Object[] arr =c.toArray();
        System.out.println(Arrays.toString(arr));
        String[] arr2 = (String[]) c.toArray(new String[c.size()]);
        System.out.println(Arrays.toString(arr2));
        
        // 把一个集合的全部数据倒入到另一个集合中去。
        java.util.Collection<String> c1 = new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        java.util.Collection<String> c2 = new ArrayList<>();
        c2.add("java3");
        c2.add("java4");
        c1.addAll(c2); // 就是把c2英合的全部数据倒入到c1集合中去。
        System.out.println(c1);//注意c2的值并没有消失还在2c里面

集合的遍历

1.Iterrator接口主要是用于遍历（迭代访问）Collection集合中的元素，Iterrator对象也被称为迭代器

2.使用方法：

Iterator < e > iterator() 说明：返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素

boolean hasNext() 说明：询问当前位置是否有元奈存在，存在返回true,不存在返回false

E next() 说明：获取当前位苦的元紊，并同时将迭代器对象指向下一个元系处。

void remove() 说明：删除集合里上一次next(）方法返回的元素

List

1.添加的元素是有序，可重复，有索引
2.继承Collection接口，可以使用Collection的方法（上面的代码都可以使用）
3.List常用方法：

int size(): 返回列表中的元素个数。

boolean isEmpty(): 如果列表中没有元素，则返回 true。

boolean contains(Object o): 如果列表中包含指定的元素，则返回 true。

boolean add(E e): 将指定的元素添加到列表的末尾。

boolean remove(Object o): 从列表中移除第一个出现的指定元素（如果存在）。

void clear(): 从列表中移除所有的元素。

E get(int index): 返回列表中指定位置的元素。

E set(int index, E element): 用指定的元素替换列表中指定位置的元素。

void add(int index, E element): 在列表中的指定位置插入指定的元素。

E remove(int index): 移除列表中指定位置的元素。

4.List接口常用的实现类有 ArrayList,LinekdList:有序，可重复，有索引

不同的是ArrayList的底层原理是基于数组实现的
特点：查询速度快，删除效率低，添加效率低

LinekdList的底层原理是基于双链表实现的
特点：查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的

5.LinkedList
因为LinkedList是双链表实现的它会有一些特殊的方法：

void addFirst(E e): 在链表的开头添加指定的元素。

void addLast(E e): 在链表的末尾添加指定的元素。

E getFirst(): 返回链表中的第一个元素。

E getLast(): 返回链表中的最后一个元素。

E removeFirst(): 移除并返回链表中的第一个元素。

E removeLast(): 移除并返回链表中的最后一个元素。

void push(E e): 将元素推入栈（等效于 addFirst(e)）。

E pop(): 从栈顶移除元素并返回（等效于 removeFirst()）。

Set

1.Set系列集合：添加的元素是无序，不重复，无索引
2.Set继承Collection接口，储存一组不可以重复的无序对象
3. HashSet:添加的元素是无序，不重复，无索引

HasgSet的底层原理是基于哈希表实现的（哈希表=数组+链表+红黑树）

4. LinkedHashSet：有序，不重复，无索引

底层原理依然是基于哈希表(数组、链表、红黑树)实现的
但是，它的每个元素都额外的多了一个双链表的机制记录它前后元素的位置

5. TreeSet：

特点: 不重复、无索引、可排序 (默认升序排序 ，按照元素的大小，由小到大排序)底层是基于红黑树实现的排序.
注意:
对于数值类型:Integer，Double，默认按照数值本身的大小进行升序排序
对于字符串类型：默认按照首字符的编号升序排序
对于自定义类型如Student对象，TreeSet默认是无法直接排席的，

自定义排序规则
TreeSet集合存储自定义类型的对象时，必须指定排序规则，支持如下两种方式来指定比较规则
方式一
让自定义的类（如学生类）实现Comparable接口，重写里面的compareTo方法来指定比较规则。
方式
通过调用TreeSet集合有参数构造器，可以设置Comparator对象(比较器对象，用于指定比较规则
public TreeSet(Comparator<? super E> comparator

Map

介绍Map

• Map集合称为双列集合，格式：{keyl=value1,key2=value2,key3=value3,…}，一次需要存一对数据做为一个元素
• Map集合的每个元素“key=value”称为一个键值对/键值对对象/一个Entry对象，Map集合也被叫做“键值对集合
• Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值

注意: Map系列集合的特点都是由键决定的，值只是一个附属品，值是不做要求的

Map常用方法：

//Hape<String，Integer> map = new HashHop<>(); // 一行经典代码。 按照继 无序，不重复，无索引。
Map<String，Integer> map = new LinkedHashMaps<>(); // 有序，不重复，无索引。map.put("手表"，10);
map.put("手表"，220); // 后面重复的数据会覆盖前面的数据（键）
map.put("手机"，2);
map.put("Java",2);
map.put(null, null):
System.out.printin(map);
// mop = {null=nulL，手表=220，Jova=2，手机=2]
// 2.public int size():获取集合的人小System.out.println(map,size());

// 3、public void clear():
map.cleor();//清空集合
System.out.printin(map);

// 4.public boolean isEmpty(): 判断集合是否为笔，为空返同true ，反之返回false；
System.out.printn(map.isEmpty());

// 5.public V get(object key): 根据继获取对应值
int vl = map,get("手表");
System,out.printin(v1);
System,out.println(map,get("手机")); //2
System.out.printin(map.get("张三")); // null

// 6， public V remove(Object key): 根键除整个元素(剔除键会返回键的值)
System.out.println(map,remove( key:"手表"));
System,out.printin(map) ;

// 7.public boolean containsKey(object key): 断是否包含个继 ，包含返回true
System.out.println(map.containsKey("手表")); // false
System,out.printin(map.containsKey("手机")); // true
System.out.printin(map,containsKey("java")); // false
System,out.printin(map,containsKey("Java")); // true

// 8.public boolean containsValue(Object yalve): 判断是否包含某个值。
System.out.printin(map.containsvalue(2));// true
System.outprintln(map,containsValue("2")): // false

// 9.public Setek> keySet(): 获取Map集合的全部键
Set<string> keys = map ,keySet();
System,out.printin(keys);

// 10.public ColLectione<V> values(); 获歌Map集合的全部值
Collection<Integer> yalues = map,values();
System,out.println(values);

// 11.把其他MoD集合的数据倒入到自己集合中来。
Mapcstring, Integer> map1 = new HashMap<>() ;
mapl.put("java1",10);map1.put("java2", 20);
Mapcstring, Integer> map2 = new HashMap<>() ;
map2,put("java3",10);
map2.put("java2",222);
map1,putAlL(map2); // putALl; 把map2集合中的元素全部的入一份到map1集合中去。
System.out.printbn(map1);

Map集合的遍历

1.键找值

先获取Map集合全部的键，再通过遍历键来找值

方法示例：

  Map<String,Double> map=new HashMap<>();
        map.put("小敏",170.0);
        map.put("小图",160.0);
        map.put("小巫",175.0);
        System.out.println(map);
  Set<String> keys= map.keySet();
  System.out.println(keys);
        for (String key : keys) {
            double value= map.get(key);
            System.out.println("姓名:"+key+",身高："+value);
        }     

2.键值对

把“键值对“看成一个整体进行遍历(难度较大)

方法示例：

  Map<String,Double> map=new HashMap<>();
        map.put("小敏",170.0);
        map.put("小图",160.0);
        map.put("小巫",175.0);
        System.out.println(map);
Set<Map.Entry<String, Double > entries = map.entrySet();
for (Map.Entry<String, Double> entry : entries) {
	String key= entry.getKey();
	double value= entry.getValue();
    System.out.println("姓名:"+key+",身高："+value);
     }

3.Lambda

它提供了一种简洁而便利的语法来表示匿名函数。Lambda 表达式可以用于简化函数式接口的实现，

方法示例：

  Map<String,Double> map=new HashMap<>();
        map.put("小敏",170.0);
        map.put("小图",160.0);
        map.put("小巫",175.0);
 System.out.println(map);
    map.forEach((k, v ) ->{
        System.out.println("姓名:"+k+",身高："+v);
    });

Hash

1.HashMap（由键决定特点）:无序、不重复、无（用的最多）
2.HashMap集合是一种增删改查数据，性能都较好的集合
3.HashMap的键依赖hashCode方法和equals方法保证键的唯一
4.如果键存储的是自定义类型的对象，可以通过重写hashCode和equals方法，这样可以保证多个对象内容一样时，HashMap集合就能认为是重复的。

LinkedHashMap

LinkedHashMap （由键决定特点）:由键决定的特点：有序、不重复、无索引。

TreeMap

TreeMap（由键决定特点）:按照大小默认升序排序、不重复、无索引。