语源科技BlogJava-储备站

zz 什么时候用GET？什么时候用POST？

iConnect — Tue, 13 Oct 2009 05:09:00 GMT

http://www.lupaworld.com/28135/viewspace_15443.html

GET和POST两种方法都是将数据送到服务器，但你该用哪一种呢？
HTTP标准包含这两种方法是为了达到不同的目的。POST用于创建资源，资源的内容会被编入HTTP请示的内容中。例如，处理订货表单、在数据库中加入新数据行等。
当请求无副作用时（如进行搜索），便可使用GET方法；当请求有副作用时（如在数据库添加数据行），则用POST方法。一个比较实际的问题是：GET方法可能会产生很长的URL，或许会超过某些浏览器与服务器对URL长度的限制。
若符合下列任一情况，则用POST方法：

请求的结果有持续性的副作用，例如，数据库内添加新的数据行。
若使用GET方法，则表单上收集的数据可能让URL过长。
要传送的数据不是采用7位的ASCII编码。

若符合下列任一情况，则用GET方法：

请求是为了查找资源，HTML表单数据仅用来帮助搜索。
请求结果无持续性的副作用。
收集的数据及HTML表单内的输入字段名称的总长不超过1024个字符。

iConnect 2009-10-13 13:09 发表评论

zz finally的小特性

iConnect — Mon, 28 Sep 2009 03:09:00 GMT

http://zangxt.javaeye.com/blog/421508

try/catch/finally语句下，finally子句是肯定会执行的。但是很多人做不同的测试，却得出了不同的结论。

具体的原理最好是去看《深入java虚拟机》，里面对jsr、ret等几个指令做了详细的说明。这里不深入分析，而仅仅是从表现形式上看一下finally的特征。

代码：

/*

* author: Zang XT

*/



public class TestFinal {

public static void main(String[] args) {

System.out.println("test1:" + testFinal1());

System.out.println("test2:" + testFinal2());

System.out.println("test3:" + testFinal3());

System.out.println("test4:" + testFinal4());

}



static int testFinal1() {

int i = 1;

try {

return i;

} finally {

System.out.println("in testFinal1():finally 肯定会被执行的！");

i = 48;

}

}



static String testFinal2() {

String str = "try";

try {

return str;

} finally {

System.out.println("in testFinal2():finally 肯定会被执行的！");

str = "finally";

}

}



static StringBuilder testFinal3() {

StringBuilder build = new StringBuilder("try ");

try {

return build;

} finally {

System.out.println("in testFinal3():finally 肯定会被执行的！");

build.append("finally");

build = new StringBuilder("你猜我是谁！");

}

}



static String testFinal4() {

try {

return "return in try";

} finally {

System.out.println("in testFinal4():finally 肯定会被执行的！");

return "return in finally";

}

}

}

输出是：

in testFinal1():finally 肯定会被执行的！

test1:1

in testFinal2():finally 肯定会被执行的！

test2:try

in testFinal3():finally 肯定会被执行的！

test3:try finally

in testFinal4():finally 肯定会被执行的！

test4:return in finally

结论很明显，finally的语句确实执行了，而且肯定是在方法return之前执行的，而且，如果finally中有return语句的话，方法直接结束。这里需要注意的只有一点：在try中的return语句会将返回结果值压栈，然后转入到finally子过程，等到finally子过程执行完毕之后（没有return），再返回。

下面具体看4个例子：

在testFinal1()中，return i;会将结果i的值，也就是1压入栈。即使在finally中将i修改了（i=48），也不回对已经压入栈里的1造成任何影响。

在testFinal2()中，return str;将str的内容压入栈，比如我们假设str的内容为0x108(只是一个地址值),通过这个地址值我们能找到"try"，那栈里的内容就是 0x108。执行str = "finally"，这时候str这个变量的内容可能变为0x237了，这是串"finally"的地址。方法调用结束后，返回的是什么？return时压入栈里的0x108。所以在打印结果时，我们打印的是通过0x108找到的字符串"try"。

在testFinal3()中，return 压栈的是build这个变量的值，比如是0x3579，通过这个值我们可以找到StringBuilder对象。finally语句块中对这个对象的内容进行了修改。build = new StringBuilder("你猜我是谁！");让build变量指向了一个新的对象，这时候build的值可能是0x4579了。但是，别忘了，原来的StringBuilder对象仍然在0x3579处，而我们压栈的正是0x3579啊！方法返回后，我们得到的返回值0x3579，通过这个引用值找到相应的StringBuilder对象，所以打印的结果是test3:try finally。

在testFinal4()中，finally有return语句，直接返回，方法结束。

为什么不同的人有不同的结论？关键是没有正确理解压栈的是什么东西。其实初学java的时候，如果理解了变量是什么，并区分引用和对象本身就不会得到错误的结论了。再有，如果理解java中，方法调用都是采用传值模式的话，这里也就类似的可以明白了。

iConnect 2009-09-28 11:09 发表评论

整数转字符串

iConnect — Sat, 26 Sep 2009 07:41:00 GMT

void IntToStr(int a,char* str){
    if(a==0){
        *str='0';
        *(str+1)='\0';
        return;
    }

    char* p = str;
    if(a<0){
        a=a*(-1);
        *p++ = '-';
    }
    int len = 0;
    while(a){
        *p++ = a%10+'0';
        a/=10;
        ++len;
    }
    int start = *str=='-'?1:0;
    int tmp;
    for(int i=0;i         tmp = str[start+i];
        str[start+i]=str[len+start-1-i];
        str[len+start-1-i]=tmp;
    }
    str[len+start]='\0';
}
void main(){

    char* str = new char[12];
    //IntToStr(0,str);
    IntToStr(-12340,str);
    //IntToStr(214748367,str);
    printf("%s\n",str);
}

iConnect 2009-09-26 15:41 发表评论

static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？

iConnect — Mon, 07 Sep 2009 15:37:00 GMT

static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？

　　全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。

　　从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。

　　static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件

　　static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;

　　static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；

　　static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝.

iConnect 2009-09-07 23:37 发表评论

(zz) Ubuntu inittab 小区别

iConnect — Sun, 02 Aug 2009 16:44:00 GMT

http://www.5dlinux.com/article/1/2008/linux_12543.html

转到kubuntu之前曾经学习了一下，了解到ubuntu在6.10开始用upstart替代init，主要脚本都在/etc/event.d下面，默认情况下/etc下没有inittab文件。

刚装上kubuntu时候专门到/etc/event.d下看了一下，特别注意到rc-default这个脚本，里面有一段内容:

说明默认情况下inittab虽然不存在，但是用户建立的inittab还是会被注意到的。

然后又经别人的指点看了一下/usr/share/doc/upstart/下面的文档，其中README.Debian中有这么一段内容：

这就给我这样一个印象，即虽然ubuntu用upstart替代init，但还是和init保持兼容。

今天正好需要将系统直接启动到字符界面下，即不启动kdm。

那就试试自建一个inittab文件，并按照以前的习惯写入一行id:3:initdefault: ，保存后重新启动，结果发现毫无变化，依然启动到桌面，有点纳闷，难道inittab不起作用？在终端里输入runlevel检查当前状态，显示 N 3，说明inittab有效果，那是什么原因呢？

将刚才建立的inittab移除，将系统恢复到之前的状态并重新启动，再用runlevel检查，显示 N 2，说明ubuntu系统的default runlevel可能是2，这和我以前的常识有些冲突，看来又需要学习了。

先去分别查看/etc/rc2.d至rc5.d下的内容，发现基本一致，都启动了kdm。这与其他的linux发行版不太一致，通常runlevel 3是Multi user mode，即直接登录到字符界面；而runlevel 5是Multi user mode with GUI，即登录到图形界面。

后来在Debian的FAQ里面搜索到这样的内容：

小区别就在这里了，看来debian以及衍生出来的发行版，如ubuntu的default runlevel确实是2，而且id 2至5都是一样的。

真相大白，再次建立inittab，写入id:3:initdefault: ，然后进入/etc/rc3.d，将S13kdm移动到其他目录备份起来，重新启动系统，如愿以偿进入字符界面。

iConnect 2009-08-03 00:44 发表评论

（zz） x&(x-1)表达式的意义

iConnect — Sun, 19 Jul 2009 07:27:00 GMT

http://hi.baidu.com/zengzhaonong/blog/item/7fb884509ee30c61853524c2.html

x&(x-1)表达式的意义

求下面函数的返回值(微软) -- 统计1的个数
-------------------------------------
int func(int x)
{
    int countx = 0;
    while(x)
    {
        countx++;
        x = x&(x-1);
    }
    return countx;
}

假定x = 9999
10011100001111
答案: 8

思路: 将x转化为2进制，看含有的1的个数。
注: 每执行一次x = x&(x-1)，会将x用二进制表示时最右边的一个1变为0，因为x-1将会将该位(x用二进制表示时最右边的一个1)变为0。

判断一个数(x)是否是2的n次方
-------------------------------------
#include

int func(int x)
{
    if( (x&(x-1)) == 0 )
        return 1;
    else
        return 0;
}

int main()
{
    int x = 8;
    printf("%d\n", func(x));
}

注:
(1) 如果一个数是2的n次方，那么这个数用二进制表示时其最高位为1，其余位为0。

(2) == 优先级高于 &

iConnect 2009-07-19 15:27 发表评论

计算整数的二进制表示有多少个1

iConnect — Sun, 19 Jul 2009 06:38:00 GMT

#include<stdio.h>
#include<stdlib.h>

unsigned long count_one(unsigned long data)
{
    unsigned long count = 0;
    unsigned long x = data;
    while(x)
    {
        count++;
        x = x & (x-1);
    }
    return count;
}

int main(){
    unsigned long data[] = {13,16,25,31,76};
    int i = 0;
    int size = sizeof(data)/sizeof(unsigned long);
    for(i=0;i<size;i++){
        printf("%d has %d 1s\n",data[i],count_one(data[i]));
    }
    return 0;
}

iConnect 2009-07-19 14:38 发表评论

(zz)IP校验和详解

iConnect — Sun, 12 Jul 2009 15:42:00 GMT

一、 校验和算法

之前一直只知道IP校验和算法反码求和相关的,但具体细节不清楚,今天了解了下。

IP校验和主要是用来保证数据(IP包头)的完整性的.它用的算法非常简单,就是反码求和校验.需要注意的是反码求和又叫1的补码(one's complement),而2的补码就是我们通常说的补码求和了.校验算法具体如下.

1、发送方

i)将校验和字段置为0,然后将IP包头按16比特分成多个单元,如包头长度不是16比特的倍数,则用0比特填充到16比特的倍数;

ii)对各个单元采用反码加法运算(即高位溢出位会加到低位,通常的补码运算是直接丢掉溢出的高位),将得到的和的反码填入校验和字段;

iii)发送数据包;

2、接收方

i)将IP包头按16比特分成多个单元,如包头长度不是16比特的倍数,则用0比特填充到16比特的倍数;

ii)对各个单元采用反码加法运算,检查得到的和是否符合是全1(有的实现可能对得到的和会取反码,然后判断最终值是不是全0);

iii)如果是全1则进行下步处理,否则意味着包已变化从而丢弃之.

需要强调的是反码和是采用高位溢出加到低位的,如3比特的反码和运算:100b+101b=010b(因为100b+101b=1001b,高位溢出1,其应该加到低位,即001b+1b(高位溢出位)=010b),具体细节请参考文章:http://blog.chinaunix.net/u/20/showart_438418.html

二、 校验和源码

网上流传多组实现,常见的有如下两种(如追求效率可改写为汇编代码):

1、RFC1071源码

unsigned short csum(unsigned char *addr, int count) { /* Compute Internet Checksum for "count" bytes * beginning at location "addr". */ register long sum = 0; while( count > 1 )

{ /* This is the inner loop */ sum += * (unsigned short) addr++; count -= 2; } /* Add left-over byte, if any */ if( count > 0 ) sum += * (unsigned char *) addr; /* Fold 32-bit sum to 16 bits */ while (sum>>16) sum = (sum & 0xffff) + (sum >> 16); return ~sum; }

第一个while循环是做普通加法(2进制补码加法),因为IP包头和TCP整个报文段比较短(没达到2^17数量级),所以不可能导致4字节的sum溢出(unsigned long 一般至少为4字节)).
    紧接着的一个判断语句是为了能处理输入数据是奇数个字节的这种情况.
    再接着的数据循环是实现反码算法(在前面的普通加法得到的数据的基础上),由反码和的高位溢出加到低位的性质,可得到"32位的数据的高位比特移位16比特,再加上原来的低16比特,不影响最终结果"这个等价运算,因为sum的最初值(刚开始循环时)可能很大,所以这个等价运算需循环进行,直到sum的高比特(16比特以上)全为0.对于32位的sum,事实上这个运算循环至多只有两轮,所以也有程序直接用两条"sum = (sum & 0xffff) + (sum >> 16);"代替了整个循环.
    最后,对和取反返回.

2、对数据长度没限制的实现

unsigned short cksum (struct ip *ip, int len) { long sum = 0; /* assume 32 bit long, 16 bit short */ while ( len >1 )

{

sum += *((unsigned short *) ip)++;

if (sum & 8x00000000) /* if high-order bit set, fold */ sum = (sum & 0xFFFF) + (sum>> 16) ;

len -= 2;

} if ( len ) /* take care of left over byte */ sum += ( unsigned short ) * (unsignedl char *) ip; while ( sum >> 16) sum =(sum & 0xFFFF) + (sum>> 16);

return ~sum;

}

这个实现与前面的一个的最大的不同是对数据的长度没什么限制了,因为它在第一个循环的加法运算中实时检测sum的高位的值,一旦发现其有溢出的危险,就及时运用等价运算关系消除了这个危险.

三、 几个细节问题

1、数据部分改变时的重校验
考虑这样的应用场景:路由器转发IP报文时,有可能只更改了IP数据包头的部分内容(如更改了TTL,分片了或SNAT更改了源IP等~~~),却需要重校验的问题.为提高转发效率,要求重校验算法尽可能快,故出现了如下的重校验算法:

UpdateTTL(struct ip_hdr *ipptr, unsigned char n) { unsigned long sum; unsigned short old; old = ntohs(*(unsigned short *)&ipptr->ttl); ipptr->ttl -= n; sum = old + (~ntohs(*(unsigned short *)&ipptr->ttl) & 0xffff); sum += ntohs(ipptr->Checksum); sum = (sum & 0xffff) + (sum>>16); ipptr->Checksum = htons(sum + (sum>>16));

}

算法的实现依据是这样的.假设包头原校验和为~C,改变的字段的原始值是m,更改后的值是m',设~C'为重校验和,则有 ~C' = ~(C+(-m)+m') = ~C+(m-m') = ~C+m+~m'
等价关系的成立基于反码的运算性质:取反运算满足结合律,按位取反运算与符号取反(及相反数)是等价的(即~C=-C).

2、为什么采用反码和运算

   IP数据包校验要求速度快,所以只采用了简单的和校验,为什么采用反码和而不是补码和呢?
   i)反码和的溢出有后效性(蔓延性)
    反码和将高位溢出加到低位,导致这个溢出会对后面操作有永久影响,有后效性;而补码和直接将高位和溢出,导致这个溢出对后面的操作再无影响,因此无后效性
   ii)反码校验无需考虑字节序
    正因为反码和的溢出有后效性,导致大端字节序(big-endian)和小端字节序(little-endian)对同一数据序列(如两个16比特的序列)产生的校验和也只是字节序相反，而补码和因为将溢出丢掉了,不同字节序之间的校验大不相同且没什么联系。
   基于以上的理由，校验和运算既可选择在数据被转换成网络字节序前，也可选择在之后。（这其实可以看作是负负得正，计算校验和与字节序有关，然后写校验和字段与字节序有关，然后直接计算校验和再写校验和字段则与字节序无关了~~）

四、 参考文章

http://blog.chinaunix.net/u/20/showart_438512.html，关于IP校验和的
http://blog.chinaunix.net/u/12313/showart_176114.html，关于网络校验和的
http://www.wesoho.com/article/Delphi/2143.htm，关于IP校验和的
http://blog.chinaunix.net/u/20/showart_438418.html，关于补码和反码的

iConnect 2009-07-12 23:42 发表评论

数组循环位移

iConnect — Sun, 07 Jun 2009 04:00:00 GMT

给定有N个元素数组，将之循环移K位，不能使用库函数，不能使用辅助数组，要求时间复杂度为O(N)

解法1：
思路：
（1）整个数组倒序
（2）0 - K位倒序
（3）K - (N-1)位倒序

代码：

void printArray(int a[],int n){

    for(int i=0;i<n;i++){
        printf("%d\t",a[i]);
    }
    printf("\n");
}

void reverse(int a[], int begin, int end){
    int n = (end-begin+1)/2;
    for(int i=0;i<n;i++){
        int t = a[begin+i];
        a[begin+i] = a[end-i-1];
        a[end-i-1] = t;
    }
}

void shift(int a[], int n, int k){
    k = (n+k%n)%n;
    reverse(a,0,n);
    reverse(a,0,k);
    reverse(a,k,n);
}

void main(){
    int a[] = {1,2,3,4,5,6,7,8};
        int n = sizeof(a)/sizeof(int);
    printArray(a,n);
    //shift(a,n,-1);
        shift(a,n,4);
    printArray(a,8);
}

解法2：

void Output(int *pBuffer, int nCount)
{
    if(!pBuffer || !nCount) return;

    for (size_t i = 0; i < nCount; i++)
    {
        printf(" %d ", pBuffer[i]);
    }

    printf("\n");

}

void ShiftN(int *pBuffer, int nCount, int nShiftN)
{
    if(!pBuffer || !nCount || !nShiftN) return;

    nShiftN %= nCount;

    int nIndex = 0;
    int nStart  = nIndex;

    int nTemp  = pBuffer[nIndex];

    for (size_t i = 0; i < nCount; i++)
    {
        nIndex = (nIndex + nShiftN) % nCount;

        pBuffer[nIndex] ^= nTemp ^=
        pBuffer[nIndex] ^= nTemp ;

        if(nIndex == nStart)
        {
            nStart ++;
            nIndex = nStart;
            nTemp = pBuffer[nIndex];
        }
    }
}

int main(int argc, char* argv[])
{
    int buffer[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

    int nCount = sizeof(buffer) / sizeof(int);

    Output(buffer, nCount);

    ShiftN(buffer, nCount, 8);

    Output(buffer, nCount);

    return 0;
}

iConnect 2009-06-07 12:00 发表评论

单链表反转

iConnect — Wed, 03 Jun 2009 14:47:00 GMT