Rising Sun

浅拷贝和深拷贝

摘要: 浅拷贝就比如像引用类型，而深拷贝就比如值类型。浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。对其中任何一个对象的改动都会影响另外一个对象。举个例子，一个人一开始叫张三，后来改名叫李四了，可是还是同一个人，不管是张三缺胳膊少腿还是李四缺胳膊少腿，都是这个人倒霉。深拷贝是指源对象与拷贝对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。... 阅读全文

posted @ 2013-02-21 11:03 brock| 编辑收藏

Hashmap 的 loadFactor设置初使化值的时候必须设置 loadFactor

1、请查看 hashmap 如何初使化

代码：

public HashMap(int initialCapacity, float loadFactor) {

if (initialCapacity < 0)

throw new IllegalArgumentException("Illegal initial capacity: " +

initialCapacity);

if (initialCapacity > MAXIMUM_CAPACITY)

initialCapacity = MAXIMUM_CAPACITY;

if (loadFactor <= 0 || Float.isNaN(loadFactor))

throw new IllegalArgumentException("Illegal load factor: " +

loadFactor);

// Find a power of 2 >= initialCapacity

int capacity = 1;

while (capacity < initialCapacity)

capacity <<= 1;

this.loadFactor = loadFactor;

threshold = (int)(capacity * loadFactor);

table = new Entry[capacity];

init();

}

当

Map map = new HashMap(9);

while (capacity < initialCapacity)

capacity <<= 1;

capacity的容量为 16

threshold扩容阀值 16*0.75 =12

和9没什么关系哈

当

Map map = new HashMap(9，1);

capacity的容量为 16

threshold扩容阀值 16*1 =16
不过这个 9 变小一点就不一样了如3时capacity 是4

posted @ 2013-02-01 16:37 brock 阅读(2912) | 评论 (0) | 编辑收藏

Java对象的4种引用类型

学了这么久的Java,才知道Java的对象引用类型有4种。所以，赶紧把不知道的东西补上！

对于需要长期运行的应用程序来说，如果无用的对象所占用的内存空间不能得到即时的释放的话，那么在一个局部的时间段内便形成了事实上的内存泄露。

以前我们学过，如果要及时地释放内存，最稳妥的方法就是使用完对象之后，立刻执行"object=null"语句。当然，这也是一种理想状态。

JDK里面引入了4种对象引用类型，可以算是强行的调用System.gc()这个的垃圾回收的方法了。

强引用：前面我们用的全部对象都是强引用类型的。这个就显示地执行"object=null"语句。

软引用：被软引用的对象，如果内存空间足够，垃圾回收器是不会回收它的，如果内存空间不足，垃圾回收器将回收这些对象占用的内存空间。软件引用对应着java.lang.ref.SoftReference类，一个对象如果要被软引用，只需将其作为参数传入SoftReference类的构造方法中就行了。感觉还是比较简单而且容易理解。

弱引用：与前面的软引用相比，被弱引用了的对象拥有更短的内存时间（也就是生命周期）。垃圾回收器一旦发现了被弱引用的对象，不管当前内存空间是不是足够，都会回收它的内存，弱引用对应着java.lang.ref.WeakReference类，同样的道理。一个对象如果想被弱引用，只需将其作为参数传入WeakReference类的构造方法中就行了。

虚引用:虚引用不是一种真实可用的引用类型，完全可以视为一种“形同虚设”的引用类型。设计虚引用的目的在于结合引用关联队列，实现对对象引用关系的跟踪（太高科技了，这几句话。目前还不知道是什么意思）。虚引用对应着java.lang.ref.PhantomReference类。一个对象如果要被虚引用，只需将其作为参数传入PhantomReference类的构造方法中就行了，同时作为参数传入的还有引用关联队列java.lang.ref.ReferenceQueue的对象实例。(没懂)

SoftReference,WeakReference,PhantomReference类都继承自java.lang.ref.Reference抽象类。Reference抽象类定义了clear() 方法用于撤销引用关系，get()方法用于返回被引用的对象。

摘抄一段代码示例:

import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.util.Set;
import java.util.HashSet;

public class TestReferences
{
    public static void main(String[] args)
    {
        int length=10;

        //创建length个MyObject对象的强引用
        Set<MyObject> a = new HashSet<MyObject>();
        for(int i = 0; i < length; i++)
        {
            MyObject ref=new MyObject("Hard_" + i);
            System.out.println("创建强引用：" +ref);
            a.add(ref);
        }
        //a=null;
        System.gc();

        //创建length个MyObject对象的软引用
        Set<SoftReference<MyObject>> sa = new HashSet<SoftReference<MyObject>>();
        for(int i = 0; i < length; i++)
        {
            SoftReference<MyObject> ref=new SoftReference<MyObject>(new MyObject("Soft_" + i));
            System.out.println("创建软引用：" +ref.get());
            sa.add(ref);
        }
        System.gc();

        //创建length个MyObject对象的弱引用
        Set<WeakReference<MyObject>> wa = new HashSet<WeakReference<MyObject>>();
        for(int i = 0; i < length; i++)
        {
            WeakReference<MyObject> ref=new WeakReference<MyObject>(new MyObject("Weak_" + i));
            System.out.println("创建弱引用：" +ref.get());
            wa.add(ref);
        }
        System.gc();

        //创建length个MyObject对象的虚引用
        ReferenceQueue<MyObject> rq = new ReferenceQueue<MyObject>();
        Set<PhantomReference<MyObject>> pa = new HashSet<PhantomReference<MyObject>>();
        for(int i = 0; i < length; i++)
        {
            PhantomReference<MyObject> ref = new PhantomReference<MyObject>(new MyObject("Phantom_" + i), rq);
            System.out.println("创建虚引用：" +ref.get());
            pa.add(ref);
        }
        System.gc();
    }
}

class MyObject
{
private String id;

    public MyObject(String id)
    {
        this.id = id;
    }

    public String toString()
    {
        return id;
    }

    public void finalize()
    {
        System.out.println("回收对象：" + id);
    }
}

posted @ 2013-01-21 16:40 brock 阅读(254) | 评论 (0) | 编辑收藏

javap使用小结 i++ ++i

一直在学习Java,碰到了很多问题，碰到了很多关于i++和++i的难题，以及最经典的String str = "abc" 共创建了几个对象的疑难杂症。知道有一日知道了java的反汇编命令 javap。现将学习记录做一小结，以供自己以后翻看。如果有错误的地方，请指正

1.javap是什么：

where options include:
-c Disassemble the code
-classpath <pathlist> Specify where to find user class files
-extdirs <dirs> Override location of installed extensions
-help Print this usage message
-J<flag> Pass <flag> directly to the runtime system
-l Print line number and local variable tables
-public Show only public classes and members
-protected Show protected/public classes and members
-package Show package/protected/public classes
and members (default)
-private Show all classes and members
-s Print internal type signatures
-bootclasspath <pathlist> Override location of class files loaded
by the bootstrap class loader
-verbose Print stack size, number of locals and args for met
hods
If verifying, print reasons for failure　

以上为百度百科里对它的描述，只是介绍了javap的一些参数和使用方法，而我们要用的就是这一个：-c Disassemble the code。

明确一个问题：javap是什么？网上有人称之为反汇编器，可以查看java编译器为我们生成的字节码。通过它，我们可以对照源代码和字节码，从而了解很多编译器内部的工作。

2.初步认识javap

从一个最简单的例子开始：

这个例子中，我们只是简单的声明了两个int型变量并赋上初值。下面我们看看javap给我们带来了什么：（当然执行javap命令前，你得首先配置好自己的环境，能用javac编译通过了，即：javac TestJavap.java )

我们只看（方便起见，将注释写到每句后面）

Code:
0: iconst_2 //把2放到栈顶
1: istore_1 //把栈顶的值放到局部变量1中，即i中
2: iconst_3 //把3放到栈顶
3: istore_2 //把栈顶的值放到局部变量1中，即j中
4: return

是不是很简单？（当然，估计需要点数据结构的知识），那我们就补点java的关于堆栈的知识：

对于 int i = 2;首先它会在栈中创建一个变量为i的引用，然后查找有没有字面值为2的地址，没找到，就开辟一个存放2这个字面值的地址，然后将i指向2的地址。

看了这段话，再比较下上面的注释，是不是完全吻合？

为了验证上面这一说法，我们继续实验：

我们将 i 和 j的值都设为2。按照以上理论，在声明j的时候，会去栈中招有没有字面值为2的地址，由于在栈中已经有2这个字面值，便将j直接指向2的地址。这样，就出现了i与j同时均指向2的情况。

拿出javap -c进行反编译：结果如下：

Code:
0: iconst_2 //把2放到栈顶
1: istore_1 //把栈顶的值放到局部变量1中，即i中
2: iconst_2 //把2放到栈顶
3: istore_2 //把栈顶的值放到局部变量2中，即j中(i 和 j同时指向2)
4: return

虽然这里说i和j同时指向2，但这里不等于说i和j指向同一块地址（java是不允许程序员直接修改堆栈中的数据的，所以就不要想着，我是不是可以修改栈中的2，那样岂不是i和j的值都会变化。另：在编译器内部，遇到j=2；时，它就会重新搜索栈中是否有2的字面值，如果没有，重新开辟地址存放2的值；如果已经有了，则直接将j指向这个地址。因此,就算j另被赋值为其他值，如j=4,j值的改变不会影响到i的值。）

再来一个例子：

还是javap -c

Code:
0: iconst_2 //把2放到栈顶
1: istore_1 //把栈顶的值放到局部变量1中，即i中
2: iload_1 //把i的值放到栈顶，也就是说此时栈顶的值是2
3: istore_2 //把栈顶的值放到局部变量2中，即j中
4: return

看到这里是不是有点明确了？

既然我们对javap有了一定的了解，那我们就开始用它来解决一些实际的问题：

1.i++和++i的问题

反编译结果为

Code:
0: iconst_1
1: istore_1
2: iinc 1, 1 //这个个指令，把局部变量1，也就是i，增加1，这个指令不会导致栈的变化，i此时变成2了
5: iconst_1
6: istore_2
7: iinc 2, 1//这个个指令，把局部变量2，也就是j，增加1，这个指令不会导致栈的变化，j此时变成2了
10: return

可以看出，++在前在后，在这段代码中，没有任何不同。

我们再看另一段代码：

反编译结果：

Code:
0: iconst_1
1: istore_1
2: iload_1
3: iinc 1, 1 //局部变量1（即i）加1变为2，注意这时栈中仍然是1，没有改变
6: istore_1 //把栈顶的值放到局部变量1中，即i这时候由2变成了1
7: iconst_1
8: istore_2
9: iinc 2, 1 //局部变量2（即j）加1变为2，注意这时栈中仍然是1，没有改变
12: iload_2 //把局部变量2（即j）的值放到栈顶，此时栈顶的值变为2
13: istore_2 //把栈顶的值放到局部变量2中，即j这时候真正由1变成了2
14: return

是否看明白了？如果这个看明白了，那么下面的一个问题应该就是迎刃而解了：

m = m ++；这句话，java虚拟机执行时是这样的： m的值加了1，但这是栈中的值还是0，马上栈中的值覆盖了m，即m变成0，因此不管循环多少次，m都等于0。

如果改为m = ++m; 程序运行结果就是100了。。。

posted @ 2013-01-21 15:26 brock 阅读(365) | 评论 (1) | 编辑收藏

201212时间计算

public static void main(String[] args) {

Calendar c = Calendar.getInstance();

System.out.println(c.get(Calendar.YEAR) * 100 + c.get(Calendar.WEEK_OF_YEAR));

c.set(Calendar.YEAR, 2013);

c.set(Calendar.WEEK_OF_YEAR, c.get(Calendar.WEEK_OF_YEAR));

int w = c.get(Calendar.DAY_OF_WEEK);

for (int i = 1; i <= 7; i++) {

c.set(Calendar.DAY_OF_WEEK, i);

System.out.println("该周第一天是[" + DateFormatUtils.format(c, "yyyy-MM-dd") + "]");

}

int dd = 201205;

System.out.println(dd / 100);

System.out.println(dd % (dd / 100));

}

posted @ 2013-01-10 10:56 brock 阅读(184) | 评论 (0) | 编辑收藏

插值算法

public static void main(String[] args) {

List<Integer> a = new ArrayList<Integer>();

a.add(1);

a.add(5);

a.add(7);

a.add(9);

List<Integer> b = new ArrayList<Integer>();

b.add(2);

b.add(4);

b.add(8);

List<Integer> c = new ArrayList<Integer>();

c.addAll(a);

c.addAll(b);

List<Integer> d = new ArrayList<Integer>();

for (Integer dd : b) {

d.add(dd);

}

// Integer

Collections.sort(c, new Comparator<Integer>() {

@Override

public int compare(Integer source, Integer desc) {

if (source.compareTo(desc) > 0) {

return 1;

}

return -1;

}

});

for (int j = 0; j < a.size(); j++) {

for (int k = 0; k < b.size(); k++) {

if (a.get(j) > b.get(k)) {

if (k == b.size() - 1) {

b.add(b.get(b.size() - 1));

break;

}

continue;

}

//

if (a.get(j) < b.get(k)) {

if (k == 0) {

b.add(k, 0);

} else {

b.add(k, b.get(k - 1));

}

break;

}

for (int j = 0; j < d.size(); j++) {

for (int k = 0; k < a.size(); k++) {

if (d.get(j) > a.get(k)) {

if (k == a.size() - 1) {

a.add(a.get(a.size() - 1));

break;

}

continue;

}

//

if (d.get(j) < a.get(k)) {

if (k == 0) {

a.add(k, 0);

} else {

a.add(k, a.get(k - 1));

}

break;

}

System.out.println(c);

System.out.println(a);

System.out.println(b);

}

posted @ 2013-01-07 15:13 brock 阅读(298) | 评论 (0) | 编辑收藏

Java.Lang.NoSuchMethodError: Org.Apache.Commons.Collections

Java.Lang.NoSuchMethodError:仔细检查，原来我自己将tomcat下的lib也导入进来了，里面有一个commons-collection.jar(2.0版本），晕啊！马上砍掉，导入commons-collection.jar 3.0版本，一切OK，郁闷了一个晚上！！！！
he.Commons.Collections

posted @ 2012-10-10 10:15 brock 阅读(278) | 评论 (0) | 编辑收藏

CMS，全称Concurrent Low Pause Collector gc

    首先感谢阿宝同学的帮助，我才对这个gc算法的调整有了一定的认识，而不是停留在过去仅仅了解的阶段。在读过sun的文档和跟阿宝讨论之后，做个小小的总结，如果有谬误，敬请指正。
    CMS，全称Concurrent Low Pause Collector，是jdk1.4后期版本开始引入的新gc算法，在jdk5和jdk6中得到了进一步改进，它的主要适合场景是对响应时间的重要性需求大于对吞吐量的要求，能够承受垃圾回收线程和应用线程共享处理器资源，并且应用中存在比较多的长生命周期的对象的应用。CMS是用于对tenured generation的回收，也就是年老代的回收，目标是尽量减少应用的暂停时间，减少full gc发生的几率，利用和应用程序线程并发的垃圾回收线程来标记清除年老代。在我们的应用中，因为有缓存的存在，并且对于响应时间也有比较高的要求，因此希望能尝试使用CMS来替代默认的server型JVM使用的并行收集器，以便获得更短的垃圾回收的暂停时间，提高程序的响应性。
    CMS并非没有暂停，而是用两次短暂停来替代串行标记整理算法的长暂停，它的收集周期是这样：
    初始标记(CMS-initial-mark) -> 并发标记(CMS-concurrent-mark) -> 重新标记(CMS-remark) -> 并发清除(CMS-concurrent-sweep) ->并发重设状态等待下次CMS的触发(CMS-concurrent-reset)。
    其中的1，3两个步骤需要暂停所有的应用程序线程的。第一次暂停从root对象开始标记存活的对象，这个阶段称为初始标记；第二次暂停是在并发标记之后，暂停所有应用程序线程，重新标记并发标记阶段遗漏的对象（在并发标记阶段结束后对象状态的更新导致）。第一次暂停会比较短，第二次暂停通常会比较长，并且 remark这个阶段可以并行标记。

    而并发标记、并发清除、并发重设阶段的所谓并发，是指一个或者多个垃圾回收线程和应用程序线程并发地运行，垃圾回收线程不会暂停应用程序的执行，如果你有多于一个处理器，那么并发收集线程将与应用线程在不同的处理器上运行，显然，这样的开销就是会降低应用的吞吐量。Remark阶段的并行，是指暂停了所有应用程序后，启动一定数目的垃圾回收进程进行并行标记，此时的应用线程是暂停的。

    CMS的young generation的回收采用的仍然是并行复制收集器，这个跟Paralle gc算法是一致的。

    下面是参数介绍和遇到的问题总结，

1、启用CMS：-XX:+UseConcMarkSweepGC。咳咳，这里犯过一个低级错误，竟然将+号写成了-号

2。CMS默认启动的回收线程数目是 (ParallelGCThreads + 3)/4) ，如果你需要明确设定，可以通过-XX:ParallelCMSThreads=20来设定,其中ParallelGCThreads是年轻代的并行收集线程数

3、CMS是不会整理堆碎片的，因此为了防止堆碎片引起full gc，通过会开启CMS阶段进行合并碎片选项：-XX:+UseCMSCompactAtFullCollection，开启这个选项一定程度上会影响性能，阿宝的blog里说也许可以通过配置适当的CMSFullGCsBeforeCompaction来调整性能，未实践。

4.为了减少第二次暂停的时间，开启并行remark: -XX:+CMSParallelRemarkEnabled。如果remark还是过长的话，可以开启-XX:+CMSScavengeBeforeRemark选项，强制remark之前开始一次minor gc，减少remark的暂停时间，但是在remark之后也将立即开始又一次minor gc。

5.为了避免Perm区满引起的full gc，建议开启CMS回收Perm区选项：

+CMSPermGenSweepingEnabled -XX:+CMSClassUnloadingEnabled

6.默认CMS是在tenured generation沾满68%的时候开始进行CMS收集，如果你的年老代增长不是那么快，并且希望降低CMS次数的话，可以适当调高此值：
-XX:CMSInitiatingOccupancyFraction=80

这里修改成80%沾满的时候才开始CMS回收。

7.年轻代的并行收集线程数默认是(cpu <= 8) ? cpu : 3 + ((cpu * 5) / 8)，如果你希望降低这个线程数，可以通过-XX:ParallelGCThreads= N 来调整。

8.进入重点，在初步设置了一些参数后，例如：

Java代码

-server -Xms1536m -Xmx1536m -XX:NewSize=256m -XX:MaxNewSize=256m -XX:PermSize=64m
-XX:MaxPermSize=64m -XX:-UseConcMarkSweepGC -XX:+UseCMSCompactAtFullCollection
-XX:CMSInitiatingOccupancyFraction=80 -XX:+CMSParallelRemarkEnabled
-XX:SoftRefLRUPolicyMSPerMB=0

需要在生产环境或者压测环境中测量这些参数下系统的表现，这时候需要打开GC日志查看具体的信息，因此加上参数：

-verbose:gc -XX:+PrintGCTimeStamps -XX:+PrintGCDetails -Xloggc:/home/test/logs/gc.log

在运行相当长一段时间内查看CMS的表现情况，CMS的日志输出类似这样：

Java代码

4391.322: [GC [1 CMS-initial-mark: 655374K(1310720K)] 662197K(1546688K), 0.0303050 secs] [Times: user=0.02 sys=0.02, real=0.03 secs]
4391.352: [CMS-concurrent-mark-start]
4391.779: [CMS-concurrent-mark: 0.427/0.427 secs] [Times: user=1.24 sys=0.31, real=0.42 secs]
4391.779: [CMS-concurrent-preclean-start]
4391.821: [CMS-concurrent-preclean: 0.040/0.042 secs] [Times: user=0.13 sys=0.03, real=0.05 secs]
4391.821: [CMS-concurrent-abortable-preclean-start]
4392.511: [CMS-concurrent-abortable-preclean: 0.349/0.690 secs] [Times: user=2.02 sys=0.51, real=0.69 secs]
4392.516: [GC[YG occupancy: 111001 K (235968 K)]4392.516: [Rescan (parallel) , 0.0309960 secs]4392.547: [weak refs processing, 0.0417710 secs] [1 CMS-remark: 655734K(1310720K)] 766736K(1546688K), 0.0932010 secs] [Times: user=0.17 sys=0.00, real=0.09 secs]
4392.609: [CMS-concurrent-sweep-start]
4394.310: [CMS-concurrent-sweep: 1.595/1.701 secs] [Times: user=4.78 sys=1.05, real=1.70 secs]
4394.310: [CMS-concurrent-reset-start]
4394.364: [CMS-concurrent-reset: 0.054/0.054 secs] [Times: user=0.14 sys=0.06, real=0.06 secs]

其中可以看到CMS-initial-mark阶段暂停了0.0303050秒，而CMS-remark阶段暂停了0.0932010秒，因此两次暂停的总共时间是0.123506秒，也就是123毫秒左右。两次短暂停的时间之和在200以下可以称为正常现象。

但是你很可能遇到两种fail引起full gc：Prommotion failed和Concurrent mode failed。

Prommotion failed的日志输出大概是这样：

Java代码

[ParNew (promotion failed): 320138K->320138K(353920K), 0.2365970 secs]42576.951: [CMS: 1139969K->1120688K(
166784K), 9.2214860 secs] 1458785K->1120688K(2520704K), 9.4584090 secs]

这个问题的产生是由于救助空间不够，从而向年老代转移对象，年老代没有足够的空间来容纳这些对象，导致一次full gc的产生。解决这个问题的办法有两种完全相反的倾向：增大救助空间、增大年老代或者去掉救助空间。增大救助空间就是调整-XX:SurvivorRatio参数，这个参数是Eden区和Survivor区的大小比值，默认是32，也就是说Eden区是 Survivor区的32倍大小，要注意Survivo是有两个区的，因此Surivivor其实占整个young genertation的1/34。调小这个参数将增大survivor区，让对象尽量在survitor区呆长一点，减少进入年老代的对象。去掉救助空间的想法是让大部分不能马上回收的数据尽快进入年老代，加快年老代的回收频率，减少年老代暴涨的可能性，这个是通过将-XX:SurvivorRatio 设置成比较大的值（比如65536)来做到。在我们的应用中，将young generation设置成256M，这个值相对来说比较大了，而救助空间设置成默认大小(1/34)，从压测情况来看，没有出现prommotion failed的现象，年轻代比较大，从GC日志来看，minor gc的时间也在5-20毫秒内，还可以接受，因此暂不调整。

Concurrent mode failed的产生是由于CMS回收年老代的速度太慢，导致年老代在CMS完成前就被沾满，引起full gc，避免这个现象的产生就是调小-XX:CMSInitiatingOccupancyFraction参数的值，让CMS更早更频繁的触发，降低年老代被沾满的可能。我们的应用暂时负载比较低，在生产环境上年老代的增长非常缓慢，因此暂时设置此参数为80。在压测环境下，这个参数的表现还可以，没有出现过Concurrent mode failed。

参考资料：
《JDK5.0垃圾收集优化之--Don't Pause》 by 江南白衣
《记一次Java GC调整经历》1,2 by Arbow
Java SE 6 HotSpot[tm] Virtual Machine Garbage Collection Tuning
Tuning Garbage Collection with the 5.0 JavaTM Virtual Machine

posted @ 2012-09-12 12:59 brock 阅读(1181) | 评论 (1) | 编辑收藏

Linux vim编辑命令总结

Posted on 2011-11-20 22:42 Biffo Lee 阅读(685) 评论(0) 编辑收藏

1. 启动vim编译器

vim filename 打开原有的文件或创建一个新文件。

vim 打开一个新文件，在编辑过程中或结束编辑时再指定文件名。

vim –r filename 恢复因意外停机或终端连接中断而未及时保存最终编辑结果的文件。

view filename 以只读方式打开文件。除了不能把编辑处理的最终结果写入文件保存之外，view的所有编辑功能均与vim无异。

2. 光标定位命令

←↑↓→ 将光标左移、上移、下移或右移一个字符（行）位置。

h j k l 同上。

- 光标上移一行。

Enter键（或加号“+”）光标下移一行。

退格键将光标左移一个字符位置。

空格键将光标右移一个字符位置（命令模式）。

Ctrl+F 往下（文件结尾方向）滚动一屏。

Ctrl+B 往上（文件开始方向）滚动一屏。

Ctrl+D 往下滚动半屏。

Ctrl+U 往上滚动半屏。

Ctrl+E 编辑窗口中的文件内容整体上移一行。

Ctrl+Y 编辑窗口中的文件内容整体下移一行。

w 将光标右移一个字。光标停留在下一个字的字首位置。

W 将光标右移一个字。光标停留在下一个字的字首位置（即使两个字之间存在标点符号）。

b 将光标左移一个字。光标停留在下一个字的字首位置。

B 将光标左移一个字。光标停留在下一个字的字首位置（即使两个字之间存在标点符号）。

e 把光标移至当前所在字（或下一个字）的最后一个字符位置。

E 同上，只是以空格字符作为字的分隔符。

^ 把光标移至当前行的起始位置，也即当前行的第一个非空白字符位置

0（零）同上

$ 把光标移至当前行的行尾，也即当前行的最后一个字符位置。

H 把光标移至编辑窗口顶部第一行的行首位置。

M 把光标移至编辑窗口中间一行的行首位置。

L 把光标移至编辑窗口底部最后一行的行首位置。

3. 插入文本数据

a 在光标当前所在字符位置的后面输入文本数据。

A 在光标当前所在行的行尾（也即最后一个字符位置）后面输入文本数据。

i 在光标当前所在字符位置的前面输入文本数据。

I 在光标当前所在行的行首（也即在第一个非空白的起始字符）前面输入文本数据。

o 在光标当前所在行下面的行首位置输入文本数据。

O 在光标当前所在行上面的行首位置输入文本数据。

4. 修改文本

C 替换当前文本行光标所在字符位置之后的所有数据，以Esc键结束。

cw 替换光标当前所在字符位置及之后的整个字或部分字，以Esc键结束。

[n]cc 替换当前行，或从当前行开始的n行文本，以Esc键结束。

[n]s 替换光标当前所在位置的单个字符，或从光标当前位置开始的n个字符，以Esc键结束。

S 替换当前行，以Esc键结束。

r 替换光标当前所在位置的单个字符。

r<Enter> 断行。也可使用“a”或“i”命令加Enter及Esc键实现。

R 从光标当前所在的字符位置开始，替换随后的所有字符，直至按下Esc键。

xp 交换字符位置。交换光标当前所在位置开始字符位置。

~ 转换光标当前所在位置字符的大小写。

u 撤销最近一次执行的编辑命令，或依次撤销先前执行的编辑命令。

:u 同上（ex编辑命令）。

U 撤销施与当前文本行的编辑处理。

5. 删除文本

[n]x 删除光标当前所在位置的字符，或删除从光标当前位置开始的n个字符。

[n]X 删除光标当前所在位置的前一个字符，或删除光标当前所在位置之前的n个字符。

dw 删除光标当前所在位置的一个整字或部分字符。如果光标在字首，则删除整字。如果光标在字的中间任何位置，则删除光标位置及之后的字符。

[n]dd 删除光标当前所在的文本行，或删除从当前行开始的n个文本行。

D 删除当前文本行从光标位置开始之后的所有字符。

dG 删除从当前行开始直至文件最后一行的所有文本行。

d[n]G 删除从文件的第n行开始直至当前行的所有文本行。

:line#1,line#2 d 删除从指定的行号line#1到line#2之间的所有文本行。

6. 复制与移动文本

[n]yy 复制光标当前所在的文本行，或从当前行开始的n个文本行。

[n]Y 同上。

p（小写）把复制或删除（“dd”命令）的文本行粘贴到光标所在行的下面。

P（大写）把复制或删除（“dd”命令）的文本行粘贴到光标所在行的上面。

:line#1,line#2 co line#3 把第line#1~line#2行复制到第line#3行之后。

:line#1,line#2 m line#3 把第line#1~line#2行移至第line#3行之后。

7. 设置行号显示

:set nu 在编辑期间增加临时行号。

:set nonu 撤销行号显示（默认情况）。

Ctrl+G 显示当前文件的名字和当前文本行的行号。

8. 设置大小写字母检索准则

:set ic 检索字符串时忽略字母的大小写。

:set noic 检索字符串时严格区分字母的大小写（默认情况）。

9. 定位文本行

G 将光标移至文件的组后一行。

[n]G 将光标移至文件的第n行。

10. 检索与替换

:/string 向前（文件结尾方向）检索指定的字符串。

:?string 向后（文件开头方向）检索指定的字符串。

n 将检索方向找出下一个匹配的字符串。

N 逆检索方向找出前一个匹配的字符串。

:[g]/search/s//replace/[g][c] 检索并替换字符串。

11. 清除屏幕

Ctrl+L 清除因其他进程的输出信息而干扰的编辑窗口。

12. 合并文件与合并行

:r filename 在光标所在行之后插入指定文件的内容。

: line#1 r filename 在第line#1行之后插入指定文件的内容。

J 把相邻的两个文本行个并为一行（把下一行合并到光标当前所在行的后面）。

13. 保存编辑结果与退出vim编辑器

:w 保存编辑处理后的结果（把内存缓冲区中的数据写到文件中）。

:w! 强制保存编辑处理后的结果。

:wq 保存编辑处理后的结果，然后退出vim编辑器。

:wq! 强制保存编辑处理后的结果，然后退出vim编辑器。

ZZ 保存编辑处理后的结果，然后退出vim编辑器。

:q 在未做任何编辑处理时，可以使用此命令退出vim编辑器。

:q! 强制退出vim编辑器，放弃编辑处理后的结果。

:w filename 把编辑处理后的结果写到指定的文件中保存。

:w! filename 把编辑处理后的结果强制写到指定的文件中保存，即使文件已经存在。

:wq! filename 把编辑处理后的结果强制写到指定的文件中保存，即使文件已经存在，然后退出vim编辑器。

14. 其他

;f 或 Ctrl+G 显示文件的名字、编辑状态、文件总的行数、光标当前所在行号和列号，以及当前行之前的行数占整个文件总行数的百分比。

Ctrl+V 输入控制字符。

posted @ 2012-09-04 17:07 brock 阅读(322) | 评论 (0) | 编辑收藏

Gson通过借助TypeToken获取泛型参数的类型的方法

最近在使用Google的Gson包进行Json和Java对象之间的转化，对于包含泛型的类的序列化和反序列化Gson也提供了很好的支持，感觉有点意思，就花时间研究了一下。

由于Java泛型的实现机制，使用了泛型的代码在运行期间相关的泛型参数的类型会被擦除，我们无法在运行期间获知泛型参数的具体类型（所有的泛型类型在运行时都是Object类型）。

但是有的时候，我们确实需要获知泛型参数的类型，比如将使用了泛型的Java代码序列化或者反序列化的时候，这个时候问题就变得比较棘手。

?

1

2

3

4

5

6

7

8

class Foo<T> {

T value;

}

Gson gson = new Gson();

Foo<Bar> foo = new Foo<Bar>();

gson.toJson(foo); // May not serialize foo.value correctly

gson.fromJson(json, foo.getClass()); // Fails to deserialize foo.value as Bar

对于上面的类Foo<T>，由于在运行期间无法得知T的具体类型，对这个类的对象进行序列化和反序列化都不能正常进行。Gson通过借助TypeToken类来解决这个问题。

?

1

2

3

4

5

6

7

8

TestGeneric<String> t = new TestGeneric<String>();

t.setValue("Alo");

Type type = new TypeToken<TestGeneric<String>>(){}.getType();

String gStr = GsonUtils.gson.toJson(t,type);

System.out.println(gStr);

TestGeneric t1 = GsonUtils.gson.fromJson(gStr, type);

System.out.println(t1.getValue());

TypeToken的使用非常简单，如上面的代码，只要将需要获取类型的泛型类作为TypeToken的泛型参数构造一个匿名的子类，就可以通过getType()方法获取到我们使用的泛型类的泛型参数类型。

下面来简单分析一下原理。

要获取泛型参数的类型，一般的做法是在使用了泛型的类的构造函数中显示地传入泛型类的Class类型作为这个泛型类的私有属性，它保存了泛型类的类型信息。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

public class Foo<T>{

public Class<T> kind;

public Foo(Class<T> clazz){

this.kind = clazz;

}

public T[] getInstance(){

return (T[])Array.newInstance(kind, 5);

}

public static void main(String[] args){

Foo<String> foo = new Foo(String.class);

String[] strArray = foo.getInstance();

}

这种方法虽然能解决问题，但是每次都要传入一个Class类参数，显得比较麻烦。Gson库里面对于这个问题采用了了另一种解决办法。

同样是为了获取Class的类型，可以通过另一种方式实现：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

public abstract class Foo<T>{

Class<T> type;

public Foo(){

this.type = (Class<T>) getClass();

}

public static void main(String[] args) {

Foo<String> foo = new Foo<String>(){};

Class mySuperClass = foo.getClass();

}

声明一个抽象的父类Foo，匿名子类将泛型类作为Foo的泛型参数传入构造一个实例，再调用getClass方法获得这个子类的Class类型。

这里虽然通过另一种方式获得了匿名子类的Class类型，但是并没有直接将泛型参数T的Class类型传进来，那又是如何获得泛型参数的类型的呢，这要依赖Java的Class字节码中存储的泛型参数信息。Java的泛型机制虽然在运行期间泛型类和非泛型类都相同，但是在编译java源代码成 class文件中还是保存了泛型相关的信息，这些信息被保存在class字节码常量池中，使用了泛型的代码处会生成一个signature签名字段，通过签名signature字段指明这个常量池的地址。

关于class文件中存储泛型参数类型的具体的详细的知识可以参考这里：http://stackoverflow.com/questions/937933/where-are-generic-types-stored-in-java-class-files

JDK里面提供了方法去读取这些泛型信息的方法，再借助反射，就可以获得泛型参数的具体类型。同样是对于第一段代码中的foo对象，通过下面的代码可以得到foo<T>中的T的类型：

?

1

2

3

Type mySuperClass = foo.getClass().getGenericSuperclass();

Type type = ((ParameterizedType)mySuperClass).getActualTypeArguments()[0];

System.out.println(type);

运行结果是class java.lang.String。

分析一下这段代码，Class类的getGenericSuperClass()方法的注释是：

Returns the Type representing the direct superclass of the entity (class, interface, primitive type or void) represented by thisClass.

If the superclass is a parameterized type, the Type object returned must accurately reflect the actual type parameters used in the source code. The parameterized type representing the superclass is created if it had not been created before. See the declaration of ParameterizedType for the semantics of the creation process for parameterized types. If thisClass represents either theObject class, an interface, a primitive type, or void, then null is returned. If this object represents an array class then theClass object representing theObject class is returned

概括来说就是对于带有泛型的class，返回一个ParameterizedType对象，对于Object、接口和原始类型返回null，对于数组class则是返回Object.class。ParameterizedType是表示带有泛型参数的类型的Java类型，JDK1.5引入了泛型之后，Java中所有的Class都实现了Type接口，ParameterizedType则是继承了Type接口，所有包含泛型的Class类都会实现这个接口。

实际运用中还要考虑比较多的情况，比如获得泛型参数的个数避免数组越界等，具体可以参看Gson中的TypeToken类及ParameterizedTypeImpl类的代码。

posted @ 2012-08-01 16:26 brock 阅读(42666) | 评论 (6) | 编辑收藏

常用链接

留言簿(10)

随笔分类

随笔档案

相册

java--->ajax

搜索

最新评论

阅读排行榜

评论排行榜

导航

Linux vim编辑命令总结