离散化——区间和（java版本）

本人水平一般，代码可能写的不够漂亮，望各位大佬指出。 

题目参考离散化——区间和_离散化 区间和_敲键盘的老乡的博客-CSDN博客

import java.lang.*;
import java.util.*;

public class homework {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int queryLength = input.nextInt();
        int len = n+2*queryLength;
        item[] allIndexValue = new item[len];
        range[] query = new range[queryLength];
        int i=0;
        for (; i<n; i++) {
            allIndexValue[i] = new item(input.nextInt(),input.nextInt());
        }
        for (int j=0; i<len; i+=2,j++) {
            int left = input.nextInt();
            int right = input.nextInt();
            allIndexValue[i] = new item(left);
            allIndexValue[i+1] = new item(right);
            query[j] = new range(left,right);
        }
        //以上是所有数据的输入，以下是对数据进行处理
        Arrays.sort(allIndexValue); //排序
//        item.showItemArray(allIndexValue);
        item[] dealedIndexValue = item.keyDistinct(allIndexValue); //去重
//        item.showItemArray(dealedIndexValue);
        int[] sum = new int[dealedIndexValue.length+1]; //求和
        sum[0] = 0; //求区间和时防止数组越下界，对应下标从1开始
        for (i=0; i<dealedIndexValue.length; i++) {
            sum[i+1] = sum[i] + dealedIndexValue[i].value;
        }
        System.out.println(Arrays.toString(sum));
        //查询区间和
        for (i=0; i<queryLength; i++) {
            int l = item.binarySearchKey(dealedIndexValue,query[i].left);
            int r = item.binarySearchKey(dealedIndexValue,query[i].right);
            System.out.println(sum[r+1] - sum[l]);
        }
    }
}

class item implements Comparable{
    int key;
    int value;

    public item() {} //key和value初值为0
    public item(int key) { //value初值为0
        this.key = key;
    }
    public item(int key,int value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public int compareTo(Object o) { //升序排序
        item obj = (item)o;
        return this.key - obj.key;
    }

    public static item[] keyDistinct(item[] items) { //已排好序
        int j=1; //items[0]不重复，直接跳过
        for (int i=1; i<items.length; i++) {
            if (items[i-1].key == items[i].key) {
                continue;
            }
            items[j++] = items[i];
        }
        //j前面的不重复，截断后面部分
        return Arrays.copyOf(items,j);
    }

    @Override
    public String toString() {
        return "item{" +
                "key=" + key +
                ", value=" + value +
                '}';
    }

    public static void showItemArray(item[] items) {
        for (item i : items) {
            System.out.print(i.toString() + " ");
        }
        System.out.println();
    }

    /*
    功能：在数组中查找key值返回数组下标
     */
    public static int binarySearchKey(item[] items,int key) {
        int left = 0;
        int right = items.length-1;
        int mid = (left+right)/2;
        while (left < right) {
            mid = (left+right)/2;
            if (key < items[mid].key) {
                right = mid;
            } else if (key == items[mid].key) {
                return mid;
            } else {
                left = mid+1;
            }
        }
        //如果找不到，返回与key相近的小值的下标
        return mid;
    }
}

class range {
    int left;
    int right;
    
    public range() {}
    public range(int left, int right) {
        this.left = left;
        this.right = right;
    }
}