Java集合知识大全

1.集合的由来

目前我们所学的两种容器可以用来存储数据

1.数组：可以存对象，但是长度固定，且只能存单一对象

2.StringBuffer（StringBuilder）：只能存字符串

显然这两种容器不能满足我们的需求，所以Java提供了另一种容器：集合。

2.集合和数组的区别

1.长度的区别：

数组的长度是固定的，集合的长度是不固定的

2.存储的区别：

数组存储同一类型数据

集合可以存储不同类型的数据

package org.wdit.unit10.集合;

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

/*
* Collection类：是集合体系结构中的根节点
* 成员方法：
*   添加功能
*     1.boolean add（E，e）添加元素
*     2.boolean addAll（collection c）添加集合元素
*   删除功能
*       1.boolean remove（E,e）
*       2.boolean removeAll(collection c)
*       3.void clear()
*  判断功能
*      1.boolean contains（E，e）
*      2.boolean containsAll(collection c)
*      3.boolean isEmpty（）
*  长度
*      1.int size():获取集合中的元素个数
* 求交集
*      1.boolean retainAll（collection c）
* Object[]toArray()
*
* */
public class CollectionDemo {
    public static void main(String[] args) {
        //创建集合对象
        Collection s= new ArrayList();
        //添加元素
        s.add("hello");
        s.add("java");
        System.out.println("s"+s);

        //添加集合元素
        /*s.addAll(s);
        s.add("world");
        System.out.println(s);*/

        Collection s2=new ArrayList();
        s2.add("java");
        System.out.println("s2"+s2);
        /*s.remove("hello");//删除指定元素
        s.removeAll(s2);//删除集合里面相同的元素
       boolean flag= s.remove("hx");
        System.out.println(flag);
        s.clear();
        System.out.println(s);*/
       s.retainAll(s2);
        System.out.println("s.retain(s2)交集:"+s);
  Object[]objects=s.toArray();
  for(Object o:objects){
      String s3=(String)o;
      System.out.println(s3);
  }
    }
}

3.Collection

package org.wdit.unit10.集合.Collection;

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

/*
* Collection类：是集合体系结构中的根节点
* 成员方法：
*   添加功能
*     1.boolean add（E，e）添加元素
*     2.boolean addAll（collection c）添加集合元素
*   删除功能
*       1.boolean remove（E,e）
*       2.boolean removeAll(collection c)
*       3.void clear()
*  判断功能
*      1.boolean contains（E，e）
*      2.boolean containsAll(collection c)
*      3.boolean isEmpty（）
*  长度
*      1.int size():获取集合中的元素个数
* 求交集
*      1.boolean retainAll（collection c）
* Object[]toArray()
*
* */
public class CollectionDemo {
    public static void main(String[] args) {
        //创建集合对象
        Collection s= new ArrayList();
        //添加元素
        s.add("hello");
        s.add("java");
        System.out.println("s"+s);

        //添加集合元素
        /*s.addAll(s);
        s.add("world");
        System.out.println(s);*/

        Collection s2=new ArrayList();
        s2.add("java");
        System.out.println("s2"+s2);
        /*s.remove("hello");//删除指定元素
        s.removeAll(s2);//删除集合里面相同的元素
       boolean flag= s.remove("hx");
        System.out.println(flag);
        s.clear();
        System.out.println(s);*/
       s.retainAll(s2);
        System.out.println("s.retain(s2)交集:"+s);
  Object[]objects=s.toArray();
  for(Object o:objects){
      String s3=(String)o;
      System.out.println(s3);
  }
        }

4.迭代器

• 并发异常

处理方法

使用for循环，不用迭代器

使用迭代器的add

package org.wdit.unit10.集合.迭代器;

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

public class IteratorDemo {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("hello");
        list.add("world");
        list.add("hx");
        /*Iterator iterator=list.iterator();*/
       /* while(iterator.hasNext()){

            String s=(String)iterator.next();
            System.out.println(s);
        }*/
        for(Iterator iterator=list.iterator();iterator.hasNext();){

            String s=(String)iterator.next();
            System.out.println(s);
        }
    }

}


package org.wdit.unit10.集合.迭代器;


import org.wdit.unit10.Object.Student;

import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
/*迭代器练习：使用两种方式遍历学生集合*/
public class ItetatorTest {
    public static void main(String[] args) {
        Student student=new Student("hx",12);
        Student student1=new Student("hxq",12);
        Student student2=new Student("hxy",12);
        List list = new ArrayList();
        list.add(student);
        list.add(student1);
        list.add(student2);


        /*//1.for遍历
        for(Object o:list){
            Student s=(Student)o;
            System.out.println(s.getName()+"-----"+s.getAge());
        }*/

        //2.迭代
       /* Iterator iterator=list.iterator();
        while(iterator.hasNext()){
            Student s=(Student)iterator.next();
            System.out.println(s.getName()+"-----"+s.getAge());
        }*/


    }



}

boolean	**[hasNext](../../java/util/Iterator.html#hasNext())**() 如果仍有元素可以迭代，则返回 true。
E	**[next](../../java/util/Iterator.html#next())**() 返回迭代的下一个元素。
void	**[remove](../../java/util/Iterator.html#remove())**() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

5.栈和队列

数据结构：数据的组织方法

栈：先进后出（子弹弹夹）

队列：先进先出

6.数组和链表

1.数组：

概述：并且它是有索引的

数组的特点：查询快，增删慢

2.链表：

概述：链子把多个数据连接起来的数据结构

节点：由数据和地址组成，数据专业叫法数据域，地址的专业叫法指针域

链表的特点：查询慢，增删快

7.List

package org.wdit.unit10.集合.List;

import java.util.ArrayList;
import java.util.List;

/*List接口：是一个元素有序，可以重复的集合
*   List特有方法
*      1.添加功能
*      add(int dex,E element):添加元素到指定索引位置,原索引位置向后移动
*      addAll（int dex , Collection c）:在指定位置添加集合
*      2.获取功能
*      Object get(int index)返回列表中指定位置的元素。
*      3.修改功能
*    E  set(int index,E element)用指定元素替换列表中指定位置的元素。//将被替代的元素返回
*      4.截取功能
*   List subList(int fromIndex,int toIndex）返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
*     将截取的元素作为新的集合返回，原来的不变，顾头不顾尾
*     5.删除功能
*   E remove(int index)移除列表中指定位置的元素（可选操作）。
*   返回删除的元素，原集合也删掉
* */
public class ListDemo {
    public static void main(String[] args) {
      List list=new ArrayList();
      list.add("hello");
      list.add("world");
      list.add("java");
      //1
      /*list.add(1,"hx");
        System.out.println(list);*/


        //addAll（int dex , Collection c）:在指定位置添加集合
        List list2=new ArrayList();
        list2.add("你好");
        list2.add("世界");
        list2.add("java");
        list.addAll(1,list2);
        System.out.println("addAll"+list);

        /*//2获取
         Object o=list.get(2);
         String s=(String)o;
        System.out.println(s);*/

       /* //3设置
         Object obj=list.set(1,"hx");
        System.out.println(obj);
        System.out.println(list);*/

        /*//4截取
        List list2=list.subList(1,2);
        System.out.println("原List："+list);
        System.out.println("新List："+list2);*/
        //5删除
     /*  Object remove = list.remove(1);
        System.out.println("原List："+list);
        System.out.println("新List："+remove);*/
    }
}

8.ArrayList

ackage org.wdit.unit10.集合.List;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/*
* ArrayList
*   特有方法：public int indexOf(Object o)返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
*public int lastIndexOf(Object o)返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
* public Object[] toArray()按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
*
* 集合到数组：toArray
* 数组到集合：Array类中的asList（）
*
* */
public class ArrayListDemo {
    public static void main(String[] args) {
       //创建集合对象
       ArrayList list=new ArrayList();
        list.add("hello");
        list.add("java");
        list.add("java");
        list.add("world");
        list.add("java");
       /*int index= list.indexOf("java");
        System.out.println("indexOf: "+index);*/
        /*int lastindex= list.lastIndexOf("java");
        System.out.println("lastindexOf: "+lastindex);*/

       /* Object []o = list.toArray();*/
       /* for(int i=0;i<o.length;i++){
            System.out.println(o[i]);
        }
*/

       /* for(Object o1:o) {
            System.out.println(o1);

        }*/

        /*for(Iterator s= list.iterator();s.hasNext();){
          String s1=(String)  s.next();
            System.out.println(s1);
        }
*/
    /* List s=   Arrays.asList(o);
        System.out.println(s);*/


   /*字符串去重复元素
   方案1：声明一个新的集合
       2.遍历旧集合获取每一个元素
       3.拿每一个旧集合中元素去新集合中查找
            a.存在：不添加
            b.不存在：添加
        4.遍历新集合
        //方案2
        选择去重
   * */
       /* System.out.println("旧集合："+list);
        List a=new ArrayList();
        for(Iterator s= list.iterator();s.hasNext();){
            String s1=(String)  s.next();
           if(!a.contains(s1)){
               a.add(s1);
           }
        }
        System.out.println("新集合:"+a);*/

        //用选择排序的思想
        for(int i=0;i<list.size()-1;i++)
        {
            for(int j=1+i;j<list.size();j++) {
                String ss1=(String)list.get(i);
                String ss2=(String)list.get(j);
                if(ss1.equals(ss2)){
                    list.remove(j);
                    j--;
                }
            }
        }
        System.out.println(list);

    }
}

package org.wdit.unit10.集合.List;

import org.wdit.unit10.Object.Student;

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

/*练习自定义对象去重*/
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList list =new ArrayList();
        list.add(new Student("wang",90));
        list.add(new Student("wg",90));
        list.add(new Student("w",67));
        list.add(new Student("wa",900));
        list.add(new Student("yhg",7));
        list.add(new Student("yhj",7));
        list.add(new Student("yhj",7));
        List a=new ArrayList();
        for(Iterator s=list.iterator();s.hasNext();){
            Student a1=(Student)s.next();
            if(!a.contains(a1)){
                a.add(a1);
            }
        }
        for(Iterator s1=a.iterator();s1.hasNext();){
            Student a1=(Student)s1.next();
            System.out.println(a1);
        }
    }
}

9.泛型E

概述：

是一种把明确数据类型的工作推迟到创建对象或调用方法的时候才去明确的一种特殊的数据类型

格式：

<数据类型>

注意：

数据类型必须是引用数据类型

优点：

把运行时可能出现的异常提前到编译时，提高了程序的健壮性

由来：

JDK早期版本使用Object类代替任意数据类型，但是在向下转型时，可能会出现运行时异常，为了解决这个问题，JDK提出了泛型这个技术

1.泛型类：

把泛型定义在类上

格式：

权限修饰符 class 类名 <泛型类型，........>

2.泛型方法：

把泛型定义在方法上

格式：

public <泛型类型> 返回类型 方法名（泛型类型.）

3.泛型接口：

把泛型定义在接口上

格式：

public interface 接口名<泛型类型，........>

4.接口泛型

1.实现类时不给定数据类型

2.实现类时给定数据类型

5.泛型通配符

package org.wdit.unit10.generic泛型;



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

/**
 *  泛型通配符
 *  泛型通配符<?>
 *          任意类型，如果没有明确，那么就是Object以及任意的Java类了
 *      <? extends E>
 *          向下限定，E及其子类
 *      <? super E>
 *           向上限定，E及其父类
 */
public class GenericDemo {
    public static void main(String[] args) {
//        Collection<Animal> collection = new ArrayList<Animal>();
//        Collection<Animal> collection2 = new ArrayList<Object>();
//        Collection<Animal> collection3 = new ArrayList<Cat>();
//        Collection<Animal> collection4 = new ArrayList<Dog>();

/*        Collection<?> collection = new ArrayList<Animal>();
        Collection<?> collection2 = new ArrayList<Object>();
        Collection<?> collection3 = new ArrayList<Cat>();
        Collection<?> collection4 = new ArrayList<Dog>();*/

 /*       Collection<? extends Animal> collection = new ArrayList<Animal>();
        Collection<? extends Animal> collection2 = new ArrayList<Object>();
        Collection<? extends Animal> collection3 = new ArrayList<Cat>();
        Collection<? extends Animal> collection4 = new ArrayList<Dog>();*/

     /*   Collection<? super Animal> collection = new ArrayList<Animal>();
        Collection<? super Animal> collection2 = new ArrayList<Object>();
        Collection<? super Animal> collection3 = new ArrayList<Cat>();
        Collection<? super Animal> collection4 = new ArrayList<Dog>();*/

    }

}

10.静态导入的概述和用法

概述：可以直接导入方法的级别

格式：import static 包名.类名.方法名

注意：

1.方法必须是静态的

2.如果有多个同名的静态方法，容易不知道使用谁，这时要使用的话，就必须加前缀。这种用法意义不大，也不常见。

11.可变参数概述及使用

概述：

定义方法的时候不知道该定义多少个参数

格式：

修饰符 返回值类型 方法名（数据类型...变量名）{}

public static int sum (int...a){
    sum=0;
    for(int temp:a){
        sum+=temp;
    }
    return sum;
}

注意：

• 这里的变量是一个数组

• 如果一个方法有可变参数，并且有多个参数，那么可变参数一定是最后一个。

Arrays工具类中的一个方法

• public static <T>List<T>asList<T...a>:将数组转换为集合

• toArray（）：将集合转换为数组

注意：我们通过测试可以发现，我增删不行，但修改可以，是因为数组转集合，实际上它还是一个数组，而我们的数组长度又不可变，所以只能修改不能增删。

12.Set接口概述

• Set接口概述：

  一个不包含重复元素的collection

无序（存储和取出顺序不一致）

• Set案例

  存储字符串并遍历

  存储自定义对象并遍历

13.HashSet类

概述：

1.实现Set接口的类，不保证set的迭代顺序

2.特别是它不保证该顺序恒久不变

HashSet如何保证元素唯一

1.底层数据结构是哈希表（元素是链表的数组）

2.哈希表依赖哈希值存储

3.添加功能依赖两个方法

int hashCode（）

boolean equals（Object obj）

14.LinkedHashSet类

概述

• 底层数据结构是哈希表和链表

• 元素有序唯一

• 链表保证有序，哈希表保证唯一

15.TreeSet类

TreeSet:能够对元素按照某种规则进行排序

• 1.自然排序---无参构造

  a让元素对应的类实现Comparable接口并重写compareTo（）方法

  b给元素指定排序规则

• 2.比较器排序-----有参构造Comparator接口

  创建set集合对象时调用有参构造，用匿名对象实现Comparator接口，重写compare（）

  给集合指定排序规则

• 3.TreeSet存储特点：唯一 和 排序

• 4.TreeSet排序过程是依赖于CompareTo方法定义在Comparable接口上，所以要实现自然排序，该类必须实现Comparable接口

• package org.wdit.unit10.集合.Collection.Set接口;
  
  import org.wdit.unit10.Object.Student;
  
  import java.util.Iterator;
  import java.util.TreeSet;
  
  /*
  * TreeSet:能够对元素按照某种规则进行排序
  *    1.自然排序---无参构造
  *    2.比较器排序-----有参构造Comparator接口
  *
  *    TreeSet存储特点：唯一  和  排序
  *
  *    通过add源码
  *     TreeSet排序过程是依赖于CompareTo方法定义在Comparable接口上，所以要实现自然排序，该类必须实现Comparable接口
  * */
  public class TreeSetDemo {
      public static void main(String[] args) {
  
          /*TreeSet<Integer>treeSet=new TreeSet<>();
          treeSet.add(10);
          treeSet.add(4);
          treeSet.add(19);
          treeSet.add(12);
          treeSet.add(66);
          treeSet.add(19);
          for(int num:treeSet){
              System.out.println(num);
          }*/
          //存储自定义对象
          TreeSet<Student>treeSet=new TreeSet<>();
          treeSet.add(new Student("www",14));
          treeSet.add(new Student("ww1",16));
          treeSet.add(new Student("www2",18));
          treeSet.add(new Student("ww3",20));
          treeSet.add(new Student("www3",20));
          Iterator <Student> iterator=treeSet.iterator();
          while(iterator.hasNext()){
              Student student = iterator.next();
              System.out.println(student);
          }
      }
  }
  
  
  
  
  
  package org.wdit.unit10.集合.Collection.Set接口;
  
  import org.wdit.unit10.Object.Student;
  
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.TreeSet;
  
  /*比较器排序*/
  public class TreeSetDemo2 {
      public static void main(String[] args) {
          TreeSet<Student>treeSet=new TreeSet<Student>(new Comparator<Student>(){
              public int compare(Student s1,Student s2){
                  int num= s1.getName().length()-s2.getName().length();
                  //名字长度相同，比较内容是否相同
                  int num2=num==0? s1.getName().compareTo(s2.getName()):num;
                  //名字长度相同，内容相同,比较年龄是否相同
                  int num3=num2==0? (s1.getAge()-s2.getAge()):num2;
                  return num3;
  
               
              }
          });
          treeSet.add(new Student("www",14));
          treeSet.add(new Student("ww1",16));
          treeSet.add(new Student("www2",18));
          treeSet.add(new Student("ww3",20));
          treeSet.add(new Student("www3",20));
          Iterator<Student> iterator=treeSet.iterator();
          while(iterator.hasNext()){
              Student student = iterator.next();
              System.out.println(student);
          }
      }
  }

  package org.wdit.unit10.集合.Collection.Set接口;
  
  
  
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.TreeSet;
  
  /*姓名，语文，数学，英语
  * 录入信息，按成绩降序输出*/
  public class TreeSetTest {
      public static void main(String[] args) {
      //创建集合set
          TreeSet<Student>treeSet=new TreeSet<>(new Comparator<Student>(){
              @Override
              public int compare(Student s1, Student s2) {
                  int num = s1.getSum() - s2.getSum();
                  int num2 = num == 0 ? (s1.getChinese() - s2.getChinese()) : num;
                  int num3 = num2 == 0 ? (s1.getMath() - s2.getMath()) : num2;
                  int num4 = num3 == 0 ? (s1.getName().length() - s2.getName().length()) : num3;
                  int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName()) : num4;
                  return num5;
              }
  
          });
         treeSet.add(new Student("hx",23,56,89));
         treeSet.add(new Student("hx1",67,56,99));
         treeSet.add(new Student("hx2",13,56,3));
         treeSet.add(new Student("hx3",43,76,19));
          Iterator<Student> iterator = treeSet.iterator();
          while(iterator.hasNext()){
              Student student = iterator.next();
              System.out.println(student);
          }
  
  
  
      }
  }

  16.Map<K,V>接口

  根据键找值

  根据键值对对象找键和值

• map<k,v>接口（集合）
     通过ApI我们学习到Map集合最大的特点：它是用来存储键值对元素的
        学号1           学生1
        学号2           学生2
        学号2（×）     学生3
        学号3（√）     学生2
        特点：将建映射到值的对象，一个映射不能包含重复的键，并且每一个键只能映射到一个值

        Map集合和Collection集合的区别（Collections是集合的工具类）
        1.Map集合存储的元素是成对出现的
        2.Collection集合存储的元素是单个出现的，并且Set是唯一的，List是可重复的
  *
       注意事项：
           Map集合的数据结构是针对键有效，跟值无关

        主要方法
          1.添加功能
          V put(K key,V value)将指定的值与此映射中的指定键关联（可选操作）。如果此映射以前包含一个该键的映射关系，则用指定值替换旧值
          2.删除功能
              void clear（）删除所有映射
              V remove(Object key)如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
          3.获取功能
           Set<Map.Entry<K,V>> entrySet()返回此映射中包含的映射关系的 Set 视图
         V get(Object key)返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
          Set<K> keySet()返回此映射中包含的键的 Set 视图。
          Collection<V> values()返回此映射中包含的值的 Collection 视图
          4.判断功能
              boolean equals(Object o)比较指定的对象与此映射是否相等
              boolean containsKey（Object key）如果此映射包含指定键的映射关系，则返回 true。
               boolean containsValue(Object value)如果此映射将一个或多个键映射到指定值，则返回 true
              boolean isEmpty()如果此映射未包含键-值映射关系，则返回 true。
          5.长度功能
            int size()返回此映射中的键-值映射关系数。如果该映射包含的元素大于 Integer.MAX_VALUE，则返回 Integer.MAX_VALUE。

public class mapDemo {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<String,String>map=new HashMap<>();
        //添加元素
        map.put("阿里巴巴","马云");
        map.put("腾讯","马化腾");
        map.put("网易","丁磊");
        map.put("字节跳动","张一鸣");
        map.put("字节跳动","赵童");
        map.put("微软","赵童");

       /* map.clear();//删除所有映射关系
        System.out.println(map);*/

      /* String s1= map.remove("阿里巴巴");
        System.out.println("remove:"+s1);*/

        /*String s1=map.get("字节跳动");
        System.out.println("get:"+s1);*/

        /*Set<String>keyset = map.keySet();
        for(String key:keyset){
            System.out.println(key+"----"+map.get(key));
        }
*/
        /*Collection<String> values = map.values();
        for(String s1:values){
            System.out.println(s1);
        }*/

      /*  System.out.println("containsKey:"+map.containsKey("阿里巴巴"));
        System.out.println("containsKey:" + map.containsKey("为"));*/

        /*System.out.println("containsValue:"+map.containsValue("马化腾"));
        System.out.println("containsValue:"+map.containsValue("比尔"));
        System.out.println("containsValue:"+map.containsValue("赵童"));
*/


        System.out.println( "isEmpty:"+map.isEmpty());

        System.out.println( "size:"+map.size());

        //遍历输出
        System.out.println(map);
    }
}

package org.wdit.unit10.集合.Map;

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

/*3.获取功能
         Set<Map.Entry<K,V>> entrySet()返回此映射中包含的映射关系的 Set 视图*/
public class MapDemo2 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();
        //添加元素
        map.put("阿里巴巴","马云");
        map.put("腾讯","马化腾");
        map.put("网易","丁磊");
        map.put("字节跳动","张一鸣");
        map.put("字节跳动","赵童");
        map.put("微软","赵童");
        Set<Map.Entry<String,String>> entrySet=map.entrySet();

        for(Map.Entry<String,String>entry:entrySet){
            System.out.println(entry);
        }
    }
}

package org.wdit.unit10.集合.Map;

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

/*3.获取功能
         Set<Map.Entry<K,V>> entrySet()返回此映射中包含的映射关系的 Set 视图*/
public class MapDemo2 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();
        //添加元素
        map.put("阿里巴巴","马云");
        map.put("腾讯","马化腾");
        map.put("网易","丁磊");
        map.put("字节跳动","张一鸣");
        map.put("字节跳动","赵童");
        map.put("微软","赵童");
        Set<Map.Entry<String,String>> entrySet=map.entrySet();
//两种方法遍历
        /*for(Map.Entry<String,String>entry:entrySet){
            System.out.println(entry);
        }*/

        Set<String> keySet = map.keySet();
        for(String key:keySet){
            System.out.println(key+"----"+map.get(key));
        }
    }
}

package org.wdit.unit10.集合.Map;

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

/*
判断
boolean equals(Object o)比较指定的对象与此映射是否相等
*/
public class MapDemo3 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();
        //添加元素
        map.put("阿里巴巴","马云");
        map.put("腾讯","马化腾");
        map.put("网易","丁磊");
        map.put("字节跳动","张一鸣");
        System.out.println(map);
        Map<String,String> map2=new HashMap<>();
        map2.putAll(map);
        System.out.println("----------");
        System.out.println(map2);
        System.out.println("equals:"+map.equals("马化腾"));
        System.out.println("equals:"+map.equals("腾讯"));
        System.out.println("equals:"+map.equals(map2));

    }
}

HashMap<K,V>

HashMap的键的数据结构是哈希表，可以保证键的唯一性

package org.wdit.unit10.集合.Map;
/*HashMap<Integer,String>*/
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashMapDemo {
    public static void main(String[] args) {
        HashMap<Integer,String>map=new HashMap<>();
        map.put(1,"马云");
        map.put(2,"马小云");
        map.put(3,"马哎云");
        map.put(null,"云");
        map.put(4,"null");


        map.put(001,"wang");
        map.put(002,"wang1");
        map.put(003,"wang2");
        map.put(004,"wang3");
        map.put(005,"wang4");
        map.put(006,"wang5");
        map.put(007,"wang6");
        //map.put(008,"wang6");

        System.out.println(map);
        //遍历
        //1.keySet
        Set<Integer> key = map.keySet();
        for(int keys:key){
            System.out.println(keys+"---"+map.get(keys));
        }

        //2.entryset
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for(Map.Entry<Integer,String> entry:entries){
            System.out.println(entry.getKey()+"---"+entry.getValue());
        }
    }
}

package org.wdit.unit10.集合.Map;

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

/*练习；
   wz1  王者1班
          刘德华 20
          张惠妹 22
  wz2  王者2班
          周杰伦 18
          林俊杰17
          蔡依林 16
   wz3  王者3班
          王乾宇 20
          夏天 19
  wz4  王者4班
          周坤 20
          赵童 22
          存储并遍历
*
* */
public class HashMapTest {
    public static void main(String[] args) {

        HashMap<String, Map<String,Integer>>map5=new HashMap<>();
        HashMap<String,Integer>map1=new HashMap<>();
        HashMap<String,Integer>map2=new HashMap<>();
        HashMap<String,Integer>map3=new HashMap<>();
        HashMap<String,Integer>map4=new HashMap<>();
        map5.put("wz1",map1);
        map5.put("wz2",map2);
        map5.put("wz3",map3);
        map5.put("wz4",map4);
        map1.put("刘德华",20);
        map1.put("张惠妹",22);
        map2.put("周杰伦",18);
        map2.put("林俊杰",17);
        map2.put("蔡依林",16);
        map3.put("王乾宇",20);
        map3.put("夏天",19);
        map4.put("周坤",20);
        map4.put("赵童",22);
        Set<Map.Entry<String, Map<String,Integer>>> entrySet = map5.entrySet();
        for(Map.Entry<String, Map<String,Integer>>entry:entrySet){
            System.out.println(entry.getKey());
            Map<String,Integer>value=entry.getValue();
            Set<Map.Entry<String,Integer>> valuesSet= entry.getValue().entrySet();
         for(Map.Entry<String,Integer>valueSet:valuesSet) {
             System.out.println(valueSet.getKey()+"---"+valueSet.getValue());
         }

        }

LinkedHashMap

有序唯一

package org.wdit.unit10.集合.Map;

import java.util.LinkedHashMap;

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String,String>map=new LinkedHashMap<>();
        
        map.put("12345","shang");
        map.put("22345","shan");
        map.put("32345","da");
        map.put("1","hihi");
        System.out.println(map);
    }
}

TreeMap

package org.wdit.unit10.集合.Map;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;

/*练习
*  TreeMap<Student1,String>
    使用两种排序方式对map中元素进行排序*/
public class TreeMapTest {
    public static void main(String[] args) {
       // TreeMap<Student1,String>map=new TreeMap<>();
        TreeMap<Student1,String>map=new TreeMap<>(new Comparator<Student1>() {
            @Override
            public int compare(Student1 o1, Student1 o2) {
                int num= o2.getName().length()-o1.getName().length();
                //名字长度相同，比较内容是否相同
                int num2=num==0? o2.getName().compareTo(o1.getName()):num;
                //名字长度相同，内容相同,比较年龄是否相同
                int num3=num2==0? (o2.getAge()-o1.getAge()):num2;
                return num3;
            }
        });
        map.put(new Student1("hx",12),"apple");
        map.put(new Student1("hx1",13),"apple1");
        map.put(new Student1("hx2",11),"apple2");
        map.put(new Student1("hx3",8),"apple3");

        Set<Student1> keySet = map.keySet();
        for(Student1 key:keySet){
            System.out.println(key+"-----"+map.get(key));
        }
    }
}




package org.wdit.unit10.集合.Map;
import  java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
import java.util.jar.JarOutputStream;


/*键盘录入字符串，获取每个字符出现的个数a---10；b----2

* 1.Scanner
* 2.用户输入
* 3.将数据转换为字符数组
* 4.创建TreeMap对象
* 5.遍历字符数组,得到每个字符
* 6.判断map中有该字符Containskey(), value= get(key)
*   false(null)：表示不存在，那该字符作为键，value=1，存入map
    true(!null)：存在，该字符作为键，value+1，重新存入map
   7.打印结果
     创建StringBudffer/StringBuilder对象
     遍历map按格式输出
     打印

* */
public class TreeMapTest2 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请用户输入字符：");
       String s=sc.nextLine();
        char[] s1 = s.toCharArray();
        TreeMap<Character,Integer>map=new TreeMap<>();
        for(char s11:s1){
            char key=s11;
            if(map.get(key)==null){
                map.put(key,1);

            }else{
                int value=map.get(key)+1;
                map.put(key,value);
            }


        }
        StringBuilder s2=new StringBuilder();
        Set<Character> set = map.keySet();
        for(Character a1:set){
            s2.append(a1).append("-----").append(map.get(a1)).append("       ");
        }
        System.out.println(s2.toString());

    }
}