找出一些数，这些数不管几个相加得到的值或着单个的数都不会重复

根据linux的权限4(read),2(write),1(x),就想可以给任意一个开始的数，求一个类似于linux权限的数据列，这些数列有这些特点：这些数不管几个相加的值或着单个的数都不会重复。就如1，2，4，8这个数列，可以产生的值有，1,2,3,4,5,6,7,8,9,10,11,12,13,14,15这些值，反过来，如果拿出来一个值7那么就能在这个数列里找到唯一的是哪几个数相加的值，比如7就一定是1+2+4的值不会是别的。

于是写了一个类，给出一个开始数，然后找到一个类似于上面的一个数列。
类如下，这里只找到10000。
用这个虽然可以找到任意开始值的这么一个数列，但是总感觉这样计算太消耗内存，效率太低，总认为可以像数学上那样可以找到一个通项工式，就像有前面一个数就可以根据这个工式得到他的下一项，这样不会消耗内存效率也高，可是研究来研究去也没有找到这样的一个工式，不过发现不管从几开始，到一定的程序下一个数就是前面一个数的2倍，关键是不知道从何时开始会出现这个规律，数越大，这个规律出现的越迟。

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;


public class TestS {
	public static void main(String []args){
		printNumbers(1);
	}
	
	public static Set<Integer> printNumbers(Integer startNumber){
		Set<Integer> resultSet = new HashSet<Integer>();
		Set<Integer> resultSet1 = new HashSet<Integer>();
		Set<Integer> numbersSet = new HashSet<Integer>();
		for(int i = startNumber ; i < 10000 ; i ++){
			if(!resultSet.contains(i)){
				boolean flag = true;
				for(Integer j : resultSet){
					if(resultSet.contains(j + i)){
						flag = false;
						break;
					}
				}
				if(!flag){
					continue;
				}
				for(Integer j : resultSet){
					resultSet1.add(j+i);
				}
				numbersSet.add(i);
				resultSet.add(i);
				if(resultSet1 != null && resultSet1.size() > 0){
					resultSet.addAll(resultSet1);
					resultSet1.clear();
				}
				
				System.out.print(i + "----");
				printSet(numbersSet);
				System.out.print("----");
				printSet1(resultSet);
			}
			
		}
//		printSet(numbersSet);
		return numbersSet;
	}
	
	public static void printSet(Set<Integer> setObj){
		Set<Integer> numberTreeSet = new TreeSet<Integer>(setObj);
		for(Integer i : numberTreeSet){
			System.out.print(i+",");
		}
	}
	
	public static void printSet1(Set<Integer> setObj){
		Set<Integer> numberTreeSet = new TreeSet<Integer>(setObj);
		for(Integer i : numberTreeSet){
			System.out.print(i+",");
		}
		System.out.println("#############");
	}
	}
	
}

“不过发现不管从几开始，到一定的程序下一个数就是前面一个数的2倍”，这个现象很有意思，我似乎有种朦朦胧胧的感觉，可是证不出来