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
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类了*      *          向下限定,E及其子类*      *           向上限定,E及其父类*/
public class GenericDemo {public static void main(String[] args) {
//        Collection collection = new ArrayList();
//        Collection collection2 = new ArrayList();
//        Collection collection3 = new ArrayList();
//        Collection collection4 = new ArrayList();/*        Collection collection = new ArrayList();Collection collection2 = new ArrayList();Collection collection3 = new ArrayList();Collection collection4 = new ArrayList();*//*       Collection collection = new ArrayList();Collection collection2 = new ArrayList();Collection collection3 = new ArrayList();Collection collection4 = new ArrayList();*//*   Collection collection = new ArrayList();Collection collection2 = new ArrayList();Collection collection3 = new ArrayList();Collection collection4 = new ArrayList();*/}} 

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 ListasList:将数组转换为集合

  • 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) {/*TreeSettreeSet=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);}*///存储自定义对象TreeSettreeSet=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  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) {TreeSettreeSet=new TreeSet(new Comparator(){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 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) {//创建集合setTreeSettreeSet=new TreeSet<>(new Comparator(){@Overridepublic 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 iterator = treeSet.iterator();while(iterator.hasNext()){Student student = iterator.next();System.out.println(student);}}
    }

    16.Map接口

    根据键找值

    根据键值对对象找键和值

  • map接口(集合)
       通过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> entrySet()返回此映射中包含的映射关系的 Set 视图
           V get(Object key)返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null。
            Set keySet()返回此映射中包含的键的 Set 视图。
            Collection 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集合对象Mapmap=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);*//*Setkeyset = map.keySet();for(String key:keyset){System.out.println(key+"----"+map.get(key));}
*//*Collection 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> entrySet()返回此映射中包含的映射关系的 Set 视图*/
public class MapDemo2 {public static void main(String[] args) {Map map=new HashMap<>();//添加元素map.put("阿里巴巴","马云");map.put("腾讯","马化腾");map.put("网易","丁磊");map.put("字节跳动","张一鸣");map.put("字节跳动","赵童");map.put("微软","赵童");Set> entrySet=map.entrySet();for(Map.Entryentry:entrySet){System.out.println(entry);}}
}
package org.wdit.unit10.集合.Map;import java.util.HashMap;
import java.util.Map;
import java.util.Set;/*3.获取功能Set> entrySet()返回此映射中包含的映射关系的 Set 视图*/
public class MapDemo2 {public static void main(String[] args) {Map map=new HashMap<>();//添加元素map.put("阿里巴巴","马云");map.put("腾讯","马化腾");map.put("网易","丁磊");map.put("字节跳动","张一鸣");map.put("字节跳动","赵童");map.put("微软","赵童");Set> entrySet=map.entrySet();
//两种方法遍历/*for(Map.Entryentry:entrySet){System.out.println(entry);}*/Set 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 map=new HashMap<>();//添加元素map.put("阿里巴巴","马云");map.put("腾讯","马化腾");map.put("网易","丁磊");map.put("字节跳动","张一鸣");System.out.println(map);Map 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

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

package org.wdit.unit10.集合.Map;
/*HashMap*/
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class HashMapDemo {public static void main(String[] args) {HashMapmap=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.keySetSet key = map.keySet();for(int keys:key){System.out.println(keys+"---"+map.get(keys));}//2.entrysetSet> entries = map.entrySet();for(Map.Entry 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张惠妹 22wz2  王者2班周杰伦 18林俊杰17蔡依林 16wz3  王者3班王乾宇 20夏天 19wz4  王者4班周坤 20赵童 22存储并遍历
*
* */
public class HashMapTest {public static void main(String[] args) {HashMap>map5=new HashMap<>();HashMapmap1=new HashMap<>();HashMapmap2=new HashMap<>();HashMapmap3=new HashMap<>();HashMapmap4=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>> entrySet = map5.entrySet();for(Map.Entry>entry:entrySet){System.out.println(entry.getKey());Mapvalue=entry.getValue();Set> valuesSet= entry.getValue().entrySet();for(Map.EntryvalueSet: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) {LinkedHashMapmap=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使用两种排序方式对map中元素进行排序*/
public class TreeMapTest {public static void main(String[] args) {// TreeMapmap=new TreeMap<>();TreeMapmap=new TreeMap<>(new Comparator() {@Overridepublic 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 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,存入maptrue(!null):存在,该字符作为键,value+1,重新存入map7.打印结果创建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();TreeMapmap=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 set = map.keySet();for(Character a1:set){s2.append(a1).append("-----").append(map.get(a1)).append("       ");}System.out.println(s2.toString());}
}


本文来自互联网用户投稿,文章观点仅代表作者本人,不代表本站立场,不承担相关法律责任。如若转载,请注明出处。 如若内容造成侵权/违法违规/事实不符,请点击【内容举报】进行投诉反馈!

相关文章