精华内容
下载资源
问答
  • java比较多个对象中的时间字段大小
    千次阅读
    2021-03-16 12:08:15

    这不是最有效的解决方案,但最简洁的代码是:

    boolean equalLists = listA.size() == listB.size() && listA.containsAll(listB);

    更新:

    @WesleyPorter是对的如果重复对象在集合中,上述解决方案将无法正常工作。

    对于一个完整的解决方案,您需要迭代一个集合,从而正确处理重复的对象。

    private static boolean cmp( List> l1, List> l2 ) {

    // make a copy of the list so the original list is not changed, and remove() is supported

    ArrayList> cp = new ArrayList<>( l1 );

    for ( Object o : l2 ) {

    if ( !cp.remove( o ) ) {

    return false;

    }

    }

    return cp.isEmpty();

    }

    2014年10月28日更新:

    @RoeeGavriel是对的返回语句需要有条件。以上代码已更新。

    更多相关内容
  • 如何获取一个Java对象所占内存大小

    千次阅读 2021-02-26 12:51:59
    新建一maven工程我们先在IDEA新建一名为ObjectSizeFetcherAgent的maven工程,如下图:在maven项目的pom.xml新增一打jar包的插件,如下:org.apache.maven.pluginsmaven-compiler-plugin3.11.81.8/src/...

    新建一个maven工程

    我们先在IDEA中新建一个名为ObjectSizeFetcherAgent的maven工程,如下图:

    f4661c33d1a57bd69109b265f6e1871d.png

    在maven项目中的pom.xml中新增一个打jar包的插件,如下:

    org.apache.maven.plugins

    maven-compiler-plugin

    3.1

    1.8

    1.8

    /src/test/**

    utf-8

    org.apache.maven.plugins

    maven-jar-plugin

    3.0.2

    ${project.build.outputDirectory}/META-INF/MANIFEST.MF

    在项目的resources中新建一个名为META-INF的目录,在这个目录下新建一个名为MANIFEST.MF的属性文件,如下图:

    1354f753ddf283e55efddf110ab87678.png

    项目的JDK设置为1.8,如下图:

    b7a038858181e27ba8f9f5daa2ca1ea6.png

    fca00c2fdc182bf7b32822cfe382bfe4.png

    e5283a47ff448e29e9e827f6877bc70e.png

    编写获取Java对象内存的工具方法

    import java.lang.instrument.Instrumentation;

    import java.lang.reflect.Array;

    import java.lang.reflect.Field;

    import java.lang.reflect.Modifier;

    import java.util.ArrayDeque;

    import java.util.Deque;

    import java.util.HashSet;

    import java.util.Set;

    public class ObjectSizeFetcher {

    // instrumentation 是一个 java.lang.instrument.Instrumentation 的实例,由 JVM 自动传入

    private static Instrumentation instrumentation;

    /**

    * 这个方法先于主方法(main)执行

    * @param args

    * @param inst

    */

    public static void premain(String args, Instrumentation inst) {

    instrumentation = inst;

    }

    /**

    * 直接计算当前对象占用空间大小,包括当前类及超类的基本类型实例字段大小、

    * 引用类型实例字段引用大小、实例基本类型数组总占用空间、实例引用类型数组引用本身占用空间大小;

    * 但是不包括超类继承下来的和当前类声明的实例引用字段的对象本身的大小、实例引用数组引用的对象本身的大小

    *

    * @param o 需要计算内存的对象

    * @return 返回内存大小

    */

    public static long sizeOf(Object o) {

    return instrumentation.getObjectSize(o);

    }

    /**

    * 递归计算当前对象占用空间总大小,包括当前类和超类的实例字段大小以及实例字段引用对象大小

    * 注意:这个方法如果你看不懂也没关系,会用就行

    *

    * @param objP

    * @return

    * @throws IllegalAccessException

    */

    public static long fullSizeOf(Object objP) throws IllegalAccessException {

    Set visited = new HashSet();

    Deque toBeQueue = new ArrayDeque<>();

    toBeQueue.add(objP);

    long size = 0L;

    while (toBeQueue.size() > 0) {

    Object obj = toBeQueue.poll();

    //sizeOf的时候已经计基本类型和引用的长度,包括数组

    size += skipObject(visited, obj) ? 0L : sizeOf(obj);

    Class> tmpObjClass = obj.getClass();

    if (tmpObjClass.isArray()) {

    //[I , [F 基本类型名字长度是2

    if (tmpObjClass.getName().length() > 2) {

    for (int i = 0, len = Array.getLength(obj); i < len; i++) {

    Object tmp = Array.get(obj, i);

    if (tmp != null) {

    //非基本类型需要深度遍历其对象

    toBeQueue.add(Array.get(obj, i));

    }

    }

    }

    } else {

    while (tmpObjClass != null) {

    Field[] fields = tmpObjClass.getDeclaredFields();

    for (Field field : fields) {

    if (Modifier.isStatic(field.getModifiers()) //静态不计

    || field.getType().isPrimitive()) { //基本类型不重复计

    continue;

    }

    field.setAccessible(true);

    Object fieldValue = field.get(obj);

    if (fieldValue == null) {

    continue;

    }

    toBeQueue.add(fieldValue);

    }

    tmpObjClass = tmpObjClass.getSuperclass();

    }

    }

    }

    return size;

    }

    /**

    * String.intern的对象不计;计算过的不计,也避免死循环

    *

    * @param visited

    * @param obj

    * @return

    */

    static boolean skipObject(Set visited, Object obj) {

    if (obj instanceof String && obj == ((String) obj).intern()) {

    return true;

    }

    return visited.contains(obj);

    }

    }

    计算一个对象的大小

    我们在项目工程中新建一个名为Point的类,然后写一个main方法来测试new Point()占用内存空间的大小,代码如下:

    public class Point {

    private int x;

    private int y;

    public static void main(String [] args) {

    System.out.println(ObjectSizeFetcher.sizeOf(new Point()));

    }

    }

    我们在文件resources/META-INF/MANIFEST.MF中新增如下一行属性配置:

    Premain-Class: com.twq.ObjectSizeFetcher

    fec9ad8a449454b16f6e3dffd92dfdb1.png

    maven打包,如下:

    b2a948fbb0f86e454d186c7108f6ae4c.png

    打开操作系统的cmd,进入到上面的jar包所在的目录,如下图:

    ebf390f7287286b6ce26ef29e4ef555f.png

    执行如下的命令:

    java -javaagent:ObjectSizeFetcherAgent-1.0-SNAPSHOT.jar Point

    得到的结果如下:

    3aaea988cd3633d1d95cc81c5029c256.png

    2acde919684437a8d51dab70ccb19364.gif

    复杂Java对象所占内存的大小

    我们在Java单个对象内存布局中讲解了单个简单的Java对象所占内存的大小的计算.那么这篇文章主要是讲解复杂Java对象所占内存大小的计算,我们把继承.复合的对象称为复杂对象 继承对象 class P ...

    如何计算Java对象所占内存的大小

    [ 简单总结: 随便一个java项目,引入jar包: lucene-core-4.0.0.jar 如果是 maven项目,直接用如下依赖:

    一个Java对象到底占多大内存

    最近在读,对Java对象的内存布局有了进一步的认识,于是脑子里自然而然就有一个很普通的问题,就是一个Java对象到底占用多大内存? 在网上搜到了一篇博客讲的非常好 ...

    一个Java对象到底占多大内存?(转)

    最近在读,对Java对象的内存布局有了进一步的认识,于是脑子里自然而然就有一个很普通的问题,就是一个Java对象到底占用多大内存? 在网上搜到了一篇博客讲的非常好 ...

    【转】一个Java对象到底占多大内存?

    最近在读,对Java对象的内存布局有了进一步的认识,于是脑子里自然而然就有一个很普通的问题,就是一个Java对象到底占用多大内存? 在网上搜到了一篇博客讲的非常好 ...

    获取JAVA对象占用的内存大小

    介绍两种获取JAVA对象内存大小的方法. 第一种:Instrumentation 简介: 使用java.lang.instrument 的Instrumentation来获取一个对象的内存大小.利用I ...

    JAVA数组所占内存大小的对比

    1.两个数据模型 第一个是基本类型数组,第二个使用的是Float对象数组 public class SummaryModel{ private float[] summaryData; public ...

    一个 Java 对象到底有多大?

    阅读本文大概需要 2.8 分钟. 出处:http://u6.gg/swLPg 编写 Java 代码的时候,大多数情况下,我们很少关注一个 Java 对象究竟有多大(占据多少内存),更多的是关注业务与逻 ...

    java中基本类型封装对象所占内存的大小&lpar;转&rpar;

    这是一个程序,java中没有现成的sizeof的实现,原因主要是java中的基本数据类型的大小都是固定的,所以看上去没有必要用sizeof这个关键字. 实现的想法是这样的:java.lang.Runt ...

    随机推荐

    嵌入式实时操作系统μCOS原理与实践任务控制与时间的解析

    /*************************************************************************************************** ...

    Uestc&lowbar;suibian 暑假集训总结

    唉,终于组队了,终于可以只BB了,我就BB,我就不上! 和Xiper以及chenxh组队了- 下面是总结: day1 第一天吃饱喝足,然后就上路了,我一开始就看到了C题大水题,但是我不敢想象这道题居然 ...

    &lpar;三大框架SSH&rpar;面试题锦集

    http://www.cnblogs.com/dieyf/p/4109233.html

    Blue Jeans&lpar;串&rpar;

    Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 10083   Accepted: 4262 Description The ...

    (转载)PHP怎么获取MySQL执行sql语句的查询时间

    (转载自CSDN) 方法一: //计时开始 runtime(); //执行查询 mysql_query($sql); //计时结束. echo runtime(1); //计时函数 function ...

    ASIHttpRequest:创建队列、下载请求、断点续传、解压缩

    ps:本文转载自网络:http://ryan.easymorse.com/?p=12 感谢作者 工程完整代码下载地址:RequestTestDownload1 可完成: 下载指定链接的zip压缩文件 ...

    C&plus;&plus; 哈希表 &lpar;hashtable&rpar; 用于保存简单的数据,及数据查找,数据删除

    /*hashtable.h*/ #include #include #include using namesp ...

    Java之路——Java初接触

    本文大纲 1.Java是什么 2.Java历史 3.Java技术范围 3.1 Java SE平台技术范围 3.2 Java EE技术范围 3.3 Java 体系技术范围 4.总结 1.Java是什么 ...

    java 源码编译

    Java语言的“编译期”其实是一段“不确定”的操作过程,因为它可能是指一个前端编译器(叫“编译器的前段”更准确)——把*.java文件转变成*.class文件的过程:也可能是虚拟机的后端运行期编译器( ...

    rhel 配置centos源

    1.删除自带的yum包,清除/etc/yum.repos.d下面的文件 rpm -qa|grep yum|xargs rpm -e --nodeps(不检查依赖,直接删除rpm包) 2.安装cento ...

    展开全文
  • 现有多个对象,存储每个租户的视频/音频/图片大小,对象结构如下 public class TBucketSize { private Long tenantId; private Long imgSize; private Long audioSize; private Long videoSize; } 租户数据...
    • 数据结构

      现有多个对象,存储每个租户的视频/音频/图片大小,对象结构如下

    public class TBucketSize  {
        private Long tenantId;
        private Long imgSize;
        private Long audioSize;
        private Long videoSize;
    }

       租户数据如下:

            TBucketSize tBucketSize1=new TBucketSize();
            tBucketSize1.setTenantId(1L);
            tBucketSize1.setAudioSize(1L);
            tBucketSize1.setVideoSize(0L);
            tBucketSize1.setImgSize(0L);
    
            TBucketSize tBucketSize2=new TBucketSize();
            tBucketSize2.setTenantId(1L);
            tBucketSize2.setVideoSize(1L);
            tBucketSize2.setAudioSize(1L);
            tBucketSize2.setImgSize(2L);
    
            TBucketSize tBucketSize3=new TBucketSize();
            tBucketSize3.setTenantId(2L);
            tBucketSize3.setImgSize(1L);
            tBucketSize3.setAudioSize(0L);
            tBucketSize3.setVideoSize(0L);
    
            TBucketSize tBucketSize4=new TBucketSize();
            tBucketSize4.setTenantId(2L);
            tBucketSize4.setImgSize(1L);
            tBucketSize4.setAudioSize(3L);
            tBucketSize4.setVideoSize(1L);
            List<TBucketSize> bucketSizes=        Arrays.asList(tBucketSize1,tBucketSize2,tBucketSize3,tBucketSize4);

     

    • 需求

             要求统计每个租户 视频/音频/图片用量

    •  java  stream lambda计算写法:
        bucketSizes.stream().collect(Collectors.toMap(TBucketSize::getTenantId, Function.identity(), (u1, u2) -> {
                u1.setImgSize(u1.getImgSize() + u2.getImgSize());
                u1.setVideoSize(u1.getVideoSize() + u2.getVideoSize());
                u1.setAudioSize(u1.getAudioSize() + u2.getAudioSize());
                return u1;
            })).forEach((k, v) -> System.out.println(k+"-->"+ JSON.toJSON(v)));
    • 输出结果
    1-->{"audioSize":2,"imgSize":2,"isDelete":0,"videoSize":1,"tenantId":1}
    2-->{"audioSize":3,"imgSize":2,"isDelete":0,"videoSize":1,"tenantId":2}

     

    展开全文
  • java 按list对象多个字段排序

    万次阅读 2015-02-12 13:47:50
    Java List的数据如何根据对象的某一个或多个字段排序引出Comparable和comparator的使用   第一节 对于引入题目的探讨 首先把引入题目表述的清楚一些,在一个List存储的是一些对象实例,而对象实例包含...

    Java List中的数据如何根据对象的某一个或多个字段排序引出Comparable和comparator的使用
         

    第一节  对于引入题目的探讨
    首先把引入题目表述的清楚一些,在一个List中存储的是一些对象实例,而对象实例包含多个属性字段,我们要根据对象的某个或者多个属性来对List进行排序。
    假设List中存储的都是Student类的实例,Student类包含name、gender、id属性。首先根据Student实例中的name属性排序,如果两个名字相同,就再根据id属性排序。
    Student类源码如下:
    [java] 

    <strong>package chapter1; 
      
    public class Student { 
        private String name; 
        private String gender; 
        private int id; 
        
        public String getName() { 
            return name; 
        } 
        
        public void setName(String name) { 
            this.name = name; 
        } 
        
        public String getGender() { 
            return gender; 
        } 
        
        public void setGender(String gender) { 
            this.gender = gender; 
        } 
        
        public int getId() { 
            return id; 
        } 
        
        public void setId(int id) { 
            this.id = id; 
        } 
    }</strong> 
              假设有三个学生:

                                         姓名       性别        ID
                                         宋超       男          100120
                                         伍星       男          100121
                                         宋超       女          100122
                把这三个学生存储在List里面,要求首先按照姓名进行排序,如果姓名相同就按照ID排序。
     
    1.1.1第一种实现方式:使用Comparable接口;
              使用这种方式时,Student类必须继承这个接口,并且实现compareTo方法。并且compareTo方法是这个接口的唯一方法。需要注意到一点,在《Effective Java》第十二条中,提供了一个通用的写法,也就是在类继承的Comparable接口的时候,利用泛型指明能比较的类型。把Student类改写如下:
                  
    [java] 


    package chapter1; 
      
    public classStudent implementsComparable<Student>{ 
        private String name; 
        private String gender; 
        private int id; 
        
        public String getName() { 
            return name; 
        } 
        
        public void setName(String name) { 
            this.name = name; 
        } 
        
        public String getGender() { 
            return gender; 
        } 
        
        public void setGender(Stringgender) { 
            this.gender = gender; 
        } 
        
        public int getId() { 
            return id; 
        } 
        
        public void setId(int id) { 
            this.id = id; 
        } 
      
        @Override 
        public int compareTo(Student arg0){ 
            //String、Integer、Double、Float等类型都实现有compareTo方法 
            if(this.name.compareTo(arg0.name) == 0) { 
                return Integer.valueOf(id).compareTo(Integer.valueOf(arg0.id)); 
            }else{ 
                return this.name.compareTo(arg0.name); 
            } 
        } 


     
    在《Effective Java》中对于compareTo方法有以下几点提示:
    ·自反性
    ·传递性
    ·对称性
    ·最好和equals方法值相同
     
    那么,在客户端调用的时候,直接写如下代码:

    [java] 


    package chapter1; 
      
    import java.util.ArrayList; 
    import java.util.Collections; 
    import java.util.List; 
      
    public class ClientInterface { 
                       publicstatic void main(String[] args) { 
                                
                                Studentsongchao = new Student(); 
                                songchao.setGender("Man"); 
                                songchao.setId(100150); 
                                songchao.setName("SongChao"); 
                                
                                Studentwuxing = new Student(); 
                                wuxing.setGender("Man"); 
                                wuxing.setId(100121); 
                                wuxing.setName("WuXing"); 
                                
                                Studentsongchao2 = new Student(); 
                                songchao2.setGender("Women"); 
                                songchao2.setId(100130); 
                                songchao2.setName("SongChao"); 
                                
                                List<Student>students = new ArrayList<Student>(); 
                                students.add(songchao); 
                                students.add(wuxing); 
                                students.add(songchao2); 
                                for(Studentstudent : students) { 
                                         System.out.println("Name  " + student.getName() + " ID  " + student.getId()); 
                                } 
                                
                                System.out.println(); 
                                
                                Collections.sort(students); 
                                for(Studentstudent : students) { 
                                         System.out.println("Name  " + student.getName() + " ID  " + student.getId()); 
                                } 
                       } 
                       

     

     
    输出结果如下:

    [java] 


    Name  SongChao ID  100150 
    Name  WuXing ID  100121 
    Name  SongChao ID  100130 
      
    Name  SongChao ID  100130 
    Name  SongChao ID  100150 
    Name  WuXing ID 100121 

     

     
    1.1.2另外一种方式:直接使用比较器comparator
     
             直接使用比较器的情况下,Student类不必继承Comparable接口,当然也不必实现compareTo方法。
             直接看调用代码,但是注意一点,这里的Student类没有继承Comparable接口。
             直接在上面的客户端代码中,把Collections.sort方法替换为:

    [java]


    Collections.sort(students, newComparator<Student>() { 
      
                @Override 
                public int compare(Student arg0,Student arg1) { 
                    if(arg0.getName().compareTo(arg1.getName())== 0) { 
                        return Integer.valueOf(arg0.getId()).compareTo(Integer.valueOf(arg1.getId())); 
                    } else { 
                        returnarg0.getName().compareTo(arg1.getName()); 
                    } 
                } 
                
            }); 

     

     
    输出结果和第一种方式相同。
    还有一个注意点,那就是排序的顺序,是按照由小到大还是由大到小。上面那种方式显然是从小到大排序,那么如何从大到小排序?只要改变参数顺序即可:
      
    [java] 


    Collections.sort(students,newComparator<Student>() { 
     
               @Override 
               public int compare(Student arg0,Student arg1) { 
                   if(arg1.getName().compareTo(arg0.getName()) == 0) { 
                       return Integer.valueOf(arg1.getId()).compareTo(Integer.valueOf(arg0.getId())); 
                   }else{ 
                       return arg1.getName().compareTo(arg0.getName()); 
                   } 
               } 
               
           }); 


     
    以上是对于sort方法的小总结,Arrays中的sort方法类似。
     
    第二节  Collections与Arrays概念分析
    1.2.1 Collection和Collections的区别
         Collection是java.util下的接口,是各种集合结构的父接口。继承它的接口主要有Set和List。
         Collections是java.util下的专用静态类,包含有各种有关集合操作的静态方法。提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
     
    1.2.2 Array与Arrays的区别
         Arrays也是一个静态类,专门用来操作array,提供搜索、排序等静态方法,还提供一个允许把数组当作列表查看的静态工厂方法asList。
     
     
    第三节  其它常用方法总结(第四节为使用中容易出现错误的方法介绍,第五节源代码)
    1.3.1 Collections中的常用方法
                java.util.Collections提供了一些静态方法实现了基于list容器的一些常用算法:
    1)  addAll(Collection c, T… elements);//将所有指定的元素添加到指定的collection中。
    2)  void sort(List);//对list容器里的元素进行排序
    3)  void reverse(List);//对List容器对象进行逆序排序
    4)  void copy(Listdest,List src)//将List src容器里的内容全部拷贝到List dest容器中
    5)   int binarySearch(List,Object)//对于顺序的List容器中采用折半查找的方法查找特定的对象
    6)   boolean disjoint(Collection c1, Collection c2);//如果两个指定的collection中没有相同的元素,返回true。
    7)   fill(List list, T obj); // 使用指定元素替换指定列表中的所有元素。
    8)   int frequency(Collection c, Object o);//返回指定的Collection中对于指定对象的元素数。
    9)   indexOfSubList(List src, List target);//返回源表中第一次出现指定目标列表的起始位置,如果没有这样的列表就返回-1。
    10) lastIndexOfSubList(List src, List target);//最后一次的起始位置,没有则返回-1
    11) max(Collection coll);//根据元素的自然顺序,返回collection的最大值;
    12) max(Collection coll,Comparator comp);//根据比较器产生的顺序,返回最大元素。
    13) min同上
    14) replaceAll(List list, T oldVal, T newVal);//使用另外一个值替换列表中出现的所有某一指定值。
    15) reverseOrder();//逆转comparable接口的对象collection的自然顺序。例如:假设a是一个字符串数组,那么:
    Arrays.sort(a, Collections.reverseOrder());将会按照字典逆序排序。
    16) reverseOrder(Comparator cmp);返回一个强行逆转比较器的顺序
    17) rotate(List list, intdistance);//根据指定的距离轮换列表中的元素。
    18) shuffle(List list);//对列表随机排序
    19) shuffle(List list, Random rnd);//根据指定的随机源排序
    20) swap(List list, int i, int j);//在指定列表的指定位置处交换元素

     
    [java] 


    package chapter1; 
     
    import java.util.ArrayList; 
    import java.util.Arrays; 
    import java.util.Collection; 
    import java.util.Collections; 
    import java.util.List; 
     
    public class CollectionsMethod { 
     
        /**
         * @param args
         */ 
        public static void main(String[] args) { 
            List<Integer> collection = new ArrayList<Integer>(); 
             
            /*1----两种方式 */ 
            Collections.addAll(collection, 1, 2, 3); 
            System.out.println(collection.toString()); 
             
            Integer[] moreInts = {10, 7, 4, 9}; 
            Collections.addAll(collection, moreInts); 
            System.out.println(collection.toString()); 
             
            /*2----简单类型下sort的使用 */ 
            Collections.sort(collection); 
            System.out.println(collection.toString()); 
             
            /*3----逆序*/  
            Collections.reverse(collection); 
            System.out.println(collection.toString()); 
             
            /*4----复制*/  
            List<Integer> copyList = new  ArrayList(Arrays.asList( new  Object[collection.size()])); 
            Collections.copy(copyList, collection); 
            copyList.remove(0); 
            System.out.println(copyList.size()); 
            System.out.println(copyList.toString()); 
            System.out.println(collection.toString()); 
             
            /*4----另外一种方式 */  
            List array = new ArrayList(collection); 
            System.out.println(array.toString()); 
            System.out.println(collection.toString()); 
             
            /*5----二分查找,首先把列表排序才行 */ 
            List<Integer> bsList = new ArrayList<Integer>(); 
            bsList.add(9); 
            bsList.add(12); 
            bsList.add(2); 
            bsList.add(78); 
            bsList.add(10); 
            System.out.println(bsList.toString());       
            Collections.sort(bsList); 
            System.out.println(bsList); 
            int index = Collections.binarySearch(bsList, 20); 
            System.out.println(index); 
             
            /*6----判定两个collection中是否没有相同的元素,返回布尔值*/ 
            System.out.println(Collections.disjoint(bsList, array)); 
             
            /*7----返回指定对象的个数*/ 
            System.out.println(Collections.frequency(bsList, 10)); 
             
            /*8----子列表在指定列表中的位置*/ 
            List<Integer> subList = new ArrayList<Integer>(); 
            subList.add(9); 
            subList.add(10); 
            subList.add(5); 
            subList.add(1); 
            System.out.println(Collections.indexOfSubList(bsList, subList)); 
             
            /*9----返回最大最小值 & 倒序 & 循环移位 & 交换*/ 
            System.out.println(Collections.max(subList)); 
            Collections.reverseOrder(); 
            System.out.println(subList.toString()); 
            Collections.rotate(subList, 2); 
            System.out.println(subList.toString()); 
            Collections.swap(subList, 0, 2); 
            System.out.println(subList.toString()); 
             
             
        } 
     


    1.3.2 Arrays中的常用方法
    Arrays中的方法比较简单,基本上分为
    1) asList方法,把一个数组转换成list
    2) 二分查找方法,可以指定在数组中的范围内执行
    3) toString方法
    4) sort方法
     
    第四节  容易出现错误的方法介绍
    1.4.1Collections中容易出现错误的方法介绍
        1)copy方法
    所以使用了Collections.copy()方法来进行拷贝,但是这样就接触到了此方法所报出的异常:
    举例如下:
    List src1 = new  ArrayList( 3 )
    src1.add( " a " );
    src2.add( " b " );
    src3.add( " c " );

    如果你使用下面方法copy链表
    /** **************************** */
    List des1 = new  ArrayList( 3 );www.2cto.com
    Collections.copy(des1,src1);
    /** **************************** */
    将会出错,抛出数组越界异常。明明已经设置了长度为3,为什么还会出错?
    打印出des1.size()才知道des1的长度为0;3表示的是这个List的容纳能力为3,并不是说des1中就有了3个元素。查看api才知 道,它的capacity(容纳能力大小)可以指定(最好指定)。而初始化时size的大小永远默认为0,只有在进行add和remove等相关操作 时,size的大小才变化。然而进行copy()时候,首先做的是将desc1的size和src1的size大小进行比较,只有当desc1的 size 大于或者等于src1的size时才进行拷贝,否则抛出IndexOutOfBoundsException异常。


    作者:Allen_Zhao_2012



    va中list里面存放map,根据map中的某两个个字段进行排序ja

    package com.compare.test;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    public class Main {
        public static void main(String[] args) {
            Main mainTest=new Main();
            mainTest.sortMap();
        }
        
        public  void sortMap(){
            List<Map<Integer, Double>> maps=new ArrayList<Map<Integer, Double>>();
            for(int i=0;i<10;i++){
                HashMap<Integer, Double> map=new HashMap<Integer, Double>();
                for(int j=0;j<2;j++){
                    map.put(j, Math.random());
                }
                maps.add(map);
            }
            
            for(Map<Integer, Double>  map:maps){
                System.out.println(getValue(map));
            }
            System.out.println("************************");
            Map<Integer, Double> currentMap;
            for(int i=0;i<maps.size()-1;i++){
                for(int j=0;j<maps.size()-i-1;j++){
                    if(getValue(maps.get(j))>getValue(maps.get(j+1))){
                        currentMap=maps.get(j+1);
                        maps.set(j+1, maps.get(j));
                        maps.set(j,currentMap);
                    }
                }
            }
            
            for(Map<Integer, Double>  map:maps){
                System.out.println(getValue(map));
            }
            
            
            
        }
        
        public Double getValue(Map<Integer, Double> currentMap){
            return currentMap.get(0)+currentMap.get(1);
        }
        
        
        
        
    }

    我采用最简单的排序大数沉底。而且getValue
    方法你可以自己实现,决定使用哪几个进行排序。(我们有进行key值不存在的判断)




    Java 对象多字段排序 Comparator


    Java 反射类:ReflexUtil

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    public class ReflexUtil {
         static Logger logger = LoggerFactory.getLogger(ReflexUtil. class );
     
         //getMethod
         static public Object invokeMethod(String propertiesName, Object object) {
             try {
                 if (object== null ) return null ;
                 if (!propertiesName.contains( "." )) {
                     String methodName = "get" +getMethodName(propertiesName);
                     Method method = object.getClass().getMethod(methodName);
                     return method.invoke(object);
                 }
                 String methodName = "get" +getMethodName(propertiesName.substring( 0 ,propertiesName.indexOf( "." )));
                 Method method = object.getClass().getMethod(methodName);
                 return invokeMethod(propertiesName.substring(propertiesName.indexOf( "." )+ 1 ), method.invoke(object));
     
             } catch (Exception e) {
                 logger.error(e.toString(), e);
                 return null ;
             }
         }
     
         private static String getMethodName(String fildeName) {
             byte [] items = fildeName.getBytes();
             items[ 0 ] = ( byte ) (( char ) items[ 0 ] - 'a' + 'A' );
             return new String(items);
         }
     
         public static void main(String args[]) {
             Video video = new Video();
             Album album = new Album();
             album.setAlbumId(346l);
             video.setAlbum(album);
             video.setVideoId(126l);
             System.out.println(ReflexUtil.invokeMethod( "album.albumId" , video));
         }
    }


    Java 对象排序 : CompareUtil


    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    public class CompareUtil {
     
         //sort 1正序 -1 倒序  filed 多字段排序
         public static <t> Comparator createComparator( int sort, String... filed) {
             return new ImComparator(sort, filed);
         }
     
         public static class ImComparator implements Comparator {
             int sort = 1 ;
             String[] filed;
     
             public ImComparator( int sort, String... filed) {
                 this .sort = sort == - 1 ? - 1 : 1 ;
                 this .filed = filed;
             }
     
             @Override
             public int compare(Object o1, Object o2) {
                 int result = 0 ;
                 for (String file : filed) {
                     Object value1 = ReflexUtil.invokeMethod(file, o1);
                     Object value2 = ReflexUtil.invokeMethod(file, o2);
                     if (value1 == null || value2 == null ) {
                         continue ;
                     }
                     if (!(value1 instanceof Integer) || !(value1 instanceof Integer)) {
                         continue ;
                     }
                     int v1 = Integer.valueOf(value1.toString());
                     int v2 = Integer.valueOf(value2.toString());
                     if (v1 == v2) continue ;
                     if (sort == 1 ) {
                         return v1 - v2;
                     } else if (sort == - 1 ) {
                         return v2 - v1;
                     } else {
                         continue ;
                     }
                 }
                 return result;
             }
         }
     
         public static void main(String args[]) {
             LabelAlbum label1 = new LabelAlbum();
             label1.setLabelId( 1 ); label1.setSequnces( 1 );
             LabelAlbum label2 = new LabelAlbum();
             label2.setLabelId( 1 );label2.setSequnces( 2 );
             LabelAlbum label3 = new LabelAlbum();
             label3.setLabelId( 3 ); label3.setSequnces( 4 );
             LabelAlbum label4 = new LabelAlbum();
             label4.setLabelId( 3 );label4.setSequnces( 3 );
             LabelAlbum label5 = new LabelAlbum();
             label5.setLabelId( 4 );label5.setSequnces( 2 );
             List<labelalbum> list = new ArrayList<labelalbum>();
             list.add(label1);
             list.add(label2);
             list.add(label3);
             list.add(label4);
             list.add(label5);
             Collections.sort(list, CompareUtil.createComparator( 1 , "labelId" , "sequnces" ));
             for ( int i = 0 ; i < list.size(); i++) {
                 LabelAlbum labelAlbum=list.get(i);
                 System.out.println( "labelId:" +labelAlbum.getLabelId()+ "  sequence:" +labelAlbum.getSequnces());
             }
         }
    }</labelalbum></labelalbum></t>







    mathmatic使用说明


    http://wenku.baidu.com/link?url=qdl5Oxq54mo3Qdm1DglICS0uADeQhiVw13lCjjw2T-vxbzTDOYurdOGsAqrPDoBAQ9p4wbPGxkmntfaiFrCEpcSClIhYhvMH0IAIP7-Rpkm


    http://wenku.baidu.com/link?url=ii01onq9srPE4pZoHLpm7oYp_S6xLeh0yMHAfKjO0Syp2eJtdxah055CRQQzVH01hsLzKzFuWySGAgoC1-mGnzOVowg3RTAtcnGS4Op494y



    展开全文
  • java浮点型比较大小

    千次阅读 2021-02-12 18:40:58
    ======1 java浮点型比较大小Float.parseFloat(String)和Float.valueOf(String).floatValue()的区别Float.parseFloat(String)表示 把String字符串转换成float原始类型的单精度数值,Float.parseFloat("")而Float.value...
  • Java对象内存大小计算

    万次阅读 多人点赞 2018-07-03 14:43:34
    最近在读《深入理解Java虚拟机》,对Java对象的内存布局有了进一步的认识,于是脑子里自然而然就有一很普通的问题,就是一个Java对象到底占用大内存? 在网上搜到了一篇博客讲的非常好:...
  • 今天做总结的时候发现java 8 比较list中对象的相关参数最大值时方法有四种方法之,做总结记录一下: 话不说上代码。 例子: 实体类: public class Transaction { private Trader trader; private int year; ...
  • java如何获取一个对象大小

    千次阅读 2019-09-25 13:21:51
    在内存足够用的情况下我们是不需要考虑java中一个对象所占内存大小的。但当一个系统的内存有限,或者某块程序代码允许使用的内存大小有限制,又或者设计一个缓存机制,当存储对象内存超过固定值之后写入磁盘做持久化...
  • java中类的对象比较大小进行排序,不像C++那样可以重载运算符比较大小java中需要实现特定的接口或者自己给类加上逻辑大小比较函数,个人认为有以下三种方式吧:一、类实现java.util.Comparator&lt;T&gt;...
  • 集合提供了一工具类:java.util.Collections 集合的工具类提供了若干静态方法,可以方便我们队集合做一系列操作,其中之一就是排序 需要注意,提供的方法只能对List集合排序,因为Set集合不全是有序的。 但是...
  • 解析一个Java对象占用多少内存空间

    万次阅读 2019-07-13 16:02:15
    说明: alignment, 对齐, 比如8字节的数据类型long, 在内存的起始地址必须是8的整数倍。 padding, 补齐; 在对象所占据空间的末尾,...一个对象具有100个属性, 与100个对象每个具有1个属性, 哪个占用的内存空间更大...
  • java list集合元素根据某些字段排序

    千次阅读 2021-03-17 03:52:46
    一、jdk1.6的环境下新建ComparatorSort类,并实现Comparator接口,重写compare方法降序排序:o1的元素&...o1的元素小于o2的元素,并返回-1在方法可对多个元素进行判断。import java.util.Comparator;import app.com...
  • Java中new一个对象的步骤:

    千次阅读 2021-01-27 18:16:34
    Java中new一个对象的步骤: 1.当虚拟机遇到一条new指令时候,首先去检查这个指令的参数是否能在常量池能否定位到一个类的符号引用(即类的带路径全名),并且检查这个符号引用代表的类是否已被加载、解析和初始...
  • Java对象大小内幕浅析

    万次阅读 2016-03-29 18:59:00
     如果:你能算出new String(“abc”)这个对象在JVM占用内存大小(64位JDK7压缩大小48B,未压缩大小64B), 那么看到这里就可以结束了~ Java对象的内存布局:对象头(Header),实例数据(Instance Data)和对齐...
  • 个Java对象和Hashmap对象占用大内存

    万次阅读 多人点赞 2019-12-03 21:47:35
    1、JAVA 对象布局1.1对象头(Header):1.2实例数据(Instance Data)1.3对齐填充(Padding)2、Java数据类型有哪些2.1基础数据类型内存占用如下2.2引用类型 内存占用如下:2.3字段重排序3、验证3.1有一Fruit类...
  • 如何计算Java对象所占内存的大小

    万次阅读 多人点赞 2018-05-24 11:42:12
    摘要:本文以如何计算Java对象占用内存大小为切入点,在讨论计算Java对象占用堆内存大小的方法的基础上,详细讨论了Java对象头格式并结合JDK源码对对象的协议字段做了介绍,涉及内存模型、锁原理、分代GC、OOP-...
  • Java中的long类型和Long类型比较大小

    千次阅读 2021-02-27 23:10:21
    ”、“==”、“Java中Long和long的区别Java的数据类型分为两种:1、基本类型:byte(8),short(16),int(32),long(64),float(32),double(64),char(16),boolean(1)2、对象类型:Byte,Short,Integer,Long,Float,Double...
  • 要看的懂对象的创建过程,首先你得有对Java虚拟机和Java基础以及JUC很是熟悉,比如类的加载过程,CAS、线程、JVM的GC等等 首先好看一图,我大概会根据图的内容来分享这六步骤(其实几步骤不重要,只要包括...
  • 当是单个字符时时是可以用“==”比较32313133353236313431303231363533e58685e5aeb931333365643661的,但是当为字符串时则不可以,应用比较函数strcmp进行比较,strcmp函数在头文件"string.h",所以要用这函数时...
  • 里面有获取所有表名、字段字段类型等(还在不断更新功能…),之前项目有需求,前端人员将一关联表id给我,我查出有存储多少表名,在把这些表的字段和类型都集合在一起返回给他,每个字段字段类型都有边上...
  • java List多字段排序

    千次阅读 2016-09-04 15:14:08
    对于一个对象,它有多个属性值,可能会根据不同的属性值对集合有个排序。 对集合的排序,主要是用到的是Collections.sort(List, Comparator)方法,或者是List.sort(Comparator c)两个方法,里面实现了compare()...
  • 测量Java对象所占内存大小

    万次阅读 2017-12-17 00:40:22
    背景: 相信大部分人都不会关注这个问题吧,只有一些偏执...方法一设置-Xms和-Xmx的大小,然后在程序循环new对象,直到发生OOM异常,记录下此时new了多少个对象,大家觉得这种方法可靠不?下面放上设置参数以及测试代
  • Java对象创建过程

    万次阅读 2022-03-28 17:54:13
    java对象创建过程、对象的组成、对象头、实例数据、对齐填充、对象创建方式、new关键字、Class类的newInstance方法、Constructor类的newInstance方法、Object类的clone方法、反序列化、无父类的对象创建、有父类的...
  • 个Java对象到底占用大内存

    千次阅读 2019-01-04 16:02:42
    做JVM调优,做内存监控与优化,但是一个Java对象到底占用大内存空间呢? 细探究,Java对象创建的奥秘一文讲述了Java对象的内存布局:对象头(Header),实例数据(Instance Data)和对齐填充(Padding)。另外:...
  • javaList集合各种情况对比处理

    千次阅读 2021-03-04 04:51:08
    Lambda作为函数式编程的基础部分,在其他编程语言(例如:Scala)早就广为使用,但在JAVA领域发展较慢,直到java8,才开始支持Lambda。抛开数学定义不看,直接来认识Lambda。Lambda表达式本质上是匿名方法,其...
  • Java类属性字段校验(validation的使用)1、需求来源:日常校验需求2、validation介绍2-1、常见的注解2-2、快速入门1、简单校验2、自定义校验注解3、通用的Validtor校验工具类 1、需求来源:日常校验需求 日常开发...
  • 首先把引入题目表述的清楚一些,在一个List存储的是一些对象实例,而对象实例包含多个属性字段,我们要根据对象的某个或者多个属性来对List进行排序。 假设List存储的都是Student类的实例,Student类包含name、...
  • java字符串如何判断字符的类型

    千次阅读 2021-03-06 14:58:28
    展开全部public static void main(String[] args) {String str="ABC_001";if(str.indexOf("ABC")!=-1){System.out.println("包含");...}}js 判断字符串是否包含某字符串,String对象中查找子字323131333532363134...
  • JVM成神之路-Java对象模型

    千次阅读 2018-07-23 15:01:17
    个Java对象可以分为三部分存储在内存,分别是:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。 对象头(包含锁状态标志,线程持有的锁等标志) 实例数据 对齐填充 oop-klass model(...
  • 目录1 Date类1.1 概述1.2 Date类构造方法2 DateFormat类2.1 其子类SimpleDateFormat的构造方法2.2 DateFormat类常用方法2.2.1 format方法...java.util.Date类表示特定的瞬间,精确到毫秒。Date类的构造函数可以把毫

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 150,239
精华内容 60,095
关键字:

java比较多个对象中的时间字段大小