精华内容
下载资源
问答
  • var map = {}; //采用递归调用方法,比较方便和简单。 function fds(node){ if(node.nodeType === 1){ var tagName = node.nodeName; map[tagName] = map[tagName]? map[tagName] + 1: 1; } var children ...
    var map = {};
    //采用递归调用的方法,比较方便和简单。
    function fds(node){
      if(node.nodeType === 1){
      	var tagName = node.nodeName;
      	map[tagName] = map[tagName]? map[tagName] + 1: 1;  
      }
      var children = node.childNodes;
      for(var i = 0;i<children.length;i++){
         fds(children[i])
      }
    }
    fds(document.body);


    展开全文
  • 但数组存在一些弊端:①数组初始化之后,长度不可以进行改变,不便于扩展②数组中提供的方法和属性少,不便于进行添加、删除、插入等操作,且效率不高,同时无法直接获取存储元素的个数③数组存储的数据是有序的可以...

    0、Java集合框架概述

    集合可以将多个对象的引用动态放入容器中,方便对对象进行一些操作。现有的用来存放多个对象的结构为Array数组,但数组存在一些弊端:

    ①数组初始化之后,长度不可以进行改变,不便于扩展

    ②数组中提供的方法和属性少,不便于进行添加、删除、插入等操作,且效率不高,同时无法直接获取存储元素的个数

    ③数组存储的数据是有序的可以重复的

    而java集合类可以用于存储数量不等的多个对象,还可用于保存具有映射关系的关联数组

    Java集合体系

    Collection接口:单列数据,定义了存取一组对象的方法的集合

    -------------|List接口:元素有序、可重复的集合 类似一个“动态”数组

    ------------------------|ArryaList类:是List接口的主要实现类;线程不安全,效率高;底层使用Object[ ]数组

    ------------------------|LinkedList类:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表

    ------------------------|Vector类:作为List接口的古老实现类;线程安全,效率低;底层使用Object[ ]数组

    -------------|Set接口:元素无序、不可重复的集合 更接近于高中所讲的“集合”概念

    ------------------------|HashSet类:作为Set接口的主要实现类;线程不安全的;可以存储null值

    ------------------------------------|LinkedHashSet类:作为HashSet的子类,遍历器内部数据时,可以按照添加时的顺序遍历

    ------------------------|TreeSet类:可以按照添加对象的指定属性进行排序

    Map接口:双列数据,保存具有映射关系“key-value”对的集合 类似于数学上的y=f(x)

    -------------|Hashtable类:作为古老的实现类,线程安全,效率低,不能存储null的key和value

    ------------------------|Properties类:常用来处理文件,key和value都是String类型的

    -------------|HashMap类:是Map的主要实现类,线程不安全的,效率高;可以存储null的key和value

    ------------------------|LinkedHashMap类:保证在遍历map元素时,可以按照添加的顺序进行遍历(在原有结构的基础上,按照添加顺序使用了双链表)

    -------------|TreeMap类:按照添加的key-value对进行排序,实现排序遍历(key的自然排序和定制排序)

    439e5312f7e4

    Collection接口继承树

    439e5312f7e4

    Map接口继承树

    1.Collection接口

    1.1 Collection接口中的常用方法

    使用Iterator接口遍历集合元素

    Collections接口继承了java.lang.Iterable接口,该接口有一个iterator()方法,所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象。集合对象每次调用iterator()方法都得到一个全新的迭代器对象,默认游标都在集合的第一个元素之前

    @Test

    public void test1(){

    Collection col=new ArrayList();

    col.add("aaaa");

    col.add("bbbb");

    col.add("vv");

    col.add("wweeeee");

    Iterator iterator = col.iterator();

    while(iterator.hasNext()){ //判断是否还有下一个元素

    //next():指针下移,将下移后集合位置上的元素返回

    System.out.println(iterator.next());

    }

    }

    使用foreach遍历数组元素

    底层仍然是调用Iterator完成操作,但注意用来修改数组元素是无用的

    @Test

    public void test1(){

    Collection col=new ArrayList();

    col.add("aaaa");

    col.add("bbbb");

    col.add("vv");

    col.add("wweeeee");

    Iterator iterator = col.iterator();

    while(iterator.hasNext()){ //判断是否还有下一个元素

    //next():指针下移,将下移后集合位置上的元素返回

    System.out.println(iterator.next());

    }

    //注意此处一定要重新获取

    iterator=col.iterator();

    while(iterator.hasNext()){ //判断是否还有下一个元素

    //next():指针下移,将下移后集合位置上的元素返回

    Object str=iterator.next();

    if (str.equals("vv"))

    iterator.remove(); //使用iterator删除集合中的元素

    }

    //使用foreach循环遍历集合元素

    for(Object str:col){

    System.out.println(str);

    }

    }

    add(Object e) 添加元素

    size() 集合中的元素个数

    addAll(Collection col) 将集合中的元素全部添加到当前集合中

    isEmpty()

    boolean remove(Object obj) 通过元素的equals方法判断是否是要删除的那个元素,只会删除找到的第一个元素

    boolean removeAll(Collection col) 取当前集合的差集

    boolean retainAll(Collection col) 把交集的结果存在当前集合中,不影响c

    boolean equals(Object o)判断集合是否相等

    Object[] toArray()转换成对象数组

    hashCode()获取当前集合对象 的哈希值

    扩展:数组变成集合 Arrays.asList(array)

    1.2 List接口中的方法

    java中使用数组存储数据具有局限性(如上所述),所以通常使用List代替数组。List集合类中元素有序、可重复,集合中的每个元素都有其对应的顺序索引,可以根据元素的存储位置序号存取容器中的元素。List中的常用实现类有:ArrayList、LinkedList、Vector

    List接口:元素有序、可重复的集合 类似一个“动态”数组

    -------|ArryaList类:是List接口的主要实现类;线程不安全,效率高;底层使用Object[ ]数组

    -------|LinkedList类:对于频繁的插入、删除操作,使用此类效率比ArrayList高;底层使用双向链表

    由于List接口的特性是元素可以通过其位置序号进行访问,所以List接口比Collection接口多出了一些有关下标index的方法,这些是Set接口中没有的,所以Collection中也没有

    void add(int index, Object ele) 在index位置插入ele元素

    boolean addAll(int index, Collection c) 在index位置插入集合c中的所有元素

    Object get(int index) 获取指定位置的元素

    int indexOf(Object o) 返回第一次出现o的位置

    int lastIndexOf(Object o) 返回最后一次出现o的位置

    Object remove(int index) 移除index位置的元素

    💢 此处一定要注意,Collection接口有一个remove(Object o)方法,如果输入是int,此时会有限考虑此int值为index,而不是数组中的元素,因为数组中存到是包装类

    Object set(int index, Object element) 设置index处的元素为element,并返回原来该位置的元素

    List subList(int fromIndex, int toIndex) 返回从fromIndex到toIndex-1的子集合(左闭右开)

    @Test

    public void test3(){

    List list = new ArrayList(); //多态

    list.add(0);

    list.add(1);

    list.add(2);

    list.add(3);

    list.add(4);

    list.add(5);

    //1 void add(int index, Object ele) 在index位置插入ele元素

    list.add(3,'A');

    System.out.println(list); //[0, 1, 2, A, 3, 4, 5]

    //2 boolean addAll(int index, Collection c) 在index位置插入集合c中的所有元素

    List list1 = new ArrayList();

    list1.add('B');

    list1.add('C');

    list1.add('D');

    list.addAll(4,list1);

    System.out.println(list); //[0, 1, 2, A, B, C, D, 3, 4, 5]

    //3 Object get(int index) 获取指定位置的元素

    System.out.println(list.get(1)); //1

    //4 int indexOf(Object o) 返回第一次出现o的位置

    System.out.println(list.indexOf(3)); //7

    //5 int lastIndexOf(Object o) 返回最后一次出现o的位置

    System.out.println(list.lastIndexOf(4)); //8

    //6 Object remove(int index) 移除index位置的元素

    // 此处一定要注意,Collection接口有一个remove(Object o)方法

    // 如果输入是int,此时会有限考虑此int值为index,而不是数组中的元素

    // 因为数组中存到是包装类

    System.out.println(list.remove(4)); //B

    System.out.println(list); //[0, 1, 2, A, C, D, 3, 4, 5]

    //7 Object set(int index, Object element) 设置index处的元素为element,并返回原来该位置的元素

    System.out.println(list.set(0,"hhhhhhh")); //0

    System.out.println(list); //[hhhhhhh, 1, 2, A, C, D, 3, 4, 5]

    //8 List subList(int fromIndex, int toIndex) 返回从fromIndex到toIndex-1的子集合(左闭右开)

    List list2 =list.subList(0,3);

    System.out.println(list2); //[hhhhhhh, 1, 2]

    }

    由于List接口是有顺序的,所以不仅可以通过之前的两种方法进行遍历(迭代器和for each),还可以使用最普通的通过位置来遍历,下面使用LinkedList来举例

    @Test

    public void test4(){

    List list = new LinkedList();

    list.add(0);

    list.add(1);

    list.add(2);

    list.add(3);

    list.add(4);

    list.add(5);

    for(int i=0;i

    System.out.println(list.get(i));

    }

    }

    💸一道面试题

    @Test

    public void test5(){

    List list = new ArrayList(); //多态

    list.add(1);

    list.add(2);

    list.add(3);

    list.add(4);

    list.add(5);

    updateList(list);

    System.out.println(list);

    }

    private void updateList(List list){

    list.remove(2);

    }

    答案: [1, 2, 4, 5] 原因上面提到过(1.2的remove方法中)

    1.3List的三个实现类

    1.3.1 ArrayList

    ArrayList在jdk7和jdk8中的实现有所不同(建议查看源码,顺着add函数一直看下去)

    jdk7️⃣中:创建ArrayList的同时就在内存中开辟空间,当内存不够时,扩容为原来的1.5倍。扩容是一个耗时的操作,所以建议在开发中使用带参的构造器:ArrayList list = new ArrayList(int capacity)

    ArrayList list = new ArrayList();//底层创建长度为10的object[ ]数组elementData

    list.add(123);//elementData[0]=new Integer(123);

    //.......

    list.add(11);//如果此次的添加导致底层elementData数组容量不够,则扩容

    //默认情况下扩容为原来的1.5倍,同时需要将原有数组中的数据复制到新的数组中

    jdk8️⃣中:创建ArrayList时并没有在内存中开辟空间,而是在首次调用add()函数添加元素时才创建长度为10的数组,并将元素添加进去,其他的与jdk7无异

    ArrayList list = new ArrayList();//底层object[ ] elementData初始化为{ },实际长度为0

    list.add(123);//第一次调用add,底层创建长度为10的数组,并将123添加到数组中

    //.......

    list.add(11);//如果此次的添加导致底层elementData数组容量不够,则扩容

    //默认情况下扩容为原来的1.5倍,同时需要将原有数组中的数据复制到新的数组中

    小结:jdk7中的ArrayList的对象的创建类似于单例的饿汉式,而jdk8中的ArrayList的对象的创建类似于单例的懒汉式,延迟了数组的创建,节省内存

    1.3.2 LinkedList

    创建list的时候实际上创建了一个空的list,源码:

    ransient int size = 0;

    /**

    * Pointer to first node.

    * Invariant: (first == null && last == null) ||

    * (first.prev == null && first.item != null)

    */

    transient Node first;

    /**

    * Pointer to last node.

    * Invariant: (first == null && last == null) ||

    * (last.next == null && last.item != null)

    */

    transient Node last;

    /**

    * Constructs an empty list.

    */

    public LinkedList() {

    }

    内部声明了Node类型的first和last属性,默认值为null,从源码可以看出,LinkedList是以双向链表的形式进行存储,添加的元素都被封装到Node中,每次添加元素时,都会与last元素链接起来(下面的代码是从源码中抽出来的,配合食用效果更佳)

    public boolean add(E e) {

    linkLast(e);

    return true;

    }

    /**

    * Links e as last element.

    */

    void linkLast(E e) {

    final Node l = last;

    final Node newNode = new Node<>(l, e, null);

    last = newNode;

    if (l == null)

    first = newNode;

    else

    l.next = newNode;

    size++;

    modCount++;

    }

    //内部使用Node进行存储,Node中的属性声明以及构造器

    private static class Node {

    E item;

    Node next;

    Node prev;

    Node(Node prev, E element, Node next) {

    this.item = element;

    this.next = next;

    this.prev = prev;

    }

    }

    1.3.3 Vector

    通过Vector()构造器创建对象时,底层都创建了长度为10的数组,在扩容方面,默认扩容为原来的数组长度的2倍

    1.4Set接口

    Set接口是Collection的子接口,它没有提供额外的方法。Set集合中不允许包含相同的元素,Set判断两个对象是否相同使用的不是==运算符,而是根据equals()方法

    Set接口:元素无序、不可重复的集合 更接近于高中所讲的“集合”概念

    ----------|HashSet类:作为Set接口的主要实现类;线程不安全的;可以存储null值

    ------------------|LinkedHashSet类:作为HashSet的子类,遍历器内部数据时,可以按照添加时的顺序遍历

    ----------|TreeSet类:可以按照添加对象的指定属性进行排序

    无序性不等于随机性,存储的数据在底层数组中并非按照数组索引的顺序添加,而是按照数据的哈希值进行存储

    不可重复性:保证添加的元素按照equals进行判断是,不能返回true,即相同的元素只能添加一个

    以HashSet为例描述添加元素的过程

    ① 调用该元素所在类的hashCode()方法,计算其哈希值,利用此哈希值通过某种算法计算出在HashSet底层数组的存放位置(索引位置)

    ② 判断该位置上是否有元素

    ③ 如果没有元素,则添加成功;

    如果有其他元素(链表形式连接),则挨个进行比较:如果hash值不同,则添加成功,;如果hash值相同但equals()返回false,则添加成功;如果hash相同,equals()返回true,则添加失败

    在链表处采用七上八下的做法:jdk7中,添加的元素放在数组位置,指向原链表列;jdk8中,添加的元素放在链表中,原数组中的元素仍在原地

    hash值不多讲,直接使用重写时idea提供的即可

    1.5Set的三个实现类

    1.5.1 HashSet

    HashSet的底层实际上是HashMap

    HashSet是Set接口的典型实现,大多时候使用Set集合时都使用这个实现类。HashSet使用Hash算法来存储集合中的元素,因此具有很好的存取、查找、删除性能

    HashSet中判断两个元素相等的标准:hashCode() 和equals()都相等

    重写hashCode()的基本原则:在程序运行时,同一个对象多次调用hashCode()方法应该返回相同的值;当两个对象的equals方法返回true时,这两个对象的hashCode方法的返回值也应该相等;equals方法用来比较的field都应该用来计算hashCode值

    1.5.2 LinkedHashSet

    LinkedHashSet作为HashSet的子类,在添加数据的同时,每个数据还维护了两个引用,记录此数据的前一个数据和后一个数据(双向链表),所以能够实现按照添加顺序进行遍历,对于频繁的遍历操作,LinkedHashSet的效率高于HashSet

    1.5.3 TreeSet

    TreeSet和后面要讲的TreeMap底层采用的是红黑树的方式进行存储,查找元素的速度比List要快,可以实现按照指定属性进行排序输出

    由于TreeSet需要对元素进行比较,所以要写该元素对应类的比较器(自然排序、定制排序),此时比较两个对象是否相同的标准不是equals而是compare或者compareTo方法

    向TreeSet中添加的数据必选是相同类的对象

    public class StudentTestDemo{

    @Test

    public void test1(){

    TreeSet set = new TreeSet();

    set.add(new StudentTest(12,"ddddd"));

    set.add(new StudentTest(13,"gggg"));

    set.add(new StudentTest(9,"rrrr"));

    set.add(new StudentTest(4,"ppppp"));

    for(Object student : set){

    System.out.println(student);

    }

    }

    }

    class StudentTest implements Comparable{

    int age;

    String name;

    public StudentTest(int age, String name) {

    this.age = age;

    this.name = name;

    }

    @Override

    public int compareTo(Object o) {

    Integer ageInteger= age;

    return ageInteger.compareTo(((StudentTest)o).age);

    }

    @Override

    public String toString() {

    return "StudentTest{" +

    "age=" + age +

    ", name='" + name + '\'' +

    '}';

    }

    }

    💸面试题一道

    💢 注意重写了Person的equals()和hashCode()

    public class PersonTest{

    @Test

    public void test(){

    HashSet set = new HashSet();

    Person person1=new Person(1001,"AA");

    Person person2=new Person(1002,"BB");

    set.add(person1);

    set.add(person2);

    person1.name="CC";

    set.remove(person1);

    System.out.println(set); //[Person{age=1002, name='BB'}, Person{age=1001, name='CC'}]

    set.add(new Person(1001,"CC"));

    System.out.println(set); //[Person{age=1002, name='BB'}, Person{age=1001, name='CC'}, Person{age=1001, name='CC'}]

    set.add(new Person(1001,"AA"));

    System.out.println(set);

    //[Person{age=1002, name='BB'}, Person{age=1001, name='CC'}, Person{age=1001, name='CC'}, Person{age=1001, name='AA'}]

    }

    }

    class Person{

    int age;

    String name;

    public Person(int age, String name) {

    this.age = age;

    this.name = name;

    }

    @Override

    public String toString() {

    return "Person{" +

    "age=" + age +

    ", name='" + name + '\'' +

    '}';

    }

    @Override

    public boolean equals(Object o) {

    if (this == o) return true;

    if (o == null || getClass() != o.getClass()) return false;

    Person person = (Person) o;

    return age == person.age &&

    Objects.equals(name, person.name);

    }

    @Override

    public int hashCode() {

    return Objects.hash(age, name);

    }

    }

    2.Map接口

    2.1 Map接口的基础知识

    Map接口:双列数据,保存具有映射关系“key-value”对的集合 类似于数学上的y=f(x)

    -------------|Hashtable类:作为古老的实现类,线程安全,效率低,不能存储null的key和value

    ------------------------|Properties类:常用来处理文件,key和value都是String类型的

    -------------|HashMap类:是Map的主要实现类,线程不安全的,效率高;可以存储null的key和value

    ------------------------|LinkedHashMap类:保证在遍历map元素时,可以按照添加的顺序进行遍历(在原有结构的基础上,按照添加顺序使用了双链表)

    -------------|TreeMap类:按照添加的key-value对进行排序,实现排序遍历(key的自然排序和定制排序)

    对Map的进一步理解

    Map中的key是无序的、不可重复的,如果将所有的key抽取出来,应该使用Set来存储,因此key所在的类要重写equals()和hashCode()方法(参考HashSet)

    Map中的value是无序的、可重复的,如果将所有的value抽取出来,应该使用Collection来存储

    一个键值对:key-value构成了一个Entry对象

    Map中的Entry是无序的、不可重复的,使用Set存储所有的entry

    增、改:Object put(Object key, Object value) 将键值对添加到或者修改当前的map对象

    void putAll(Map m)将m中所有的键值对存储到当前map中

    删:Object remove(Object key)删除指定key值的键值对,返回其value值

    void clear():清楚map中的所有数据,但是此时的map并不是null,只是没有存数据

    查:Object get(Object key) 获取指定key对应的value

    boolean containsKey(Object key)是否包含指定的key

    boolean containsValue(Object value)是否包含指定的value

    int size()

    boolean isEmpty()判断当前map是否为空

    boolean equals(Object obj)判断当前map和参数对象obj是否相等(类型不相同的话一定不相等)

    元视图操作的方法

    Set keySet() 返回所有key构成的set集合

    Collection values() 返回所有values构成的Collection集合

    Set entrySet() 返回所有key-value对构成的set集合

    //遍历所有的set

    public void test(){

    //遍历所有的key 遍历key-value对的方法之一

    HashMap map = new HashMap();

    map.put("AA",123);

    map.put("BB",456);

    map.put("CC",789);

    Set keys=map.keySet();

    //迭代器 foreach keys.size() 都可以

    Iterator iterator1=keys.iterator();

    while(iterator1.hasNext()){

    Object o=iterator1.next();

    System.out.println("key:"+o+";value:"+map.get(o));

    }

    //遍历所有的values

    Collection values = map.values();

    for(Object o:values){

    System.out.println(obj);

    }

    //遍历key-value对的方法之二

    Set entrySet = map.entrySet();

    Iterator iterator2 = entrySet.iterator();

    while(iterator2.hasNext()){

    Object o=iterator1.next();

    Map.Entry entry = (Map.Entry)o;

    System.out.println("key:"+entry.getKey()+";value:"+entry.getValue());

    }

    }

    2.2 Map的相关实现类

    2.2.1 HashMap

    HashMap的底层:

    jdk7.0及之前:数组+链表

    jdk8.0及之后:数组+链表+红黑树

    此处以HashMap(jdk7.0)为例用来理解添加键值对的基本过程:

    HashMap map = new HashMap(); //实例化之后,底层创建了长度为16的一维数组Entry[] table

    map.put(key1, value1);

    ① 调用key1所在类的hashCode()计算其hash值,此hash值经过计算后得到Entry数组中的存放位置

    ② 如果此位置为空,则key1-value1添加成功

    ③如果跟不为空,证明此位置上存在着一个或多个通过链表结构链接的entry,比较key1与他们的哈希值(过程与HashSet的添加过程相同)

    ④如果hash不相同,则添加成功;如果hash相同,equals不同,则添加成功;如果都相同,则使用value1替换原位置上的value,更新成功。(添加成功的情况均以链表的形式存在,并且添加的过程中会涉及到扩容的问题,建议查看源码,扩容为原来容量的二倍,将原有的数据复制过来)

    JDK8.0相较于JDK7.0在底层实现方面的不同:

    ① new HashMap() 底层并不会创建一个长度为16的数组

    ② jdk 8底层的数组是 Node[ ]

    ③ 首次使用put方法添加数据时,底层创建长度为16的数组

    ④ jdk7.0及之前的底层结构为数组+链表;jdk8.0及之后的底层结构为数组+链表+红黑树。具体来说,当数组某一个索引位置上的元素以链表形式存在的数组个数>8且当前数组的长度>64时,此时会将此索引上的所有数据改为红黑树进行存储

    🚩强烈建议查看源码

    几个比较重要的常量

    1️⃣DEFAULT_INITIAL_CAPACITY:HashMap的默认容量,16(初始化的容量)

    2️⃣DEFAULT_LOAD_FACTOR:加载因子,默认加载因子为0.75

    3️⃣thread:扩容的临界值=容量加载因子 160.75=12

    4️⃣TREEIFY_THRESHOLD:Bucket中链表长度大于该默认值(8)时,转化为红黑树

    5️⃣MIN_TREEIFY_CAPACITY:Bucket中的Node被树化时最小的hash表容量 64

    2.2.2 LinkedHashMap

    是HashMap的子类,在其基础上使用双向链表将元素按照添加顺序连接起来,频繁执行遍历操作时建议使用LinkedHashMap(同一个位置上的元素使用单向链表连接)

    2.2.3 Properties

    该对象用于处理属性文件。由于属性文件里的key和value都是字符串类型,所以Properties里的key和value也都是字符串类型

    存取数据时,建议使用setProperty(String key, String value)方法和getProperty(String key)

    示例(idea创建属性文件的后缀为.properties,看看就好了,涉及到文件读写的exception没有处理)

    public void test(){

    Properties pro = new Properties();

    FileInputStream fis = new FileInputStream("jdbc.properties");

    pro.load(fis);

    String name = pro.getproperty("name");

    pro.setproperty("password","123456789");

    fis.close();

    }

    3.Collections工具类

    Collections是一个操作List、Set和Map等集合的工具类

    Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

    排序操作:

    reverse(List) 反转

    shuffle(List) 对List中元素进行随机排序

    sort(List) 根据元素所在类的自然排序都元素按照升序进行排序

    sort(List, Comparator) 定制排序

    swap(List, int ,int) 交换指定位置上的两个元素

    查找、替换

    Object max(Collection) 按照元素的自然排序,返回集合中的最大元素

    Object max(Collection, Comparator)按照元素的定制排序,返回集合中的最大元素

    Object min(Collection)

    Object min(Collection, Comparator)

    int frequency(Collection, Object) 返回集合中指定元素出现的次数

    void copy(List dest,List src) 将src的内容复制到dest中

    boolean replaceAll(List list, Object oldVal, Object newVal)使用新值替换List对象的所有旧值

    需要注意的💢void copy(List dest,List src)` 将src的内容复制到dest中

    在源码中,会首先比较dest和src的长度,如果dest.size()

    正确的处理方式如下:

    List dest = Arrays.asList(new Object[list.size]);//list为需要被复制的src

    System.out.println(dest.size());

    Collections.copy(dest,list);

    System.out.println(dest);

    Collections类中提供了多个synchronizedXxx()方法,该方法可以将指定的集合包装成线程同步的集合,从而可以解决多线程并发访问集合时的线程安全问题,例如synchronizedCollection()、synchronizedList()、synchronizedMap()、synchronizedSet()

    其实看它的源码,使用的还是类自己的原始方法,只是包装的时候,用synchronized同步代码块的方式把它包裹起来了

    展开全文
  • 2、创建一个Map集合,key是字符串中的字符,value是字符的个数。3、遍历字符串,获取每一个字符。5、使用获取到的字符,去集合Map判断key(字符)是否存在。6、假如key(字符)存在,那么该key对应的value数值增加1,即...

    步骤分析

    1、给出一串字符串,字符串中可以包含字母、数字、符号等等。

    2、创建一个Map集合,key是字符串中的字符,value是字符的个数。

    3、遍历字符串,获取每一个字符。

    5、使用获取到的字符,去集合Map判断key(字符)是否存在。

    6、假如key(字符)存在,那么该key对应的value数值增加1,即该字符的数量加一。

    7、假如key(字符)不存在,value的值设为1,并将key-value添加到Map集合中。

    8、遍历Map集合,输出每个字符个数的结果。

    代码实现

    创建一个CharNumber类,在类中定义keyValue方法,计算字符串中每个字符的个数

    public classCharNumber {/*** 计算字符串中每个字符的个数

    *@paramstring 要被计算字符个数的字符串

    *@return 的Map集合*/

    public static HashMapkeyValue(String string) {//字符串转换为字符数组

    char[] chars =string.toCharArray();//创建一个Map集合用来存放记录

    HashMap hashMap = new HashMap<>();//遍历字符串,获取每一个字符

    for (charc : chars) {//使用获取到的字符,去Map集合判断key是否存在//利用Map集合的containsKey()方法,判断key是否存在//如果存在 value ++,如果不存在 value = value

    if(hashMap.containsKey(c)) {//key存在,获取key对应的value,数值增加一,然后再更新到集合中

    Integer value =hashMap.get(c);

    value++;

    hashMap.put(c, value);

    }else{//key不存在,将key添加到Map集合中,且其对应的value为1

    hashMap.put(c, 1);

    }

    }returnhashMap;

    }

    }

    创建一个CharNumber类,在类中定义iteratorMap方法,遍历输出计算结果

    public classCharNumber {/*** 遍历输出Map集合

    *@paramhashMap 的Map集合*/

    public static void iteratorMap(HashMaphashMap) {//调用Map集合的entrySet()方法,获取集合Map的Key-Value,赋值给Set集合

    Set> set =hashMap.entrySet();//创建Set集合的迭代器

    Iterator> kvIterator =set.iterator();//迭代输出Set集合//hasNext():是否存在下一个元素//next():获取下一个元素

    while(kvIterator.hasNext()) {

    Map.Entry kv =kvIterator.next();

    System.out.println("字符'" + kv.getKey() + "'的个数是:" +kv.getValue());

    }

    }

    }

    测试一下CharNumber类,随便输入一串字符串,计算每个字符的个数

    public classDemoCharNumber {public static voidmain(String[] args) {

    Scanner scn= newScanner(System.in);

    System.out.print("请输入一个字符串:");

    String string=scn.next();

    CharNumber.iteratorMap(CharNumber.keyValue(string));

    }

    }

    运行代码(注意,不能输入空格):

    请输入一个字符串:dafsdaganjsda!!!!!!字符'a'的个数是:4字符'!'的个数是:6字符's'的个数是:2字符'd'的个数是:3字符'f'的个数是:1字符'g'的个数是:1字符'j'的个数是:1字符'n'的个数是:1

    代码总和

    CharNumber类

    importjava.util.HashMap;importjava.util.Iterator;importjava.util.Map;importjava.util.Set;public classCharNumber {public static HashMapkeyValue(String string) {char[] chars =string.toCharArray();

    HashMap hashMap = new HashMap<>();for (charc : chars) {if(hashMap.containsKey(c)) {

    Integer value=hashMap.get(c);

    value++;

    hashMap.put(c, value);

    }else{

    hashMap.put(c,1);

    }

    }returnhashMap;

    }public static void iteratorMap(HashMaphashMap) {

    Set> set =hashMap.entrySet();

    Iterator> kvIterator =set.iterator();while(kvIterator.hasNext()) {

    Map.Entry kv =kvIterator.next();

    System.out.println("字符'" + kv.getKey() + "'的个数是:" +kv.getValue());

    }

    }

    }

    DemoCharNumber类

    //测试

    importjava.util.Scanner;public classDemoCharNumber {public static voidmain(String[] args) {

    Scanner scn= newScanner(System.in);

    System.out.print("请输入一个字符串:");

    String string=scn.next();

    CharNumber.iteratorMap(CharNumber.keyValue(string));

    }

    }

    展开全文
  • 记录每个元素出现的个数 找出出现最多的元素出现的次数 筛选出次数和最多次数相等的所有元素 import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; ...

    获取数组中重复最多的元素

    1. 记录每个元素出现的个数

    2. 找出出现最多的元素出现的次数

    3. 筛选出次数和最多次数相等的所有元素,特别注意:网络上很多算法都只能找一个最多的元素

      import java.util.HashMap;
      import java.util.Iterator;
      import java.util.Map;
      import java.util.Set;
      
      public class chongfuMax {
          /*获取数组中重复最多的元素*/
          public static void main(String[] args) {
              int a[]={5,5,8,5,3,7,7,3,2,1,7};
              /*记录每个元素出现的个数*/
              Map<Integer,Integer> m= new HashMap<Integer,Integer>();
              for (int i = 0; i < a.length; i++) {
                  if (m.containsKey(a[i])) {
                      m.put(a[i],m.get(a[i])+1);
                  }else{
                      m.put(a[i],1);
                  }
              }
              /*找出出现最多的元素的次数*/
              int most=0;
              Iterator iter=m.entrySet().iterator();
              while (iter.hasNext()){
                  Map.Entry entry=(Map.Entry)iter.next();
                  int key=(Integer)entry.getKey();
                  int val=(Integer)entry.getValue();
                  System.out.println("键"+key+"值"+val);
                  if(val>most){
                      most=val;
                  }
              }
              /*筛选出次数和最多次数相等的所有元素*/
              Set<Map.Entry<Integer,Integer>> entrySet =m.entrySet();
              for (Map.Entry<Integer,Integer> en : entrySet) {
                  int num=en.getValue();
                  if (num == most) {
                      System.out.println(en.getKey());
                  }
              }
      
          }
      }
      
      结果为
      键1值1
      键2值1
      键3值2
      键5值3
      键7值3
      键8值1
      5
      7

       

    展开全文
  • //判断一个元素出现次数 //第一步:使用Scanner用户输入字符串,使用toArray方法转换为数组 //创建map集合,字符作为关键字key,value作为字符出现次数 //遍历字符串,获取每一个字符 //把获取字符串在map...
  • 那就是获取map元素的个数。 像普通的map,直接使用len()就可以测量出当前map的键值对的个数。但是sync.Map是一个封装好的产品,不能使用len(),也没有提供输出的接口告诉使用者当前里面的元素的个数。 当然也...
  • Map

    千次阅读 2021-01-24 11:56:20
    Map集合是以 键值对<...int size() : 集合中元素的个数 boolean isEmpty() : 判断集合是否为空 Object get(Object key): 根据key获取value Collection values() : 获取map中的所有value值
  • Map集合

    2020-04-16 12:28:13
    一、HashMap的使用 Map 集合名=new HashMap(); HashMap 集合名=new HashMap();...size(): 获取集合元素的个数 keySet(): 获取所有的key 返回set集合 values(): 获取所有的value,返回的是collection集合 g...
  • 集合中元素的个数4.集合是否为空5.删除元素6.判断键是否存在7.判断值是否存在8.获取元素9.获取所有kay的集合10.获取所有value的集合11.获取所有key-value关系的集合12.整合代码3.HashMap和HashTable的区别 1.Map ...
  • 1、找出字符串中重复的元素并写入文件: 问题:键入(或者从一个文件中读取... * 键入一串字符,计算每个字符出现的个数,并输入到一个文件上 * 1、键入 * 2、hashmap存储 * 3、写入文件 */ import java.io.Buf...
  • Java——Map集合

    2019-02-25 21:19:46
    开发中最常用的就是List集合和Map集合,Map集合是基于java核心类——java.util中的;Map集合用于储存元素对,Map储存的是一对...1、map.size():获取map中键值的个数 public class Demo_java_Map { public stati...
  • 2、获取有效元素的个数  int size() 3、清空集合  void clear() 4、是否是空集合  boolean isEmpty() 5、是否包含某个元素  boolean contains(Object obj):是通过元素的equals方法来判断是否是同一个对象 ...
  • gmap 获取瓦片数

    2019-02-26 19:12:00
    在gmap1.7版本中gMapControl1.MapProvider....但是在1.9版本中取消了GetAreaTileCount,只有GetAreaTileList()这个方法了,,返回的是个链表,,,再获取链表里元素的个数,,一样可以获取到瓦片数,但如果数据量很大时速...
  • Java集合概述1. Collection接口1.1 Collection接口方法1.2 遍历集合元素... 同时无法直接获取存储元素的个数 数组存储数据的特点单一 (只能存放有序、可重复数据) 集合可以动态地存储多个对象的引用,并且提供多
  • //Reduce方法:将输入的Key复制到输出的value中,然后根据输入的中元素的个数决定Key的输出次数 //全局用linenum来代表key的位次 public static class MyReduce extends Reducer, IntWritable, IntWritable, ...
  • 数组与集合 集合、数组都是对多个数据进行存储操作的结构。此时的存储,主要指的是...3、获取数组中实际元素的个数的需求,数组没有现成的属性或方法可用。 4、数组存储数据的特点:有序、可重复。对于无序、不可重复的
  • 先解决键盘输入,这里用nextLine来解决输入中有空格的问题 将键盘输入的字符串拆成char型数组 ...若有则count获取该数组元素Map的个数count,然后count自增,再将Map中的count覆盖 要求不查询符号的个数,再将判...
  • import java.util.Map; import java.util.Set; import java.util.concurrent.TimeUnit; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.util.CollectionUtils; ...
  • 1、首先用HashMap存储每个key及其对应的个数value 2、使用优先队列PriorityQueue,重写比较方法,把map的key从大到小进行排列。 3、使用List获取queue中的结果,Collections.reverse(list)将其倒序。 4、关键是要...
  • Java集合类的总结 各个集合类的关系总图 ...int size() //获取集合中元素的个数 void clear() //清空集合 boolean remove(object o)//删除集合中的某个元秦。 boolean isEmpty() //判断该集合中元素的个数是否为e objec
  • JAVA中的集合 JAVA中的集合大致分为两大类 一类是单个方式存储元素: 单个方式存储元素,这一类集合中超级父接口:Collection类 一类是以键值对的方式存储...获取集合中元素的个数 3.void clear() 清空集合 ...
  • 集合类概述

    2020-04-01 22:42:13
    常用的集合:Lise,Set,Map,其中List,Set继承了Collection接口 Collection接口常用的方法: 1:add(E,e) 对象添加 2:remove(Object o) 对象移出 ...5:size() 获取元素的个数 List接口定义的方法: 1:get(int inde...
  • java中集合

    2021-03-20 21:25:56
    1)集合的继承结构图 1.1、Collection集合结构图 1.2、Map集合的继承结构图 2)关于Java.until.Collection接口中常用的方法 2.1、 Collection c=new ArrayList();...//(2) int size() 获取集合中元素的个数 c.siae();
  • Java集合管理

    2021-03-29 14:35:57
    Java集合可分为Collection和Map两种体系 Collection集合:单列数据、定义存取一组对象的方法的集合 List:元素有序、可重复的集合 ... 2、获取有效元素的个数 int size() 3、清空集合 void clear() ...
  • Java集合框架概述 ...addAll(Collection coll) 2、获取有效元素的个数 int size() 3、清空集合 void clear() 4、是否是空集合 boolean isEmpty() 5、是否包含某个元素 boolean contains(Object obj)
  • 复习——集合

    2021-03-12 03:06:41
    集合 Java 集合就像一种容器,可以动态地把多个对象的引用放入容器中,Java 集合可分为 Collection 和 Map 两种体系。...2、获取有效元素的个数 int size() 3、清空集合 void clear() 4、是否是空集合
  • 集合框架

    2021-03-18 15:30:21
    java集合框架提供了一套性能优良,使用方便的接口和类,位于java.until包中 Collection接口存储一组不唯一,无序的对象 List接口存储一组不唯一,有序(插入顺序)的对象 ...3.size获取集合中元素的个数 4
  • Java基础9:Java集合

    2021-04-29 15:01:47
    同时无法直接获取存储元素的个数 数组存储的数据是有序的、可以重复的。---->存储数据的特点单一 集合的出现有效解决了数组的部分弊端 集合分类: Java 集合可分为 Collection 和 Map 两种体系 Collection接口...
  • C++中mutimap简单用法

    千次阅读 2018-09-16 22:51:04
    mutimap和map的头文件都是,都是关联容器,都是需要通过迭代器来访问元素的,只不过在mutimap中需要使用count()函数获取一个key的个数,使用find(),find会将迭代器进行排序,这样就可以通过迭代器和key的个数来访....
  • 集合

    2020-03-05 17:13:37
    一.容器类 1.1定义 容器其实就是一种用来存储数据的数据结构,在java中容器可以分为集合(Collection)和映射(Map)。...1)容量可以动态的改变,并且可以根据size()方法来获取容器类中有效元素的个数。 2...

空空如也

空空如也

1 2 3
收藏数 60
精华内容 24
关键字:

获取map元素的个数