Заполнение массива с использованием другого массива, но некоторые из вставляемых значений являются нулевыми

Question

У меня есть массив строк, и я хочу заполнить другой массив самыми большими строками из вышеупомянутого массива. Я могу правильно определить размер массива и заполнить его правильным количеством переменных, но две переменные равны нулю, а третье - правильное значение.

public static void main(String[] args) {
    String[] inputArray = {"aba", "aa", "ad", "vcd", "123"};
    String[] resultsArray = allLongestStrings(inputArray);


    for(String x: inputArray) {
        System.out.println("Input array: " + x);
    }

    for(String temp: resultsArray) {
        System.out.println("Results array: " + temp);
    }
}

public static String[] allLongestStrings(String[] inputArray) {
    int len = 0;
    for(String temp: inputArray) {
        if(temp.length() > len) {
            len = temp.length();
        }
    }
    String[] ret = new String[len];

    for(int i = 0; i <= inputArray.length-1; i++) {
        if(inputArray[i].length() == len) {
            ret[ret.length-1] = inputArray[i];
        }
    }


    return ret;
}

мои результаты:

Input array: aba

Input array: aa

Input array: ad

Input array: vcd

Input array: 123

Results array: null

Results array: null

Results array: 123

Как я могу получить два нулевых значения, чтобы стать aba и vcd?

Answer 1

Вы должны посчитать количество элементов этой длины. В настоящее время ваш код выделяет массив результатов с len количеством элементов. Длина самой длинной строки (len в вашем коде) не имеет ничего общего с количеством строк этой длины.

public static String[] allLongestStrings(String[] inputArray) {
    int len = 0;
    int num = 0;
    for (String temp : inputArray) {
        if (temp.length() == len) {
            num++;
        } else if (temp.length() > len) {
            len = temp.length();
            num = 1;
        }
    }

    String[] ret = new String[num]; // <-- allocate the right number of elements

    for (int i = 0, j = 0; i <= inputArray.length - 1; i++) {
        if (inputArray[i].length() == len) {
            ret[j++] = inputArray[i];
        }
    }
    return ret;
}

Она выполняет итерацию по массиву, проверяя самую длинную строку, сохраняя при этом числоэлементов самой длинной строки, которую мы видели до сих пор. После первой итерации вы будете знать количество элементов, которые будут включены в массив результатов, и, следовательно, вы можете выделить правильный размер и заполнить его.

---

Еще один интересный способ сделать это с помощью потоков Java:

public static String[] allLongestStrings(String[] inputArray) {
    TreeMap<Integer, List<String>> lengthToStrings = Arrays.stream(inputArray)
            .collect(Collectors.groupingBy(String::length, TreeMap::new, Collectors.toList()));

    return lengthToStrings.lastEntry()
            .getValue()
            .toArray(new String[0]);
}

Первая часть создает TreeMap, который имеет отображение от длины String до списка строк этой длины. Так как он упорядочен естественным порядком целых чисел (в порядке возрастания), мы можем получить максимальную длину, прочитав последнюю запись. Эта запись будет иметь все строки этой длины.

Последняя часть преобразует List<String> в String[] и возвращает его.

Answer 2

Вот решение с одним контуром.

public static String[] allLongestStrings(String[] inputArray) {
    int len = 0;
    ArrayList<String> ret = new ArrayList<>(inputArray.length);
    for(String temp: inputArray) {
        if(temp.length() > len) {//reset list as bigger length is found.
            len = temp.length();
            ret.clear();
            ret.add(temp);
        }else if(temp.length()==len){//accumulate all longest Strings in the list
            ret.add(temp);
        }
    }
    return ret.toArray(new String[0]);
}

Answer 3

Игнорирование того факта, что количество элементов, соответствующих максимальному значению, не рассчитано должным образом (но случайно, в вашем случае использования, максимальная длина соответствует количеству элементов этой длины, то есть 3). Вы можете использовать List, чтобы удалить ограничение размера и вернуть retList.toArray (), если вам действительно нужен массив.

Возвращаясь к реальной проблеме, вы неправильно заполняете массив ret. Вы должны следить за индексом, а не всегда использовать длину -1:

   for(int j=0,i = 0; i <= inputArray.length-1; i++) { // <-- See j declared here
        if(inputArray[i].length() == len) {
            ret[j++] = inputArray[i]; // <--- See j++ usage instead of ret.length -1
        }
    }

Cheers!

Answer 4

Короткая версия Java 8:

    String[] inputArray = {"aba", "aa", "ad", "vcd", "123"};

    // find out the biggest element size
    Optional<String> biggest = asList(inputArray).stream().max(Comparator.comparing(String::length));

    // filter only element that contains the same size as the biggest one
    List<String> bigOnes = asList(inputArray).stream()
            .filter(element -> element.length() == biggest.map(String::length).orElse(0))
            .collect(Collectors.toList());

    // print them
    bigOnes.forEach(System.out::println);

Answer 5

Есть несколько проблем с вашим кодом:

1. Размер массива ret не связан с фактической максимальной длиной len.
2. Youвы просто добавляете элементы в последний индекс массива ret:

ret[ret.length-1] = inputArray[i];

Итак, для первого выпуска вы можете сохранить count строк максимальной длины в оригиналемассив и адрес второй, используя правильные указатели индекса:

public static String[] allLongestStrings(String[] inputArray) {
    int len = 0, count = 0;
    for(String temp: inputArray) {
        if (temp.length() > len) {
            len = temp.length();
            count = 1;           // new max length, so reset count to 1
        } else if (temp.length() == len) {
            count++;
        }
    }
    String[] ret = new String[count];

    for(int i = 0, j = 0; i < inputArray.length; i++) {
        if (inputArray[i].length() == len) {
            ret[j++] = inputArray[i];
        }
    }

    return ret;
}