Question

我需要编写一个方法，当给定一个数字时，它会将数字添加到数组中的所有其他元素。例如，如果值是3，而您加上5，则新值将是8。我尝试了此方法，但遇到了我第一次遇到的错误。我说的是最后一个方法addValue方法。代码：

class IntegerList {
        private LinkedList<Integer> integers;

        public IntegerList() {
            this.integers = new LinkedList<>();
        }

        public IntegerList(Integer... numbers) {
            integers = new LinkedList<Integer>(Arrays.asList(numbers));
        }

        public boolean validateIndex(int index) {
            if(index < 0 || index > integers.size()) {
                throw new ArrayIndexOutOfBoundsException();
            }
            return true;
        }

        public void add(int el, int idx) {
            int size = integers.size();
            if(idx < integers.size()) {
                integers.add(idx, el);
            } else if(idx > integers.size()) {
                size = idx;
                el = 0;
            }
        }

        public int remove(int idx) {
            return integers.remove(idx);
        }

        public void set(int el, int idx) {
            integers.add(idx, el);
        }

        public int get(int idx) {
            return integers.get(idx);
        }

        public int size() {
            return integers.size();
        }

        public int count(int el) {
            int count = 0;
            for(int i: integers) {
                if(el == i) {
                    count++;
                }
            }
            return count;
        }

        public void removeDuplicates() {
            for(int i = 0; i < integers.size(); i++) {
                Integer integer = integers.get(i);

                for(int j = 0; j < i; j++) {
                    if(integer.equals(integers.get(i))) {
                        integers.remove(j);
                        i--;

                        break;
                    }
                }
            }
        }

        private int validateCount(int count) {
            if(count > integers.size()) {
                return integers.size();
            }

            return count;
        }

        public int sumFirst(int k) {
            k = validateCount(k);

            return integers.stream().limit(k).mapToInt(Integer::valueOf).sum();
        }

        public int sumLast(int k) {
            k = validateCount(k);

            return integers.stream().skip(integers.size() - k).mapToInt(Integer::valueOf).sum();
        }

        public void shiftRight(int index, int count) {
            validateIndex(index);
            int shiftIndex = (index + count) % integers.size();
            Integer element = integers.remove(index);
            integers.add(shiftIndex, element);
        }

        public void shiftLeft(int index, int count) {
            validateIndex(index);
            int shiftIndex = (index - count) % integers.size();
            if(shiftIndex < 0) {
                shiftIndex = integers.size() + shiftIndex;
            }
            Integer element = integers.remove(index);
            integers.add(shiftIndex, element);
        }

        public IntegerList addValue(int value) {
            return new IntegerList(
                    integers.stream()
                            .map(objectInteger -> new Integer(objectInteger + value))
                            .collect(Collectors.toCollection(LinkedList::new)));
        }
    }

错误：

Bad return type in method reference: cannot convert java.util.LinkedList<E> to C

Answer 1

IntegerList有两个构造函数，一个构造函数使用零个参数，另一个构造函数使用一个数组；您正在尝试将其传递给LinkedList。

转换为数组，而不是收集到列表：

       return new IntegerList(
                integers.stream()
                        .map(objectInteger -> new Integer(objectInteger + value))
                        .toArray(Integer[]::new));

@Hulk指出，new Integer是不必要的：您可以改用Integer.valueOf，但是省略任何一个仍将导致装箱：

                        .map(objectInteger -> objectInteger + value)

Answer 2

您的lambda函数一切正常，问题是您返回了LinkedList<Integer>，但没有构造函数

像这样更改它：

public IntegerList(List<Integer> numbers) {
    integers = new LinkedList<>(numbers);
}

或者您可以将流更改为返回数组，而不是LinkedList

Integer[] integers = this.integers.stream()
            .map(objectInteger -> objectInteger + value)
            .toArray(Integer[]::new);

Lambda中的错误类型返回

2 个答案: