混就完事了

findFirstByOrderByIdDesc() // 1.查询ID最大的一条数据，注意first后面要跟by（）。
findTop5ByOrderByIdAsc() // 2. 查询top5。id从小到大排序,return list
findFirstByValidAtBeforeAndInvalidAtAfterOrderByCreatedAtDesc（Instant time1,Instant time2）  //3. 查询数据在某一时间段内。
findByNameLike(String name) //4. like查询,return list
findByIdIsBetween(Integer low, Integer high) //5. 查询数据在某一范围，与3相似。return list
findByMoneyOrderByIdDesc(int money) //6.相同钱数的人，根据id排。 return list

public class MyArrayWritable extends ArrayWritable { 
	public MyArrayWritable() { 
		super(SomeComplexClass.class);  //首先构造函数中写需要存放的对象的类
		} 
	}
	
	public MyArrayWritable(String[] strings) {
        
        super(SomeComplexClass.class);
        Text[] texts = new Text[strings.length];
        for (int i = 0; i < strings.length; i++) {
            texts[i] = new Text(strings[i]);
        }
       set(texts);  //这个是set父类的value
    }
	
	
	//由于是自定义的对象，因此需要写toString函数。
	//否则在存入的时候会存入对象的地址，而不是想要的信息。

	public String toString() {
		StringBuilder sb = new StringBuilder();
		//使用this.get()获取strings的长度
		for (int i = 0; i < this.get().length; i++) {
			//some code
		}
		return sb.toString();
	}
	
	//最后在reduce的时候，就可以存入一个array的value了。
	
	//例如这样，在reduce时，有一个复杂对象的values。可以用arraylist将其加入，最后变成string数组放到MyArrayWritable中。
	ArrayList<String> al = new ArrayList<String>();
	for (SomeComplexClass val : values) {
		al.add(val.toString());
	}
	
	context.write(key, new MyArrayWritable((String[]) al.toArray(new String[al.size()])));

public void quickSort(int[] arr, int begin, int end) {
	if (begin < end) {
		int partition = partition(arr, begin, end);
		quickSort(arr, begin, partition - 1);
		quickSort(arr, partition + 1, end);
	}

}

public int partition(int[] arr, int begin, int end) {
	int pivot = arr[end];
	int start = begin;

	for (int i = begin; i < end; i++) {
		if (arr[i] < pivot) {
			swap(arr, i, start);
			start++;
		}
	}
	swap(arr, start, end);
	return start;
}

public int partition(int[] arr, int begin, int end) {
	int pivot = arr[begin];
	int i = begin;
	int j = end - 1;
	int k = begin + 1;
	while(k <= j){
		if(arr[k] < pivot){
               swap(arr, i, k);
               i++;
               k++;
           } else if (arr[k] > pivot) {
               swap(items, j, k);
               j--;
           } else {
               k++;
           }
	
	}		
	swap(arr, start, end);
	return start;
}

/*
          *   left part           center part                   right part
          * +--------------------------------------------------------------+
          * |  < pivot1  |  pivot1 <= && <= pivot2  |    ?    |  > pivot2  |
          * +--------------------------------------------------------------+
          *               ^                          ^       ^
          *               |                          |       |
          *              less                        k     great
 */

public void quickSort(int[] arr) {
	partition(arr,0,arr.length-1);
}
public void partition(int[] arr, int begin, int end) {

       if (begin < end) {

           int pivot1 = arr[begin];
           int pivot2 = arr[end];
           if (pivot1 > pivot2) {
               swap(arr, begin, end);
               int temp = pivot1;
               pivot1 = pivot2;
               pivot2 = temp;
           }
           int i = begin, j = end, k = begin + 1;

           outer:
           while (k < j) {
               if (arr[k] < pivot1) {
                   i++;
                   swap(arr, i, k);
                   k++;
               } else if (arr[k] <= pivot2) {
                   k++;
               } else { // arr[k] > pivot2

                   while (arr[--j] > pivot2) {
                       if (j == k) {
                           break outer;
                       }
                   }
                   if (arr[j] < pivot1) {
                       swap(arr, j, k);
                       i++;
                       swap(arr, i, k);
                   } else { // pivot1 <= x <= pivot2
                       swap(arr, j, k);
                   }
                   k++;
               }
           }
           swap(arr, begin, i);
           swap(arr, end, j);

           partition(arr, begin, i - 1);
           partition(arr, i + 1, j - 1);
           partition(arr, j + 1, end);
       }

   }