public class FindMdlInArray {

public static void main(String args[])
{
    double []num = {0.5,1.24,18,1.4,2.1,3.2,2.5,13,2.6,18,2.55,1.2,1.83,1.3,2.1};
    double []weight = {0.8,0.2,1.98,1.4,2.1,3.8,2.1,2.12,0.5,5.6,1.1,1.2,3.5,1.2,1.5};
    double tmp[] = new double[num.length];

    for (int i = 0; i < num.length; i++)
        tmp[i] = num[i] * weight[i];

//

// for (int k = 0; k < num.length; k++)
// System.out.print(tmp[k] + " ");
// System.out.println();

    double mld = getMdlInArray(tmp, num);

    System.out.println("位数 = " + mld);
}

public static double getMdlInArray(double array[], double num[])
{
    double k;
    // 对array, num数组排序
    for (int i = 0; i < array.length; i++)
    {
        for (int j = 1; j < array.length - i; j++)
            if (array[j - 1] > array[j])
            {
                k = array[j - 1];
                array[j - 1] = array[j];
                array[j] = k;

                k = num[j - 1];
                num[j - 1] = num[j];
                num[j] = k;
            }
    }

// for (int t = 0; t < num.length; t++)
// System.out.print(array[t] + " ");
// System.out.println();
return num[(num.length-1)/2];
}
}

我的上一个回答是错的，要注意带权中位数和普通中位数的不同

public class WeightedMedian {

@Test
public void main() throws Exception {
    //进行排序arrays，weightsLast
    double[] arrays={0.5,1.24,18,1.4,2.1,3.2,2.5,13,2.6,18,2.55,1.2,1.83,1.3,2.1};
    double[] arraysBefore=new double[arrays.length];
    System.arraycopy(arrays,0,arraysBefore,0,arrays.length);
    double[] weights={0.8,0.2,1.98,1.4,2.1,3.8,2.1,2.12,0.5,5.6,1.1,1.2,3.5,1.2,1.5};
    double[] weightsLast=new double[weights.length];
    Arrays.sort(arrays);
    for (int i = 0; i < arrays.length; i++) {
        int index=search(arraysBefore,arrays[i]);
        weightsLast[i]=weights[index];
        arraysBefore[index]=-1;
    }
    System.out.println(getMedian(arrays,weightsLast));
}

/**
 *
 * @param arrays
 * @param weights
 * @return
 */
private double getMedian(double[] arrays,double[] weights){
    double sum=0,sum1=0;
    for (int i = 0; i < weights.length; i++) {
        System.out.println("  "+i);
        sum+=weights[i];
    }
    for (int i = 0; i < weights.length; i++) {
        sum1+=weights[i];
        if (sum1>=sum/2){
            return arrays[i];
        }
    }
    return -1;
}

/**
 * 查找实现，此查找只用于此程序，所以在getMedian(double[] arrays,double[] weights)
 * 方法里没有做查找失败检测，因为此查找必然成功。
 * @param arrays 需要查找的数组
 * @param key 需要查找的值
 * @return 返回值所在的数组下标
 */
private int search(double[] arrays,double key)
{
    for (int i=0;i<arrays.length;i++){
        if(arrays[i]==key){
            return i;
        }
    }
    return -1;
}

}

 float[] n = {0.5,1.24,18,1.4,2.1,3.2,2.5,13,2.6,18,2.55,1.2,1.83,1.3,2.1};
float[] w = [0.8,0.2,1.98,1.4,2.1,3.8,2.1,2.12,0.5,5.6,1.1,1.2,3.5,1.2,1.5};
double sum = 0.0, sum1 = 0.0, r = 0.0;
for (int i = 0; i < n.length(); i++)
sum += n[i] * w[i];
for (int i = 0; i < n.length(); i++)
if (sum1+ n[i] * w[i] >= sum / 2.0) { r = n[i]; break; }
//r就是结果

带权中位数 = 累加后带权的总数的1/2的数。
代码手工输入的，你参考下。如果问题得到解决，麻烦点下我回答右边的采纳，谢谢。

public class WeightedMedian {

@Test
public void main() throws Exception {
    double[] arrays={0.5,1.24,18,1.4,2.1,3.2,2.5,13,2.6,18,2.55,1.2,1.83,1.3,2.1};
    double[] weights={0.8,0.2,1.98,1.4,2.1,3.8,2.1,2.12,0.5,5.6,1.1,1.2,3.5,1.2,1.5};
    System.out.println(getMedian(arrays,weights));
}

/**
 * 求中位数
 * @param arrays 数值数组
 * @param weights 权重数组
 * @return 数值的带权中位数
 * @throws Exception 数值和权重数组长度不一致
 */
private double getMedian(double[] arrays,double[] weights) throws Exception {
    double sum=0;
    double sum1=0;
    //检测数值和权重数组长度是否一致，不一致抛出异常
    if (arrays.length!=weights.length){
        throw new Exception("数值和权重数组长度不一致");
    }else {
        double[] results=new double[arrays.length];
        double[] resultsOfArrays=new double[arrays.length];
        for (int i=0;i<arrays.length;i++) {
            //求出数值和权重的乘积
            results[i] = arrays[i] * weights[i];
        }
        //求出sum
        for (int i=0;i<results.length;i++) {
            //求出带权数值的和
            sum+=results[i];
        }
        //进行数组拷贝，因为执行排序后根据java语言特性数组的顺序会该改变，无法通过下标去查找数值中的中位数
        System.arraycopy(results,0,resultsOfArrays,0,results.length);
        //通过快排进行排序
        quickSort(results,0,results.length-1);
        for (int i=0;i<results.length;i++){
            sum1+=results[i];
            if(sum1>=sum/2){
                //求出中位数索引
                int index=search(resultsOfArrays,results[i]);
                return arrays[index];
            }
        }

    }
    return -1;//返回数值数组的中位数
}

/**
 * 快速排序实现
 * @param arrays 需要排序的数组
 * @param low 数组的低位下标
 * @param high 数组的高位下标
 */
private void quickSort(double[] arrays,int low,int high){
    int i=low;
    int j=high;
    double tmp=arrays[low];
    while (low<high)
    {
        while ((low<high)&&(arrays[high]>=tmp))
        {
            high--;
        }
        arrays[low]=arrays[high];
        arrays[high]=tmp;
        low++;
        while ((low<high)&&(arrays[low]<=tmp))
        {
            low++;
        }
        if (low<high)
        {
            arrays[high]=arrays[low];
            arrays[low]=tmp;
            high--;
        }
    }
    if(i<low-1)
    {
        quickSort(arrays,i,low-1);
    }
    if(low<j)
    {
        quickSort(arrays,low,j);
    }
}

/**
 * 查找实现，此查找只用于此程序，所以在getMedian(double[] arrays,double[] weights)
 * 方法里没有做查找失败检测，因为此查找必然成功。
 * @param arrays 需要查找的数组
 * @param key 需要查找的值
 * @return 返回值所在的数组下标
 */
private int search(double[] arrays,double key)
{
    for (int i=0;i<arrays.length;i++){
        if(arrays[i]==key){
            return i;
        }
    }
    return -1;
}

}

实现思路：
我们知道，在10以内的整数里，0~3出现的概率是0.3，3~6出现的概率是0.3，6~7出现的概率是0.1，7~9出现的概率是0.2，9~10出现的概率是0.1 ；上面对应的权重可对应为3 、3 、1、2 、1 。

所以，当我们需要实现不知道权重到底是多少时，我们只需要将所有权重加起来，假设为100，然后让随机数只出现0到100，接着给每个权重设定一个区间段，权重有多大，该区间段就有多宽，其中总区间就是总权重。

在组装我们的数据上也需要一定的技巧，我们用TreeMap来组装，key是区间段后面一个值，如下面0~4区间段对应的是4，然后将后面的值（如”4444“）放进value里。

生成在总权重范围内的随机数，假设是2；然后我们根据TreeMap的ceilingKey(2) 方法获得大于等于2的最键，这里得到是4。这样就能去TreeMap里取到我们需要的值了