解法1（运用的最大堆，但是运行超时了）：

 public int[] maxSlidingWindow(int[] nums, int k) {
         queue= new PriorityQueue<Integer>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        int [] max=new int[nums.length-k+1]; //存放最大值的数组
        for (int i=0;i<nums.length;i++){
            if (i<k-1){
                queue.add(nums[i]);
            }else if (i==k-1){
                queue.add(nums[i]);
                max[0]=queue.peek();
            }else {
                queue.remove(nums[i-k]);
                queue.add(nums[i]);
                max[i-k+1]=queue.peek();
            }
        }
        return max;
     }

解法2（运用双向队列）：

public int[] maxSlidingWindow(int[] nums, int k) {
 ArrayDeque<Integer> deque = new ArrayDeque<Integer>(k);
        //定义一个存放大
        int [] max=new int[nums.length-k+1];
        for (int i=0;i<nums.length;i++){
            //当队列不为空,并且进入的数的下标与最前面的那个数的下标差值为k，就应该把第一个数给干掉了，它就应该走了
            if (!deque.isEmpty()&&deque.peekFirst()==i-k){
                deque.removeFirst();
            }
            //当队列不为空，队列最后一个元素的值如果小于即将进入的值的话，就必需删除，直到最后一个元素大于即将进入的元素，这样队列始终维持一个逆序的状态
            while (!deque.isEmpty()&&nums[deque.peekLast()]<nums[i]){
                deque.removeLast();
            }
            //元素进入队列
            deque.offerLast(i);
            if (i>=k-1){
                //如果一个元素，就要获取一个队列中的最大值，放入最大值的数组里面
               max[i-k+1]=nums[deque.peekFirst()];
            }
        }
        return max;
    }