Как объединить две строки по алфавиту?

Начинающий здесь. Я пытаюсь объединить строки в алфавитном порядке, используя compareTo метод, но мой fullfirstarray[i] = arrayone[i]; а также fullsecondarray[i] = arraytwo[i]; строки, а также мой последний черный код дают мне ошибки, в основном OutofBoundsExceptions

`import java.util.Scanner;
import java.lang.Math; 


class NamesMerge
{
public static void main(String[] args)
 {
  Scanner scan = new Scanner (System.in); 

  int flag = 0;
  int i = 0;
  String name = "";
  String input = "";
  int firstcounter = 0;
  int secondcounter = 0;

  String[] fullfirstarray = new String[firstcounter];
  String[] fullsecondarray = new String[secondcounter];

  System.out.println("Enter the values for the first array, up to 10000 values, enter 'End' to quit");

  //first array prompt (arrayone)
  String[] arrayone = new String[10000];

    input = scan.nextLine();

    input = input.toLowerCase();
    input = input.substring(0, 1).toUpperCase() + input.substring(1);

  while (!(input.equals("End")))
  {
    System.out.println(input);
    arrayone[i] = input;
        i++;
    input = scan.nextLine();
    input = input.toLowerCase();
    input = input.substring(0, 1).toUpperCase() + input.substring(1);
  }

  if (input.equals("End"))
  {
    System.out.println("Enter the values for the second array, up to 10000 values, enter 'End' to quit");
  }

  //next array prompt (arraytwo)
  String[] arraytwo = new String[10000];

    input = scan.nextLine();
    input = input.toLowerCase();
    input = input.substring(0, 1).toUpperCase() + input.substring(1);

  while (!(input.equals("End")))
  {
    System.out.println(input);

    arraytwo[i] = input;
        i++;
    input = scan.nextLine();
    input = input.toLowerCase();
    input = input.substring(0, 1).toUpperCase() + input.substring(1);    
  }

  //PRINTING THE FIRST ARRAY
  if (input.equals("End"))
  {
    System.out.println("First Array");
  }


  for (i =0; i < arrayone.length; i++)
  {
    if  (arrayone[i]!=null)
    {
      System.out.print(arrayone[i] + " ");
             firstcounter++;  
      fullfirstarray[i] = arrayone[i];
    }
  }

  //PRINTING THE SECOND ARRAY
  System.out.println("\nSecond Array");

  for (i =0; i < arraytwo.length; i++)
  {
    if  (arraytwo[i]!=null)
    {
      System.out.print(arraytwo[i] + " ");
              secondcounter++; 
      fullsecondarray[i] = arraytwo[i];
    }
  }


  //counter for total names
  System.out.println(firstcounter);
  System.out.println(secondcounter);


  //merge
  String[] merge = new String[firstcounter + secondcounter];

  int arrayoneindex = 0; 
  int arraytwoindex = 0;

  for (i = 0; i < (firstcounter + secondcounter); i++)
    if (fullfirstarray[i].compareTo(fullsecondarray[i])<0)
    {
    merge[i] = fullfirstarray[i]; 
    arrayoneindex++;
    }
  else
    if (fullsecondarray[i].compareTo(fullfirstarray[i])<0)
    {
      merge[i] = fullsecondarray[i];
      arraytwoindex++;
    }
  for (i = 0; i<merge.length; i++)
    {
      System.out.print(merge[i]);
    }
    }

    }
Источник

4 ответа

Решение

Вот ваш рабочий код. Пожалуйста, сравните оба и посмотрите на различия. Вот высокий уровень изменений, которые я сделал

  1. Рефакторинг кода
  2. Обработанные крайние случаи
  3. Сортировать входные массивы

Если у вас есть дополнительные вопросы, дайте мне знать.

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class NamesMerge {

  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter the values for the first array, up to 10000 values, enter 'End' to quit");
    String[] arrayOne = getArray(scan);
    System.out.println("Enter the values for the second array, up to 10000 values, enter 'End' to quit");
    String[] arrayTwo = getArray(scan);

    sortArray(arrayOne);
    sortArray(arrayTwo);
    //merge
    String[] merge = mergeAndSort(arrayOne, arrayTwo);

  }

  private static String[] mergeAndSort(String[] arrayOne, String[] arrayTwo) {
    String[] merge = new String[arrayOne.length + arrayTwo.length];

    int arrayOneindex = 0;
    int arrayTwoindex = 0;
    int mergeIndex = 0;

    while (arrayOneindex + arrayOneindex < arrayOne.length + arrayTwo.length
        && arrayOneindex < arrayOne.length
        && arrayTwoindex < arrayTwo.length) {

      if (arrayOne[arrayOneindex].compareTo(arrayTwo[arrayTwoindex]) < 0) {
        merge[mergeIndex] = arrayOne[arrayOneindex];
        arrayOneindex++;
        mergeIndex++;
      } else if (arrayOne[arrayOneindex].compareTo(arrayTwo[arrayTwoindex]) >= 0) {
        merge[mergeIndex] = arrayTwo[arrayTwoindex];
        arrayTwoindex++;
        mergeIndex++;
      }
    }

    while (arrayOneindex < arrayOne.length) {
      merge[mergeIndex] = arrayOne[arrayOneindex];
      mergeIndex++;
      arrayOneindex++;
    }
    while (arrayTwoindex < arrayTwo.length) {
      merge[mergeIndex] = arrayTwo[arrayTwoindex];
      mergeIndex++;
      arrayTwoindex++;
    }
    System.out.println("\nMerged sorted array");
    print(merge);
    return merge;
  }

  private static String[] getArray(Scanner scan) {
    String input;
    List<String> list = new ArrayList<>();

    input = scan.nextLine();
    input = input.toLowerCase();
    input = input.substring(0, 1).toUpperCase() + input.substring(1);

    while (!(input.equals("End"))) {
      System.out.println(input);
      list.add(input);
      input = scan.nextLine();
      input = input.toLowerCase();
      input = input.substring(0, 1).toUpperCase() + input.substring(1);
    }
    return list.toArray(new String[list.size()]);
  }

  private static void print(String[] arr) {
    if (arr != null) {
      for (int i = 0; i < arr.length; i++) {
        System.out.print(arr[i] + " ");
      }
    }
  }

  private static String[] sortArray(String[] arr) {
    String temp;
    for (int i = 0; i < arr.length; i++) {
      for (int j = 0; j < arr.length; j++) {
        if (arr[i].compareTo(arr[j]) < 0) {
          temp = arr[i];
          arr[i] = arr[j];
          arr[j] = temp;
        }
      }
    }
    System.out.println("SortedArray");
    print(arr);
    return arr;
  }

}
Источник

Эти строки вызывают ваше OutOfBoundsException (они создают массивы длины 0):

    int firstcounter = 0;
    int secondcounter = 0;

изменить эти и исключения исчезнут

Источник

Ваш код пахнет

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

    List<String> result = new ArrayList<>();
    result.addAll(Arrays.asList(arrayOne));
    result.addAll(Arrays.asList(arrayTwo));
    result.sort(String.CASE_INSENSITIVE_ORDER);
    String[] resultArray = result.toArray(new String[]{});

Версия массива этого кода:

    String[] result = new String[one.length + two.length];
    System.arraycopy(one, 0, result, 0, one.length );
    System.arraycopy(two, 0, result, one.length, two.length);
    Arrays.sort(result, String.CASE_INSENSITIVE_ORDER);
Источник

Проблема с исключениями возникает, когда вы пытаетесь получить доступ к вашему массиву 'fullfirstarray'. Когда массив объявлен и создан, вы сообщаете компилятору, сколько элементов он будет иметь, и вы сообщаете компилятору, что он будет иметь 0:

int firstcounter = 0;
int secondcounter = 0;

String[] fullfirstarray = new String[firstcounter];
String[] fullsecondarray = new String[secondcounter];

Поэтому, когда вы пытаетесь заполнить массивы таким образом:

     fullsecondarray[i] = arraytwo[i];

вы пытаетесь получить доступ к элементу массива, который не существует.

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

В следующих строках код потерпит неудачу, но я призываю вас попытаться выяснить проблему;)

Источник
Другие вопросы по тегам