精华内容
下载资源
问答
  • 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
    publicclass ReflexUtil {
        staticLogger logger = LoggerFactory.getLogger(ReflexUtil.class);
     
        //getMethod
        staticpublic Object invokeMethod(String propertiesName, Object object) {
            try{
                if(object==null)returnnull;
                if(!propertiesName.contains(".")) {
                    String methodName = "get"+getMethodName(propertiesName);
                    Method method = object.getClass().getMethod(methodName);
                    returnmethod.invoke(object);
                }
                String methodName = "get"+getMethodName(propertiesName.substring(0,propertiesName.indexOf(".")));
                Method method = object.getClass().getMethod(methodName);
                returninvokeMethod(propertiesName.substring(propertiesName.indexOf(".")+1), method.invoke(object));
     
            }catch(Exception e) {
                logger.error(e.toString(), e);
                returnnull;
            }
        }
     
        privatestatic String getMethodName(String fildeName) {
            byte[] items = fildeName.getBytes();
            items[0] = (byte) ((char) items[0] - 'a'+ 'A');
            returnnew String(items);
        }
     
        publicstatic void main(String args[]) {
            Video video = newVideo();
            Album album = newAlbum();
            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
    publicclass CompareUtil {
     
        //sort 1正序 -1 倒序  filed 多字段排序
        publicstatic <t> Comparator createComparator(intsort, String... filed) {
            returnnew ImComparator(sort, filed);
        }
     
        publicstatic class ImComparator implementsComparator {
            intsort = 1;
            String[] filed;
     
            publicImComparator(intsort, String... filed) {
                this.sort = sort == -1? -1: 1;
                this.filed = filed;
            }
     
            @Override
            publicint compare(Object o1, Object o2) {
                intresult = 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 instanceofInteger) || !(value1 instanceofInteger)) {
                        continue;
                    }
                    intv1 = Integer.valueOf(value1.toString());
                    intv2 = Integer.valueOf(value2.toString());
                    if(v1 == v2) continue;
                    if(sort == 1) {
                        returnv1 - v2;
                    }elseif (sort == -1) {
                        returnv2 - v1;
                    }else{
                        continue;
                    }
                }
                returnresult;
            }
        }
     
        publicstatic void main(String args[]) {
            LabelAlbum label1 = newLabelAlbum();
            label1.setLabelId(1); label1.setSequnces(1);
            LabelAlbum label2 = newLabelAlbum();
            label2.setLabelId(1);label2.setSequnces(2);
            LabelAlbum label3 = newLabelAlbum();
            label3.setLabelId(3); label3.setSequnces(4);
            LabelAlbum label4 = newLabelAlbum();
            label4.setLabelId(3);label4.setSequnces(3);
            LabelAlbum label5 = newLabelAlbum();
            label5.setLabelId(4);label5.setSequnces(2);
            List<labelalbum> list = newArrayList<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(inti = 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计算一个对象占用内存的大小

    千次阅读 2015-05-27 17:13:02
    Java计算一个对象占用内存的大小


    在C/C++中计算某一个基本类型或者对象占用内存大小的方法很简单,只要调用库里面的sizeof()操作符即可,但是在Java的API里面并没有给我们提供类似的方法。那么我们可不可以自己实现一个Java中的sizeof()方法呢?答案是肯定的。为了计算一个Java对象占用内存的大小,首先你得对Java对象的内存结构有所了解。如果你还不了解,请先阅读Java内存结构

    首先介绍一下sun.misc.Unsafe类,该类是Java中很神奇的一个类,这个类是用于执行低级别、不安全操作的方法集合。尽管这个类和所有的方法都是公开的(public),但是这个类的使用仍然受限,你无法在自己Java程序中直接使用该类,因为它的构造函数是私有的(private)


    Unsafe类的更多介绍和用法可以参照http://mishadoff.github.io/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/

    </pre><pre name="code" class="java">package size;
    
    import java.lang.reflect.Array;
    import java.lang.reflect.Field;
    import java.lang.reflect.Modifier;
    
    import sun.misc.Unsafe;
    
    public class UnsafeTest {
    	/** 对象头部的大小 */
    	private static final int OBJECT_HEADER_SIZE = 8;
    	/** 对象占用内存的最小值 */
    	private static final int MINIMUM_OBJECT_SIZE = 8;
    	/** 对象按多少字节的粒度进行对齐 */
    	private static final int OBJECT_ALIGNMENT = 8;
    
    	public static long sizeOf(Object obj) {
    		// 获得Unsafe实例
    		Unsafe unsafe;
    		try {
    			Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
    			unsafeField.setAccessible(true);
    			unsafe = (Unsafe) unsafeField.get(null);
    		} catch (Throwable t) {
    			unsafe = null;
    		}
    
    		// 判断对象是否为数组
    		if (obj.getClass().isArray()) {
    			Class<?> klazz = obj.getClass();
    			int base = unsafe.arrayBaseOffset(klazz);
    			int scale = unsafe.arrayIndexScale(klazz);
    			long size = base + (scale * Array.getLength(obj));
    			if ((size % OBJECT_ALIGNMENT) != 0) {
    				size += OBJECT_ALIGNMENT - (size % OBJECT_ALIGNMENT);
    			}
    			return Math.max(MINIMUM_OBJECT_SIZE, size);
    		} else {
    			// 如果数组对象则迭代遍历该对象的父类,找到最后一个非静态字段的偏移量
    			for (Class<?> klazz = obj.getClass(); klazz != null; klazz = klazz
    					.getSuperclass()) {
    				long lastFieldOffset = -1;
    				for (Field f : klazz.getDeclaredFields()) {
    					if (!Modifier.isStatic(f.getModifiers())) {
    						lastFieldOffset = Math.max(lastFieldOffset,
    								unsafe.objectFieldOffset(f));
    					}
    				}
    				if (lastFieldOffset > 0) {
    					lastFieldOffset += 1;
    					if ((lastFieldOffset % OBJECT_ALIGNMENT) != 0) {
    						lastFieldOffset += OBJECT_ALIGNMENT
    								- (lastFieldOffset % OBJECT_ALIGNMENT);
    					}
    					return Math.max(MINIMUM_OBJECT_SIZE, lastFieldOffset);
    				}
    			}
    			// 该对象没有任何属性
    			long size = OBJECT_HEADER_SIZE;
    			if ((size % OBJECT_ALIGNMENT) != 0) {
    				size += OBJECT_ALIGNMENT - (size % OBJECT_ALIGNMENT);
    			}
    			return Math.max(MINIMUM_OBJECT_SIZE, size);
    		}
    	}
    
    	public static void main(String[] args) throws InterruptedException {
    
    		OpusVoiceInfo voice = new OpusVoiceInfo();
    		
    		OpusVoiceInfo voicex = new OpusVoiceInfo();
    		voicex.setOpusId(8888888888888888888L);
    		voicex.setOpusId2(8888888888888888888L);
    		voicex.setOpusId3(8888888888888888888L);
    		voicex.setOpusId4(8888888888888888888L);
    
    		OpusVoiceInfo2 voice2 = new OpusVoiceInfo2();
    
    		System.out.println(UnsafeTest.sizeOf(voice));// 输出
    		System.out.println(UnsafeTest.sizeOf(voicex));
    		System.out.println("voice2:" + UnsafeTest.sizeOf(voice2));// 输出
    
    		Thread.sleep(100000);// 阻塞线程,为了使用jmap工具
    	}
    }
    
    /**
    output:
    72
    72
    voice2:56
    */


    jmap 查看 一致的:OK 

    jmap -histo PID | findstr ObjName

    打印出某个java进程(使用pid)内存内的,所有‘对象’的情况(如:产生那些对象,及其数量)。

    可以输出所有内存中对象的工具,甚至可以将VM 中的heap,以二进制输出成文本。使用方法 jmap -histo pid。如果连用SHELL jmap -histo pid>a.log可以将其保存到文本中去,在一段时间后,使用文本对比工具,可以对比出GC回收了哪些对象。jmap -dump:format=b,file=outfile 3024可以将3024进程的内存heap输出出来到outfile文件里,再配合MAT(内存分析工具(Memory Analysis Tool),使用参见:http://blog.csdn.net/fenglibing/archive/2011/04/02/6298326.aspx)或与jhat (Java Heap Analysis Tool)一起使用,能够以图像的形式直观的展示当前内存是否有问题。

    64位机上使用需要使用如下方式:

    jmap -J-d64 -heap pid

    2、命令格式


    SYNOPSIS

    jmap [ option ] pid

    jmap [ option ] executable core

    jmap [ option ] [server-id@]remote-hostname-or-IP

    3、参数说明


    1)options: 

    executable Java executable from which the core dump was produced.

    (可能是产生core dump的java可执行程序)

    core 将被打印信息的core dump文件

    remote-hostname-or-IP 远程debug服务的主机名或ip

    server-id 唯一id,假如一台主机上多个远程debug服务 

    2)基本参数:

    -dump:[live,]format=b,file=<filename> 使用hprof二进制形式,输出jvm的heap内容到文件=. live子选项是可选的,假如指定live选项,那么只输出活的对象到文件. 

    -finalizerinfo 打印正等候回收的对象的信息.

    -heap 打印heap的概要信息,GC使用的算法,heap的配置及wise heap的使用情况.

    -histo[:live] 打印每个class的实例数目,内存占用,类全名信息. VM的内部类名字开头会加上前缀”*”. 如果live子参数加上后,只统计活的对象数量. 

    -permstat 打印classload和jvm heap长久层的信息. 包含每个classloader的名字,活泼性,地址,父classloader和加载的class数量. 另外,内部String的数量和占用内存数也会打印出来. 

    -F 强迫.在pid没有相应的时候使用-dump或者-histo参数. 在这个模式下,live子参数无效. 

    -h | -help 打印辅助信息 

    -J 传递参数给jmap启动的jvm. 

    pid 需要被打印配相信息的java进程id,创业与打工的区别 - 博文预览,可以用jps查问.

    4、使用示例


    1)[fenglb@ccbu-156-5 ~]$ jmap -histo 4939

    [输出较多这里不贴了]

    2)[fenglb@ccbu-156-5 ~]$ jmap -dump:format=b,file=test.bin 4939

    Dumping heap to /home/fenglb/test.bin ...

    Heap dump file created






    展开全文
  • java Api接口判断传入的对象以及对象字段是否为空

    常见的未封装的api接口我们会这么写,来判断这个传入参数是否为空,来输出什么什么参数为空

    if(Stringutils.isEmpty(vo.getName())) {

    return "name参数为空";

    }

    if(Stringutils.isEmpty(vo.getAge())) {

    return "age参数为空";

    }


    下面使用工具类封装的方式校验传入对象的指定参数是否为空,较为简便。

    缺点:

    并没有对list或者map中的某字段是否为空做判断,只做了大小和非空的判断

    public class ArrayIsNotNull {
    
    	public static boolean isNull(Object o) {
            boolean result = false;
            if (null == o) {
                result = true;
            } else if (o instanceof List) {
                result = ((List) o).size() == 0;
            } else if (o instanceof Map) {
                result = ((Map) o).isEmpty();
            } else if (o.getClass() == String.class) {
                result = isEmpty(o.toString());
            }
            return result;
        }
    	
    	public static  boolean isEmpty(String s) {
        	boolean result=false;
        	if("".equals(s)) {
        		result=true;
        	}
        	return result;
        }
    	
    	public static void isNullAndThrowExp(String[] msg, Object... o) throws Exception {
            if (null != o && msg.length>0) {
                for (int i = 0; i < o.length; i++) {
                    if (isNull(o[i])) {
                    	String name=i < msg.length ? msg[i] : "";
                    	System.out.println("第"+i+"个参数"+name+"为空!");
                        throw new Exception();
                    }
                }
            }else{
            	System.out.println("传入对象为null");
            	throw new Exception();
            }
        }
    	
    	public static void main(String[] args) throws Exception {
    		Student student=new Student();
    		student.setAge(11);
    		student.setNameString("name");
    		student.setPeople(true);
    		ArrayList<Object> list=new ArrayList<Object>();
    		//list.add("");
    		student.setList(list);
    		Map<Object, Object> map=new HashMap<Object, Object>();
    		map.put("", "");
    		student.setMap(map);
    		
    		isNullAndThrowExp(new String[]{"age","nameString","isPeople","list","map"},student,student.getAge(),student.getNameString(),student.isPeople(),student.getList(),student.getMap());
    		
    	}


    student对象,get set略

    public class Student {
    
    	private String nameString;
    	private int age;
    	private boolean isPeople;
    	private ArrayList<Object> list;
    	private Map<Object, Object> map;
    	



    展开全文
  • 现有多个对象,存储每个租户的视频/音频/图片大小,对象结构如下 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对象大小内幕浅析

    万次阅读 2016-03-29 18:59:00
     如果:你能算出new String(“abc”)这个对象在JVM占用内存大小(64位JDK7压缩大小48B,未压缩大小64B), 那么看到这里就可以结束了~ Java对象的内存布局:对象头(Header),实例数据(Instance Data)和对齐...
  • 小编这里不赘言,直接举栗子。 Product [] data = new Product[5]; //定义Product对象的参数为名称和价格 data[0] = new Product("iphone", 10800); data[0] = new Product("vivo", 3589); data[0] = new ...
  • Java对象内存大小计算

    千次阅读 2018-07-03 14:43:34
    最近在读《深入理解Java虚拟机》,对Java对象的内存布局有了进一步的认识,于是脑子里自然而然就有一很普通的问题,就是一个Java对象到底占用大内存? 在网上搜到了一篇博客讲的非常好:...
  • 集合提供了一工具类:java.util.Collections 集合的工具类提供了若干静态方法,可以方便我们队集合做一系列操作,其中之一就是排序 需要注意,提供的方法只能对List集合排序,因为Set集合不全是有序的。 但是...
  • 首先把引入题目表述的清楚一些,在一个List存储的是一些对象实例,而对象实例包含多个属性字段,我们要根据对象的某个或者多个属性来对List进行排序。 假设List存储的都是Student类的实例,Student类包含name、...
  • java List多字段排序

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

    万次阅读 热门讨论 2011-12-13 22:18:49
    关于java对象的大小测量,网上有很例子,大多数是申请一个对象后开始做GC,后对比前后的大小,不过这样,虽然说这样测量对象的大小是可行的,不过未必是完全准确的,因为过程包含对象本身的开销,也许你运气好,...
  • 1、JAVA 对象布局1.1对象头(Header):1.2实例数据(Instance Data)1.3对齐填充(Padding)2、Java数据类型有哪些2.1基础数据类型内存占用如下2.2引用类型 内存占用如下:2.3字段重排序3、验证3.1有一Fruit类...
  • 里面有获取所有表名、字段字段类型等(还在不断更新功能…),之前项目有需求,前端人员将一关联表id给我,我查出有存储多少表名,在把这些表的字段和类型都集合在一起返回给他,每个字段字段类型都有边上...
  • 测量Java对象所占内存大小

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

    万次阅读 多人点赞 2018-05-24 11:42:12
    摘要:本文以如何计算Java对象占用内存大小为切入点,在讨论计算Java对象占用堆内存大小的方法的基础上,详细讨论了Java对象头格式并结合JDK源码对对象的协议字段做了介绍,涉及内存模型、锁原理、分代GC、OOP-...
  • 对象 List 根据的某一字段过滤、排序,使用 Java8 stream 的 map 操作实现非常便捷。 示例代码如下: List<String> newList = objectList.stream().filter(object -> object.getVar().equals("Value")) ...
  • 我们利用JDK的sun.misc.Unsafe来计算下字段的偏移地址,一则验证下之前文章的结论,再则跟jol输出结果对比下。通过上面的几段代码,我们可以成功获取类各个字段的偏移地址,这跟jol工具的输出结果和我们的结论...
  • 引入题目:List的数据如何根据对象的某一个或多个字段排序?   第一节 对于引入题目的探讨 首先把引入题目表述的清楚一些,在一个List存储的是一些对象实例,而对象实例包含多个属性字段,我们要根据...
  • JVM —— Java 对象占用空间大小计算

    万次阅读 2016-03-22 22:04:30
    为什么要知道 Java 对象占用空间大小Java 里面一切都是对象,每天都在使用的 Java 对象占据多少内存空间,原来竟是这样...
  • 今天做总结的时候发现java 8 比较list中对象的相关参数最大值时方法有四种方法之,做总结记录一下: 话不说上代码。 例子: 实体类: public class Transaction { private Trader trader; private int year; ...
  • 个Java对象到底占用大内存

    千次阅读 2019-01-04 16:02:42
    做JVM调优,做内存监控与优化,但是一个Java对象到底占用大内存空间呢? 细探究,Java对象创建的奥秘一文讲述了Java对象的内存布局:对象头(Header),实例数据(Instance Data)和对齐填充(Padding)。另外:...
  • 文章目录简介对象和其隐藏的秘密Object对象头数组对象头整个对象的结构 简介 ...接下来我们来对这个java对象的鼻祖进行一详细的解剖分析,从而理解JVM的深层次的秘密。 工具当然是使用JOL: @Slf4j
  • Java对象的字节大小计算

    万次阅读 2018-05-06 17:34:55
    计算Java对象的字节大小 Java基本类型长度及对应对象的字节长度 基本类型 长度 the size of an object Int 4 16 Short 2 16 Long 8 24 Byte 1 16 Character 1 16 Float 4 ...
  • 个java对象到底占大内存?

    千次阅读 2015-02-09 22:01:42
    最近在读《深入理解Java虚拟机》,对Java对象的内存布局有了进一步的认识,于是脑子里自然而然就有一很普通的问题,就是一个Java对象到底占用大内存? 在网上搜到了一篇博客讲的非常好:...
  • 在前面文章了解到Java对象实例是如何在Java创建的,下面我们详细了解Java普通对象创建后,在HotSpot虚拟机Java的内存布局是怎样的,可以分为3区域:对象头(Header)、实例数据(Instance)和对齐填充...
  • 基于Java基础-面向对象实现植物大战僵尸简易版

    万次阅读 多人点赞 2019-03-31 15:15:44
    从零开始学习的Java的第一月,在面向对象(OOP)的学习,跟着讲师完成了飞机大战的游戏编码。第二月开始接触API,心血来潮便结合API的集合、线程开始植物大战僵尸的编码,从游戏模式的设计到游戏内容的实现...
  • 解析一个Java对象占用多少内存空间

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 125,054
精华内容 50,021
关键字:

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

java 订阅