geohash java算法

1. geohash有以下几个特点：

   首先，geohash用一个字符串表示经度和纬度两个坐标。某些情况下无法在两列上同时应用索引 （例如MySQL 4之前的版本，Google App Engine的数据层等），利用geohash，只需在一列上应用索引即可。

   其次，geohash表示的并不是一个点，而是一个矩形区域。比如编码wx4g0ec19，它表示的是一个矩形区域。 使用者可以发布地址编码，既能表明自己位于北海公园附近，又不至于暴露自己的精确坐标，有助于隐私保护。

   第三，编码的前缀可以表示更大的区域。例如wx4g0ec1，它的前缀wx4g0e表示包含编码wx4g0ec1在内的更大范围。 这个特性可以用于附近地点搜索。首先根据用户当前坐标计算geohash（例如wx4g0ec1）然后取其前缀进行查询 （SELECT * FROM place WHERE geohash LIKE 'wx4g0e%'），即可查询附近的所有地点。

   Geohash比直接用经纬度的高效很多。

    

   Geohash的原理

   Geohash的最简单的解释就是：将一个经纬度信息，转换成一个可以排序，可以比较的字符串编码

   
           首先将纬度范围(-90, 90)平分成两个区间(-90,0)、(0, 90)，如果目标纬度位于前一个区间，则编码为0，否则编码为1。

   由于39.92324属于(0, 90)，所以取编码为1。

   然后再将(0, 90)分成 (0, 45), (45, 90)两个区间，而39.92324位于(0, 45)，所以编码为0。

   以此类推，直到精度符合要求为止，得到纬度编码为1011 1000 1100 0111 1001。

   纬度范围	划分区间0	划分区间1	39.92324所属区间
   (-90, 90)	(-90, 0.0)	(0.0, 90)	1
   (0.0, 90)	(0.0, 45.0)	(45.0, 90)	0
   (0.0, 45.0)	(0.0, 22.5)	(22.5, 45.0)	1
   (22.5, 45.0)	(22.5, 33.75)	(33.75, 45.0)	1
   (33.75, 45.0)	(33.75, 39.375)	(39.375, 45.0)	1
   (39.375, 45.0)	(39.375, 42.1875)	(42.1875, 45.0)	0
   (39.375, 42.1875)	(39.375, 40.7812)	(40.7812, 42.1875)	0
   (39.375, 40.7812)	(39.375, 40.0781)	(40.0781, 40.7812)	0
   (39.375, 40.0781)	(39.375, 39.7265)	(39.7265, 40.0781)	1
   (39.7265, 40.0781)	(39.7265, 39.9023)	(39.9023, 40.0781)	1
   (39.9023, 40.0781)	(39.9023, 39.9902)	(39.9902, 40.0781)	0
   (39.9023, 39.9902)	(39.9023, 39.9462)	(39.9462, 39.9902)	0
   (39.9023, 39.9462)	(39.9023, 39.9243)	(39.9243, 39.9462)	0
   (39.9023, 39.9243)	(39.9023, 39.9133)	(39.9133, 39.9243)	1
   (39.9133, 39.9243)	(39.9133, 39.9188)	(39.9188, 39.9243)	1
   (39.9188, 39.9243)	(39.9188, 39.9215)	(39.9215, 39.9243)	1

    

   经度也用同样的算法，对(-180, 180)依次细分，得到116.3906的编码为1101 0010 1100 0100 0100。
   
   

   经度范围	划分区间0	划分区间1	116.3906所属区间
   (-180, 180)	(-180, 0.0)	(0.0, 180)	1
   (0.0, 180)	(0.0, 90.0)	(90.0, 180)	1
   (90.0, 180)	(90.0, 135.0)	(135.0, 180)	0
   (90.0, 135.0)	(90.0, 112.5)	(112.5, 135.0)	1
   (112.5, 135.0)	(112.5, 123.75)	(123.75, 135.0)	0
   (112.5, 123.75)	(112.5, 118.125)	(118.125, 123.75)	0
   (112.5, 118.125)	(112.5, 115.312)	(115.312, 118.125)	1
   (115.312, 118.125)	(115.312, 116.718)	(116.718, 118.125)	0
   (115.312, 116.718)	(115.312, 116.015)	(116.015, 116.718)	1
   (116.015, 116.718)	(116.015, 116.367)	(116.367, 116.718)	1
   (116.367, 116.718)	(116.367, 116.542)	(116.542, 116.718)	0
   (116.367, 116.542)	(116.367, 116.455)	(116.455, 116.542)	0
   (116.367, 116.455)	(116.367, 116.411)	(116.411, 116.455)	0
   (116.367, 116.411)	(116.367, 116.389)	(116.389, 116.411)	1
   (116.389, 116.411)	(116.389, 116.400)	(116.400, 116.411)	0
   (116.389, 116.400)	(116.389, 116.394)	(116.394, 116.400)	0

   接下来将经度和纬度的编码合并，奇数位是纬度，偶数位是经度，得到编码 11100 11101 00100 01111 00000 01101 01011 00001。

   最后，用0-9、b-z（去掉a, i, l, o）这32个字母进行base32编码，得到(39.92324, 116.3906)的编码为wx4g0ec1。

   十进制	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
   base32	0	1	2	3	4	5	6	7	8	9	b	c	d	e	f	g
   十进制	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31
   base32	h	j	k	m	n	p	q	r	s	t	u	v	w	x	y	z

    

   解码算法与编码算法相反，先进行base32解码，然后分离出经纬度，最后根据二进制编码对经纬度范围进行细分即可，这里不再赘述。

   
   
2. 
   
3. 
   
4. 
   
5. 
   
6. View Code  
7.  import java.io.File;    
8.  import java.io.FileInputStream;    
9.  import java.util.BitSet;    
10.  import java.util.HashMap;    
11.      
12.      
13.  public class Geohash {    
14.      
15.      private static int numbits = 6 * 5;    
16.      final static char[] digits = { '0', '1', '2', '3', '4', '5', '6', '7', '8',    
17.              '9', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n', 'p',    
18.              'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };    
19.          
20.      final static HashMap<Character, Integer> lookup = new HashMap<Character, Integer>();    
21.      static {    
22.          int i = 0;    
23.          for (char c : digits)    
24.              lookup.put(c, i++);    
25.      }    
26.      
27.      public static void main(String[] args)  throws Exception{    
28.      
29.          System.out.println(new Geohash().encode(45, 125));    
30.                  
31.      }    
32.    
33.      public double[] decode(String geohash) {    
34.          StringBuilder buffer = new StringBuilder();    
35.          for (char c : geohash.toCharArray()) {    
36.      
37.              int i = lookup.get(c) + 32;    
38.              buffer.append( Integer.toString(i, 2).substring(1) );    
39.          }    
40.              
41.          BitSet lonset = new BitSet();    
42.          BitSet latset = new BitSet();    
43.              
44.          //even bits    
45.          int j =0;    
46.          for (int i=0; i< numbits*2;i+=2) {    
47.              boolean isSet = false;    
48.              if ( i < buffer.length() )    
49.                isSet = buffer.charAt(i) == '1';    
50.              lonset.set(j++, isSet);    
51.          }    
52.              
53.          //odd bits    
54.          j=0;    
55.          for (int i=1; i< numbits*2;i+=2) {    
56.              boolean isSet = false;    
57.              if ( i < buffer.length() )    
58.                isSet = buffer.charAt(i) == '1';    
59.              latset.set(j++, isSet);    
60.          }    
61.              
62.          double lon = decode(lonset, -180, 180);    
63.          double lat = decode(latset, -90, 90);    
64.              
65.          return new double[] {lat, lon};         
66.      }    
67.          
68.      private double decode(BitSet bs, double floor, double ceiling) {    
69.          double mid = 0;    
70.          for (int i=0; i<bs.length(); i++) {    
71.              mid = (floor + ceiling) / 2;    
72.              if (bs.get(i))    
73.                  floor = mid;    
74.              else    
75.                  ceiling = mid;    
76.          }    
77.          return mid;    
78.      }    
79.          
80.          
81.      public String encode(double lat, double lon) {    
82.          BitSet latbits = getBits(lat, -90, 90);    
83.          BitSet lonbits = getBits(lon, -180, 180);    
84.          StringBuilder buffer = new StringBuilder();    
85.          for (int i = 0; i < numbits; i++) {    
86.              buffer.append( (lonbits.get(i))?'1':'0');    
87.              buffer.append( (latbits.get(i))?'1':'0');    
88.          }    
89.          return base32(Long.parseLong(buffer.toString(), 2));    
90.      }    
91.      
92.      private BitSet getBits(double lat, double floor, double ceiling) {    
93.          BitSet buffer = new BitSet(numbits);    
94.          for (int i = 0; i < numbits; i++) {    
95.              double mid = (floor + ceiling) / 2;    
96.              if (lat >= mid) {    
97.                  buffer.set(i);    
98.                  floor = mid;    
99.              } else {    
100.                  ceiling = mid;    
101.              }    
102.          }    
103.          return buffer;    
104.      }    
105.      
106.      public static String base32(long i) {    
107.          char[] buf = new char[65];    
108.          int charPos = 64;    
109.          boolean negative = (i < 0);    
110.          if (!negative)    
111.              i = -i;    
112.          while (i <= -32) {    
113.              buf[charPos--] = digits[(int) (-(i % 32))];    
114.              i /= 32;    
115.          }    
116.          buf[charPos] = digits[(int) (-i)];    
117.      
118.          if (negative)    
119.              buf[--charPos] = '-';    
120.          return new String(buf, charPos, (65 - charPos));    
121.      }    
122.      
123.  }