我们都知道，在整数中，能够被2整除的数称作偶数，不能被2整除的数称作奇数。因此判断一个数的奇偶性我们都是拿它除以2，看是否有余数来确定。那么有没有一种更高级一点的方法呢？

学过计算机二进制的朋友们应该都知道或(|)、与(&)、非(！)的概念，比如0|0=0，0&0=0，0|1=1，0&1=0，1|1=1，1&1=1。而任何一个奇数的二进制表示形式，第一位肯定是1，比如3的二进制是00000011，5的二进制是00000101，7的二进制是00000111，相反偶数的第一位肯定是0，因此拿这个数和00000001相与，如果是偶数，则结果必是0，比如偶数2，00000010&00000001，结果是0。那么，我们就可以基于这一点来进行判断了。

可能有人会说，这有什么用，把简单问题复杂化根本没有意义。其实对于我们人来说，确实意义不大，但是对于计算机来说意义很大，因为计算机内部的算法就是这样，即使我们用数字除以2来判断，编译后计算机还是会这么算。所以，我们直接跳过中间这一步，直接用&方法来判断，则能省下一个步骤，对于大量运算的计算机来说，还是很有实际意义的。为此，我还专门写了一个程序，看看两种算法下计算1000次、10000次、100000次甚至1000000次所花费的时间，代码如下。

直接贴代码：

public class MyTest {

/**

* 比较两种判断奇偶数方法的执行效率

* @param count 执行次数

* @param numberSize 生成随机数的个数

*/

public static void compare(int count, int numberSize) {

Long tt1 = Long.valueOf(0);

Long tt2 = Long.valueOf(0);

Set numberSet;

for(int i = 0; i < count; i++) {

// 获取指定个数的随机数

numberSet = randomNumber(numberSize);

System.out.println(“第”+ (i + 1) + “次执行：”);

Long t1 = System.currentTimeMillis();

judgeNumber(numberSet);

Long t2 = System.currentTimeMillis();

tt1 += (t2 - t1);

Long t3 = System.currentTimeMillis();

judgeNumber1(numberSet);

Long t4 = System.currentTimeMillis();

tt2 += (t4 - t3);

}

System.out.println("\n第一种方法平均耗时：" + (float) tt1/count + " ms");

System.out.println(“第二种方法平均耗时：” + (float) tt2/count + " ms");

}

// 生成指定个数的随机数

public static Set<Integer> randomNumber(int numberSize) {

Random random = new Random();

int n = 0;

Set<Integer> numberSet = new HashSet<>();

for (int i = 0; i < Integer.MAX_VALUE; i++) {

if (numberSet.size() < numberSize) {

numberSet.add(random.nextInt());

} else {

break;

}

}

return numberSet;

}

// 判断奇偶数

public static void judgeNumber(Set<Integer> numberSet) {

int n1 = 0,n2 = 0;

for (Integer number:numberSet) {

if ((number & 0x01) == 0) {

n1++;

} else {

n2++;

}

}

System.out.println("第一种方法偶数的个数是：" + n1 + "\t\t奇数的个数是：" + n2);

}

// 判断奇偶数

public static void judgeNumber1(Set<Integer> numberSet) {

int n1 = 0,n2 = 0;

for (Integer number:numberSet) {

if ((number % 2) == 0) {

n1++;

} else {

n2++;

}

}

System.out.println("第二种方法偶数的个数是：" + n1 + "\t\t奇数的个数是：" + n2);

}

public static void main(String[] args) {

compare(10, 1000000);

}

}

首先我判断一千次的耗时，执行十次，算出平均耗时，结果如下：

第1次执行：

第一种方法偶数的个数是：519 奇数的个数是：481

第二种方法偶数的个数是：519 奇数的个数是：481

第2次执行：

第一种方法偶数的个数是：512 奇数的个数是：488

第二种方法偶数的个数是：512 奇数的个数是：488

第3次执行：

第一种方法偶数的个数是：486 奇数的个数是：514

第二种方法偶数的个数是：486 奇数的个数是：514

第4次执行：

第一种方法偶数的个数是：500 奇数的个数是：500

第二种方法偶数的个数是：500 奇数的个数是：500

第5次执行：

第一种方法偶数的个数是：482 奇数的个数是：518

第二种方法偶数的个数是：482 奇数的个数是：518

第6次执行：

第一种方法偶数的个数是：506 奇数的个数是：494

第二种方法偶数的个数是：506 奇数的个数是：494

第7次执行：

第一种方法偶数的个数是：478 奇数的个数是：522

第二种方法偶数的个数是：478 奇数的个数是：522

第8次执行：

第一种方法偶数的个数是：528 奇数的个数是：472

第二种方法偶数的个数是：528 奇数的个数是：472

第9次执行：

第一种方法偶数的个数是：496 奇数的个数是：504

第二种方法偶数的个数是：496 奇数的个数是：504

第10次执行：

第一种方法偶数的个数是：514 奇数的个数是：486

第二种方法偶数的个数是：514 奇数的个数是：486

第一种方法平均耗时：1.6 ms

第二种方法平均耗时：1.0 ms

然后我判断一万次的耗时，执行十次，算出平均耗时，结果如下：

第1次执行：

第一种方法偶数的个数是：4946 奇数的个数是：5054

第二种方法偶数的个数是：4946 奇数的个数是：5054

第2次执行：

第一种方法偶数的个数是：4936 奇数的个数是：5064

第二种方法偶数的个数是：4936 奇数的个数是：5064

第3次执行：

第一种方法偶数的个数是：4977 奇数的个数是：5023

第二种方法偶数的个数是：4977 奇数的个数是：5023

第4次执行：

第一种方法偶数的个数是：5004 奇数的个数是：4996

第二种方法偶数的个数是：5004 奇数的个数是：4996

第5次执行：

第一种方法偶数的个数是：5072 奇数的个数是：4928

第二种方法偶数的个数是：5072 奇数的个数是：4928

第6次执行：

第一种方法偶数的个数是：4914 奇数的个数是：5086

第二种方法偶数的个数是：4914 奇数的个数是：5086

第7次执行：

第一种方法偶数的个数是：4962 奇数的个数是：5038

第二种方法偶数的个数是：4962 奇数的个数是：5038

第8次执行：

第一种方法偶数的个数是：5077 奇数的个数是：4923

第二种方法偶数的个数是：5077 奇数的个数是：4923

第9次执行：

第一种方法偶数的个数是：5006 奇数的个数是：4994

第二种方法偶数的个数是：5006 奇数的个数是：4994

第10次执行：

第一种方法偶数的个数是：4940 奇数的个数是：5060

第二种方法偶数的个数是：4940 奇数的个数是：5060

第一种方法平均耗时：3.5 ms

第二种方法平均耗时：2.3 ms

判断十万次的耗时，执行十次，算出平均耗时，结果如下：

第1次执行：

第一种方法偶数的个数是：49929 奇数的个数是：50071

第二种方法偶数的个数是：49929 奇数的个数是：50071

第2次执行：

第一种方法偶数的个数是：49893 奇数的个数是：50107

第二种方法偶数的个数是：49893 奇数的个数是：50107

第3次执行：

第一种方法偶数的个数是：49932 奇数的个数是：50068

第二种方法偶数的个数是：49932 奇数的个数是：50068

第4次执行：

第一种方法偶数的个数是：49898 奇数的个数是：50102

第二种方法偶数的个数是：49898 奇数的个数是：50102

第5次执行：

第一种方法偶数的个数是：50004 奇数的个数是：49996

第二种方法偶数的个数是：50004 奇数的个数是：49996

第6次执行：

第一种方法偶数的个数是：50019 奇数的个数是：49981

第二种方法偶数的个数是：50019 奇数的个数是：49981

第7次执行：

第一种方法偶数的个数是：49881 奇数的个数是：50119

第二种方法偶数的个数是：49881 奇数的个数是：50119

第8次执行：

第一种方法偶数的个数是：50004 奇数的个数是：49996

第二种方法偶数的个数是：50004 奇数的个数是：49996

第9次执行：

第一种方法偶数的个数是：49899 奇数的个数是：50101

第二种方法偶数的个数是：49899 奇数的个数是：50101

第10次执行：

第一种方法偶数的个数是：50066 奇数的个数是：49934

第二种方法偶数的个数是：50066 奇数的个数是：49934

第一种方法平均耗时：8.5 ms

第二种方法平均耗时：8.8 ms

我判断一百万次的耗时，执行十次，算出平均耗时，结果如下：

第1次执行：

第一种方法偶数的个数是：499904 奇数的个数是：500096

第二种方法偶数的个数是：499904 奇数的个数是：500096

第2次执行：

第一种方法偶数的个数是：500172 奇数的个数是：499828

第二种方法偶数的个数是：500172 奇数的个数是：499828

第3次执行：

第一种方法偶数的个数是：499950 奇数的个数是：500050

第二种方法偶数的个数是：499950 奇数的个数是：500050

第4次执行：

第一种方法偶数的个数是：499937 奇数的个数是：500063

第二种方法偶数的个数是：499937 奇数的个数是：500063

第5次执行：

第一种方法偶数的个数是：499896 奇数的个数是：500104

第二种方法偶数的个数是：499896 奇数的个数是：500104

第6次执行：

第一种方法偶数的个数是：499992 奇数的个数是：500008

第二种方法偶数的个数是：499992 奇数的个数是：500008

第7次执行：

第一种方法偶数的个数是：500145 奇数的个数是：499855

第二种方法偶数的个数是：500145 奇数的个数是：499855

第8次执行：

第一种方法偶数的个数是：499907 奇数的个数是：500093

第二种方法偶数的个数是：499907 奇数的个数是：500093

第9次执行：

第一种方法偶数的个数是：499958 奇数的个数是：500042

第二种方法偶数的个数是：499958 奇数的个数是：500042

第10次执行：

第一种方法偶数的个数是：500116 奇数的个数是：499884

第二种方法偶数的个数是：500116 奇数的个数是：499884

第一种方法平均耗时：59.7 ms

第二种方法平均耗时：70.7 ms

可以看到，当判断次数为一千次和一万次的时候，第一种方法甚至比第二种方法耗时更久，直到判断次数达到十万次的时候，第一种方法的优势才开始慢慢显露出来，判断一百万次的时候直接耗时少了十多毫秒。