public static boolean isConsecutive(Integer[] a) {
if (a != null && a.length >= 1) {
Set<Integer> set = new HashSet<Integer>();
set.addAll(Arrays.asList(a));
if (Collections.max(set) - Collections.min(set) + 1 == set.size()) {
return true;
}
}
return false;
}

排序的同时 在加个判断大小就行了

正解

可以初始化和给出数组相同大小的数组A，以第一个数作为参照标准，采用增量标志法在数组A中置位相应的元素（越界或者重复置位返回false，最后返回true）。2遍循环搞定

对oriArr一次遍历，取min,max,sum
return 计算min到max之和==sum
避免了中间数组，排序，使用集合类估计得不了分吧

有点儿意思哈

Arrays.sort()排序数字
循环，数组后位减去前位，只要满足大于1则不能组成连续数字。

我的思路：先排序，后遍历
不知道最优的算法是什么

import java.util.Arrays;
public class Driver{
	public static void main(String[]args){
		int testArray1[] = { 1 , 2 , 3 , 4 , 5 , 8};
		System.out.print("testArray1 ");
		new IsContinousArray().isContinous(testArray1);
		
		int testArray2[] = {  6 , 5 ,3 ,1 ,2 ,4 ,7 ,0 ,8 };
		System.out.print("testArray2 ");
		new IsContinousArray().isContinous(testArray2);
	}
	
}
class IsContinousArray {
	public void isContinous(int []array){
		
		if(array.length == 0){        //空数组
			System.out.println("empty array");
			return;
		}else if(array.length == 1){  // 数组长度为1
		    System.out.println("continous array");
		    return;
		}else   
			Arrays.sort(array);  // 升序	
			int i = 1;			
			while( i < array.length){
				if( array[i-1] == array[i]  ||  array[i-1] == array[i] - 1){  //重复或者前面比后面的小1
					i++;
				}else{
					System.out.println("is not a continous array");
					return;
				}	
			}
			System.out.println("is a continous array");
	}
}

输出：
testArray1 is not a continous array
testArray2 is a continous array

find  intMin  and  intMax,
if array.length < intMax - intMin +1  return false;
new int array[intMax - intMin +1]
for 0 --> valueArray.length
newArray[valueArray[index] - intMin] = 1

for 0 --> newArray.length
if newArray[index] == 0 return false;
return ture;

import java.util.Random;

public class Ss {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Random ra = new Random();
		int intValues[] = new int[44710089/10];
		for (int i = 0; i < intValues.length; i++) {
			intValues[i] = ra.nextInt(300000) - 100000;
			// intValues[i] = (int)(Math.random()*80000) - 40000;
		}

		long startTime = System.currentTimeMillis();
		System.out.println("intValues[] "
				+ (isLinkArray(intValues) ? "is " : "is not ") + "linked !");
		long endTime = System.currentTimeMillis();
		System.out.println("Spend " + (endTime - startTime) +" ms !");
	}

	public static boolean isLinkArray(int[] intValues) {
		int min, max;
		min = max = intValues[0];
		for (int i = 1; i < intValues.length; i++) {
			if (intValues[i] < min) {
				min = intValues[i];
			} else if (intValues[i] > max) {
				max = intValues[i];
			}
		}
		System.out.println("min = " + min + ";  max = " + max);

		if (intValues.length < max - min + 1) {
			return false;
		}

		int tempArray[] = new int[max - min + 1];
		for (int i = 0; i < intValues.length; i++) {
			tempArray[intValues[i] - min] = 1;
		}

		for (int i = 0; i < tempArray.length; i++) {
			if (tempArray[i] == 0) {
				return false;
			}
		}
		return true;
	}
}

这个方法比较帅