天天av综合,97se亚洲,国产精品伦理久久久久久

Java for foreach

abin — Thu, 21 May 2015 15:59:00 GMT

java 有for(;;)�?for(Object obj : List/Array)

最明显的一个：前者是有范��_��后者是全部�?br />

��q��码来说各有好处：for更灵�z�，foreach更简�?br />

for和foreach都是java中重要的集合遍历�Ҏ�� 
for循环�?你可以选择从前往后遍历，也可以从后往前遍历，也可以不遍历默写�?
但是foreach只能从前往后遍历，而且每一个都会遍历一�ơ，他们之间的选择得看你项目程序中的需求而定

JVM在解释执行行�Q�都会将for与foreach解释成iterator�?/pre>
�ȝ��如下�Q?/p>
1.如果只是遍历集合或者数�l�，用foreach好些�Q�快些�?/p>
2.如果寚w��合中的��D��行修改，���p��用for循环了�?br />其实foreach的内部原理其实也是Iterator,但它不能像Iterator一样可以�h为的控制�Q�而且也不能调用iterator.remove()�Q?br />更不能��用下标来讉K��每个元素�Q�所以不能用于增加，删除�{�复杂的操作�?/p>

abin 2015-05-21 23:59 发表评论

abin — Tue, 21 Apr 2015 16:22:00 GMT

静态代�?/div>

静态代理相�Ҏ��说比较简单，无非��是聚合+多态：

参考：设计模式�W�记 – Proxy 代理模式 (Design Pattern)

动态代�?/div>

我们知道�Q�通过使用代理�Q�可以在被代理的�cȝ��Ҏ��的前后添加一些处理方法，�q�样��p��C��c�M��AOP的效果。而JDK中提供的动态代理，��是实现AOP的绝好底层技术�?/div>

JDK动态代�?/div>

JDK动态代理主要涉及到java.lang.reflect包中的两个类�Q�Proxy和InvocationHandler。InvocationHandler是一个接口，通过实现该接口定义横切逻辑�Q��ƈ通过反射机制调用目标�cȝ��代码�Q�动态将横切逻辑和业务逻辑�~�制在一赗��?/div>

Proxy利用InvocationHandler动态创��Z��个符合某一接口的实例，生成目标�cȝ��代理对象�?/div>

例子�Q�Java�W�记 – 反射动态代�?/div>

CGLib动态代�?/div>

�q�有一个叫CGLib的动态代理，CGLib全称为Code Generation Library�Q�是一个强大的高性能�Q�高质量的代码生成类库，可以在运行期扩展Java�c�M��实现Java接口�Q�CGLib��装了asm�Q�可以再�q�行期动态生成新的class。和JDK动态代理相比较�Q�JDK创徏代理有一个限�Ӟ��是只能为接口创��Z��理实例，而对于没有通过接口定义业务�Ҏ��的类�Q�则可以通过CGLib创徏动态代理�?/div>

CGLib采用非常底层的字节码技术，可以��Z��个类创徏子类�Q��ƈ在子�c�M��采用�Ҏ��拦截的技术拦截所有父�c�L��法的调用�Q��ƈ��势�l�入横切逻辑�?/p>

abin 2015-04-22 00:22 发表评论

abin — Tue, 31 Mar 2015 10:22:00 GMT

If you are not sure about the string pool usage, try -XX:+PrintStringTableStatistics JVM argument. It will print you the string pool usage when your program terminates.

abin 2015-03-31 18:22 发表评论

Java中Static�Ҏ��和Static�E�序块的用法�ȝ��

abin — Wed, 25 Mar 2015 07:24:00 GMT

Static 静态：�q�里主要记录的是静态程序块和静态方�?/p>

如果有些代码必须在项目启动的时候就执行,��需要��用静态代码块,�q�种代码是主动执行的;需要在��目启动的时候就初始化但是不执行,在不创徏对象的情况下,可以供其他程序调�?而在调用的时候才执行�Q�这需要��用静态方�?�q�种代码是被动执行的. 静态方法在�c�d��载的时�?��已�l�加�?可以用类名直接调用�?/p>

静态代码块和静态方法的区别是：

静态代码块是自动执行的;

静态方法是被调用的时候才执行�?

静态方法：如果我们在程序编写的时候需要一个不实例化对象就可以调用的方法，我们��可以��用静态方法，具体实现是在�Ҏ��前面加上static�Q�如下：

public static void method(){}

在��用静态方法的时候需要注意一下几个方面：

在静态方法里只能直接调用同类中其他的静态成员（包括变量和方法）�Q�而不能直接访问类中的非静态成员。这是因为，对于非静态的�Ҏ��和变量，需要先创徏�cȝ��实例对象后才可��用，而静态方法在使用前不用创��Z�Q何对象。（备注�Q�静态变量是属于整个�cȝ��变量而不是属于某个对象的�Q?/p>

静态方法不能以��M��方式引用this和super关键字，因�ؓ静态方法在使用前不用创��Z�Q何实例对象，当静态方法调用时�Q�this所引用的对象根本没有��生�?/p>

静态程序块�Q�当一个类需要在被蝲入时��执行一�D늨�序，�q�样可以使用静态程序块�?/p>

public class DemoClass {

private DemoClass(){}

public static DemoClass _instance;

static{

if(null == _instance ){

_instance = new DemoClass();

}

public static DemoClass getInstance(){

return _instance;

}

�q�样的程序在�c�被加蝲的时候就执行了static中的代码�?/p>

Ps:java中类的装载步骤：

在Java中，�c�装载器把一个类装入Java虚拟��Z��Q�要�l�过三个步骤来完成：装蝲、链接和初始化，其中链接又可以分成校验、准备和解析三步�Q�除了解析外�Q�其它步骤是严格按照��序完成的，各个步骤的主要工作如下：

所谓装载就是寻找一个类或是一个接口的二进制�Ş式�ƈ用该二进制�Ş式来构造代表这个类或是�q�个接口的class对象的过�E�。其中类或接口的名称是给定了的�?/p>

装蝲�Q�查扑֒�导入�c�L��接口的二�q�制数据�Q?/p>

链接�Q�执行下面的校验、准备和解析步骤�Q�其中解析步骤是可以选择的；

校验�Q�检查导入类或接口的二进制数据的正确性；

准备�Q�给�cȝ��静态变量分配�ƈ初始化存储空��_��

解析�Q�将�W�号引用转成直接引用�Q?/p>

初始化：�Ȁ�zȝ��的静态变量的初始化Java代码和静态Java代码�?/p>

abin 2015-03-25 15:24 发表评论

JAVA内存占用

abin — Fri, 01 Aug 2014 08:54:00 GMT

摘要: 最�q�对�E�序占用内存斚w��做了一些优化，取得了不错的效果�Q��ȝ��了一些经验简要说一下，�怿�会对大家写出优质的程序有所帮助下面的论�q�针�?2位系�l�，�?4位系�l�不适用�Q�后叙经�怽�写了一个程序，一��试�Q�功能没问题�Q�一看内存占用也不多�Q�就不去考虑其它的东西了。但可能�E�序使用了一个什么数据结构，会当数据规模变大�Ӟ��内存占用�Ȁ增。基�?amp;&关键的问题是�Q�Java里各�U�东东占多少内存�Q�？�Q�？�Q�？�Q�？�Q?.. 阅读全文

abin 2014-08-01 16:54 发表评论

abin — Fri, 18 Oct 2013 14:43:00 GMT

java位运��?br />
http://www.cnblogs.com/highriver/archive/2011/08/15/2139600.html
单点��d��Q?br />
http://www.aygfsteel.com/rabbit/archive/2013/10/18/405392.html

abin 2013-10-18 22:43 发表评论

abin — Fri, 18 Oct 2013 14:31:00 GMT

数据�c�d��                   大小(二进制位�?                 范围                                                                                 默认�?

byte(字节) 	         8                     -128 - 127                                                                                             0
shot(短整�?            16                   -32768 - 32768                                                                                      0
int(整型)                  32                    -2147483648-2147483648                                                                    0
long(长整�?            64                   -9233372036854477808-9233372036854477808                                0        
float(���点�?/a>)            32                   -3.40292347E+38-3.40292347E+38                                                     0.0f
double(双精�?	        64                 -1.79769313486231570E+308-1.79769313486231570E+308              0.0d
char(字符�?           16                  ‘ \u0000 - u\ffff ’                                                                                      ‘\u0000 ’

boolean(布尔�?/a>)      1                   true/false                                                                                                 false

JAVA基本数据�c�d��所占字节数是多��？

char 2字节�Q�C语言中是1字节�Q�可以存储一个汉�?/div>

float 4字节

double 8字节

boolean false/true(理论上占�?bit,1/8字节�Q�实际处理按1byte处理)

JAVA是采用Unicode�~�码。每一个字节占8位。你电脑�pȝ��应该�?32位系�l�，�q�样每个int���是 4个字�?br />

其中一个字节由8个二�q�制位组�?br />

Java一共有8�U�基�?a class="inner-link decor-none"  target="_blank" rel="nofollow" data-word="0" style="color: #2d64b3; text-decoration: none; ">数据�c�d���Q�原�?a class="inner-link decor-none"  target="_blank" rel="nofollow" data-word="0" style="color: #2d64b3; text-decoration: none; ">数据�c�d���Q�：     
�c�d��  存储要求 范围�Q�包含） 默认�?包装�c?br />�?int 4字节�Q?2位） -231~ 231-1 0 Integer
�?short 2字节�Q?6位） -215~215-1 0 Short
�c?long 8字节�Q?4位） -263~263-1 0 Long
�?byte 1字节�Q?位） -27~27-1 0 Byte
���点 float 4字节�Q?2位） -3.4e+38 ~ 3.4e+38 0.0f Float
�c�d�� double 8字节�Q?4位） -1.7e+308 ~ 1.7e+308 0 Double
字符 char 2字节�Q?6位） u0000~uFFFF�Q?#8216;’~‘�Q?#8217;�Q?‘0’ Character
   �Q?~216-1�Q?5535�Q�）  
布尔 boolean 1/8字节�Q?位） true, false FALSE Boolean

在移动开发中�׃��U�d��讑֤�内存的局限性，往往需要考虑使用的数据类型所占用的字节数。下面简单介�l�下Java中几�U�基本数据类型，以加��p��忆�?br />在Java中一共有8�U�基本数据类型，其中�?�U�整型，2�U��Q点类型，1�U�用于表�C�Unicode�~�码的字�W�单元的字符�c�d��?�U�用于表�C�真值的boolean�c�d��。（一个字节等�?个bit�Q?/span>

1.整型
�c�d��              存储需�? bit�? 取��D��?nbsp;     备注
int                 4字节 4*8
short             2字节 2*8 �Q?2768�?2767
long              8字节 8*8
byte              1字节 1*8 �Q?28�?27

2.��点�?/span>
�c�d��              存储需�? bit�? 取��D��?nbsp;     备注
float              4字节 4*8 float�c�d��的数值有一个后�~�F(例如�Q?.14F)
double          8字节 8*8 没有后缀F的��Q�Ҏ��?�?.14)默认为double�c�d��

3.char�c�d��
�c�d��              存储需�? bit�? 取��D��?nbsp;     备注
char              2字节 2*8

4.boolean�c�d��
�c�d��              存储需�? bit�? 取��D��?nbsp;     备注
boolean        1字节 1*8 false、true

补充�Q?/span>Java有一个能够表�C�Z�Q意精度的��书包，通常�U�Cؓ“大数�?#8221;(big number)。虽然被�U�Cؓ大数��|��但它�q�不是一�U�Java�c�d��Q�而是一个Java对象�?/span>

如果基本的整数和��点数精度不能够满��需求，那么可以使用java.math包中的两个很有用的类�Q?span style="color: #ff0000; ">BigIntegerBigDecimal(Android SDK中也包含了java.math包以及这两个�c?�q�两个类可以处理包含��L��长度数字序列的数倹{��BigInteger�c�d��C��L��_�ֺ�的整数运��，BigDecimal实现了�Q意精度的��点数运��。具体的用法可以参见Java API�?/span>

http://blog.csdn.net/witsmakemen/article/details/8974200

int常见�?个字节，跟操作系�l�有关系�?br />turbo c�Q�以及Turbo c的一些衍生编译器�Q�他们用的一�?a class="inner-link decor-none"  target="_blank" rel="nofollow" data-word="0" style="color: #2d64b3; text-decoration: none; ">�~�译�E�序�Q�是dos时代的编译器�Q�是上世�U?0�q�代的��物，严重�q�时�Q�属于老掉牙的产品�Q�他们编译出来的�E�序�?6位操作系�l�dos下的�E�序�Q�所以长度�ؓ16位，即两个字节。windows��Z��兼容dos�Q�所以turbo c生成的文件也可以在windows中运行�?br />其他一般就都是4个字节了�?/pre>操作�pȝ��16位的时候，int 2字节�Q�操作系�l?2位的时候，int 4字节�Q�由�?2位系�l�之前占��L����C���Q�实际现在就���是64位系�l�，��Z��兼容性考虑�Q�int也是4字节�?/span>




abin 2013-10-18 22:31 发表评论

JAVA�~�程中URL传值符��L��转换

abin — Thu, 22 Aug 2013 12:23:00 GMT

有些�W�号在URL中是不能直接传递的�Q�如果要在URL中传递这些特�D�符��P��那么��p��使用他们的编码了。下表中列出了一些URL�Ҏ��W�号及编�?/p>

十六�q�制�?/p>

1	+	URL �?可��C�空�?/td>	%2B
2	�I�格	URL中的�I�格可以�?��h��者编�?/td>	%20
3	/	分隔目录和子目录	%2F
4	?	分隔实际�?URL 和参�?/td>	%3F
5	%	指定�Ҏ��字符	%25
6	#	表示书签	%23
7	&	URL 中指定的参数间的分隔�W?/td>	%26
8	=	URL 中指定参数的�?/td>	%3D

　　解决的方法：

　　replace() �Ҏ��如果直接用str.replace("-","!") 只会替换�W�一个匹配的字符.

　　而str.replace(/\-/g,"!")则可以替换掉全部匚w��的字�W?g为全局标志)�?/p>

　　replace()

　　js中替换字�W�变量如下：

　　data2=data2.replace(/\%/g,"%25");

　　data2=data2.replace(/\#/g,"%23");

　　data2=data2.replace(/\&/g,"%26");

abin 2013-08-22 20:23 发表评论

java中的堆、栈、常量池

abin — Thu, 23 May 2013 14:39:00 GMT

Java内存分配:

1. 寄存器：我们在程序中无法控制
2. 栈：存放基本�c�d��的数据和对象的引用，但对象本�w�不存放在栈中，而是存放在堆�?br />3. 堆：存放用new产生的数�?br />4. 静态域�Q�存攑֜�对象中用static定义的静态成�?br />5. 帔R��池：存放帔R��
6. 非RAM(随机存取存储�?/span>)存储�Q�硬盘等�怹�存储�I�间
----------------------------------------------------------------------------------------------------------------------

a.在函��C��定义的一些基本类型的变量数据和对象的引用变量都在函数的栈内存中分配�?nbsp;
当在一�D�代码块定义一个变量时�Q�Java��在栈中��个变量分配内存空��_��当该变量退��作用域后�Q�Java会自动释放掉��变量所分配的内存空��_��该内存空间可以立卌��另作他用�?nbsp;
b.堆内存用来存攄��new创徏的对象和数组�?nbsp;在堆中分配的内存�Q�由Java虚拟机的自动垃圾回收器来��理�?nbsp;
在堆中��生了一个数�l�或对象后，�q�可以在栈中定义一个特�D�的变量�Q�让栈中�q�个变量的取值等于数�l�或对象在堆内存中的首地址�Q�栈中的�q�个变量��成了数�l�或对象的引用变量�?nbsp; 引用变量��q��当于是�ؓ数组或对象�v的一个名�U�ͼ�以后��可以在�E�序中��用栈中的引用变量来访问堆中的数组或对象。引用变量就相当于是�?数组或者对象�v的一个名�U�。引用变量是普通的变量�Q�定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数�l�和对象本��n在堆中分配，即�ɽE�序�q�行��C��?new 产生数组或者对象的语句所在的代码块之外，数组和对象本�w�占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用�Q�但仍然占据内存�I�间不放�Q�在随后的一个不��定的时间被垃圾回收器收赎ͼ�释放掉）。这也是 Java 比较占内存的原因�?nbsp;
实际上，栈中的变量指向堆内存中的变量�Q�这��是 Java 中的指针�Q?nbsp;
c.帔R��?/span>(constant pool)指的是在�~�译期被��定�Q��ƈ被保存在已编译的.class文�g中的一些数据。除了包含代码中所定义的各�U�基本类型（如int、long�{�等�Q�和对象型（如String及数�l�）的常量�?final)�q�包含一些以文本形式出现的符号引用，比如�Q?�c�d��接口的全限定名；字段的名�U�和描述�W�； �Ҏ��和名�U�和描述�W��?虚拟机必��Mؓ每个被装载的�c�d��l�护一个常量池。常量池��是该类型所用到帔R��的一个有序集和，包括直接帔R��Q�string,integer和floating point帔R��Q�和对其他类型，字段和方法的�W�号引用。对于String帔R��Q�它的值是在常量池中的。而JVM中的帔R��池在内存当中是以表的形式存在的，对于String�c�d��Q�有一张固定长度的CONSTANT_String_info表用来存储文字字�W�串��|��注意�Q�该表只存储文字字符串��|��不存储符号引用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了�?/p>

在程序执行的时�?帔R��?/span>会储存在Method Area,而不是堆�?
d.Java的堆是一个运行时数据�?�cȝ��(对象从中分配�I�间。这些对象通过new、newarray、anewarray和multianewarray�{�指令徏立，它们不需要程序代码来昑ּ�的释放。堆是由垃圾回收来负责的�Q�堆的优势是可以动态地分配内存大小�Q�生存期也不必事先告诉编译器�Q�因为它是在�q�行时动态分配内存的�Q�Java的垃圾收集器会自动收走这些不再��用的数据。但�~�点是，�׃��要在�q�行时动态分配内存，存取速度较慢�?nbsp;

栈的优势是，存取速度比堆要快�Q�仅�ơ于寄存器，栈数据可以共享。但�~�点是，存在栈中的数据大��与生存期必��L��定的，�~�Z��灉|��性。栈中主要存放一些基本类型的变量数据�Q�int, short, long, byte, float, double, boolean, char�Q�和对象句柄(引用)�?nbsp;

栈有一个很重要的特�D�性，��是存在栈中的数据可以共享。假设我们同时定义：
int a = 3;
int b = 3�Q?nbsp;
�~�译器先处理int a = 3�Q�首先它会在栈中创徏一个变量�ؓa的引用，然后查找栈中是否�?�q�个��|��如果没找刎ͼ��将3存放�q�来�Q�然后将a指向3。接着处理int b = 3�Q�在创徏完b的引用变量后�Q�因为在栈中已经�?�q�个��|��便将b直接指向3。这��P��出��C��a与b同时均指�?的情��c�?nbsp;

�q�时�Q�如果再令a=4�Q�那么编译器会重新搜索栈中是否有4��|��如果没有�Q�则��?存放�q�来�Q��ƈ令a指向4�Q�如果已�l�有了，则直接将a指向�q�个地址。因此a值的改变不会影响到b的倹{�?nbsp;

要注意这�U�数据的�׃�n与两个对象的引用同时指向一个对象的�q�种�׃�n是不同的�Q�因��U�情况a的修改�ƈ不会影响到b, 它是��q��译器完成的，它有利于节省�I�间。而一个对象引用变量修改了�q�个对象的内部状态，会媄响到另一个对象引用变量�?/p>

/*****************************************************************************/

String是一个特�D�的包装�c�L��据。可以用�Q?nbsp;
String str = new String("abc");
String str = "abc";
两种的�Ş式来创徏�Q�第一�U�是用new()来新建对象的�Q�它会在存放于堆中。每调用一�ơ就会创��Z��个新的对象�?nbsp;
而第二种是先在栈中创��Z��个对String�cȝ��对象引用变量str�Q�然后通过�W�号引用�?span style="color: #ff0000;">字符串常量池里找有没�?abc",如果没有�Q�则��?abc"存放�q?span style="color: #ff0000;">字符串常量池�Q��ƈ令str指向”abc”�Q�如果已�l�有”abc” 则直接��ostr指向“abc”�?nbsp;

比较�c�里面的数值是否相�{�时�Q�用equals()�Ҏ��Q�当��试两个包装�cȝ��引用是否指向同一个对象时�Q�用==�Q�下面用例子说明上面的理论�?nbsp;
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true
可以看出str1和str2是指向同一个对象的�?nbsp;

String str1 =new String ("abc");
String str2 =new String ("abc");
System.out.println(str1==str2); // false
用new的方式是生成不同的对象。每一�ơ生成一个�?nbsp;

因此用第二种方式创徏多个”abc”字符�?在内存中其实只存在一个对象而已. �q�种写法有利与节省内存空�? 同时它可以在一定程度上提高�E�序的运行速度�Q�因为JVM会自动根据栈中数据的实际情况来决定是否有必要创徏新对象。而对于String str = new String("abc")�Q�的代码�Q�则一概在堆中创徏新对象，而不��其字符串值是否相�{�，是否有必要创建新对象�Q�从而加重了�E�序的负担�?nbsp;

另一斚w��, 要注�? 我们在��用诸如String str = "abc"�Q�的格式定义�c�L��Q��L��惛_��然地认�ؓ�Q�创��Z��String�cȝ��对象str。担心陷阱！对象可能�q�没有被创徏�Q�而可能只是指向一个先前已�l�创建的对象。只有通过new()�Ҏ��才能保证每次都创��Z��个新的对象�?nbsp;
�׃��String�cȝ��immutable性质�Q�当String变量需要经常变换其值时�Q�应该考虑使用StringBuffer�c�，以提高程序效率�?nbsp;
1. 首先String不属�?�U�基本数据类型，String是一个对象�?nbsp;
因�ؓ对象的默认值是null�Q�所以String的默认��g��是null�Q�但它又是一�U�特�D�的对象�Q�有其它对象没有的一些特性�?nbsp;

2. new String()和new String(”")都是��x��一个新的空字符�Ԍ��是空串不是null�Q?nbsp;

3. String str=”kvill”�Q�String str=new String (”kvill”)的区�?br />
看例1�Q?nbsp;

String s0="kvill";
String s1="kvill";
String s2="kv" + "ill";
System.out.println( s0==s1 );
System.out.println( s0==s2 );
�l�果为：
true
true

首先�Q�我们要知结果�ؓ�?span style="background-color: #ffff00;">Java会确保一个字�W�串帔R��只有一个拷贝�?nbsp;
因�ؓ例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期��p��定了，所以s0==s1为true�Q��?#8221;kv”�?#8221;ill”也都是字�W�串帔R��Q�当一个字�W�串由多个字�W�串帔R��q�接而成�Ӟ��它自��p��定也是字�W�串帔R��Q�所以s2也同样在�~�译期就被解析�ؓ一个字�W�串帔R��Q�所以s2也是帔R��池中” kvill”的一个引用。所以我们得出s0==s1==s2�Q�用new String() 创徏的字�W�串不是帔R��Q�不能在�~�译期就��定�Q�所以new String() 创徏的字�W�串不放入常量池中，它们有自��q��地址�I�间�?nbsp;

看例2�Q?nbsp;
String s0="kvill";
String s1=new String("kvill");
String s2="kv" + new String("ill");
System.out.println( s0==s1 );
System.out.println( s0==s2 );
System.out.println( s1==s2 );
�l�果为：
false
false
false

�?中s0�q�是帔R��池中"kvill”的应用，s1因�ؓ无法在编译期��定�Q�所以是�q�行时创建的新对�?#8221;kvill”的引用，s2因�ؓ有后半部�?new String(”ill”)所以也无法在编译期��定�Q�所以也是一个新创徏对象”kvill”的应�?明白了这些也��q��道�ؓ何得出此�l�果了�?nbsp;

4. String.intern()�Q?nbsp;
再补充介�l�一点：存在�?class文�g中的帔R��池，在运行期被JVM装蝲�Q��ƈ且可以扩充。String的intern()�Ҏ��是扩充帔R��池的一个方法；当一个String实例str调用intern()�Ҏ��Ӟ��Java查找帔R��池中是否有相同Unicode的字�W�串帔R��Q�如果有�Q�则�q�回其的引用�Q�如果没有，则在帔R��池中增加一个Unicode�{�于str的字�W�串�q�返回它的引用；看例3��清楚了

�?�Q?nbsp;
String s0= "kvill";
String s1=new String("kvill");
String s2=new String("kvill");
System.out.println( s0==s1 );
System.out.println( "**********" );
s1.intern();
s2=s2.intern(); //把常量池�?kvill"的引用赋�l�s2
System.out.println( s0==s1);
System.out.println( s0==s1.intern() );
System.out.println( s0==s2 );
�l�果为：
false
**********
false //虽然执行了s1.intern(),但它的返回值没有赋�l�s1
true //说明s1.intern()�q�回的是帔R��池中"kvill"的引�?nbsp;
true

最后我再破除一个错误的理解�Q�有��Q?#8220;使用 String.intern() �Ҏ��则可以将一�?String �cȝ��保存��C��个全局 String 表中 �Q�如果具有相同值的 Unicode 字符串已�l�在�q�个表中�Q�那么该�Ҏ��q�回表中已有字符串的地址�Q�如果在表中没有相同值的字符�Ԍ��则将自己的地址注册到表�?#8221;如果我把他说的这个全局�?String 表理解�ؓ帔R��池的话，他的最后一句话�Q?#8221;如果在表中没有相同值的字符�Ԍ��则将自己的地址注册到表�?#8221;是错的：

看例4�Q?nbsp;
String s1=new String("kvill");
String s2=s1.intern();
System.out.println( s1==s1.intern() );
System.out.println( s1+" "+s2 );
System.out.println( s2==s1.intern() );
�l�果�Q?nbsp;
false
kvill kvill
true

在这个类中我们没有声名一�?#8221;kvill”帔R��Q�所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新��d��了一�?#8221;kvill”帔R��Q�原来的不在帔R��池中�?#8221;kvill”仍然存在�Q�也��׃��?#8220;��自��q��地址注册到常量池�?#8221;了�?nbsp;
s1==s1.intern()为false说明原来�?#8221;kvill”仍然存在�Q�s2现在为常量池�?#8221;kvill”的地址�Q�所以有s2==s1.intern()为true�?nbsp;

5. 关于equals()�?=:
�q�个对于String��单来说就是比较两字符串的Unicode序列是否相当�Q�如果相�{�返回true;�?=是比较两字符串的地址是否相同�Q�也��是是否是同一个字�W�串的引用�?nbsp;

6. 关于String是不可变�?nbsp;
�q�一说又要说很多�Q�大家只要知道String的实例一旦生成就不会再改变了�Q�比如说�Q�String str=”kv”+”ill”+” “+”ans”; ��是�?个字�W�串帔R��Q�首�?#8221;kv”�?#8221;ill”生成�?#8221;kvill”存在内存中，然后”kvill”又和” ” 生成 “kvill “存在内存中，最后又和生成了”kvill ans”;�q�把�q�个字符串的地址赋给了str,��是因�ؓString�?#8221;不可�?#8221;产生了很多��时变量，�q�也��是��Z��么徏议用StringBuffer的原因了�Q�因为StringBuffer是可改变的�?/p>

/*******************************************************************************/

下面是一些String相关的常见问题：

String中的final用法和理�?br />final StringBuffer a = new StringBuffer("111");
final StringBuffer b = new StringBuffer("222");
a=b;//此句�~�译不通过

final StringBuffer a = new StringBuffer("111");
a.append("222");//�~�译通过

可见�Q�final只对引用�?�?(卛_��存地址)有效�Q�它�q��引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化�Q�final是不负责的�?/p>

String 帔R��池问题的几个例子

下面是几个常见例子的比较分析和理解：
[1]
String a = "a1";
String b = "a" + 1;
System.out.println((a == b)); //result = true
String a = "atrue";
String b = "a" + "true";
System.out.println((a == b)); //result = true
String a = "a3.4";
String b = "a" + 3.4;
System.out.println((a == b)); //result = true

分析�Q�JVM对于字符串常量的"+"可��接，��程序编译期�Q�JVM��将帔R��字符串的"+"�q�接优化��接后的��|��?a" + 1来说�Q�经�~�译器优化后在class中就已经是a1。在�~�译期其字符串常量的值就��定下来�Q�故上面�E�序最�l�的�l�果都�ؓtrue�?/p>

[2]
String a = "ab";
String bb = "b";
String b = "a" + bb;
System.out.println((a == b)); //result = false

分析�Q�JVM对于字符串引用，�׃��在字�W�串�?+"�q�接中，有字�W�串引用存在�Q�而引用的值在�E�序�~�译期是无法��定的，�?a" + bb无法被编译器优化�Q�只有在�E�序�q�行期来动态分配�ƈ��连接后的新地址赋给b。所以上面程序的�l�果也就为false�?/p>

[3]
String a = "ab";
final String bb = "b";
String b = "a" + bb;
System.out.println((a == b)); //result = true

分析�Q�和[3]中唯一不同的是bb字符串加了final修饰�Q�对于final修饰的变量，它在�~�译时被解析为常量值的一个本地拷贝存储到自己的常量池中或嵌入到它的字节码��中。所以此时的"a" + bb�?a" + "b"效果是一��L��。故上面�E�序的结果�ؓtrue�?/p>

[4]
String a = "ab";
final String bb = getBB();
String b = "a" + bb;
System.out.println((a == b)); //result = false
private static String getBB() {
return "b";
}

分析�Q�JVM对于字符串引用bb�Q�它的值在�~�译期无法确定，只有在程序运行期调用�Ҏ��后，��方法的�q�回值和"a"来动态连接�ƈ分配地址为b�Q�故上面�E�序的结果�ؓfalse�?/p>

通过上面4个例子可以得出得知：
String s = "a" + "b" + "c";
��q��价于String s = "abc";

String a = "a";
String b = "b";
String c = "c";
String s =   a + b + c;

�q�个��׃��一样了�Q�最�l�结果等于：
StringBuffer temp = new StringBuffer();
temp.append(a).append(b).append(c);
String s = temp.toString();

�׃��面的分析�l�果�Q�可��׃��难推断出String 采用�q�接�q�算�W�（+�Q�效率低下原因分析，形如�q�样的代码：

public class Test {
public static void main(String args[]) {
String s = null;
for(int i = 0; i < 100; i++) {
s += "a";
}
}
}

每做一��?+ ��׃�生个StringBuilder对象�Q�然后append后就扔掉。下�ơ��@环再到达旉��C�生个StringBuilder对象�Q�然�?append 字符�Ԍ��如此循环直至�l�束�?如果我们直接采用 StringBuilder 对象�q�行 append 的话�Q�我们可以节�?N - 1 �ơ创建和销毁对象的旉��。所以对于在循环中要�q�行字符串连接的应用�Q�一般都是用StringBuffer或StringBulider对象来进行append操作�?/p>

String对象的intern�Ҏ��理解和分析：

public class Test4 {
private static String a = "ab";
public static void main(String[] args){
String s1 = "a";
String s2 = "b";
String s = s1 + s2;
System.out.println(s == a);//false
System.out.println(s.intern() == a);//true
}
}

�q�里用到Java里面是一个常量池的问题。对于s1+s2操作�Q�其实是在堆里面重新创徏了一个新的对�?s保存的是�q�个新对象在堆空间的的内容，所以s与a的值是不相�{�的。而当调用s.intern()�Ҏ��Q�却可以�q�回s在常量池中的地址��|��因�ؓa的值存储在帔R��池中�Q�故s.intern和a的值相�{?/p>

�ȝ��:

a.栈中用来存放一些原始数据类型的局部变量数据和对象的引�?String,数组.对象�{�等)但不存放对象内容

b.堆中存放使用new关键字创建的对象.

c.字符串是一个特�D�包装类,其引用是存放在栈里的,而对象内容必��L��据创建方式不同定(帔R��池和�?.有的是编译期��已�l�创建好�Q�存攑֜�字符串常量池中，而有的是�q�行时才被创�?使用new关键字，存放在堆中�?/p>

本文转自�Q?a style="color: #ff9900; text-decoration: initial;">http://zy19880423.javaeye.com/blog/434179

abin 2013-05-23 22:39 发表评论

jdk动态代理和java的多态有啥区别？

abin — Tue, 11 Dec 2012 09:46:00 GMT

首先说明一下：�q�是两个2个东西拉

动态代理，不是java语言�Ҏ��，只是java提供动态方法拦截的一�U�方式（工具�Q?br />有点�c�M�� hook
动态代理，只是动态的通过反射�Q�动态执行目标的相关操作�Q?br />当然要想实现动态代理，必须该类有接�?貌似cglib不需要的)
动态代理，是一�U�实现方�?br />

多态，是oo语言的特�?br />

多态表现在重蝲�Q�一个父�cȝ��变量可以引用子类的对�?/p>

abin 2012-12-11 17:46 发表评论

Java 抽象�c�d��接口适用场合

abin — Thu, 22 Nov 2012 09:01:00 GMT

对于抽象�c�d��接口�Q�我个�h觉得�Q�一般性的接口�Q�都可以用这两者，
1、接口，接口实现�c�，
2、普通类�l�承抽象�c?br />
我想问下�Q�什么场合用接口好点�Q�什么场合用抽象�c�d��?br />接口�c�M��一个协议，一般只作定�?br />面向对象的语意是完全不同�?br />一�U�是实现�Q�一�U�是个别�?br />看uml ��q��道了
�q�个都用�q�，接口用的是最多的�Q�但是能不能�l�讲个语境，比如�q�里用抽象类��比接口好点
目前�Q�有观点��是�Q��用接�?nbsp;解�?br />不是�q�样圎ͼ�模式里用的接口多�Q�但有些模式�Q�如模版�Ҏ��模式�Q�用到抽�?br />看具体的使用
恩恩�Q�总觉得迷�q�L��p�的
之前我公�总�们写呼叫�pȝ��的时候，大量的��用了抽象�c?br />抽象�c�d��以定义方法的内容�Q�具体实现留�l�子�c�d��?br />抽象的目的是个别化，��是各个子类都有自己的特�?br />虽然都��承父�c�，但有些方法需要重斎ͼ�或新增，��是实现了子�cȝ��Ҏ��?br />接口不一��P��接口只是单独�?nbsp;realize

abin 2012-11-22 17:01 发表评论

Java ZIP文�g压羃

abin — Sun, 11 Nov 2012 15:32:00 GMT

package lc.abin.lee.basic.zip;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.util.zip.CRC32;
import java.util.zip.CheckedOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class CreateZip {
public static String createZipFile(String filePath){
  String result="failure";
  try {
   FileOutputStream fileOut=new FileOutputStream("example.zip");
   CheckedOutputStream checkOut=new CheckedOutputStream(fileOut,new CRC32());
   ZipOutputStream zipOut=new ZipOutputStream(new BufferedOutputStream(checkOut));

   BufferedReader in=new BufferedReader(new FileReader(filePath));
   zipOut.putNextEntry(new ZipEntry(filePath));
   int line;
   while((line=in.read())!=-1){
    zipOut.write(line);
    zipOut.flush();
   }
   result="success";
   in.close();
   zipOut.close();
  } catch (Exception e) {
   e.printStackTrace();
  }
  return result;
}
public static void main(String[] args) {
  String fileName="D:\\abin.txt";
  String result=createZipFile(fileName);
  System.out.println("result="+result);
}
}

貌似�q�有炚w��题，明天解决一�?img src ="http://www.aygfsteel.com/stevenjohn/aggbug/391170.html" width = "1" height = "1" />

abin 2012-11-11 23:32 发表评论

Java Cloneable

abin — Wed, 24 Oct 2012 05:27:00 GMT

package net.abin.lee.basic;

public class Can implements Cloneable{
private int id;
private String address;
public Can() {
}
public Can(int id, String address) {
  super();
  this.id = id;
  this.address = address;
}
public Object clone()throws CloneNotSupportedException{
  return super.clone();
}
public int hashCode(){
  final int prime=31;
  int result=1;
  result=prime*result+id;
  result=prime*result+((address==null?0:address.hashCode()));
  return result;
}
public int getId() {
  return id;
}
public void setId(int id) {
  this.id = id;
}
public String getAddress() {
  return address;
}
public void setAddress(String address) {
  this.address = address;
}

}

package net.abin.lee.basic;

import junit.framework.TestCase;

public class UserTest extends TestCase{
public void test1() throws CloneNotSupportedException{
  User user1=new User("12","abin",3);
  User user2=user1;
  User user3=(User)user1.clone();
  System.out.println("user1=user2 :"+(user1==user2));
  System.out.println("user1equalsuser2 :"+(user1.equals(user2)));

  System.out.println("user1=user3 :"+(user1==user3));
  System.out.println("user1equalsuser3 :"+(user1.equals(user3)));

}
@Override
protected void runTest() throws Throwable {
  System.out.println("55");
  super.runTest();
}
}

abin 2012-10-24 13:27 发表评论

Java volatile的用�?

abin — Fri, 31 Aug 2012 16:27:00 GMT

package com.abin.lee.collection.singleton;
/**
* 双重��查加�?单例模式
* @author abin
* �q�个单例模式写法可以大大减少getInstance的时间消耗！
*/
public class SingletonOne {
/**
     * volatile关键词确保：当singleton变量被初始化成SingletonOne实例�Ӟ��多个�U�程正确地处理singleton变量
     */
private volatile static SingletonOne singleton=null;
public SingletonOne(){}
public static SingletonOne getInstance(){
  if(null==singleton){//��查实例，如果不存在就�q�入同步区块
   synchronized (SingletonOne.class) {//注意�Q�只有第一�ơ才��d��执行�q�里的代�?
    if(null!=singleton){
     singleton=new SingletonOne();
    }
   }
  }
  return singleton;
}
}

package com.abin.lee.collection.singleton;

public class SingletonTwo {
/**
* volatile关键词确保：当uniqueInstance变量被初始化成Singleton实例�Ӟ��
* 多个�U�程正确地处理uniqueInstance变量
*/
private volatile static SingletonTwo singleton = new SingletonTwo();

private SingletonTwo() {
}

public static SingletonTwo getInstance() {
return singleton;
}
}

abin 2012-09-01 00:27 发表评论

�l�承中静态块、游��d��、构造器�{�的执行��序

abin — Wed, 22 Aug 2012 07:07:00 GMT

在��承关�p�M��Q�静态块、游��d��、构造器、静态方法、静态变量、变量等的加载顺序是如何的呢�Q�！让代码来告诉我们�Q�结果如下：

父类静态块
子类静态块
父类变量
父类静态变�?br /> 父类游离�?br /> 父类构造器
子类变量
子类静态变�?br /> 子类游离�?br /> 子类的构造器

验证的代码：

package com.jlq.test;

public class Test1 {

private static String s1 = "父类静态变�?;

private String s2 = "父类变量";

public Test1() {
System.out.println("父类构造器");
}
/**
* 静态代码块
*/

static {
System.out.println("父类静态块");

}
/**
* 游离�?
*/
{
System.out.println(s2);
System.out.println(s1);
System.out.println("父类游离�?);

}

public static void main(String[] args) {
new TestChild();
}

}

class TestChild extends Test1 {

private static String s1 = "子类静态变�?;

private String s2 = "子类变量";
/**
* 静态代码块
*/

static {
System.out.println("子类静态块");

}
/**
* 游离�?
*/
{
System.out.println(s2);
System.out.println(s1);
System.out.println("子类游离�?);

}

public TestChild() {
System.out.println("子类的构造器");
}

}

abin 2012-08-22 15:07 发表评论

Java 重写equals和hashcode

abin — Wed, 08 Aug 2012 08:30:00 GMT

public boolean equals(Object other) {
  if ((this == other))
   return true;
  if ((other == null))
   return false;
  if (!(other instanceof BtsfSysAlipayNotifyJournal))
   return false;
  BtsfSysAlipayNotifyJournal castOther = (BtsfSysAlipayNotifyJournal) other;

  return ((this.getId() == castOther.getId()) || (this.getId() != null
    && castOther.getId() != null && this.getId().equals(
    castOther.getId())))
    && ((this.getPartner() == castOther.getPartner()) || (this
      .getPartner() != null
      && castOther.getPartner() != null && this.getPartner()
      .equals(castOther.getPartner())))
    && ((this.getDiscount() == castOther.getDiscount()) || (this
      .getDiscount() != null
      && castOther.getDiscount() != null && this
      .getDiscount().equals(castOther.getDiscount())))
    && ((this.getPaymentType() == castOther.getPaymentType()) || (this
      .getPaymentType() != null
      && castOther.getPaymentType() != null && this
      .getPaymentType().equals(castOther.getPaymentType())))
    && ((this.getSubject() == castOther.getSubject()) || (this
      .getSubject() != null
      && castOther.getSubject() != null && this.getSubject()
      .equals(castOther.getSubject())))
    && ((this.getTradeNo() == castOther.getTradeNo()) || (this
      .getTradeNo() != null
      && castOther.getTradeNo() != null && this.getTradeNo()
      .equals(castOther.getTradeNo())))
    && ((this.getBuyerEmail() == castOther.getBuyerEmail()) || (this
      .getBuyerEmail() != null
      && castOther.getBuyerEmail() != null && this
      .getBuyerEmail().equals(castOther.getBuyerEmail())))
    && ((this.getGmtCreate() == castOther.getGmtCreate()) || (this
      .getGmtCreate() != null
      && castOther.getGmtCreate() != null && this
      .getGmtCreate().equals(castOther.getGmtCreate())))
    && ((this.getQuantity() == castOther.getQuantity()) || (this
      .getQuantity() != null
      && castOther.getQuantity() != null && this
      .getQuantity().equals(castOther.getQuantity())))
    && ((this.getOutTradeNo() == castOther.getOutTradeNo()) || (this
      .getOutTradeNo() != null
      && castOther.getOutTradeNo() != null && this
      .getOutTradeNo().equals(castOther.getOutTradeNo())))
    && ((this.getSellerId() == castOther.getSellerId()) || (this
      .getSellerId() != null
      && castOther.getSellerId() != null && this
      .getSellerId().equals(castOther.getSellerId())))
    && ((this.getTradeStatus() == castOther.getTradeStatus()) || (this
      .getTradeStatus() != null
      && castOther.getTradeStatus() != null && this
      .getTradeStatus().equals(castOther.getTradeStatus())))
    && ((this.getIsTotalFeeAdjust() == castOther
      .getIsTotalFeeAdjust()) || (this.getIsTotalFeeAdjust() != null
      && castOther.getIsTotalFeeAdjust() != null && this
      .getIsTotalFeeAdjust().equals(
        castOther.getIsTotalFeeAdjust())))
    && ((this.getTotalFee() == castOther.getTotalFee()) || (this
      .getTotalFee() != null
      && castOther.getTotalFee() != null && this
      .getTotalFee().equals(castOther.getTotalFee())))
    && ((this.getGmtPayment() == castOther.getGmtPayment()) || (this
      .getGmtPayment() != null
      && castOther.getGmtPayment() != null && this
      .getGmtPayment().equals(castOther.getGmtPayment())))
    && ((this.getSellerEmail() == castOther.getSellerEmail()) || (this
      .getSellerEmail() != null
      && castOther.getSellerEmail() != null && this
      .getSellerEmail().equals(castOther.getSellerEmail())))
    && ((this.getGmtClose() == castOther.getGmtClose()) || (this
      .getGmtClose() != null
      && castOther.getGmtClose() != null && this
      .getGmtClose().equals(castOther.getGmtClose())))
    && ((this.getPrice() == castOther.getPrice()) || (this
      .getPrice() != null
      && castOther.getPrice() != null && this.getPrice()
      .equals(castOther.getPrice())))
    && ((this.getBuyerId() == castOther.getBuyerId()) || (this
      .getBuyerId() != null
      && castOther.getBuyerId() != null && this.getBuyerId()
      .equals(castOther.getBuyerId())))
    && ((this.getUseCoupon() == castOther.getUseCoupon()) || (this
      .getUseCoupon() != null
      && castOther.getUseCoupon() != null && this
      .getUseCoupon().equals(castOther.getUseCoupon())))
    && ((this.getCreateTime() == castOther.getCreateTime()) || (this
      .getCreateTime() != null
      && castOther.getCreateTime() != null && this
      .getCreateTime().equals(castOther.getCreateTime())))
    && ((this.getLastUpdateTime() == castOther.getLastUpdateTime()) || (this
      .getLastUpdateTime() != null
      && castOther.getLastUpdateTime() != null && this
      .getLastUpdateTime().equals(
        castOther.getLastUpdateTime())))
    && ((this.getPaymentMethod() == castOther.getPaymentMethod()) || (this
      .getPaymentMethod() != null
      && castOther.getPaymentMethod() != null && this
      .getPaymentMethod()
      .equals(castOther.getPaymentMethod())));
}

public int hashCode() {
int result = 17;

  result = 37 * result + (getId() == null ? 0 : this.getId().hashCode());
  result = 37 * result
    + (getPartner() == null ? 0 : this.getPartner().hashCode());
  result = 37 * result
    + (getDiscount() == null ? 0 : this.getDiscount().hashCode());
  result = 37
    * result
    + (getPaymentType() == null ? 0 : this.getPaymentType()
      .hashCode());
  result = 37 * result
    + (getSubject() == null ? 0 : this.getSubject().hashCode());
  result = 37 * result
    + (getTradeNo() == null ? 0 : this.getTradeNo().hashCode());
  result = 37
    * result
    + (getBuyerEmail() == null ? 0 : this.getBuyerEmail()
      .hashCode());
  result = 37 * result
    + (getGmtCreate() == null ? 0 : this.getGmtCreate().hashCode());
  result = 37 * result
    + (getQuantity() == null ? 0 : this.getQuantity().hashCode());
  result = 37
    * result
    + (getOutTradeNo() == null ? 0 : this.getOutTradeNo()
      .hashCode());
  result = 37 * result
    + (getSellerId() == null ? 0 : this.getSellerId().hashCode());
  result = 37
    * result
    + (getTradeStatus() == null ? 0 : this.getTradeStatus()
      .hashCode());
  result = 37
    * result
    + (getIsTotalFeeAdjust() == null ? 0 : this
      .getIsTotalFeeAdjust().hashCode());
  result = 37 * result
    + (getTotalFee() == null ? 0 : this.getTotalFee().hashCode());
  result = 37
    * result
    + (getGmtPayment() == null ? 0 : this.getGmtPayment()
      .hashCode());
  result = 37
    * result
    + (getSellerEmail() == null ? 0 : this.getSellerEmail()
      .hashCode());
  result = 37 * result
    + (getGmtClose() == null ? 0 : this.getGmtClose().hashCode());
  result = 37 * result
    + (getPrice() == null ? 0 : this.getPrice().hashCode());
  result = 37 * result
    + (getBuyerId() == null ? 0 : this.getBuyerId().hashCode());
  result = 37 * result
    + (getUseCoupon() == null ? 0 : this.getUseCoupon().hashCode());
  result = 37
    * result
    + (getCreateTime() == null ? 0 : this.getCreateTime()
      .hashCode());
  result = 37
    * result
    + (getLastUpdateTime() == null ? 0 : this.getLastUpdateTime()
      .hashCode());
  result = 37
    * result
    + (getPaymentMethod() == null ? 0 : this.getPaymentMethod()
      .hashCode());
  return result;
}

abin 2012-08-08 16:30 发表评论

abin — Tue, 27 Mar 2012 12:04:00 GMT

package com.abin.inter.test;

public class SplitString1 {
public static void main(String[] args) {
  StringBuffer stb = new StringBuffer();
  String unitId1 = "aaaaa";
  String callerNumber1 = "bbbbb";
  String calleeNumber1 = "ccccc";
  stb.append(unitId1).append("|").append(callerNumber1).append("|")
    .append(calleeNumber1);
  System.out.println("stb=" + stb.toString());
  String unitId = stb.toString()
    .substring(0, stb.toString().indexOf("|"));
  System.out.println("unitId=" + unitId);
  String temp1 = stb.toString().substring(unitId.length() + 1,
    stb.toString().length() - unitId.length());
  System.out.println("temp1=" + temp1);
  String callerNumber = temp1.substring(0, temp1.indexOf("|"));
  System.out.println("callerNumber=" + callerNumber);
  System.out.println("unitId.length()=" + unitId.length());
  System.out.println("callerNumber.length()=" + callerNumber.length());
  System.out.println("stb=" + stb.toString().length());
  String temp2 = stb.toString().substring(
    unitId.length() + callerNumber.length() + 2,
    stb.toString().length());
  System.out.println("temp2=" + temp2);
  String calleeNumber = temp2.substring(0, temp2.length());
  System.out.println("calleeNumber=" + calleeNumber);
}
}

abin 2012-03-27 20:04 发表评论