精华内容
下载资源
问答
  • 实体类继承hashmap
    千次阅读
    2018-11-29 09:08:05

    https://blog.csdn.net/u010575093/article/details/50731281
    

    抽象类中可以定义成员变量,而接口中定义的成员变量实际上都是常量
    接口不可继承抽象类,抽象类可实现多个接口。接口与接口之间是继承,用extends,可继承多个接口

    mport java.util.HashMap;
    import java.util.Map;
    
    interface Test{
            public void mm();
    }
    
    interface Test1{
            public void kk();
    }
    //接口可以继承多个接口
    interface Test2 extends Test, Test1{
            public void mk();
    }
    //抽象类成员都是public,
    //抽象类中可以定义成员变量,而接口中定义的成员变量实际上都是常量。
    //抽象类可以继承接口,并实现接口方法
    abstract class ATest1 implements Test1{
            public void kk(){  System.out.println("ATtest mm");  }
    }
    
    abstract class ATest2 implements Test1, Test{
            public void mm(){       System.out.println("ATest2 mm");        }
            public void kk(){}
    }
    // 抽象类可以继承抽象类 也可以继承实体类
    abstract class ATest3 extends ATest1{
    
    }
    
    class Solution{
    	//时间复杂度n
            public void tosum(int[] nums, int target){
                    Map<Integer, Integer> map = new HashMap<>();
                    for(int i = 0; i < nums.length; i++)
                            map.put(nums[i],i);
                    for(int i = 0; i < nums.length; i++){
                            int comp = target - nums[i];
                            System.out.println("comp="+comp+" containsKey "+map.containsKey(comp));
                            System.out.println("map get "+map.get(comp));
                            if(map.containsKey(comp) && map.get(comp)!=i){
                                    System.out.println("match:"+i+" "+map.get(comp));
                            }
                    }
                    System.out.println("tosum");
            }
            //时间复杂度1
            public int[] tosum1(int[] nums, int target){
                    Map<Integer, Integer> map = new HashMap<>();
                    for (int i = 0; i < nums.length; i++) {
                            int complement = target - nums[i];
                            if (map.containsKey(complement)) {
                                    return new int[] { map.get(complement), i };
                            }
                            map.put(nums[i], i);
                    }
                    throw new IllegalArgumentException("No two sum solution");
            }
    }
    class HashSum{
    
            public static void main(String argv[]){
                    System.out.println("111");
                    new Solution().tosum();
            }
    }
    
    
    更多相关内容
  • 继承HashMap导致的Json序列化问题

    千次阅读 2021-04-11 19:49:53
    新建一个继承HashMap的Bean @Data @EqualsAndHashCode(callSuper = true) public class R<T> extends HashMap<String,Object> implements Serializable { private T data; } 进行fastjson...

    新建一个继承了HashMap的Bean

    @Data
    @EqualsAndHashCode(callSuper = true)
    public class R<T> extends HashMap<String,Object> implements Serializable {
    
        private T data;
    
    }

    进行fastjson进行序列化和反序列化

    public static void main(String[] args) {
       R r = new R();
       r.setData("1");
       String s = JSONObject.toJSONString(r);
       R r1 = JSONObject.parseObject(s,R.class);
       System.out.println(r1.getData());
    }

     结果输出null

    R如果不继承HashMap,结果输出“1”

    这是为什么呢???

    我们进一步观察可以看到,其实是R在序列化的时候就为{},所以反序列化也为null

    可以用debug去看下fastjson的源码:

    以上是fastjson的源码,会将Map类型的javaBean强转为Map类型,所以子类的私有属性都会被丢弃,而又是不是所有都会转化为Map类型呢?不是的

    可以看到,如果使用Map.class.isAssignableFrom(clazz)判断就会进入Map的处理方式中,看来fastjson是对map进行了特殊封装

    那么spring自带的jackson呢?

    public static void main(String[] args) {
       R<String> r = new R<>();
       r.put("test","1");
       r.setData("1");
       ObjectMapper build = new Jackson2ObjectMapperBuilder().build();
       System.out.println(r.getData());
       String s = null;
       try {
          s = build.writeValueAsString(r);
       } catch (JsonProcessingException e) {
          e.printStackTrace();
       }
       System.out.println(s);
    }
    

    不出意料,以上代码也是输出为:

    1
    {"test":"1"}

    其中“data”属性并没有被带上

    我们也可以进入jackson的源码中分析下:

    可以看到,jackson也是在不断的尝试寻找Serializer,但是并没有通过常规的方式找到,我们进入这个_createAndCacheUntypedSerializer方法,它是返回了一个MapSerializer序列化器

    找不到了,反正是返回了一个MapSerializer.....

    然后我们可以继续往下面看,看这个MapSerializer是怎么进行序列化的

    到了以上这步就很明显了,Object作为实参,而Map作为形参,所以会有类型强制转化的操作,相当于进行了向上转型,导致了子类中的私有变量消失了

    至此,我们得出了结论,继承了HashMap的实体类的私有属性,通过fastjson与Jackson都是不能被序列化与反序列化的

     

    展开全文
  • 反射获取hashmap以及继承hashmap

    反射获取hashMap

    反射是基于hashmap内部实现原理,Hashmap的核心在putval方法和内部类Node的组成.

    核心方法putVal

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                       boolean evict) {
            Node<K,V>[] tab; Node<K,V> p; int n, i;
            if ((tab = table) == null || (n = tab.length) == 0)
                n = (tab = resize()).length;
            if ((p = tab[i = (n - 1) & hash]) == null)
                tab[i] = newNode(hash, key, value, null);
            else {
                Node<K,V> e; K k;
                if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                    e = p;
                else if (p instanceof TreeNode)
                    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                else {
                    for (int binCount = 0; ; ++binCount) {
                        if ((e = p.next) == null) {
                            p.next = newNode(hash, key, value, null);
                            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                treeifyBin(tab, hash);
                            break;
                        }
                        if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                            break;
                        p = e;
                    }
                }
                if (e != null) { // existing mapping for key
                    V oldValue = e.value;
                    if (!onlyIfAbsent || oldValue == null)
                        e.value = value;
                    afterNodeAccess(e);
                    return oldValue;
                }
            }
            ++modCount;
            if (++size > threshold)
                resize();
            afterNodeInsertion(evict);
            return null;
        }
    

    可以看到hashmap由Node对象构成基础,那么我们反射的时候就要想法设法的把它的node给搞出来

    Node构成

    static class Node<K,V> implements Map.Entry<K,V> {
            final int hash;
            final K key;
            V value;
            Node<K,V> next;
    
            Node(int hash, K key, V value, Node<K,V> next) {
                this.hash = hash;
                this.key = key;
                this.value = value;
                this.next = next;
            }
    
            public final K getKey()        { return key; }
            public final V getValue()      { return value; }
            public final String toString() { return key + "=" + value; }
    
            public final int hashCode() {
                return Objects.hashCode(key) ^ Objects.hashCode(value);
            }
    
            public final V setValue(V newValue) {
                V oldValue = value;
                value = newValue;
                return oldValue;
            }
    
            public final boolean equals(Object o) {
                if (o == this)
                    return true;
                if (o instanceof Map.Entry) {
                    Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                    if (Objects.equals(key, e.getKey()) &&
                        Objects.equals(value, e.getValue()))
                        return true;
                }
                return false;
            }
        }
    

    node由hash,key,value,next这几个构成,他们都为属性名,那么就是可以通过反射获取到的。

    反射的实现

    //o 就是一个hash数组 里面有{code,msg,data}
    private Object  GetHashTableValue(Object o){
            Object resObj = new Object();
        //定义hashmap
            Class clsHashMap = null;
        //定义hashmap里的Node
            Class clsHashMap$Node = null;
        
            Field[] f = null;
            Field t = null, fNode = null;
    
            try {
                clsHashMap = Class.forName("java.util.HashMap");
                clsHashMap$Node = Class.forName("java.util.HashMap$Node");
    
                // 获取hashmap里的全部属性
                //里面有serialVersionUID,DEFAULT_INITIAL_CAPACITY,MAXIMUM_CAPACITY,DEFAULT_LOAD_FACTOR,TREEIFY_THRESHOLD,UNTREEIFY_THRESHOLD,MIN_TREEIFY_CAPACITY,
                f = clsHashMap.getDeclaredFields();
                
                AccessibleObject.setAccessible(f, true);
                for (Field field : f) {
                    // System.out.println(field.getName());
                    //获取属性名为table的,然后赋值给 filed
                    if (field.getName() == "table")
                        t = field;
                }
                //这这里的t为tree  transient Node<K,V>[] table; 由此可见这个是一个数组,所以要Object[] 来转换下
                 //注:如果是继承hashmap那么继承的属性也会在这里面。比如有个getmes类,其中有code,msg属性,那么o1也会有
                Object[] o1 = ((Object[]) t.get(o));
                //这里面遍历的便是node
                for (Object o2 : o1) {
                    if (o2!=null){
                        Object next = o2;//这个next就相当于是node一个类
                        while (next!=null){
                            //反射value属性
                            Field value = clsHashMap$Node.getDeclaredField("value");
                            //反射next属性
                            Field o_next  = clsHashMap$Node.getDeclaredField("next");
                            //根据自己需要还可以反射key和hash,方法一样
    
                            o_next.setAccessible(true);
                            value.setAccessible(true);
    
                            //得到value值
                            resObj = value.get(next);
                            
                            //得到下个节点node 可以赋值给fNode
                            Object objNext = o_next.get(next);
                            next = objNext;
                        }
                    }
                }
            } catch (ClassNotFoundException | IllegalAccessException | NoSuchFieldException e) {
                e.printStackTrace();
            }
    
            return resObj;
        }
    

    可以看到hashmap有大量的属性

     transient Node<K,V>[] table;
    
    private static final long serialVersionUID = 362498820763181265L;
    
       
    
        /**
         * The default initial capacity - MUST be a power of two.
         */
        static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    
        /**
         * The maximum capacity, used if a higher value is implicitly specified
         * by either of the constructors with arguments.
         * MUST be a power of two <= 1<<30.
         */
        static final int MAXIMUM_CAPACITY = 1 << 30;
    
        /**
         * The load factor used when none specified in constructor.
         */
        static final float DEFAULT_LOAD_FACTOR = 0.75f;
    
        /**
         * The bin count threshold for using a tree rather than list for a
         * bin.  Bins are converted to trees when adding an element to a
         * bin with at least this many nodes. The value must be greater
         * than 2 and should be at least 8 to mesh with assumptions in
         * tree removal about conversion back to plain bins upon
         * shrinkage.
         */
        static final int TREEIFY_THRESHOLD = 8;
    
        /**
         * The bin count threshold for untreeifying a (split) bin during a
         * resize operation. Should be less than TREEIFY_THRESHOLD, and at
         * most 6 to mesh with shrinkage detection under removal.
         */
        static final int UNTREEIFY_THRESHOLD = 6;
    
        /**
         * The smallest table capacity for which bins may be treeified.
         * (Otherwise the table is resized if too many nodes in a bin.)
         * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
         * between resizing and treeification thresholds.
         */
        static final int MIN_TREEIFY_CAPACITY = 64;
        /**
         * Holds cached entrySet(). Note that AbstractMap fields are used
         * for keySet() and values().
         */
        transient Set<Map.Entry<K,V>> entrySet;
    
        /**
         * The number of key-value mappings contained in this map.
         */
        transient int size;
    
        /**
         * The number of times this HashMap has been structurally modified
         * Structural modifications are those that change the number of mappings in
         * the HashMap or otherwise modify its internal structure (e.g.,
         * rehash).  This field is used to make iterators on Collection-views of
         * the HashMap fail-fast.  (See ConcurrentModificationException).
         */
        transient int modCount;
    
     
        int threshold;
    
        final float loadFactor;
    

    :transient是短暂的意思。对于transient 修饰的成员变量,在类的实例对象的序列化处理过程中会被忽略。 因此,transient变量不会贯穿对象的序列化和反序列化,生命周期仅存于调用者的内存中而不会写到磁盘里进行持久化

    总结:

    ​ 反射hashmap核心还是反射其中hashmap的内部类node类,只要拿的到它,就能反射相应的元素

    展开全文
  • 一开始我是用R继承hashmap然后定义一个私有属性data,没想到出错了,因为序列化过程中会忽略掉的私有属性(继承hashmap),因此在反序列过程中会吧data的值丢失。 public class R<T> extends HashMap<...

    在springcloud微服务调用返回数据时,出现获取数据为null的情况:
    一开始我是用R继承hashmap然后定义一个私有属性data,没想到出错了,因为序列化过程中会忽略掉类的私有属性(继承hashmap的类),因此在反序列过程中会吧data的值丢失。

    public class R<T> extends HashMap<String,T> {
        private T data;
        public void setData(T data){
            this.data = (T) data;
        };
    
        public T getData(){
            return data;
        }
    }
    class t{
        public static void main(String[] args) {
            R r = new R();
            r.setData(new Integer(1));
            System.out.println(r.getData());
            //序列化
            String s = JSON.toJSONString(r);
            System.out.println(s);
            //反序列化
            R r1 = JSON.parseObject(s, R.class);
            System.out.println(r1.getData());
            /**结果为
             * 1
             * {}
             * null
             */
        }
    }
    

    因此在放入数据时,需要利用put的方法放入map中,而又因为springcloud在调用其他服务后返回结果会转换为LinkedHashMap(前提是,如果map中的value为复杂对象,例如为List。这里不是很清楚,懂得人可以解答下),所以先将LinkedHashMap转换为json字符串,然后再转换为自己想要的类型对象
    在这里插入图片描述

    public class R extends HashMap<String, Object> {
    	private static final long serialVersionUID = 1L;
    
    	public <T> T getData(TypeReference<T> typeReference){
    		Object data = get("data");
    		String s = JSON.toJSONString(data);
    		T t = JSON.parseObject(s, typeReference);
    		return t;
    	}
    
    	public R setData(Object data){
    		put("data",data);
    		return this;
    	}
    
    展开全文
  • 1、Java 用自定义作为 HashMap 的键需要重写 hashCode ( ) 和 equals ( ) 两个方法。 2、 HashMap 中的比较 key 是先求出 key 的 hashCode 值,比较其是否相等,若相等再通过 equals ( ) 比较其Key值 是否相等 ,若...
  • mybatis-plus生成实体继承基类

    万次阅读 2019-12-11 23:20:16
    一、什么是基类 如BaseEntity,BaseController 等父类,便称之为基类。 我们在设计数据库表时,时常会碰到如下情况: ... 多张表,都需要这五个字段,那么,对应的实体类,也需要这5个字段: class A{ ...
  • 如题,对象中的参数为hashMap时,使用Json工具转Json时,发现是空,原来是需要对该参数添加set和get方法才可以;
  • Map不能直接实例化

    千次阅读 2020-04-05 22:44:32
    代码片: Map,ArrayList<String>> map = new ... 原因: Map——>public abstract interface java.util.Map 解决方法: 使用Map的实现进行实例化。 Map,ArrayList<String>> map = new HashMap,ArrayList<String>>();
  • 错误信息: java.lang.ClassCastException: java.util.LinkedHashMap cannot be cast to org....实现将LinkedHashMap转为Json字符串,再转为JSON对象,最后转为实体List Controller接受参数类型 @PostMapping("/saveSu
  • HashMap源码解析

    2021-04-20 14:17:37
    HashMap继承于AbstractMap,实现了Map、Cloneable、Serializable接口 HashMap是线程不安全的,其中key、value都可以为null,且是无序的。 二、HashMap的数据结构 HashMap的底层主要是基于数组和链表来实现的,它之...
  • java响应实体类封装

    千次阅读 2020-06-11 10:24:49
    前后端分离的开发模式中,或者与第三方接口交互,需要规范接口响应,下面是我在开发中的封装的一组响应实体类
  • 继承HashMap类,重写了toString()方法。

    千次阅读 2008-04-22 13:53:00
    package collections_example;.../** * * @author andy */ //定义Personclass Person{ private String name;private int age;Person(String name, int age){this.name=name;this.age=age;}//重写Per
  • java7-8中的 HashMap和ConcurrentHashMap全解析 如果你想了解底层的逻辑就来看看吧
  • //生成的实体类名字,增加前后缀的 ,下面的mapper xml 同理,另外还有controller和service的名称配置 // globalConfig.setEntityName("%sEntity"); globalConfig.setMapperName("%sMapper"); globalConfig....
  • java返回结果使用HashMap接收

    千次阅读 2021-02-12 22:25:46
    java返回结果使用HashMap接收发布时间:2020-11-07 16:22:48来源:亿速云阅读:108作者:Leahjava返回结果使用HashMap接收?相信很多没有经验的人对此束手无策,为此本文总结了问题出现的原因和解决方法,通过这篇...
  • mybatis-plus自动生成实体类(包含swagger注解) mybatis-plus逆向工程, 自动生成实体类,带swaager注解 首先导入相应的jar包 <dependencies> <dependency> <groupId>org.springframework....
  • 集合系列---HashMap原理

    千次阅读 2019-05-13 21:47:43
    HashMap采用Entry数组来存储key-value对,每一个键值对组成了一个Entry实体,Entry实际上是一个单向的链表结构,它具有Next指针,可以连接下一个Entry实体,以此来解决Hash冲突的问题。 数组存储区间是连续的,...
  • /*** 获取一个和其父的所有属性** @param clazz* @return*/public static List findAllFieldsOfSelfAndSuperClass(Class clazz) {Field[] fields = null;List fieldList = Lists.newArrayList();while (true) {...
  • HashMap的理解

    2020-12-22 06:39:26
    (1)HashMap的实现原理?此题可以组成如下连环炮来问你看过HashMap源码嘛,知道原理嘛?为什么用数组+链表?hash冲突你还知道哪些解决办法?我用LinkedList代替数组结构可以么?既然是可以的,为什么HashMap不用...
  • } 如果是自己自定义的,就不能利用set去重了,需要自己重写继承自Object的hashCode方法以及equals方法,这样就可以自定义set添加时去重的逻辑了. 为什么用了hashCode方法还要再次重写equals方法呢?因为哈希值相同...
  • 反射简介 Java的反射(reflection)机制是指在程序的运行状态中,可以构造任意一个类的对象,可以了解任意一...咱们先弄个实体类用作测试 @Data public class DemoModel { private Integer age; private String name;
  • } } Foo类继承HashMap,而且有一个私有的属性 data,经过json序列化后,data属性丢失,被放到了map中, 当反序列化时,data属性就为null了。测试代码如下:Foo foo = new Foo("XXXXXXXXXXXXX"); String json...
  • 工具 负责对象字节数组的相互转换,传输数据用 package com.yq.utils; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io....
  • java中list、map、array、实体类、字符串之间的相互转换,以及java8 stream使用
  • java万能实体类PageData

    千次阅读 2019-09-09 08:30:13
    这是一个获取前端get/post数据的工具,简单,方便,易理解,详细如下!! 详细代码 注:该工具仅用于json格式的数据,没有json则需如下几步操作!!!! 首先引入gson的Maven依赖 <dependency> <...
  • HashMap < Integer , Integer > ( ) ; Map < Integer , Integer > map2 = new HashMap < Integer , Integer > ( ) ; map1 . put ( 1 , 100 ) ; map1 . put ( 2 , 200 ) ; map1 . put ( 3 ,...
  • 万能实体类PageData的详细使用

    千次阅读 2019-09-26 19:26:00
    最近发现了一个很好用的工具———PageData,它有什么用呢?好用在哪里? 使用了PageData,只需要用PageData对象就可以接收前端传过来的所有数据,也可以把数据库查出来的数据封装在PageData里,而不需要像以前...
  • HashMap 和 ...上图中,每个绿色的实体是嵌套 Entry 的实例,Entry 包含四个属性:key, value, hash 值和用于单向链表的 next。 HashMap根据key的hash()方法计算哈希值,即数组的index。如果有多个key的
  • HashMap基于Map接口实现,元素以键值对的方式存储,并且允许使用null 键和null值,因为key不允许重复,因此只能有一个键为null,另外HashMap不能保证放入元素的顺序,它是无序的。HashMap是线程不安全的。
  • 前言 HashMap一直是我的一个心病,因为在面试的时候HashMap是个出现频率高发点,不管是知识点,还是现场编程,而且自己当时答得不好,今天就回归到源码,真正...(除了非同步和允许使用 null 之外,HashMap 与 Hash

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,225
精华内容 15,290
关键字:

实体类继承hashmap