J2SE5.0新特性

[1]J2SE5.0新特性之静态导入

J2se5.0之前，如果需要使用其他类的静态方法，如java.lang.Math中的方法，需要写以下的代码：

double value = Math.log(100)*Math.PI;

 

现在你只需在静态导入，然后就可以直接在代码中使用静态方法和静态字段：

import static java.lang.Math.*;
…

double value = log(100)*PI;

 

 

看一个详细的例子。我们先建一个包含一个静态方法和一个静态字段的类：

2. package com.kuaff.jdk5;
4.  
6. public class StaticClass
8. {
10.     public static String LABEL = "中国古代名剑";
12.  
14.     public static void printList()
16.     {
18.         String[] swords = new String[] { "轩辕夏禹剑", "湛泸", "赤霄", "太阿", "龙渊", "干将", "莫邪", "鱼肠", "纯钧", "承影" };
20.         for (String name : swords)
22.         {
24.             System.out.printf("%s%n", name);
26.         }
28.     }
30. }
31.  
33.  

新建一个类，静态导入上面的字段和方法，并使用它们：

2. package com.kuaff.jdk5;
4.  
6. import static com.kuaff.jdk5.StaticClass.*;//静态导入
8.  
10. public class StaticImportShow
12. {
14.     public void testSI()
16.     {
18.         System.out.printf("%s:%n",LABEL);
20.         printList();
22.     }
24.     public static void main(String[] args)
26.     {
28.         StaticImportShow show = new StaticImportShow();
30.         show.testSI();
32.     }
34. }

[2]J2SE5.0新特性之Foreach

<script language="javascript" type="text/javascript"> showbanner(6,6,1); </script> <script type="text/javascript"> google_ad_client ="pub-2141342037947367";google_ad_width = 120;google_ad_height =240;google_ad_format = "120x240_as";google_ad_channel="8570654326";google_color_border = "CCCCCC";google_color_bg ="FFFFFF";google_color_link = "000000";google_color_url ="666666";google_color_text = "333333"; </script> <script src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type="text/javascript"> </script>

C＃中提供了Foreach的用法:

foreach (string item in f)

{

   Console.WriteLine(item);

}
 

Java也增加了这样的功能：

package com.kuaff.jdk5;

 

import java.util.*;

import java.util.Collection;

 

 

public class Foreach

{

    private Collection<String> c = null;

    private String[] belle = new String[4];

    public Foreach()

    {

        belle[0] = "西施";

        belle[1] = "王昭君";

        belle[2] = "貂禅";

        belle[3] = "杨贵妃";

        c = Arrays.asList(belle);

    }

    public void testCollection()

    {

        for (String b : c)

        {

              System.out.println("曾经的风化绝代:" + b);

        }

    }

    public void testArray()

    {

        for (String b : belle)

        {

              System.out.println("曾经的青史留名:" + b);

        }

    }

    public static void main(String[] args)

    {

        Foreach each = new Foreach();

        each.testCollection();

        each.testArray();

    }

}
 

对于集合类型和数组类型的，我们都可以通过foreach语法来访问它。上面的例子中，以前我们要依次访问数组，挺麻烦：

for (int i = 0; i < belle.length; i++)

{

        String b = belle[i];

        System.out.println("曾经的风化绝代:" + b);

}
 

现在只需下面简单的语句即可：

for (String b : belle)

{

       System.out.println("曾经的青史留名:" + b);

 }
 

对集合的访问效果更明显。以前我们访问集合的代码：

for (Iterator it = c.iterator(); it.hasNext();)

{

        String name = (String) it.next();

        System.out.println("曾经的风化绝代:" + name);

}
 

现在我们只需下面的语句：

for (String b : c)

{

        System.out.println("曾经的风化绝代:" + b);

}
 

 

Foreach也不是万能的，它也有以下的缺点：

在以前的代码中,我们可以通过Iterator执行remove操作。

for (Iterator it = c.iterator(); it.hasNext();)

{

       itremove()

}

 

但是，在现在的foreach版中，我们无法删除集合包含的对象。你也不能替换对象。

同时，你也不能并行的foreach多个集合。所以，在我们编写代码时，还得看情况而使用它。
[3]J2SE5.0新特性之枚举类型

J2SE5.0新特性之枚举类型

 在传统的设计中，为了达到c、c++的枚举的功能，我们一般在类中声明几个常量:

public static final String BELLE_XISHI = “西施”;

public static final String BELLE_WANGZHAOJUN = “王昭君”;

public static final String BELLE_DIAOCHAN = “貂禅”;

public static final String BELLE_YANGGUIFEI = “杨贵妃”;

 

然而，这样做有些问题:

1.       不是类型安全的:因为被声明为String类型，您可以给它们赋值任意的字符串，而且，有可能两个常量的值相同。

2.       没有命名空间:为了区别与非分类，我们定义的常量以BELLE做前缀。

3.       脆弱:一旦被编译后，如果想插入常量，或者他们的顺序和值被更改，使用它们的程序需要重新编译。

4.       打印值代表的意义不明显。

 

现在，在新的Java语言中，已经可以使用枚举类型解决上面的问题，我们首先以一个例子来看一下枚举类型是怎么工作的。

2. package com.kuaff.jdk5;
4.  
6. public class EnumShow1
8. {
10.     enum Belle
12.     {
14.         西施, 
16.         貂禅, 
18.         王昭君, 
20.         杨贵妃,
22.     }
24.     
26.     public static void main(String[] args)
28.     {
30.         EnumShow1 show = new EnumShow1();
32.         for (Belle belle : Belle.values())
34.         {
36.             System.out.printf("美女的名字=%s%n", belle);
38.         }
40.     }
42. }
43.  

这里定义了一个枚举类型Belle(美女)。它四个值：西施、貂禅、王昭君和杨贵妃。注意，这里的值可是中文。

通过Belle.values()方法可以得到Belle枚举类型的所有的值，它返回一个包含Belle值的数组。

这样我们就可以通过belle.getName()或者belle.toString()得到枚举值。

 

注意：这里用到了printf方法和Foreach类型的循环，在后面的文章中会对这些新特性进行介绍。

 

事实上，每个枚举值可以设置多个参数，我们将上面的例子扩充一下：

2. package com.kuaff.jdk5;
4.  
6. public class EnumShow2
8. {
10.     enum Belle
12.     {
14.         西施("春秋战国", "范蠡,勾践,夫差"), 
16.         王昭君("西汉", "刘?,毛延寿,呼韩邪单于"),
18.         貂禅("三国", "吕布,董卓"), 
20.         杨贵妃("唐朝", "李隆基");
22.         private final String empire;
24.         private final String mans;
26.         private Belle(String empire, String mans)
28.         {
30.             this.empire = empire;
32.             this.mans = mans;
34.         }
36.     }
38.     public static void main(String[] args)
40.     {
42.         EnumShow2 show = new EnumShow2();
44.         for (Belle belle : Belle.values())
46.         {
48.             System.out.printf("美女的名字:%s,  生活年代:%s,  美女身后的相关男人:%s%n",belle,belle.empire,belle.mans);
50.         }
52.     }
54. }
55.  

在这个例子中，我们为每位美人都加了一个生活年代和相关的男人这两个参数。

这里必须有Belle(String empire, String mans)这样一个构造方法。对每个枚举值，可以象使用对象一样使用它，要得到它的参数，可以通过  枚举对象.参数   方式访问。如果反编译以下它的类，事实上，java编译器也是把它编译成一个类：

static class EnumShow2$Belle extends Enum

{

       …

}

 

以上两个例子可以在Eclipse 3.1M3下编译通过，现在的Eclipse3.1M3已经对JDK5达到了97%的支持。

 

既然它被编译成了类，我们也会联想到，类可以有方法的，枚举类型是不是页支持方法内呢？是！

我们在扩充一下上面的例子，为每个美人增加一个显示其生平事件的方法：

2. package com.kuaff.jdk5;
4.  
6. public class EnumShow3
8. {
10.     enum Belle
12.     {
14.         西施("春秋战国", "范蠡,勾践,夫差")
16.         {
18.             String mainEvent()
20.             {
22.                 return "为勾践,嫁夫差,与范蠡泛西湖终老";
24.             }
26.         }, 
28.         王昭君("西汉", "刘?,毛延寿,呼韩邪单于")
30.         {
32.             String mainEvent()
34.             {
36.                 return "毛延寿，不厚道，刘?不走访基层，不听群众意见，昭君和亲，青冢埋芳泽";
38.             }
40.         }, 
42.         貂禅("三国", "吕布,董卓")
44.         {
46.             String mainEvent()
48.             {
50.                 return "红颜真祸水乎？男人好色而已!";
52.             }
54.         }, 
56.         杨贵妃("唐朝", "李隆基")
58.         {
60.             String mainEvent()
62.             {
64.                 return "温泉在，佳人无，长生殿内暗伤神，却闻凤凰东度。";
66.             }
68.         }
70.         ;
72.  
74.         private final String empire;
76.  
78.         private final String mans;
80.  
82.         private Belle(String empire, String mans)
84.         {
86.             this.empire = empire;
88.             this.mans = mans;
90.         }
92.         abstract String mainEvent();
94.          
96.         
98.     }
100.  
102.     public static void main(String[] args)
104.     {
106.         EnumShow3 show = new EnumShow3();
108.  
110.         for (Belle belle : Belle.values())
112.         {
114.             System.out.printf("美女的名字:%s,  生活年代:%s,  美女身后的相关男人:%s%n",belle,belle.empire,belle.mans);
116.             System.out.printf("   相关事件:%s%n", belle.mainEvent() );
118.         }
120.     }
122. }
123.  

我们为每个美人增加了一个方法String mainEvent()；同时，我们也必须在此枚举类型内增加一个抽象的方法声明：abstract String mainEvent();

和类型一样，通过 枚举对象.方法(…)  来调用枚举类型的方法。

 

上面的例子在eclipse 3.1M3下显示有错误，因为目前的eclipse还认为抽象方法只能在抽象类中声明，没关系，在命令行中直接编译吧: javac -source 5 -target 5 -d bin src/com/kuaff/jdk5/EnumShow3.java。
[4]J2SE5.0新特性之元数据

元数据，在java中也叫注释、注解。微软的.net从开始设计时就有这个功能，不过它的术语叫属性。

这时一个强大的功能，程序员如果想挣钱，得好好研究它，因为

在将来的j2ee开发中，广泛的使用它，包括ejb的声明,IOC中的注入等。

 

IBM网站有篇文章详细介绍了它，挺好的一篇文章。

http://www-900.ibm.com/developerWorks/cn/java/j-annotate1/

http://www-900.ibm.com/developerworks/cn/java/j-annotate2.shtml

 

我曾兴致勃勃的根据例子在eclipse中测试了一把，可怎么也得不到注释信息。后来，在命令行直接编译java文件，运行才正常。虽然现在的eclipse 编辑器可以识别java的注释语法，但是在编译的时候并没有生成带注释的java类。我没有仔细深究，可能时eclipse在编译的时候枚加上-target 5参数吧，猜测而已。

 

新建一个注释类型，这个类型指明了一本名著的作者和他的email。

2. package com.kuaff.jdk5;
4.  
6. import java.lang.annotation.*;
8.  
10. @Retention(RetentionPolicy.RUNTIME)
12. @Target(ElementType.METHOD)
14. public @interface BookAuthor 
16. {
18.     String name(); 
20.        String email();
22. }
23.  
25.  

使用这个注释为我们的方法加上注解：

2. package com.kuaff.jdk5;
4.  
6. import java.lang.annotation.Annotation;
8.  
10. public class MetadataShow
12. {
14.     @BookAuthor(name="曹雪芹",email="caoxueqin@hongloumeng.books") 
16.     public void introHongLouMeng()
18.     {
20.         System.out.println("这是一本好书啊");
22.     }
24.  
26.     public static void main(String[] args)
28.     {
30.         MetadataShow metadata = new MetadataShow();
32.         try
34.         {
36.             Annotation[] annotation = metadata.getClass().getMethod("introHongLouMeng").getAnnotations();
38.             for(Annotation  a : annotation)
40.             {
42.                 System.out.printf("作者:%s%n", ((BookAuthor)a).name());
44.                 System.out.printf("他的电子邮件(可能已被注销):%s%n", ((BookAuthor)a).email());
46.             }
48.         }
50.         catch (SecurityException e)
52.         {
54.             e.printStackTrace();
56.         }
58.         catch (NoSuchMethodException e)
60.         {
62.             e.printStackTrace();
64.         }
66.     }
68. }
69.  
71.  

 

请注意，要想在程序运行时能读取这些注释，需要在注释的声明的时候加上

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD) //也可能时其他类型，如针对声明的注释

 

这是对注释的注释。

编译这两个文件：

javac -source 5 -target 5 -d bin src/com/kuaff/jdk5/*.java
[5]J2SE5.0新特性之范型编程

本章主要参考sun公司文档。

 

C++程序员对范型编程肯定不陌生，尤其在STL大行其道的时候，C#2.0也将实现范型编程的功能。Java也不甘示弱，也推出了范型编程的语言新特性。

 

1．一个简单的范型示例

在以前，你可能遇到过这样的代码：

2. List list = new LinkedList();
4. list.add(“麻省理工”);
6. list.add(“普林斯顿”);
8. list.add(“伯克利”);
10. String name = (String)list.iterator.next();
11.  

注意，第三行需要强制转换。而使用范型：

2. List<String> list = new LinkedList<String>();
4. list.add(“麻省理工”);
6. list.add(“普林斯顿”);
8. list.add(“伯克利”);
10. String name = list.iterator.next();
11.  

这里将list声明成String类型的List。List是有一个类型参数的范型接口。这个例子中类型参数是String。

 

2．定义简单的范型

看j2se5.0中List和Iterator接口的实现（片断）：

2. public interface List<E> 
4. { 
6. void add(E x);
8. Iterator<E> iterator();
10. }
12. public interface Iterator<E> 
14. { 
16. E next();
18. boolean hasNext();
20. }
22.  
23.  

上面的代码我们比较熟悉，但是其中增加了尖括号。尖括号中的内容定义了接口List和Iterator的形式类型参数。类型参数可以用在范型声明中，如类和接口的声明。

一旦声明了范型，你就可以使用它。在上面的例子中使用了List<String>。这里使用String是实参，代替了形参E。如果使用List<Integer>，则用实参Integer代替了形参E。

不管List<Integer>还是List<String>，它们的类只有一个。考虑下面的代码：

2. List<String> list1 = new LinkedList<String>();
4. List<Integer> list2 = new LinkedList<Integer>();
6. System.out.println(list1.getClass()==list2.getClass());

 

输出结果为true。

 

一般来说，形式类型参数都是大写，尽量使用单个字母，许多容器类都使用E作为参数。

 

3．范型和继承

考虑下面的代码，你认为它会出错吗？

2. String s ＝ “smallnest@163.com”;
4. Object o = s:
5.  

当然，String类继承Object类，这样做不会出错。但下面的代码呢？

2. List<String> s = new LinkedList<String>();
4. List<Object>o=s;
5.  

编译出错！

是的，List<Object>和List<String>没有继承关系。

 

4．通配符

考虑下面一个方法：

2. public void printCollection(Collection<Object> c)
4. {
6.    for(Object o:c)
8. {
10.    System.out.printf(“%s%n”,o);
12. }
14. }
15.  

事实上，上面这个方法并不通用，它只能打印Collection<Object>类型的集合，象其他的如Collection<String>、Collection<Integer>并不能被打印，因为对象类型不一致。

为了解决这个问题，可以使用通配符：

2. public void printCollection(Collection<？> c)
4. {
6.    for(Object o:c)
8. {
10.    System.out.printf(“%s%n”,o);
12. }
14. }
15.  

Collection<？>被称作未知类型的集合。问号代表各种类型。

上面的读取集合中的数据时，我们采用Object类型。这样做时可以的，因为不管未知类型最终代表何种类型，它的数据都继承Object类，那么再考虑一下下面的代码:

2. Collection<?> c = new ArrayList<String>();
4. c.add(new Object());  //!!!!
5.  

这样做时错误的，因为我们不知道?代表何种类型，所以我们不能直接将Object增加到集合中，这会出现类型不匹配的情况。

 

5．有限制的通配符

考虑下面的代码

2. class Man
4. {
6.    public String name = “”;
8. }
10. class GoodMan extends Man
12. {
14.    public String name = “”
16. }
18. class BadMan extends Man
20. {
22.    public String name = “”
24. }
26.  
27.  

考虑下面的范型方法：

2. public void printName(List<Man> men)
4. {
6.    for(Man man:men)
8.    {
10.       System.out.println(“姓名:” + man.name);
12.    }
14. }
15.  

这个范型方法只能显示List<Man>类型的数据,下面的代码允许显示Man和它的子类。

2. public void printName(List<？ extends  Man> men)
4. {
6.    for(Man man:men)
8.    {
10.       System.out.println(“姓名:” + man.name);
12.    }
14. }
15.  

这里使用? extends Man代替Man，表明接受任何Man的子类做为参数。

和前面的代码类似，下面的代码也是不正确的：

2. public void adman(List<? extends Man> men)
4. {
6.    GoodMan good = new GoodMan();
8.    good.name = “晁岳攀”;
10.    men.add(good);
12. }
13.  

原因也很简单，因为?代表一切继承Man的类，你并不能保证就一定时GoodMan类。

 

和这种用法类似：

2. public void adman(List<? super GoodMan> men)
4. {
6.    GoodMan good = new GoodMan();
8.    good.name = “晁岳攀”;
10.    men.add(good);
12. }
13.  
15.  

6．范型方法

考虑下面的代码,我们将一个数组的内容加到一个集合中

2. public  void copyArrayToCollection(Man[] men, Collection<?>c)
4. {
6. for(Man man:men)
8. {
10.    c.add(man);
12. }
14. }
15.  

这段代码时错的！

因为我们并不知道集合C的类型，所以不能将Man类型的数据加到集合中。

可以使用范型方法解决：

2. public <T> void copyArrayToCollection(T[] men, Collection<T>c)
4. {
6. for(T man:men)
8. {
10.    c.add(man);
12. }
14. }
15.  
17.  

这里T时一个形式类型参数。

何时该采用通用方法？何时该采用通配符？

考虑下面的例子：

2. interface  Collection<E>
4. {
6.   public boolean containsAll(Collection<?> c);
8. public boolean addAll(Collection<? extends E> c);
10. }
11.  

改写成通用方法

2. interface  Collection<E>
4. {
6.    public <T> boolean containsAll(Collection<T> c);
8. public <T extends E> boolean addAll(Collection<T> c);
10. }
11.  

然而，在这里每个方法T只使用了一次,返回值不依赖形式参数，其他参数也不依赖形式参数。这说明实参被用作多态，这种情况下就应该用通配符。
[6]J2SE5.0新特性之监控与管理

j2se 5.0使用 Java Management Extensions (JMX)来管理和监控java平台。
我们以一个例子来测试一下:

2. import java.lang.management.ClassLoadingMXBean;
3. import java.lang.management.CompilationMXBean;
4. import java.lang.management.ManagementFactory;
5. import java.lang.management.MemoryMXBean;
6. import java.lang.management.MemoryManagerMXBean;
7. import java.lang.management.MemoryPoolMXBean;
8. import java.lang.management.OperatingSystemMXBean;
9. import java.lang.reflect.InvocationTargetException;
10. import java.lang.reflect.Method;
11. import java.util.List;
13. public class JDKMBean
14. {
15.     
16.     public static <T> void printMXBean(Class<T> t,Object object)
17.     {
18.         Method[] methods = t.getMethods();
19.         T instance = (T)object;
20.         System.out.printf("%n---%s---%n", t.getName());
21.         for(Method m:methods)
22.         {
23.             if (m.getName().startsWith("get"))
24.             {
25.                 try
26.                 {
27.                     Object rtValue = m.invoke(instance,new Object[0]);
28.                     System.out.printf("%s:%s%n",m.getName().substring(3),rtValue);
29.                 }
30.                 catch (IllegalArgumentException e1)
31.                 {   
32.                 }
33.                 catch (IllegalAccessException e)
34.                 {  
35.                 }
36.                 catch (InvocationTargetException e)
37.                 {
38.                 }
39.             }
40.         }
41.     }
42.     public static <T> void printMXBeans(Class<T> t,List<T> list)
43.     {
44.         for(T bean:list)
45.         {
46.             printMXBean(t,bean);
47.         }
48.     }
49.     public static void main(String[] args)
50.     {
51.         JDKMBean.printMXBean(OperatingSystemMXBean.class,ManagementFactory.getOperatingSystemMXBean());
52.         JDKMBean.printMXBean(CompilationMXBean.class,ManagementFactory.getCompilationMXBean());
53.         JDKMBean.printMXBean(ClassLoadingMXBean.class,ManagementFactory.getClassLoadingMXBean());
54.         JDKMBean.printMXBean(MemoryMXBean.class,ManagementFactory.getMemoryMXBean());
55.         JDKMBean.printMXBeans(MemoryManagerMXBean.class,ManagementFactory.getMemoryManagerMXBeans());
56.         JDKMBean.printMXBeans(MemoryPoolMXBean.class,ManagementFactory.getMemoryPoolMXBeans());
57.     }
58. }

运行结果:

---java.lang.management.OperatingSystemMXBean---
Arch:x86
AvailableProcessors:2
Name:Windows 2000
Version:5.0

---java.lang.management.CompilationMXBean---
TotalCompilationTime:5
Name:HotSpot Client Compiler

---java.lang.management.ClassLoadingMXBean---
LoadedClassCount:431
UnloadedClassCount:0
TotalLoadedClassCount:431

---java.lang.management.MemoryMXBean---
HeapMemoryUsage:init = 0(0K) used = 458288(447K) committed = 2031616(1984K) max = 66650112(65088K)
NonHeapMemoryUsage:init = 29556736(28864K) used = 12541248(12247K) committed = 29851648(29152K) max = 121634816(118784K)
ObjectPendingFinalizationCount:0

---java.lang.management.MemoryManagerMXBean---
MemoryPoolNames:[Ljava.lang.String;@6ca1c
Name:CodeCacheManager

---java.lang.management.MemoryManagerMXBean---
MemoryPoolNames:[Ljava.lang.String;@1bf216a
Name:Copy

---java.lang.management.MemoryManagerMXBean---
MemoryPoolNames:[Ljava.lang.String;@12ac982
Name:MarkSweepCompact

---java.lang.management.MemoryPoolMXBean---
CollectionUsage:null
MemoryManagerNames:[Ljava.lang.String;@c20e24
PeakUsage:init = 196608(192K) used = 482048(470K) committed = 491520(480K) max = 33554432(32768K)
Usage:init = 196608(192K) used = 524352(512K) committed = 557056(544K) max = 33554432(32768K)
UsageThreshold:0
UsageThresholdCount:0
Name:Code Cache
Type:Non-heap memory

---java.lang.management.MemoryPoolMXBean---
CollectionUsage:init = 524288(512K) used = 0(0K) committed = 0(0K) max = 4194304(4096K)
CollectionUsageThreshold:0
CollectionUsageThresholdCount:0
MemoryManagerNames:[Ljava.lang.String;@2e7263
PeakUsage:init = 524288(512K) used = 511160(499K) committed = 524288(512K) max = 4194304(4096K)
Usage:init = 524288(512K) used = 521688(509K) committed = 524288(512K) max = 4194304(4096K)
Name:Eden Space
Type:Heap memory

---java.lang.management.MemoryPoolMXBean---
CollectionUsage:init = 65536(64K) used = 0(0K) committed = 0(0K) max = 458752(448K)
CollectionUsageThreshold:0
CollectionUsageThresholdCount:0
MemoryManagerNames:[Ljava.lang.String;@157f0dc
PeakUsage:init = 65536(64K) used = 65528(63K) committed = 65536(64K) max = 458752(448K)
Usage:init = 65536(64K) used = 65528(63K) committed = 65536(64K) max = 458752(448K)
Name:Survivor Space
Type:Heap memory

---java.lang.management.MemoryPoolMXBean---
CollectionUsage:init = 1441792(1408K) used = 0(0K) committed = 0(0K) max = 61997056(60544K)
CollectionUsageThreshold:0
CollectionUsageThresholdCount:0
MemoryManagerNames:[Ljava.lang.String;@863399
PeakUsage:init = 1441792(1408K) used = 142120(138K) committed = 1441792(1408K) max = 61997056(60544K)
Usage:init = 1441792(1408K) used = 142120(138K) committed = 1441792(1408K) max = 61997056(60544K)
UsageThreshold:0
UsageThresholdCount:0
Name:Tenured Gen
Type:Heap memory

---java.lang.management.MemoryPoolMXBean---
CollectionUsage:init = 8388608(8192K) used = 0(0K) committed = 0(0K) max = 67108864(65536K)
CollectionUsageThreshold:0
CollectionUsageThresholdCount:0
MemoryManagerNames:[Ljava.lang.String;@a59698
PeakUsage:init = 8388608(8192K) used = 641040(626K) committed = 8388608(8192K) max = 67108864(65536K)
Usage:init = 8388608(8192K) used = 641040(626K) committed = 8388608(8192K) max = 67108864(65536K)
UsageThreshold:0
UsageThresholdCount:0
Name:Perm Gen
Type:Non-heap memory

---java.lang.management.MemoryPoolMXBean---
CollectionUsage:init = 8388608(8192K) used = 0(0K) committed = 0(0K) max = 8388608(8192K)
CollectionUsageThreshold:0
CollectionUsageThresholdCount:0
MemoryManagerNames:[Ljava.lang.String;@141d683
PeakUsage:init = 8388608(8192K) used = 5601632(5470K) committed = 8388608(8192K) max = 8388608(8192K)
Usage:init = 8388608(8192K) used = 5601632(5470K) committed = 8388608(8192K) max = 8388608(8192K)
UsageThreshold:0
UsageThresholdCount:0
Name:Perm Gen [shared-ro]
Type:Non-heap memory

---java.lang.management.MemoryPoolMXBean---
CollectionUsage:init = 12582912(12288K) used = 0(0K) committed = 0(0K) max = 12582912(12288K)
CollectionUsageThreshold:0
CollectionUsageThresholdCount:0
MemoryManagerNames:[Ljava.lang.String;@16a55fa
PeakUsage:init = 12582912(12288K) used = 5850024(5712K) committed = 12582912(12288K) max = 12582912(12288K)
Usage:init = 12582912(12288K) used = 5850024(5712K) committed = 12582912(12288K) max = 12582912(12288K)
UsageThreshold:0
UsageThresholdCount:0
Name:Perm Gen [shared-rw]
Type:Non-heap memory