精华内容
下载资源
问答
  • 常用的集合方式有哪些
    万次阅读 多人点赞
    2018-09-07 15:56:11

    常用的三大类集合:Set、List、Map。


    1 Set

    1) Set 集合属于单列集合,不允许包含重复元素;
    2) 判断元素是否重复的标准为对象的 equals 方法,存在时返回 false,不存在返回 true;
    3) 元素的排序规则,由相应的实现类决定,分为无序、元素大小排序、写入顺序排序;
    4) 初始化大小,扩容参考 HashMap。
    

    1.1 Set 接口、实现类:

    名称类型线程同步描述
    Set接口继承了Collection接口
    SortedSet接口继承了Set接口
    HashSet实现类不同步继承了AbstractSet类,实现了Set、Cloneable、Serializable接口
    TreeSet实现类不同步继承了AbstractSet类,实现了NavigableSet(继承了SortedSet)、Cloneable、Serializable接口
    LinkedHashSet实现类不同步继承了HashSet类,实现了Set、Cloneable、Serializable接口

    1.2 HashSet

    1) HashSet 实现了 Set 接口,继承了 AbstractSet 类,由哈希表支持,看源码可以发现是一个 HashMap 实例。
    2) HashSet 不保证集合内元素的迭代顺序,特别是不保证迭代顺序永久不变,该集合运行 null 元素存在。
    3) HashSet 中的元素,作为 HashMap 键值对的 Key 存储,而 Value 由一个统一的值保存。 
    4) HashSet 默认初始化大小为 16,扩容加载因子为 0.75,扩容大小为原来的一倍。即一个初始化size为16的
       HashSet,元素添加到12个的时候会进行扩容,扩容后的大小为32。
    备注:具体添加、读取、删除等规则需要参考 HashMap 的具体实现。
    

    1.3 TreeSet

    1) TreeSet 实现了 NavigableSet 接口,继承了AbstractSet类,由哈希表支持,看源码可以发现是一个 TreeMap 实例。
    2) TreeSet 中的元素有序的,排序规则遵照元素本身的大小进行排序,元素不能重复。
    3) TreeSet 中的元素,作为 TreeMap 键值对的 Key 存储,而 Value 由一个统一的值保存。 
    备注:具体添加、读取、删除等规则需要参考 TreeMap 的具体实现。
    

    1.4 LinkedHashSet

    1) LinkedHashSet 实现了 Set 接口,继承了HashSet类,由哈希表支持,看源码可以发现是一个 LinkedHashMap 实例。
    2) LinkedHashSet 中的元素有序的,排序规则遵照元素写入顺序进行排序,元素不能重复。
    3) LinkedHashSet 中的元素,作为 LinkedHashMap 键值对的 Key 存储,而 Value 由一个统一的值保存。 
    备注:具体添加、读取、删除等规则需要参考 LinkedHashMap、HashMap 的具体实现,LinkedHashMap继承了HashMap。
    

    1.5 线程安全

    由于 HashSet、TreeSet、LinkedHashSet的底层实现为HashMap、TreeMap、LinkedHashMap,所以Set集合是非线程安全的。
    如果要实现 Set 集合的线程安全,可以使用 ConcurrentHashMap 实现一个Set集合。
    

    2 List

    1) List 集合属于单列、有序的、允许元素重复、可以为 null 的集合;
    2) List 接口的实现类主要有三种:ArrayList、LinkedList、Vector。
    

    2.1 List 接口、实现类:

    名称类型线程同步描述
    List接口继承了Collection接口
    ArrayList实现类不同步继承了AbstractList类,实现了List、RandomAccess、Cloneable、Serializable接口
    LinkedList实现类不同步继承了AbstractSequentialList类,实现了List、Deque、Cloneable、Serializable接口
    Vector实现类同步继承了AbstractList类,实现了List、RandomAccess、Cloneable、Serializable接口

    2.2 ArrayList

    1) ArrayList 实现了 List 接口,继承了 AbstractList 类,由一个 Object[] 实例实现,即底层为数组结构;
    2) 默认初始化长度为 10,扩容规则为 0.5倍的原容量加1,即一次扩容后的长度为 16;
    3) 特点:查询速度快,添加、删除相对于LinkedList较慢、线程不同步(不安全)。
    

    2.2 LinkedList

    1) LinkedList 实现了 List 接口,继承了 AbstractSequentialList 类,由一个 Node 节点链表实现,即底层为链表结构;
    2) 由于LinkedList 数据结构为链表,无预扩容机制;
    3) 特点:添加、删除速度快,查询相对于ArrayList较慢、线程不同步(不安全)。
    

    2.3 Vector

    1) Vector实现了 List 接口,继承了 AbstractList 类,由一个 Object[] 实例实现,即底层为数组结构;
    2) 默认初始化长度为 10,扩容加载因子为 1,当元素长度大于原容量时进行扩容,默认为 10,一次扩容后容量为 20;
    3) 特点:线程安全,但是速度慢;在实现的方法上,用 synchronized 关键字进行了修饰,即在方法上实现了同步锁。
    备注:具体实现细节请查看源码。
    

    3 Map

    1) Map 集合属于双列Key-value键值对的集合,Key不允许重复,是否允许为 null 根据实现类而定,Value 随意;
    2) Map 接口的实现类主要有三种:HashMap、LinkedHashMap、TreeMap、Hashtable、ConcurrentHashMap。
    

    3.1 Map 接口、实现类:

    名称类型线程同步描述
    Map接口
    HashMap实现类不同步继承了AbstractMap类,实现了Map、Cloneable、Serializable接口
    LinkedHashMap实现类不同步继承了HashMap类,实现了Map接口
    TreeMap实现类不同步继承了AbstractMap类,实现了NavigableMap(继承了SortedMap)、Cloneable、
    Serializable接口
    Hashtable实现类同步继承了Dictionary类,实现了Map、Cloneable、Serializable接口
    ConcurrentHashMap实现类同步继承了AbstractMap类,实现了ConcurrentMap(继承了Map)、Serializable接口

    3.2 HashMap

    1) HashMap实现了 Map接口,继承了 AbstractMap类,数据结构采用的位桶数组,底层采用链表或红黑树进行存储;
    2) 默认初始化长度为 16,扩容加载因子为 0.75,一旦大于 0.75*16之后,就会调用resize()进行扩容,扩容2倍,即32;
    3) JDK1.7中,数据结构采用:位桶数组+链表结构;
       JDK1.8中,数据结构采用:位桶数组+(链表/红黑树);
    4) 支持克隆,无序,线程不同步,非安全。
    

    3.3 LinkedHashMap

    1) LinkedHashMap 实现了 Map 接口,继承了 HashMap 类;
       引用实现;
    3) 迭代顺序由 accessOrder 属性的决定,默认为 false,以插入顺序访问;设置为 true 则按上次读取顺序访问(每次访问
       元素时会把元素移动到链表末尾方便下次访问,结构会时刻变化)。
    4) 默认初始化长度为 16,扩容加载因子为 0.75,一旦>0.75*16之后,就会调用resize()进行扩容,与HashMap一致;
    5) 支持克隆,有序,线程不同步,非安全。
    

    3.4 TreeMap

    1) TreeMap实现了 NavigableMap接口,继承了 AbstractMap 类;
    2) 数据结构基于红黑树实现;
    3) 该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法;
    4) 无初始化长度;
    5) 支持克隆,有序,线程不同步,非安全。
    

    3.5 Hashtable

    1) Hashtable实现了 Map 接口,继承了 Dictionary类;
    2) 数据结构:也是一个散列表,数据结构与HashMap相同,key、value都不可以为 null;
    3) 该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法;
    4) 默认初始化长度为 11,扩容加载因子为 0.75,一旦>0.75*11之后,就会进行扩容,扩容到2n+1,即23;
    5) 支持克隆,无序,线程同步,安全。在实现的方法上,用 synchronized 关键字进行了修饰,即在方法上实现了同步锁。
    6) 支持 Enumeration 遍历方式。
    

    3.6 ConcurrentHashMap

    1) ConcurrentHashMap实现了 ConcurrentMap接口,继承了 AbstractMap类;
    2) 默认初始化长度为 16,扩容加载因子为 0.75,一旦大于 0.75*16之后,就会调用resize()进行扩容,扩容2倍,即32;
    3) 数据结构:由Segment数组结构和HashEntry数组结构组成,一个ConcurrentHashMap中包含一个Segment数组,
       Segment的结构和HashMap类似,是一种数组和链表结构。
    4) 使用了锁分段技术,Segment是一种可重入锁ReentrantLock,每个Segment拥有一个锁,当对HashEntry数组的
       数据进行修改时,必须先获得对应的Segment锁
    5) 不支持克隆,无序,线程同步,安全。
    
    更多相关内容
  • Collection下两个比较常用的接口分别是List(列表)和Set(集),其中List可以存储重复元素,元素是有序的(存取顺序一致),可以通过List脚标来获取指定元素;而Set不可以重复元素,元素是无序的。 List接口中,...
    类图关系

    集合

    集合的两个顶级接口分别为:Collection和Map

    Collection下有两个比较常用的接口分别是List(列表)和Set(集),其中List可以存储重复元素,元素是有序的(存取顺序一致),可以通过List脚标来获取指定元素;而Set不可以有重复元素,元素是无序的。

    List接口中,比较常用的类有三个:ArrayList、Vactor、LinkedList。

    ArrayList :线程不安全的,对元素的查询速度快。

    Vector :线程安全的,多了一种取出元素的方式:枚举(Enumeration),但已被ArrayList取代。

    LinkedList :链表结构,对元素的增删速度很快。

    Set接口中,比较常用的类有两个:HashSet、TreeSet:

    HashSet:要保证元素唯一性,需要覆盖掉Object中的equals和hashCode方法(因为底层是通过这两个方法来判断两个元素是否是同一个)。

    TreeSet:以二叉树的结构对元素进行存储,可以对元素进行排序。

    排序的两种方式:
    1、元素自身具备比较功能,元素实现Comparable接口,覆盖compareTo方法。
    2、建立一个比较器对象,该对象实现Comparator接口,覆盖compare方法,并将该对象作为参数传给TreeSet的构造函数(可以用匿名内部类)。
    
    Map接口其特点是

    元素是成对出现的,以键和值的形式体现出来,键要保证唯一性:常用类有:HashMap,Hashtable ,TreeMap。

    HashMap:线程不安全等的,允许存放null键null值。

    Hashtable:线程安全的,不允许存放null键null值。

    TreeMap:可以对键进行排序(要实现排序方法同TreeSet)。

    Collection和Map两个接口对元素操作的区别:

    存入元素:

    Collection接口下的实现类通过add方法来完成,而Map下是通过put方法来完成。

    取出元素:

    Collection接口下:List接口有两种方式:1、get(脚标);2、通过Iterator迭代方式获取元素;而Vactor多了一种枚举(Enumeration)的方式。Set接口通过迭代的方式获取元素。

    Map接口下:先通地keySet获取键的系列,然后通过该系列使用Iterator迭代方式获取元素值。

    展开全文
  • spring 常用的注入方式有哪些

    万次阅读 多人点赞 2019-07-16 11:58:40
    spring 常用的注入方式有哪些? 1、xml中配置 bean 的申明、注册 <bean> 节点注册 bean <bean> 节点的 factory-bean 参数指工厂 bean,factory-method 参数指定工厂方法 bean 的注入 <property...

    spring 常用的注入方式有哪些?

    1、xml中配置

    • bean 的申明、注册

    <bean> 节点注册 bean
    <bean> 节点的 factory-bean 参数指工厂 bean,factory-method 参数指定工厂方法

     

    • bean 的注入

    <property> 节点使用 set 方式注入
    <constructor-arg> 节点使用 构造方法注入

     

    实测代码

    maven pom 文件 

    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-beans</artifactId>
    	<version>4.2.4.RELEASE</version>
    </dependency>
    
    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-context</artifactId>
    	<version>4.2.4.RELEASE</version>
    </dependency>

    A、<bean> + <property>,set方法注入

    class Bowl

    package constxiong.interview.inject;
    
    public class Bowl {
    
    	public void putRice() {
    		System.out.println("盛饭...");
    	}
    
    }
    

    class Person

    package constxiong.interview.inject;
    
    public class Person {
    
    	private Bowl bowl;
    	
    	public void eat() {
    		bowl.putRice();
    		System.out.println("开始吃饭...");
    	}
    
    	public void setBowl(Bowl bowl) {
    		this.bowl = bowl;
    	}
    	
    }

    spring 配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xsi:schemaLocation="
    		http://www.springframework.org/schema/beans 
    		http://www.springframework.org/schema/beans/spring-beans.xsd
    	    http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
            
    	<bean id="bowl" class="constxiong.interview.inject.Bowl" />
    	
    	<bean id="person" class="constxiong.interview.inject.Person">
    		<property name="bowl" ref="bowl"></property>
    	</bean>
    	
    </beans>

    测试类

    package constxiong.interview.inject;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class InjectTest {
    
    	public static void main(String[] args) {
    		ApplicationContext context = new ClassPathXmlApplicationContext("spring_inject.xml");
    		Person person = (Person)context.getBean("person");
    		person.eat();
    	}
    }
    

     

    B、修改为 配置文件和class Person,<bean> + <constructor-arg> 节点使用 构造方法注入

    class Person

    package constxiong.interview.inject;
    
    public class Person {
    
    	private Bowl bowl;
    	
    	public Person(Bowl bowl) {
    		this.bowl = bowl;
    	}
    	
    	public void eat() {
    		bowl.putRice();
    		System.out.println("开始吃饭...");
    	}
    	
    }
    

    spring 配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xsi:schemaLocation="
    		http://www.springframework.org/schema/beans 
    		http://www.springframework.org/schema/beans/spring-beans.xsd
    	    http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
            
    	<bean id="bowl" class="constxiong.interview.inject.Bowl" />
    	
    	<bean id="person" class="constxiong.interview.inject.Person">
    		<constructor-arg name="bowl" ref="bowl"></constructor-arg>
    	</bean>
    	
    </beans>

     

    C、<bean> 节点 factory-method 参数指定静态工厂方法

    工厂类,静态工厂方法

    package constxiong.interview.inject;
    
    public class BowlFactory {
    
    	public static final Bowl getBowl() {
    		return new Bowl();
    	}
    	
    }

    spring 配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xsi:schemaLocation="
    		http://www.springframework.org/schema/beans 
    		http://www.springframework.org/schema/beans/spring-beans.xsd
    	    http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
            
    	<bean id="bowl" class="constxiong.interview.inject.BowlFactory" factory-method="getBowl"/>
    	
    	<bean id="person" class="constxiong.interview.inject.Person">
    		<constructor-arg name="bowl" ref="bowl"></constructor-arg>
    	</bean>
    	
    </beans>

    D、非静态工厂方法,需要指定工厂 bean 和工厂方法

    工厂类,非静态工厂方法

    package constxiong.interview.inject;
    
    public class BowlFactory {
    
    	public Bowl getBowl() {
    		return new Bowl();
    	}
    	
    }

    配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xsi:schemaLocation="
    		http://www.springframework.org/schema/beans 
    		http://www.springframework.org/schema/beans/spring-beans.xsd
    	    http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
        
        <bean id="bowlFactory" class="constxiong.interview.inject.BowlFactory"></bean>   
    	<bean id="bowl" factory-bean="bowlFactory" factory-method="getBowl"/>
    	
    	<bean id="person" class="constxiong.interview.inject.Person">
    		<constructor-arg name="bowl" ref="bowl"></constructor-arg>
    	</bean>
    	
    </beans>



    2、注解

    • bean 的申明、注册

    @Component //注册所有bean
    @Controller //注册控制层的bean
    @Service //注册服务层的bean
    @Repository //注册dao层的bean

     

    • bean 的注入

    @Autowired 作用于 构造方法、字段、方法,常用于成员变量字段之上。
    @Autowired + @Qualifier 注入,指定 bean 的名称
    @Resource JDK 自带注解注入,可以指定 bean 的名称和类型等

     

    测试代码

    E、spring 配置文件,设置注解扫描目录

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xsi:schemaLocation="
    		http://www.springframework.org/schema/beans 
    		http://www.springframework.org/schema/beans/spring-beans.xsd
    	    http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
            
    	<context:component-scan base-package="constxiong.interview" />
    	
    </beans>

    class Bowl

    package constxiong.interview.inject;
    
    import org.springframework.stereotype.Component;
    //import org.springframework.stereotype.Controller;
    //import org.springframework.stereotype.Repository;
    //import org.springframework.stereotype.Service;
    
    @Component //注册所有bean
    //@Controller //注册控制层的bean
    //@Service //注册服务层的bean
    //@Repository //注册dao层的bean
    public class Bowl {
    
    	public void putRice() {
    		System.out.println("盛饭...");
    	}
    
    }
    

    class Person

    package constxiong.interview.inject;
    
    //import javax.annotation.Resource;
    //
    import org.springframework.beans.factory.annotation.Autowired;
    //import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Component;
    
    @Component //注册所有bean
    //@Controller //注册控制层的bean
    //@Service //注册服务层的bean
    //@Repository //注册dao层的bean
    public class Person {
    
    	@Autowired
    //	@Qualifier("bowl")
    //	@Resource(name="bowl")
    	private Bowl bowl;
    
    	public void eat() {
    		bowl.putRice();
    		System.out.println("开始吃饭...");
    	}
    	
    }
    

    测试类同上

     

    A、B、C、D、E 测试结果都ok

    盛饭...
    开始吃饭...
    

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • 常用的Map集合

    千次阅读 2019-05-22 21:12:22
    Map集合Map集合常用方法增加删除判断获取Map集合中TreeSet的应用Map集合中HashSet的应用 Map集合常用方法 Map集合和Collection集合的区别 Map集合Key和Value的,Collection集合是只有Value。 Collection集合底层...

    Map集合常用方法

    Map集合和Collection集合的区别

    Map集合是有Key和Value的,Collection集合是只有Value。

    Collection集合底层也是有Key和Value,只是隐藏起来。

    1.增加 put (K key, V value)
    2.删除 clear() 删除这个集合的所有值 remove(Object key) 根据键删除这一类
    3.判断 containsKey(Object key) containsValue(Object value) isEmpty()
    4.获取 get(Object key) size() values() entrySet() keySet()

    增加

    Map的put方法

    • 1.添加集合元素的同时,它可以编辑原有的元素
    • 如果说集合中没有key对应的value,那么就往集合中添加元素
    • 如果说集合对应的key有value值,则代表替换原有的值
    • 2.返回替换前key对应的value值
      在这里插入图片描述

    删除

    clear() 删除这个集合的所有值

    在这里插入图片描述 remove(Object key) 根据键删除这一类

    在这里插入图片描述

    判断

    containsKey(Object key) 这里就举这一个例子
    在这里插入图片描述

    获取

    KeySet():
    将Map中所有的键存入到set集合中。因为set具备迭代器。所有可以迭代方式取出所有的键,再根据get方法。获取每一个键对应的值。 keySet():迭代后只能通过get()取key

    entrySet():

    Set<Map.Entry<K,V>> entrySet() //返回此映射中包含的映射关系的 Set 视图。 Map.Entry表示映射关系。entrySet():迭代后可以e.getKey(),e.getValue()取key和value。返回的是Entry接口 。

    在这里插入图片描述

    Map集合中TreeSet的应用

    底层是二叉树数据结构,线程不同步,可以用于给Map集合中的键进行排序

    package com.zking.Map;
    
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Set;
    import java.util.TreeMap;
    
    /**
     * 1、将学生作为键,地址作为值进行存储,名字年龄相同则被认定为一个人,最后输出
     * 		A.建立一个student类,实例化作为key添加到map集合中
     * 		B.对学生进行判重
     * 2、最后按年龄进行排序
     * 3、需求改变、按姓名进行排序
     * @author huguiyun
     *
     */
    public class TreeMapDemo {
    	public static void main(String[] args) {
    //		Map<Student, String > map = new HashMap<>();//判重
    //		Map<Student, String > map = new TreeMap<>();//判重需要实现Comparable方法,排序
    		Map<Student, String > map = new TreeMap<>(new StuComp());//比较器排序
    
    		map.put(new Student("liuting", 18), "beijing");
    		map.put(new Student("wangwang", 43), "xingjiang");
    		map.put(new Student("goudan", 28), "dongjing");
    		map.put(new Student("xuyangyang", 38), "hulunbeier");
    		map.put(new Student("liuting", 18), "beijing");
    		map.put(new Student("liutingting", 18), "beijing");
    		
    		
    		System.out.println(map.size());
    		Set<Entry<Student, String>> entryset = map.entrySet();
    		for(Entry<Student, String> entry:entryset) {
    			System.out.println(entry.getKey()+"   ===   "+entry.getValue());
    		}
    	}
    }
    class Student implements Comparable<Student>{//让它具有比较性
    	private String name;
    	private int age;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "Student [name=" + name + ", age=" + age + "]";
    	}
    	public Student(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	public Student() {
    		super();
    	}
    	
    	//乘以39是为了增大他们的哈希,防止他们的哈希值相等
    	@Override
    	public int hashCode() {
    		return this.getName().hashCode()+this.getAge()*39;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		Student stu = (Student)obj;
    		return this.getAge() ==stu.getAge()&&this.getName().equals(stu.getName()) ;
    	}
    	@Override
    	public int compareTo(Student o) {//一定要判断主要条件和次要条件
    		int num = this.getAge() - o.getAge();
    		if(num==0) {
    			this.getName().compareTo(o.getName());
    		}
    		return num;
    	}
    }
    
    
    class StuComp implements Comparator<Student>{//比较器排序
    
    	@Override
    	public int compare(Student o1, Student o2) {
    		int num = o1.getName().compareTo(o2.getName());
    		if(num==0) {
    			return o1.getAge() - o2.getAge();
    		}
    		return num;
    	}
    	
    }
    

    Map集合中HashSet的应用

    统计字符串中字符出现次数

    package com.zking.Map;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.TreeMap;
    
    /**
     * 
     * map集合中的泛型要使用包装类,或者是引用数据类型
     * 
     * 统计字符串中出现的次数
     *     sdkfgkdfadasdfasd
     *     a(2)c(5)
     *     
     * 思考
     *    统计,排序
     *    
     *    统计功能
     *    1.将字符串转为字符数组,将这个字符串中的字符当作map集合中的key,
     *    将出现的次数作为value值
     *    
     *    2.当字符第一次出现的时候,那么用它在集合中进行寻找,返回值必然是null,
     *    之后将该字符对应的值改为1
     *    
     *    3.如果说该字符不是第一次出现,该字符对应的值不为null,然后应该+1
     *     
     * @author huguiyun
     *
     */
    public class HashMapDemo {
    	public static void main(String[] args) {
    		String str = "ksdflaksdfasdrtwrtwerxvsdfghflaihijfaidfai";
    		str = cishu(str);
    		System.out.println(str);
    	}
    	public static String cishu(String str) {
    		char[] chararray = str.toCharArray();
    		Map<Character, Integer> map = new TreeMap<>();
    		for(char c : chararray) {
    			Integer value = map.get(c);
    			if(value==null) {
    				map.put(c, 1);
    			}
    			else {
    				map.put(c, ++value);
    			}
    		}
    //		StringBuffer跟string  string 会创建新的空间
    		StringBuffer sb = new StringBuffer();
    		for(Map.Entry<Character, Integer> entry:map.entrySet()) {
    			sb.append(entry.getKey()+"("+entry.getValue()+")");
    		}
    		return sb.toString();
    	}
    
    }
    
    
    展开全文
  • 遍历map集合常用的4种方式

    千次阅读 2019-03-09 23:48:12
    之前面试被问到遍历map集合有几种方式:现做常见的4种遍历方式: @Test public void testMap() { Map&lt;String, Integer&gt; map = new HashMap&lt;String, Integer&gt;(); map.put("01&...
  • java中常用的几个集合

    万次阅读 多人点赞 2019-06-10 20:19:24
    //包含Collection(集合),List,Set,Map(图),以及其Iterator,Comparator,Cloneable,还有常用的具体实现类 //List<List<String>>集合的嵌套使用 //1、是否允许空 //2、是否允许重复数据 //3、...
  • 集合常用方法

    千次阅读 2020-07-13 23:13:55
    1.Collection集合常用方法 1、boolean add(E e) 添加元素到Collection集合中。 2、boolean addAll(Collection<? extends E> c) 将指定c中的所有元素都添加到此Collection集合中 3、void clear() 移除此...
  • Map集合常用的三种遍历方式

    千次阅读 2022-02-01 22:20:28
    Map集合的常见的遍历方式
  • 常用的六种集合的遍历方式

    千次阅读 2022-05-08 23:21:44
    遍历List集合有以下几种方式: 1.普通for循环: List<String> list = new ArrayList<String>(); list.add("北京"); list.add("上海"); list.add("广州"); list.add("西安"); //通过普通...
  • 工作中常用的Java集合有哪些

    千次阅读 多人点赞 2020-03-26 13:46:40
    换个说法:“工作中常用到的Java集合有哪些,应用场景是什么” List集合 List集合下最常见的集合两个:ArrayList和LinkedList 在工作中,我都是无脑用ArrayList。我问了两个同事:“你们在项目中用过LinkedList...
  • 常用的几种java集合类总结

    万次阅读 多人点赞 2018-08-09 18:13:16
    一:直观框架图 简单版: ...Collection接口又3种子类型,List、Set和Queue,再下面是一些抽象类,最后是具体实现类,常用ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedH...
  • C# 集合类型(常用集合类型整理)

    万次阅读 多人点赞 2018-06-24 09:41:16
    一、常用集合类型及概念 2. 1)List &amp;amp;amp;amp;amp;amp;amp;lt; T &amp;amp;amp;amp;amp;amp;amp;gt; 泛型的List 类是一个不限长度的集合类型,它内部实际就是一个数组,初始长度是4,每次...
  • java并发集合有哪些

    千次阅读 2017-11-13 10:39:45
    java并发集合  数据结构(Data Structure)是编程中的基本元素... 当需要在并发程序中使用数据集合时,必须要谨慎地选择相应的实现方式。大多数集合类并不能直接用于并发应用,因为他们没有对本身数据的并发访问进行
  • 常用集合的常用遍历方法

    万次阅读 2018-03-08 17:07:15
    集合框架:就是数据结构,主要List数据结构,Set数据结构,Map数据结构。List数据结构:数据内容无序,但数据的位置是有序的,从0开始,Set 数据结构:数据内容无序,但外置也无序,但内容不能重复。Map数据结构...
  • 常用集合有哪些?比如List如何排序? Set、List、Map.png Java中常用集合类 对于集合,大家都不陌生了,常见的集合接口Set、List、Map等,其中Set和List继承自Collection。 Collection是一组对象的集合...
  • Java集合转数组 数组转集合的几种常用方式
  • Java中常见的集合框架及常用的方法

    万次阅读 2022-09-05 21:49:04
    本篇文章主要说明Java中一些常见的集合框架及经常用到的一些方法 , 由于都是一些父类 , 所以没有做太深入的分析说明 , 后面的文章将会分别对List , Set , Map及其常用子类进行深入研究分析。
  • 常用的并发集合

    千次阅读 2018-01-11 10:22:42
    ConcurrentLinkedQueue适用于高并发场景下的队列,通过无锁的方式实现,通常ConcurrentLinkedQueue的性能要优于BlockingQueue。BlockingQueue的典型应用场景是生产者-消费者模式中,如果生产快于消费,生产队列装满...
  • 【Java】List集合常用创建方式

    千次阅读 2019-07-24 15:05:02
    1、常规方式 List<String> languages = new ArrayList<>(); languages.add("Java"); languages.add("PHP"); languages.add("Python"); System.out.println(languages); 2、Arrays 工具类 List<...
  • List集合去重的常见及常用的四种方式 01 实现思路:使用两个for循环遍历集合所有元素,然后进行判断是否相同元素,如果,则去除。这种方式是大部分最先想到的,也是最简单的实现方式。其中,这种方式可以保证...
  • 常用List集合初始化方式

    千次阅读 2020-02-23 16:37:46
    常用List集合初始化方式 1. 先创建List再赋值 标准方式,先创建集合对象,然后逐个调用add方法初始化。用起来比较繁琐,不太方便! List<Integer> list = new ArrayList(); list.add(1); list.add(2); ...
  • Collection 接口下的集合,元素都是单个存储的,称为单列集合 * 现实生活中,很多数据是成对存在的,比如:IP地址与主机名,身份证号与个人,学生与学号等这种 "一一对应" 的关系,叫做 "映射";java中提供了 Map ...
  • java常用集合集合讲解

    万次阅读 多人点赞 2018-07-04 13:32:59
    一、java集合系列 java的集合主要分为List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections )java中集合类的关系图 由此图可以看到,主要分为Collection和Map两大类: 1....
  • Map集合的一些常用方法

    千次阅读 2020-04-05 11:09:35
    通过查看Map接口描述,看到Map多个子类,常用的是HashMap集合、LinkedHashMap集合。 HashMap<K,V>:存储数据采用的哈希表结构,元素的存取顺序不能保证一致。由于要保证键的唯一、不重复,需要重写键的...
  • seo常用工具-seo常用工具有哪些

    千次阅读 2022-03-28 14:38:12
    seo常用工具,为什么要用seo常用工具,因为seo常用工具可以快速让网站收录以及排名以及检查网站的,今天给大家分享一款万能SEO排名优化工具多个功能集合。一键建站+内容以及资源采集+伪原创+主动推送给搜索引擎收录+...
  • java中集合遍历的几种方式

    千次阅读 2022-03-18 11:33:27
    Collection接口遍历元素使用Iterator(称为迭代器),所有实现Collection接口的集合类都一个Iterator()方法,只能用于遍历集合。 List list = new ArrayList<>(); Iterator iterator = list.iterator();...
  • ArrayList集合常用方法

    千次阅读 多人点赞 2021-01-20 20:20:29
    ArrayList集合常用方法 ArrayList集合的创建 非泛型 创建ArrayList集合对象,可以添加任意Object子类元素至集合 //非泛型创建的ArrayList集合对象可以保存任何类型的值 ArrayList list = new ArrayList(); list....
  • 首先给出结论,ArrayList,LinkedList,HashMap,StringBuilder是不安全的...Java API中所用的集合类,都是实现了Collection接口,他的一个类继承结构如下: Collection<–List<–Vector Collection<–Li...
  • 集合常用数据结构总结

    千次阅读 2019-04-28 20:17:49
    常见的和集合相关的数据结构: 数组, 栈, 队列,链表,哈希表, 二叉树 下面简单总结一下个数据结构特点: 1. 数组 ArrayList(public class ArrayList extends AbstractList implements List, RandomAccess, ...
  • java中Map集合常用方法

    千次阅读 2021-03-14 16:36:30
    Map集合和Collection集合的区别Map集合Key和Value的,Collection集合是只有Value。Collection集合底层也是Key和Value,只是隐藏起来。1、V put(Kkey, Vvalue)向map集合中添加Key为key,Value为value的元素,当...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 539,464
精华内容 215,785
热门标签
关键字:

常用的集合方式有哪些