精华内容
下载资源
问答
  • 有一批节点,每个节点的字段是是一样的,如下:uid,cmmdtyCode,supplierCode。要求统计各商户下各个cmmdtyCode出现了多少次。样例数据如下: [ { "uid":"127437864373237009", "cmmdtyCod...

    业务场景:

    有一批节点,每个节点的字段是是一样的,如下:uid,cmmdtyCode,supplierCode。要求统计各商户下各个cmmdtyCode出现了多少次。样例数据如下:

    [
     {
        "uid":"127437864373237009",
        "cmmdtyCode":" 000000000659869748",
        "supplierCode":" 0070113914"
     },
     {
        "uid":"127437864373237010",
        "cmmdtyCode":" 000000000659869748",
        "supplierCode": " 0070113914"
     },
     {
        "uid":”127437864373237011”,
        "cmmdtyCode":" 000000000659869749",
        "supplierCode":" 0070113914"
     },
     {
        "uid”:”127437864373237012”,
        "cmmdtyCode":" 000000000659869748",
        "supplierCode": "0070113915"
     }
    ]

    预期输出:supplierCode:cmmdtyCode=商品出现次数

    实现方法

    1)环境说明

    本例jdk版本为1.7,代码在testng里面执行

    2)数据准备

    将前面的样例数据以List<Map<String,Object>>的格式存储起来,代码如下:

    import java.util.List;
    import java.util.Map;
    
    import org.powermock.modules.testng.PowerMockTestCase;
    import org.testng.annotations.BeforeMethod;
    
    import com.beust.jcommander.internal.Lists;
    import com.google.common.collect.Maps;
    
    public class TestJ2 extends PowerMockTestCase {
        private List<Map<String, Object>> params = Lists.newArrayList();
    
        @BeforeMethod
        public void initMethod() {
            Map<String, Object> item = Maps.newHashMap();
            item.put("uid", "127437864373237009");
            item.put("cmmdtyCode", "000000000659869748");
            item.put("supplierCode", "0070113914");
            params.add(item);
            Map<String, Object> item2 = Maps.newHashMap();
            item2.put("uid", "127437864373237010");
            item2.put("cmmdtyCode", "000000000659869748");
            item2.put("supplierCode", "0070113914");
            params.add(item2);
            Map<String, Object> item3 = Maps.newHashMap();
            item3.put("uid", "127437864373237011");
            item3.put("cmmdtyCode", "000000000659869749");
            item3.put("supplierCode", "0070113914");
            params.add(item3);
            Map<String, Object> item4 = Maps.newHashMap();
            item4.put("uid", "127437864373237012");
            item4.put("cmmdtyCode", "000000000659869748");
            item4.put("supplierCode", "0070113915");
            params.add(item4);
        }
    }

    3)实现方法1

        // 一般计算方法
        @Test
        public void execute() {
            // 每个商户下,不同商品出现的次数
            Map<String, Integer> numMap = Maps.newHashMap();
            for (Map<String, Object> item : params) {
                Integer num = MapUtils.getInteger(numMap, getKey(item));
                if (num == null) {
                    num = 1;
                } else {
                    num += 1;
                }
                numMap.put(getKey(item), num);
            }
            printResult(numMap);
        }
    
        // 拼接业务主键
        private String getKey(Map<String, Object> item) {
            return MapUtils.getString(item, "supplierCode") + ":" + MapUtils.getString(item, "cmmdtyCode");
        }
        // 打印计算结果
        private void printResult(Map<String, Integer> numMap) {
            for (Map.Entry<String, Integer> entry : numMap.entrySet()) {
                System.out.println(entry.getKey() + "=" + entry.getValue());
            }
        }

    输出结果:

    0070113914:000000000659869748=2
    0070113914:000000000659869749=1
    0070113915:000000000659869748=1

    耗时:8ms

    4)实现方法2

        // 改进计算方法
        /**
         * 在jdk1.7(含)以下的版本中,普通Map类没有putIfAbsent,只有ConcurrentMap的子类才有,jdk8(含)之后,普通类也提供了该方法
         * 由于作者本人机器使用的是JDK1.7,故使用ConcurrentMap类进行演示,实际上,在单线程计算中,普通map类的效率要高于ConcurrentMap
         */
        @Test
        public void execute2() {
            ConcurrentMap<String, AtomicInteger> numMap = Maps.newConcurrentMap();
            for (Map<String, Object> item : params) {
                // 如果集合中不包括key,则写入默认值1,并返回null;否则直接返回集合中key对应的value对象的引用
                AtomicInteger oldValue = numMap.putIfAbsent(getKey(item), new AtomicInteger(1));
                if (oldValue != null) {
                    // 对象数值+1
                    oldValue.incrementAndGet();// 利用map存储的是对象的引用,直接对象的值,不需要重新写回map
                }
            }
            printResult(numMap);
        }
        // 拼接业务主键
        private String getKey(Map<String, Object> item) {
            return MapUtils.getString(item, "supplierCode") + ":" + MapUtils.getString(item, "cmmdtyCode");
        }
    
        private void printResult(Map<String, AtomicInteger> numMap) {
            for (Map.Entry<String, AtomicInteger> entry : numMap.entrySet()) {
                System.out.println(entry.getKey() + "=" + entry.getValue());
            }
        }

    输出结果:

    0070113914:000000000659869749=1
    0070113914:000000000659869748=2
    0070113915:000000000659869748=1

    耗时:11ms

    5)实现方法3

        // 分组计算方法
        @Test
        public void execute3() {
            HashMultimap<String, Map<String, Object>> group = HashMultimap.create();
            // 将所有节点分组,cmmdtyCode和supplierCode相同的item分入一组
            for (Map<String, Object> item : params) {
                group.put(getKey(item), item);
            }
            Map<String, Integer> numMap = Maps.newHashMap();
            // 统计每一组的元素个数
            for (String key : group.keySet()) {
                numMap.put(key, group.get(key).size());
            }
            printResult(numMap);
        }
    
        // 拼接业务主键
        private String getKey(Map<String, Object> item) {
            return MapUtils.getString(item, "supplierCode") + ":" + MapUtils.getString(item, "cmmdtyCode");
        }
    
        // 打印计算结果
        private void printResult(Map<String, Integer> numMap) {
            for (Map.Entry<String, Integer> entry : numMap.entrySet()) {
                System.out.println(entry.getKey() + "=" + entry.getValue());
            }
        }

    该方法引入了google API,具体引用路径为:

    import com.google.common.collect.HashMultimap;

    输出结果:

    0070113914:000000000659869748=2
    0070113914:000000000659869749=1
    0070113915:000000000659869748=1

    耗时:43ms

    6)增加测试数据

        @BeforeMethod
        public void initMethod() {
            for (int i = 0; i < 100; i++) {
                Map<String, Object> itemR = Maps.newHashMap();
                itemR.put("uid", i);
                itemR.put("cmmdtyCode", "000000000659869748");
                itemR.put("supplierCode", "0070113915");
                params.add(itemR);
            }
            for (int j = 0; j < 100; j++) {
                Map<String, Object> itemR = Maps.newHashMap();
                itemR.put("uid", j);
                itemR.put("cmmdtyCode", "000000000659869749");
                itemR.put("supplierCode", "0070113915");
                params.add(itemR);
            }
            for (int j = 0; j < 100; j++) {
                Map<String, Object> itemR = Maps.newHashMap();
                itemR.put("uid", j);
                itemR.put("cmmdtyCode", "000000000659869748");
                itemR.put("supplierCode", "0070113914");
                params.add(itemR);
            }
        }

    耗时如下:

    数据量 10 100 1000
    方法1耗时 11ms 8ms 19ms
    方法2耗时 9ms 11ms 18ms
    方法3耗时 45ms 40ms 59ms

     

    总结:

    方法1耗时最少,且较为常见,推荐

    转载于:https://my.oschina.net/u/3874846/blog/2222111

    展开全文
  • 业务场景:有一批节点,每个节点的字段是是一样的,如下:uid,cmmdtyCode,supplierCode。要求统计各商户下各个cmmdtyCode出现了多少次。样例数据如下:[{"uid":"127437864373237009","cmmdtyCode":" ...

    业务场景:

    有一批节点,每个节点的字段是是一样的,如下:uid,cmmdtyCode,supplierCode。要求统计各商户下各个cmmdtyCode出现了多少次。样例数据如下:

    [

    {

    "uid":"127437864373237009",

    "cmmdtyCode":" 000000000659869748",

    "supplierCode":" 0070113914"

    },

    {

    "uid":"127437864373237010",

    "cmmdtyCode":" 000000000659869748",

    "supplierCode": " 0070113914"

    },

    {

    "uid":”127437864373237011”,

    "cmmdtyCode":" 000000000659869749",

    "supplierCode":" 0070113914"

    },

    {

    "uid”:”127437864373237012”,

    "cmmdtyCode":" 000000000659869748",

    "supplierCode": "0070113915"

    }

    ]

    预期输出:supplierCode:cmmdtyCode=商品出现次数

    实现方法

    1)环境说明

    本例jdk版本为1.7,代码在testng里面执行

    2)数据准备

    将前面的样例数据以List>的格式存储起来,代码如下:

    import java.util.List;

    import java.util.Map;

    import org.powermock.modules.testng.PowerMockTestCase;

    import org.testng.annotations.BeforeMethod;

    import com.beust.jcommander.internal.Lists;

    import com.google.common.collect.Maps;

    public class TestJ2 extends PowerMockTestCase {

    private List> params = Lists.newArrayList();

    @BeforeMethod

    public void initMethod() {

    Map item = Maps.newHashMap();

    item.put("uid", "127437864373237009");

    item.put("cmmdtyCode", "000000000659869748");

    item.put("supplierCode", "0070113914");

    params.add(item);

    Map item2 = Maps.newHashMap();

    item2.put("uid", "127437864373237010");

    item2.put("cmmdtyCode", "000000000659869748");

    item2.put("supplierCode", "0070113914");

    params.add(item2);

    Map item3 = Maps.newHashMap();

    item3.put("uid", "127437864373237011");

    item3.put("cmmdtyCode", "000000000659869749");

    item3.put("supplierCode", "0070113914");

    params.add(item3);

    Map item4 = Maps.newHashMap();

    item4.put("uid", "127437864373237012");

    item4.put("cmmdtyCode", "000000000659869748");

    item4.put("supplierCode", "0070113915");

    params.add(item4);

    }

    }

    3)实现方法1

    // 一般计算方法

    @Test

    public void execute() {

    // 每个商户下,不同商品出现的次数

    Map numMap = Maps.newHashMap();

    for (Map item : params) {

    Integer num = MapUtils.getInteger(numMap, getKey(item));

    if (num == null) {

    num = 1;

    } else {

    num += 1;

    }

    numMap.put(getKey(item), num);

    }

    printResult(numMap);

    }

    // 拼接业务主键

    private String getKey(Map item) {

    return MapUtils.getString(item, "supplierCode") + ":" + MapUtils.getString(item, "cmmdtyCode");

    }

    // 打印计算结果

    private void printResult(Map numMap) {

    for (Map.Entry entry : numMap.entrySet()) {

    System.out.println(entry.getKey() + "=" + entry.getValue());

    }

    }

    输出结果:

    0070113914:000000000659869748=2

    0070113914:000000000659869749=1

    0070113915:000000000659869748=1

    耗时:8ms

    4)实现方法2

    // 改进计算方法

    /**

    * 在jdk1.7(含)以下的版本中,普通Map类没有putIfAbsent,只有ConcurrentMap的子类才有,jdk8(含)之后,普通类也提供了该方法

    * 由于作者本人机器使用的是JDK1.7,故使用ConcurrentMap类进行演示,实际上,在单线程计算中,普通map类的效率要高于ConcurrentMap

    */

    @Test

    public void execute2() {

    ConcurrentMap numMap = Maps.newConcurrentMap();

    for (Map item : params) {

    // 如果集合中不包括key,则写入默认值1,并返回null;否则直接返回集合中key对应的value对象的引用

    AtomicInteger oldValue = numMap.putIfAbsent(getKey(item), new AtomicInteger(1));

    if (oldValue != null) {

    // 对象数值+1

    oldValue.incrementAndGet();// 利用map存储的是对象的引用,直接对象的值,不需要重新写回map

    }

    }

    printResult(numMap);

    }

    // 拼接业务主键

    private String getKey(Map item) {

    return MapUtils.getString(item, "supplierCode") + ":" + MapUtils.getString(item, "cmmdtyCode");

    }

    private void printResult(Map numMap) {

    for (Map.Entry entry : numMap.entrySet()) {

    System.out.println(entry.getKey() + "=" + entry.getValue());

    }

    }

    输出结果:

    0070113914:000000000659869749=1

    0070113914:000000000659869748=2

    0070113915:000000000659869748=1

    耗时:11ms

    5)实现方法3

    // 分组计算方法

    @Test

    public void execute3() {

    HashMultimap> group = HashMultimap.create();

    // 将所有节点分组,cmmdtyCode和supplierCode相同的item分入一组

    for (Map item : params) {

    group.put(getKey(item), item);

    }

    Map numMap = Maps.newHashMap();

    // 统计每一组的元素个数

    for (String key : group.keySet()) {

    numMap.put(key, group.get(key).size());

    }

    printResult(numMap);

    }

    // 拼接业务主键

    private String getKey(Map item) {

    return MapUtils.getString(item, "supplierCode") + ":" + MapUtils.getString(item, "cmmdtyCode");

    }

    // 打印计算结果

    private void printResult(Map numMap) {

    for (Map.Entry entry : numMap.entrySet()) {

    System.out.println(entry.getKey() + "=" + entry.getValue());

    }

    }

    该方法引入了google API,具体引用路径为:

    import com.google.common.collect.HashMultimap;

    输出结果:

    0070113914:000000000659869748=2

    0070113914:000000000659869749=1

    0070113915:000000000659869748=1

    耗时:43ms

    6)增加测试数据

    @BeforeMethod

    public void initMethod() {

    for (int i = 0; i < 100; i++) {

    Map itemR = Maps.newHashMap();

    itemR.put("uid", i);

    itemR.put("cmmdtyCode", "000000000659869748");

    itemR.put("supplierCode", "0070113915");

    params.add(itemR);

    }

    for (int j = 0; j < 100; j++) {

    Map itemR = Maps.newHashMap();

    itemR.put("uid", j);

    itemR.put("cmmdtyCode", "000000000659869749");

    itemR.put("supplierCode", "0070113915");

    params.add(itemR);

    }

    for (int j = 0; j < 100; j++) {

    Map itemR = Maps.newHashMap();

    itemR.put("uid", j);

    itemR.put("cmmdtyCode", "000000000659869748");

    itemR.put("supplierCode", "0070113914");

    params.add(itemR);

    }

    }

    耗时如下:

    数据量

    10

    100

    1000

    方法1耗时

    11ms

    8ms

    19ms

    方法2耗时

    9ms

    11ms

    18ms

    方法3耗时

    45ms

    40ms

    59ms

    总结:

    方法1耗时最少,且较为常见,推荐

    展开全文
  • 个人分类: java 需要动态的传入一个Class的类型,然后反射到启动的List,根据List里定义的泛型,知道其中List的具体对象的各种属性。  代码   import java.lang.reflect.Field; ...

    java反射获取聚合<List>属性字段

    2016年09月30日 11:59:40 阅读数:7997 标签: javareflect 更多

    个人分类: java

    需要动态的传入一个Class的类型,然后反射到启动的List,根据List里定义的泛型,知道其中List的具体对象的各种属性。 

    代码

    
     
    1. import java.lang.reflect.Field;

    2. import java.lang.reflect.ParameterizedType;

    3. import java.lang.reflect.Type;

    4. import java.util.ArrayList;

    5. import java.util.HashMap;

    6. import java.util.HashSet;

    7. import java.util.List;

    8. import java.util.Map;

    9. import java.util.Set;

    10.  
    11. import com.meyacom.ruleapp.dto.Ztree;

    12.  
    13. public class test {

    14.  
    15. public static void main(String[] args) throws ClassNotFoundException {

    16. Class<?> apply = Class.forName("com.chac.ruleapp.bom.ApplyTest");

    17. Field[] fields = apply.getFields();

    18. //获取所有属性

    19. List> allFieldList = getBomFields1(new ArrayList(), fields);

    20. for (List list : allFieldList) {

    21. System.out.println(list.toString());

    22. }

    23. }

    24.  
    25. protected static List> getBomFields(List chain, Field[] fields) {

    26. List> result = new ArrayList>();

    27. for (Field field : fields) {

    28. Class<?> fieldClass = field.getType();

    29. if (fieldClass.getName().startsWith("java")

    30. || fieldClass.getName().startsWith("javax")

    31. || fieldClass.getName().startsWith("com.sun")

    32. || fieldClass.getName().startsWith("boolean")

    33. || fieldClass.getName().startsWith("double")

    34. || fieldClass.getName().startsWith("int")) {

    35. List endChain = new ArrayList(chain);

    36. endChain.add(field);

    37. result.add(endChain);

    38. continue;

    39. } else {

    40. List thisChain = new ArrayList(chain);

    41. thisChain.add(field);

    42. result.addAll(getBomFields(new java.util.ArrayList(

    43. thisChain), fieldClass.getDeclaredFields()));

    44. }

    45. }

    46. return result;

    47. }

    48. public static List> getBomFields1(List chain,

    49. Field[] fields) {

    50. List> result = new ArrayList>();

    51. for (Field field : fields) {

    52. Class<?> fieldClass = field.getType();

    53. if (fieldClass.isPrimitive()

    54. || fieldClass.getName().startsWith("java.lang")

    55. || fieldClass.getName().startsWith("java.util.Date")

    56. || fieldClass.getName().startsWith("javax")

    57. || fieldClass.getName().startsWith("com.sun")

    58. || fieldClass.getName().startsWith("sun")

    59. || fieldClass.getName().startsWith("boolean")

    60. || fieldClass.getName().startsWith("double")

    61. || fieldClass.getName().startsWith("int")) {

    62. List endChain = new ArrayList(chain);

    63. endChain.add(field);

    64. result.add(endChain);

    65. continue;

    66. } else {

    67. if (fieldClass.isAssignableFrom(List.class)) // 【2】

    68. {

    69. Type fc = field.getGenericType(); // 关键的地方,如果是List类型,得到其Generic的类型

    70. if (fc instanceof ParameterizedType) // 【3】如果是泛型参数的类型

    71. {

    72. ParameterizedType pt = (ParameterizedType) fc;

    73. Class genericClazz = (Class) pt.getActualTypeArguments()[0]; // 【4】

    74. if ( genericClazz.getName().startsWith("java.lang") //设置list的终止类型

    75. || genericClazz.getName().startsWith("java.util.Date")

    76. || genericClazz.getName().startsWith("javax")

    77. || genericClazz.getName().startsWith("com.sun")

    78. || genericClazz.getName().startsWith("sun")

    79. || genericClazz.getName().startsWith("boolean")

    80. || genericClazz.getName().startsWith("double")

    81. || genericClazz.getName().startsWith("int")) {

    82. continue;

    83. }

    84. //System.out.println(genericClazz);

    85. // 得到泛型里的class类型对象。

    86. List thisChain = new ArrayList(chain);

    87. // System.out.println(chain);

    88. thisChain.add(field); //!!

    89. result.addAll(getBomFields1(new ArrayList(thisChain), genericClazz.getDeclaredFields()));

    90. }

    91. } else {

    92. List thisChain = new ArrayList(chain);

    93. thisChain.add(field);

    94. result.addAll(getBomFields1(new ArrayList(thisChain),

    95. fieldClass.getDeclaredFields()));

    96. }

    97.  
    98. }

    99. }

    100. return result;

    101. }

    其中针对List类型的单独判断参考一下别人的代码片段如下 

    1.  Field[] fs = clazz.getDeclaredFields(); // 得到所有的fields  
    2.   
    3. for(Field f : fs)   
    4. {   
    5.     Class fieldClazz = f.getType(); // 得到field的class及类型全路径  
    6.   
    7.     if(fieldClazz.isPrimitive())  continue;  //【1】 //判断是否为基本类型  
    8.   
    9.     if(fieldClazz.getName().startsWith("java.lang")) continue; //getName()返回field的类型全路径;  
    10.   
    11.     if(fieldClazz.isAssignableFrom(List.class)) //【2】  
    12.     {   
    13.              Type fc = f.getGenericType(); // 关键的地方,如果是List类型,得到其Generic的类型  
    14.   
    15.              if(fc == null) continue;  
    16.   
    17.              if(fc instanceof ParameterizedType) // 【3】如果是泛型参数的类型   
    18.             {   
    19.                    ParameterizedType pt = (ParameterizedType) fc;  
    20.   
    21.                    Class genericClazz = (Class)pt.getActualTypeArguments()[0]; //【4】 得到泛型里的class类型对象。  
    22.   
    23.                    m.put(f.getName(), genericClazz);  
    24.   
    25.                    Map<String, Class> m1 = prepareMap(genericClazz);  
    26.   
    27.                    m.putAll(m1);   
    28.              }   
    29.       }   
    30. }  




    【解释】: 
    1、isPrimitive 

    public boolean isPrimitive()判定指定的 Class 对象是否表示一个基本类型。 
    有九种预定义的 Class 对象,表示八个基本类型和 void。这些类对象由 Java 虚拟机创建,与其表示的基本类型同名,即 boolean、byte、char、short、int、long、float 和 double。 【注:像Integer,Boolean等包装类不是基本类型!】 

    这些对象仅能通过下列声明为 public static final 的变量访问,也是使此方法返回 true 的仅有的几个 Class 对象。  

    返回: 当且仅当该类表示一个基本类型时,才返回 true 
    从以下版本开始:JDK1.1 

     

     

    参考http://lorry1113.iteye.com/blog/973903

    http://www.360doc.com/content/11/1231/14/1954236_176297236.shtml

    展开全文
  • 问题描述有如下collection, 我需要根据name quote.sign 字段去分组统计,根据last_updated时间去取最新的一条记录,或者根据quote.price在整个表里的最大值将数据按现有格式取出来。{"_id" : ObjectId("5bfd20dc8e...

    问题描述

    有如下collection, 我需要根据name quote.sign 字段去分组统计,根据last_updated时间去取最新的一条记录,或者根据quote.price在整个表里的最大值将数据按现有格式取出来。

    {

    "_id" : ObjectId("5bfd20dc8e01a44a64c9a455"),

    "name" : "test",

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "quote" : [

    {

    "price" : 0.00362,

    "volume" : 172.952,

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "sign" : "CNY"

    },

    {

    "price" : 0.0000346,

    "volume" : 1.6559,

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "sign" : "USD"

    },

    {

    "price" : 0.00369,

    "volume" : 176.591,

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "sign" : "USDT"

    }

    ]

    }

    问题出现的环境背景及自己尝试过哪些方法

    现在使用以下方式来查找

    查找到的数据是这样子的:比如数据

    {

    "_id" : {

    "name" : "test"

    },

    "last_updated" : [

    ISODate("2018-11-27T10:47:03.000Z"),

    ISODate("2018-11-27T10:48:03.000Z")

    ],

    "quote" : [

    {

    "price" : 0.00362,

    "volume" : 172.952,

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "sign" : "CNY"

    },

    {

    "price" : 0.0000346,

    "volume" : 1.6559,

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "sign" : "USD"

    }

    ]

    }

    相关代码

    // 请把代码文本粘贴到下方(请勿用图片代替代码)

    db.getCollection('test').aggregate([{

    $unwind: '$quote'

    },{

    "$group" : {

    "_id" : {

    "name" : "$name",

    },

    "price" : {

    "$max" : "$quote.price"

    },

    "last_updated" : {

    "$push" : "$last_updated"

    },

    "quote" : {

    "$push" : "$quote"

    }

    }

    }, {

    "$project" : {

    "name" : "$_id.name",

    "last_updated" : 1,

    "quote" : 1

    }

    },{

    "$sort" : {

    "quote.volume" : -1

    }

    }])

    你期待的结果是什么?实际看到的错误信息又是什么?

    我希望查到的每条数据是这样子的:

    {

    "_id" : ObjectId("5bfd20dc8e01a44a64c9a455"),

    "name" : "test",

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "quote" : [

    {

    "price" : 0.00362,

    "volume" : 172.952,

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "sign" : "CNY"

    },

    {

    "price" : 0.0000346,

    "volume" : 1.6559,

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "sign" : "USD"

    },

    {

    "price" : 0.00369,

    "volume" : 176.591,

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "sign" : "USDT"

    }

    ]

    },

    {

    "_id" : ObjectId("5bfd20dc8e01a44a64c9a455"),

    "name" : "test1",

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "quote" : [

    {

    "price" : 0.00362,

    "volume" : 172.952,

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "sign" : "CNY"

    },

    {

    "price" : 0.0000346,

    "volume" : 1.6559,

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "sign" : "USD"

    },

    {

    "price" : 0.00369,

    "volume" : 176.591,

    "last_updated" : ISODate("2018-11-27T10:47:03.000Z"),

    "sign" : "USDT"

    }

    ]

    }

    展开全文
  • category表中一个字段id,一个字段fid(父id)。这样可以根据WHERE id = fid来判断上一级内容,运用递归至最顶层。 分析:通过这种数据库设计出的无限级,可以说读取的时候相当费劲,所以大部分的程
  • 需求陈述 ... 根据判断对象中的username字段和village字段是否重复,将其取出分类存在不同的集合中。 具体实现 import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import
  • 首先举一个生活中的例子,这个是京东的搜索界面,在搜索框中输入“华为”进行搜索,就会得到如上界面,搜索框就是我们常用的搜索功能,而下面这些,比如分类、热点、操作系统、CPU 类型等是根据 ES 的聚合...
  • function (item, index)相当于 java中的foreach 数组循环 index 是索引 item 是索引下对应的对象 下面是为了获取数组中每个对象的成员变量数据 其中遍历也是有字段的绑定的 这里item绑定的是shopCategoryList 对列表...
  •   根据报文字段特点分类 类型 编号 填充方式 说明 普通字符串 S 右补空格 不含中文的字符串 中文字符串 C 右补空格 可含中文的字符串,如名称,附言等 普通数字 N 左补零 一般是整数
  • 1. 变量的分类 变量根据在类中定义位置的不同,可以分为两大类: 成员变量:全局变量/字段(Field),不要称之为属性(错误),直接定义在类中,方法外面; (1)类成员变量:使用static修饰符; (2)实例成员变量...
  • 从resultmap中看出以下sqlt_product_category为主表聚合,其前后的表是副表 ,...这样就会有很多重复行,此时可用java8的分类,去重实现用java组装嵌套,去重(key-value),再分类(以此key字段分类),通过分类key获取
  • java面试_数据库

    2018-12-28 12:21:00
    根据表里的字段分类,相同字段名只显示一行记录,通常与聚集函数max、min合用选择最大值最小值,或者与having合用筛选,结果按照group by的字段排序 例:select * from examine group by e_date; 结果: +--------...
  • list T为一个对象,取出某一个字段,判断该字段值,进行分类 (filter)3. 根据 list 获取 list t对象 (map)4. 根据list T对象某个字段进行归类4.1 有几类就分几类 (Collectors.groupingBy)4.2 分为两类,true为符合...
  • Java虚拟机规范

    2012-11-13 11:21:20
    Java虚拟机规范 (Java SE 7 中文版)》是一份根据Java Virtual Machine Specification (Java SE 7)》翻译的、非官方的、以Open Document形式发布的文档。 本译文由ItEye社区三位水友IcyFenix、wupuyuan、...
  • 一 注解的定义注解(Annotation),也...如果要对于元数据的作用进行分类,还没有明确的定义,不过我们可以根据它所起的作用,注解不会改变编译器的编译方式,也不会改变虚拟机指令执行的顺序,它更可以理解为是一种特...
  • 一 注解的定义注解(Annotation),也...如果要对于元数据的作用进行分类,还没有明确的定义,不过我们可以根据它所起的作用,注解不会改变编译器的编译方式,也不会改变虚拟机指令执行的顺序,它更可以理解为是一种特...
  • Java之注解

    2019-03-11 17:28:59
    一 注解的定义 注解(Annotation),也...如果要对于元数据的作用进行分类,还没有明确的定义,不过我们可以根据它所起的作用,注解不会改变编译器的编译方式,也不会改变虚拟机指令执行的顺序,它更可以理解为是一...
  • 页面中有一个下拉列表,这个列表也需要从数据库中读取,并且需要根据产品中的分类字段让下拉表默认选中相应的元素。 开发思路:当用户请求跳转这个页面时-->控制器接受请求,然后调用业务层取得产品数据-->...
  • Java变量深入

    2017-06-12 20:20:02
    1.变量的定义以及分类 定义变量的语法:  数据类型 变量名 = 值; -------------------------------------------------- 变量根据在类中定义位置的不同,分成两大类: 成员变量: 全局变量/字段(Field),不要称之为...
  • 现有两张表一张表里面是所有表的分类/分级(所有的表会组成一个目录,子节点就是具体的表,目录就是分类),另一张表里面是所有表的字段信息辅助工具:HTML Help Workshop (是否必须安装还不确定)步骤:1、根据数据库...
  • Java学习第19天

    2019-08-25 23:28:33
    变量的分类和初始值 定义变量的语法: 数据类型 变量名 = 值; 变量根据在类中定义位置的不同分为两大类: 1.成员变量: 全局变量/字段。直接定义在类中方法外; 类成员变量。使用static修饰的字段; 实例成员变量...
  • 一 注解的定义注解(Annotation),也...如果要对于元数据的作用进行分类,还没有明确的定义,不过我们可以根据它所起的作用,注解不会改变编译器的编译方式,也不会改变虚拟机指令执行的顺序,它更可以理解为是一种特...
  • 一 注解的定义注解(Annotation),也...如果要对于元数据的作用进行分类,还没有明确的定义,不过我们可以根据它所起的作用,注解不会改变编译器的编译方式,也不会改变虚拟机指令执行的顺序,它更可以理解为是一种特...
  • Java中的访问修饰符

    2019-05-07 09:38:55
    修饰符:可以根据权限分类;还可以根据特征进行分类 访问权限修饰符: 实际有是四个访问权限,修饰符是三个 private 私有的 表示:类访问权限只能在本类中访问,离开本类之后,就不能直接访问。 不写(缺省): ...
  • 模型对象一般分为:Po...Bo一般是根据业务需求映射请求参数,比如你查询商品Spu时,可能会根据品牌Id、分类Id、商品属性值等条件进行查询,同时还有排序要求、分页要求,此时你的Po通常是无法对应这些筛选记录的条...
  • 一 注解的定义注解(Annotation),也...如果要对于元数据的作用进行分类,还没有明确的定义,不过我们可以根据它所起的作用,注解不会改变编译器的编译方式,也不会改变虚拟机指令执行的顺序,它更可以理解为是一种特...
  • 给类的注解 一般在编译前根据注解编译成.class文件 java底层会用 运行时,动态代理.我们开发的一般是这个 元注解 用来注解注解的注解。。。。 就是最基本的几个注解 @Target 指定在类上 还是字段上 还是方法上来...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 123
精华内容 49
关键字:

java根据字段分类

java 订阅