java集合

一、集合介绍

集合框架（单列集合）

之前我们学了保存数据的有：变量，数组，但是数组定长所以如果添加一个数据或者删除一个数据，需要创建一个新数组，所以学一个长度可变的容器，集合

集合的特点：

  只能存储引用数据类型的数据

  长度可变

  集合中有大量的方法方便操作

分类：

  单列集合：一个元素就一个组成部分   list.add（“张三”）

  双列集合：一个元素有两部分构成：key和value   map.put（“名”，“怡”）->key，value叫做键值对

1.Collection接口的使用

概述：单列集合的顶级接口

使用：

   创建：

      Collection<E> 对象名=new  实现类对象<E> ()

<E>:泛型，决定了集合中能存储什么类型的数据，可以统一元素类型

  泛型中只能写引用数据类型，如果不写，默认Object类型，此时什么类型的数据都可以存储了

<int>  不行

<Integer> 行

<Person> 行

泛型细节：我们等号前面的泛型必须写，等号后面的泛型可以不写，jvm会根据前面的泛型推导出后面的泛型是啥

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Demo01Collection {
    public static void main(String[] args) {
        Collection<String> collection=new ArrayList<>();

        //boolean add（E e）：将给定的元素添加到当前集合中（我们一般调add时不用boolean接收因为add一定成功）
        collection.add("萧炎");
        collection.add("萧熏儿");
        collection.add("彩鳞");
        collection.add("小医仙");
        collection.add("云韵");
        System.out.println(collection);
        System.out.println("============");


        //boolean  addAll（collection<？extends E>c）：将另一个集合元素添加到当前集合中（集合合并）
        Collection<String> collection1=new ArrayList<>();
        collection.add("名");
        collection.add("怡");
        collection.add("杨");
       collection1.addAll(collection);
        System.out.println(collection1);
        System.out.println("=============");


        //void clear（）：清除集合中所有的元素
        collection1.clear();
        System.out.println(collection1);
        System.out.println("============");


        //boolean contains（object o）：判断当前集合中时否包含指定的元素
        boolean result01=collection.contains("名");
        System.out.println("result="+result01);

        System.out.println("=========");
        //boolean  isEmpty（）：判断当前集合中是否有元素——>判断集合是否为空

        System.out.println(collection1.isEmpty());


        System.out.println("==========");
        //boolean  remove（object o）：将指定的元素从集合中删除

        collection.remove("云韵");
        System.out.println(collection);

        System.out.println("=================");
        //int size（）：返回集合中的元素个数
        System.out.println(collection.size());


        System.out.println("================");
        //object[]  toArray():把集合中的元素，存储到数组中

        Object[] objects = collection.toArray();
        System.out.println(Arrays.toString(objects));


    }
}

2.迭代器

概述：Iterator接口

主要作用：遍历集合

获取：Collection中的方法

  Iterator<E> iterator()

方法：

 Boolean hasNext（）->判断集合中没有下一个元素

 E next（）->获取下一个元素

注意：next方法在获取的时候不要连续使用多次（否则会报错NosuchElementEx'ception）没有可操作的元素异常

迭代器底层原理

获取Iterator的时候怎么获取的：

  Iterator  iterator=list.iterator（）

我们知道Iterator是一个接口，等号右边一定是他的实现类对象

问题：Iterator接收的到底是哪个实现类对象呢->ArrayList中的内部类Itr对象

注意：只有ArrayList使用迭代器的时候Iterator接口才会指向Itr，其他集合使用迭代器Iterator就指向的不是Itr了

import java.util.ArrayList;
import java.util.Iterator;

public class Demo01Iterator {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("熊大");
        list.add("熊二");
        list.add("吉吉国王");
        list.add("光头强");
        list.add("地鼠");
        //获取迭代器对象
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){

            String element = iterator.next();
            System.out.println(element);

        }

    }
}

3.并发修改异常

需求：定义一个集合，存储唐僧，孙悟空，猪八戒，沙僧，遍历集合，如果遍历到猪八戒，往集合中添加一个白龙马

import java.util.ArrayList;

import java.util.ListIterator;

public class Demo02Iterator {
    public static void main(String[] args) {


        ArrayList<String> list = new ArrayList<>();
        list.add("唐僧");
        list.add("孙悟空");
        list.add("猪八戒");
        list.add("沙僧");

//        Iterator<String> iterator = list.iterator();
        ListIterator<String> listIterator = list.listIterator();


        while (listIterator.hasNext()){
            String element = listIterator.next();
            if ("猪八戒".equals(element)){
                list.add("白龙马");
            }
        }

        System.out.println(list);
    }
}

ArrayList中的方法：ListIterator<E> listIterator()

使用迭代器迭代集合的过程中不要随意修改集合的长度

二、ArrayList集合

List接口

概述：是collection接口的子接口

List集合下的实现类

ArrayList集合

概述：ArrayList是list接口的实现类

特点：

• 元素有序->按照什么顺序存的，就按照什么顺序取
• 元素可重复
• 有索引->可以利用索引去操作元素
• 线程不安全

数据结构：数组

常用方法：

boolean  add（E e）->将元素添加到集合中->尾部（add方法一定能添加成功的，所以我们不用boolean接收返回值）

void  add(int  index,E  element)->在指定索引位置上添加元素

boolean  remove(object  o)->删除指定的元素，删除成功为true，失败为false

E remove(int  index)->删除指定索引位置上的元素，返回的是被删除的那个元素

E  set（int  index，E  element）->将指定索引位置上的元素，修改成后面的element元素

E  get（int  index）->根据索引获取元素

int  size（）->获取集合元素个数

import java.util.ArrayList;

public class Demo01ArrayList {
    public static void main(String[] args) {

         ArrayList<String> list=new ArrayList<>();

         list.add("唐僧");
         list.add("僧");
         list.add("唐");
         list.add("唐僧1");
         list.add("唐僧2");
        System.out.println(list);
        System.out.println("=============");
        list.add(2,"名");
        System.out.println(list);
        System.out.println("=========");

        String element=list.remove(0);
        System.out.println(element);
        System.out.println(list);
        System.out.println("=========");

        String element1=list.set(0,"怡");
        System.out.println(element1);
        System.out.println(list);
        System.out.println("==============");

        System.out.println(list.get(0));
        System.out.println("===============");
        System.out.println(list.size());



    }
}

import java.util.ArrayList;
import java.util.Iterator;

public class Demo02ArrayList {
    public static void main(String[] args) {

         ArrayList<String> list=new ArrayList<>();

         list.add("唐僧");
         list.add("僧");
         list.add("唐");
         list.add("唐僧1");
         list.add("唐僧2");


        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());

        }


        System.out.println("==========");


        for (int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }


        System.out.println("==============");
        /*
        *
        * 遍历带索引集合的快捷键
        * 集合名.fori
        *
        *
        * */

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }


    }
}

import java.util.ArrayList;
import java.util.Iterator;

public class Demo03ArrayList {
    public static void main(String[] args) {

         ArrayList<Integer> list=new ArrayList<>();

      list.add(2);
        System.out.println(list);

        /*删除2

        remove(object o)->直接删除指定元素
        remove（int index）->删除指定索引位置上的元素

        如果remove中直接传递整数默认调用按照指定索引删除元素的remove但是此时list中没有2索引
        所以越界

        解决：将2包装成包装类，变成包装类以后其父类就是object



        * */
        //list.remove(2);
        list.remove(Integer.valueOf(2));
        System.out.println(list);

    }
}

三、LinkedList集合

概述：LinkedList是List接口的实现类

特点：

• 元素有序
• 元素可重复
• 有索引->这里说的有索引仅仅指的是有操作索引的办法，不代表本质上具有索引
• 线程不安全

数据结构：双向链表

方法：有大量直接操作首尾元素的方法

public  void  addFirst(E  e):将指定元素插入此列表的开头

public  void  addLast(E e):将指定元素添加到此列表的结尾

public  E  getFirst():返回此列表的第一个元素
public  E  getLast():返回此列表的最后一个元素

public  E  removerFirst():移除并返回此列表的第一个元素

public  E  removeLast():移除并返回此列表的最后一个元素

public  E  pop():从此列表所表示的堆栈处弹出一个元素

public  void  push(E  e):将元素推入此列表所表示的堆栈

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

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

public class Demo04ArrayList {
    public static void main(String[] args) {
        LinkedList<String> linkedList=new LinkedList<>();

        linkedList.add("吕布");
        linkedList.add("关羽");
        linkedList.add("张飞");

        System.out.println(linkedList);


        linkedList.addFirst("孙尚香");
        System.out.println(linkedList);

        linkedList.addLast("董卓");
        System.out.println(linkedList);

        linkedList.removeFirst();
        System.out.println(linkedList);
        System.out.println("===============");
        Iterator<String> iterator = linkedList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("=============");

        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }

    }
}

import java.util.Iterator;
import java.util.LinkedList;

public class Demo05ArrayList {
    public static void main(String[] args) {
        LinkedList<String> linkedList=new LinkedList<>();

        linkedList.add("吕布");
        linkedList.add("关羽");
        linkedList.add("张飞");

        //从列表中栈处弹出一个元素
        linkedList.pop();
        System.out.println(linkedList);

        linkedList.push("名");
        System.out.println(linkedList);
    }
}

1.增强for

基本使用

作用：遍历集合或者数组

格式：

  For（元素类型 变量名：要遍历的集合名或者数组名）{

   变量名就是代表每一个数组

}

快捷键：集合名或者数组名.for

注意：增强for遍历集合时，底层实现原理为迭代器

增强for遍历数组时，底层实现原理为普通for

不管用迭代器还是增强for在遍历集合过程中都不要随意修改集合长度否则会出现并发修改异常

四、Collections集合工具类

概述：集合工具类

特点：

• 构造私有
• 方法都是静态的

使用：类名直接调用

方法：

static  <T> boolean  addAll(Collection<? super>c,T......elements)->批量添加元素

static void  shuffle(List<?> list)->将集合中的元素顺序打乱

static  <T> void  sort  (List<T>  list)->将集合中的元素按照默认规则排序

static <T> void  sort  (List<T> ）list，comparator<? super T>c)->将集合中的元素按照指定规则排序

import java.util.Collections;

public class Demo01Collections {
    public static void main(String[] args) {
     ArrayList<String> list= new ArrayList<>();

     //批量添加元素
        Collections.addAll(list,"唐僧","张三","李四","猪八戒","孙悟空");
        System.out.println(list);
        System.out.println("=================");

        //将集合中的元素顺序打乱
        Collections.shuffle(list);
        System.out.println(list);

        System.out.println("=================");

        //将集合中的元素按照默认规则排序

        ArrayList<String> list1=new ArrayList<>();
        list1.add("c.举头望明月");
        list1.add("a.窗前明月光");
        list1.add("b.明月光");
        list1.add("d.窗前");
        Collections.sort(list1);
        System.out.println(list1);

        System.out.println("=====================");
        //将集合中的元素按照指定规则排序
    }
}

Comparator：比较器

方法：int  compare（T o1,T o2）

                 O1->o2升序 反之降序

public class Person {
    private String name;
    private Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Demo02Collections {
    public static void main(String[] args) {

        ArrayList<Person> list=new ArrayList<>();
        list.add(new Person("熊大",20));
        list.add(new Person("熊二",18));
        list.add(new Person("杨",16));


        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        System.out.println(list);
    }
}

接口：Comparable接口

方法：int  compareTo（T o）->this-o(升序)  o-this（降序）

public class Student  implements Comparable<Student> {
    private String name;
    private Integer score;

    public Student() {
    }

    public Student(String name, Integer score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getScore() {
        return score;
    }

    public void setScore(Integer score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return this.getScore()-o.getScore();
    }
}

import java.util.ArrayList;
import java.util.Collections;

public class Demo03Collections {
    public static void main(String[] args) {
        ArrayList<Student> list=new ArrayList<>();
        list.add(new Student("名",99));
        list.add(new Student("杨",60));
        list.add(new Student("怡",89));
        Collections.sort(list);
        System.out.println(list);
    }
}

Arrays中的静态方法：

  Static<T> List<T> asList(T....a)->直接指定元素转存到list集合中

import java.util.Arrays;
import java.util.List;

public class Demo04Collections {
    public static void main(String[] args) {

        List<String> list= Arrays.asList("张三","李四","王五");
        System.out.println(list);


    }
}

1.泛型

泛型：<>

作用：统一数据类型，防止将来的数据转换异常

注意：泛型中的类型必须是引用类型

   如果泛型不写，默认类型为Object

为什么要使用泛型？

从使用层面来看：统一数据类型，防止将来的数据类型转换异常

定义层面来看：定义带泛型的类方法等，将来使用的时候给泛型确定什么类型，凡是涉及到泛型的都会变成确定的类型代码更灵活

泛型的定义

含有泛型的类

  定义：public  class  类名<E>{

      

}

什么时候确定数据类型？New对象的时候

含有泛型的方法

格式：修饰符<E>  返回值类型 方法名（E e）

什么时候确定类型？调用的时候确定类型

含有泛型的接口

格式：public  interface  接口名<E>{

}

什么时候确定类型：在实现的时候还没有确定类型，只能在new实现类的时候确定类型->比如ArrayList

在实现类的时候直接就确定类型了->比如Scanner

泛型的上限和下限

作用：可以规定泛型的范围

上限：

  格式：<？ extends 类型>

  含义：？只能接收extends后面的本类型以及子类类型

下限：

  格式：<？Super 类型>

  含义：？只能接收super后面的本类类型以及父类类型

应用场景：

如果我们在定义类，方法接口的时候，如果类型不确定，我们可以考录定义含有泛型的类，方法接口。

如果类型不确定，但是能知道以后只能传递某个类的继承体系中的子类或者父类，就可以使用泛型的通配符

五、Set集合

Set接口并没有对collection接口进行功能性的扩充，而且所有的Set集合底层都是依靠Map实现

Set和map是密切相关的

Map遍历需要先遍历单列集合，只能变成set集合

1.HashSet集合的介绍和使用

概述：HashSet是Set接口的实现类

特点：

  元素唯一

  元素无序

  无索引

  线程不安全

数据结构：哈希表

方法：和collection一样

遍历：增强for   迭代器  

import java.util.HashSet;
import java.util.Iterator;

public class Demo01HashSet {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("张三");
        set.add("李");
        set.add("五");
        set.add("王");
        set.add("张");
        set.add("张三");
        System.out.println(set);


        //迭代器
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }


        System.out.println("============");
        //增强for
        for (String s : set) {
            System.out.println(s);
        }


    }
}

2.LinkedHashSet介绍和使用

特点：

  元素唯一

  元素有序（如何存如何取）

  无索引

  线程不安全

数据结构：

   哈希表+双向链表

使用：和hashSet一样

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;

public class Demo02HashSet {
    public static void main(String[] args) {
      LinkedHashSet<String> set = new LinkedHashSet<>();
        set.add("张三");
        set.add("李");
        set.add("五");
        set.add("王");
        set.add("张");
        set.add("张三");
        System.out.println(set);


        //迭代器
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }


        System.out.println("============");
        //增强for
        for (String s : set) {
            System.out.println(s);
        }


    }
}

哈希值

概述：是由计算机算出来的十进制数，可以看作是对象的地址值

获取对象的哈希值，使用的是object中的方法

Public native int hashCode（）

注意：如果重写了hashCode方法，那计算的就是对象内容的哈希值了

总结：

 哈希值不一样，内容肯定不一样

 哈希值一样，内容也有可能不一样例如（字符串通话和重地）

public class Demo01Hash {
    public static void main(String[] args) {

        Person p1 = new Person("名",18);
        Person p2 = new Person("名",18);
        System.out.println(p1);
        System.out.println(p2);


        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());

        System.out.println(Integer.toHexString(460141958));
        System.out.println(Integer.toHexString(1163157884));


        System.out.println("==================");
        String s1="abc";
        String s2=new String("abc");
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());

        //String底层重写了hashcode所以地址值一样，内容一样


        System.out.println("====================");
        String s3="通话";
        String s4="重地";

        System.out.println(s3.hashCode());
        System.out.println(s4.hashCode());



    }
}

import java.util.Objects;

public class Person {
    private String name;
    private Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

如果不重写hashcode方法，默认计算对象的哈希值

如果重写hashcode方法，计算的是对象内容的哈希值

问题：在计算哈希值的时候有一个定值就是31，为什么？

  31是一个质数，31这个数是通过大量的计算，统计，认为用31，可以尽量的降低内容不一样，但是哈希值一样的情况

内容不一样，哈希值一样（哈希冲突，哈希碰撞）

3.HashSet的存储去重复的过程

• 先计算元素的哈希值（重新hashCode方法），在比较内容（重写equals方法）
• 先比较哈希值，如果哈希值不一样，存
• 如果哈希值一样，在比较内容（如果哈希值一样，内容不一样，存。如果哈希值一样，内容也一样，去重复）

import java.util.HashSet;

public class Test02 {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("abc");
        set.add("童话");
        set.add("重地");
        set.add("通话");
        set.add("abc");

        System.out.println(set);

    }
}

六、Map集合

概述：是双列集合的顶级接口

元素特点：元素都是由key（键）value（值）组成->键值对

1.HashMap

概述：HashMap是Map的实现类

特点：

• key唯一，value可重复->如果key重复了，会发生value覆盖
• 无序
• 无索引
• 线程不安全
• 可以存null键null值

数据结构：哈希表

方法：

v put(K  key,V  value)->添加元素，返回的是

v remove（object  key）->根据key删除键值对，返回的是被删除的value

v get（object  key）->根据key获取value

boolean  containskey（object  key）->判断集合中是否包含指定的key

Collection<V>  values()->获取集合中所有的value。转存到collection集合中

import java.util.Collection;
import java.util.HashMap;

public class Demo01HashMap {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        String value1 = map.put("猪八", "嫦娥");
        System.out.println(value1);
        String value2 = map.put("猪八", "高翠兰");
        System.out.println(value2);
        System.out.println(map);

        map.put("后裔","嫦娥");
        map.put("二郎神","嫦娥");
        map.put("唐僧","女儿国国王");
        System.out.println(map);

        String value3 = map.remove("唐僧");
        System.out.println(value3);
        System.out.println(map);

        System.out.println(map.get("后裔"));

        System.out.println(map.containsKey("二郎神"));

        Collection<String> values = map.values();
        System.out.println(values);



    }
}

2.LinkedHashMap

概述：LinkedHashMap  extend  HashMap

特点：

• key唯一，value可重复->如果key重复了，会发生value覆盖
• 有序
• 无索引
• 线程不安全
• 可以存null键null值

数据结构：哈希表+双向链表

使用：和hashmap一样

3.HashMap的两种遍历方式

方式一：获取key，根据key在获取value

Set<key> keySet()->将map中的key获取出来转存到Set集合中

import java.util.HashMap;
import java.util.Set;

public class Demo03HashMap {
    public static void main(String[] args) {
       HashMap<String, String> map = new HashMap<>();
        map.put("唐僧","嫦娥");
        map.put("僧","娥");
        map.put("唐","嫦");
        map.put("猪","女儿");
        map.put("猪","金");

        Set<String> set = map.keySet();//获取所有的key，保存到set集合中
        for (String key : set) {
            //根据key获取value
            System.out.println(key+".."+map.get(key));
        }


    }
}

方式2：同时获取key和value

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo04HashMap {
    public static void main(String[] args) {
       HashMap<String, String> map = new HashMap<>();
        map.put("唐僧","嫦娥");
        map.put("僧","娥");
        map.put("唐","嫦");
        map.put("猪","女儿");
        map.put("猪","金");

        /*
        *
        * set集合中保存的都是“结婚证”->map.entry
        * 我们需要将结婚证从set集合中遍历出来
        *
        * */
        Set<Map.Entry<String, String>> set = map.entrySet();
        for (Map.Entry<String, String> entry : set) {

            String key=entry.getKey();
            String value=entry.getValue();
            System.out.println(key+"..."+value);
        }


    }
}

4.Map存储自定义对象时如何去重复

import java.util.Objects;

public class Person {
    private String name;
    private Integer age;

    public Person() {
    }

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

如果key为自定义类型，去重复的话，重写hashCode和equals方法，去重复过程和set一样一样的因为set集合的元素到了底层都是保存到了map的key位置上

5.Map练习

需求：用map集合统计字符串中每一个字符出现的次数

步骤：1.创建Scanner和HashMap

 2.遍历字符串，将每一个字符获取出来

 3.判断，map中是否包含遍历出来的字符->containskey

 4.如果不包含证明字符第一次出现直接将此字符和一存储到map

5.如果包含根据字符获取对应的value让value++

6.将此字符和改变后的value重新保存到map集合中

7.输出

import java.util.HashMap;
import java.util.Scanner;

public class Demo06HashMap {
    public static void main(String[] args) {
//        1.创建Scanner和HashMap
        Scanner sc = new Scanner(System.in);

        HashMap<String, Integer> map = new HashMap<>();
        String data=sc.next();

//        2.遍历字符串，将每一个字符获取出来

        char[] chars=data.toCharArray();
        for (char aChar : chars) {

            String key=aChar+"";
 //  3.判断，map中是否包含遍历出来的字符->containskey
            if (!map.containsKey(key)){
                //        4.如果不包含证明字符第一次出现直接将此字符和一存储到map
                map.put(key,1);
            }else {
//        5.如果包含根据字符获取对应的value让value++
//        6.将此字符和改变后的value重新保存到map集合中
                Integer value = map.get(key);
                value++;
                map.put(key,value);
            }
        }


//        7.输出
        System.out.println(map);


    }
}

七、TreeSet

概述：TreeSet时Set的实现类

特点：

• 对元素进行排序
• 无索引
• 不能存null
• 线程不安全
• 元素唯一

数据结构：红黑树

构造：

TreeSet（）->构造一个新的空set，该set根据其元素的自然顺序进行排序->ASCII

TreeSet(Comparator<? super E>comparator)构造一个新的空TreeSet，它根据只当比较器进行排序

public class Person {
    private String name;
    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

import java.util.Comparator;
import java.util.TreeSet;

public class Demo01TreeSet {
    public static void main(String[] args) {

        TreeSet<String> set1 = new TreeSet<>();
        set1.add("c.大大大大");
        set1.add("a.大大大大");
        set1.add("b.大大大大");
        set1.add("d.大大大大");
        set1.add("e.大大大大");
        System.out.println(set1);

        System.out.println("=============");
        TreeSet<Person> set2 = new TreeSet<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });

        set2.add(new Person("名",18));
        set2.add(new Person("怡",18));
        set2.add(new Person("yi",20));
        System.out.println(set2);


    }
}

1.TreeMap

概述：map的实现类

特点;

 对key进行排序

 无索引

 Key唯一

 线程不安全

 不能存null

数据结构：红黑树

八、Properties集合（属性集）

概述：Properties继承自Hashtable

特点：

 key唯一，value可重复

 无序

 无索引

 线程安全

不能存null键，null值

Properties的key和value类型默认为String

数据结构：哈希表

特有方法：

Object  setProperty（String  key，String  value）->存键值对

String  getProperty(String  key)->根据key获取value的

Set<String>stringPropertyNames()->获取所有的key，保存到set集合中，相当于keyset方法

void  load(InputStream  instream)->将流中的数据加载到properties集合中

import java.util.Properties;
import java.util.Set;

public class Demo01PROperties {
    public static void main(String[] args) {
        Properties properties = new Properties();

        properties.put("username","root");
        properties.put("password","1234");
        System.out.println(properties);

        System.out.println(properties.getProperty("username"));

        Set<String> set=properties.stringPropertyNames();
        for (String key : set) {
            System.out.println(properties.getProperty(key));
        }

    }
}

九、集合嵌套

1.List嵌套list

需求：创建2个list集合，每个集合中分别存储一些字符串，将2个集合存储到3个list集合中

import java.util.ArrayList;

/*

需求：创建2个list集合，每个集合中分别存储一些字符串
，将2个集合存储到3个list集合中
* */
public class Demo01List {
    public static void main(String[] args) {

        ArrayList<String> list1 = new ArrayList<>();
        list1.add("名");
        list1.add("杨");
        list1.add("怡");

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("凯");
        list2.add("熊大");
        list2.add("熊二");


        ArrayList<ArrayList> list = new ArrayList<>();
        list.add(list1);
        list.add(list2);

        /*
        *
        * 先遍历大集合将两个小集合遍历出来
        * 在遍历两个小集合将元素获取出来
        * */


        for (ArrayList<String> arrayList : list) {
            for (String s : arrayList) {
                System.out.println(s);
            }
        }

    }
}

2.List嵌套map

1班级有第三名同学，学号和姓名分别为：1=张三，2=李四，3=王五，2班有三名同学，学号和姓名分别为：1=黄晓明，2=杨颖，3=刘德华，请将同学的信息以键值对的形式存储到2个map集合中，将2个map集合存储到list集合中

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo02ListInMap {
    public static void main(String[] args) {
        HashMap<Integer, String> map1 = new HashMap<>();
        map1.put(1,"张三");
        map1.put(2,"李四");
        map1.put(3,"王五");

        HashMap<Integer, String> map2 = new HashMap<>();
        map2.put(1,"黄晓明");
        map2.put(2,"杨颖");
        map2.put(3,"刘德华");

        //创建一个存储map集合的list集合
        ArrayList<HashMap<Integer,String>> list = new ArrayList<>();
        list.add(map1);
        list.add(map2);

        //先遍历list集合
        for (HashMap<Integer, String> map : list) {
            Set<Map.Entry<Integer, String>> set = map.entrySet();
            for (Map.Entry<Integer, String> entry : set) {
                System.out.println(entry.getKey()+"..."+entry.getValue());

            }
        }

    }
}

3.map嵌套map

JavaSE  集合  存储的是学号 键值学生姓名

1  张三

2  李四

JAVAEE 集合  存储的是学号 键，值 学生姓名

1 王五

2 赵六

public class Demo03MapInMap {
    public static void main(String[] args) {
        HashMap<Integer, String> map1 = new HashMap<>();
        map1.put(1,"张三");
        map1.put(2,"李四");


        HashMap<Integer, String> map2 = new HashMap<>();
        map2.put(1,"王五");
        map2.put(2,"赵六");

        HashMap<String, HashMap<Integer, String>> map = new HashMap<>();
        map.put("javaSE",map1);
        map.put("javaEE",map2);


        Set<Map.Entry<String, HashMap<Integer, String>>> set = map.entrySet();
        for (Map.Entry<String, HashMap<Integer, String>> entry : set) {
            HashMap<Integer, String> hashMap = entry.getValue();
            Set<Integer> set1 = hashMap.keySet();
            for (Integer key : set1) {
                System.out.println(key+"...."+hashMap.get(key));
            }
        }


    }
}