Блог

У меня есть массив строк -> string[] arr={"CSE01A","ECE02B","MECH03C"};

Теперь я должен напечатать course= CSE01, ECE02,MECH03 и grade= 'A','B','C'

Я пытался использовать split(), используя разделитель запятой, но это не работает для массива строк..

Пожалуйста, дайте мне знать, как это сделать.

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

Вам нужно перебрать элементы массива и захватить последний символ каждой строки.

 for (String s : arr) {
    int l = s.length();
    String course = s.substring(0, l-1);
    String grade = s.substring(l-1);
}
  

Для полноты:

 List<String> courses = new ArrayList<String>();
List<String> grades = new ArrayList<String>();
for (String s : arr) {
    int l = s.length();
    courses.add(s.substring(0, l-1));
    grades.add(s.substring(l-1));
}
System.out.println(StringUtils.join(courses, ", "));
System.out.println(StringUtils.join(grades, ", "));
  

Функция split() Java принимает строку и разбивает ее на массив, например («abc, def, ghi»).разделение(«,») дает вам строку [] с «abc», «def», «ghi». Вам нужно взять каждую строку в вашем массиве и разделить последнюю букву (класс). Если вы просто хотите распечатать его:

 for(String s : arr) {
    String course = s.substring(0,s.length()-1);
    String grade = s.substring(s.length()-1);

    System.out.println("Course: " course " Grade: " grade);
}
  

Вам не нужно разделять, вы должны объединить элементы массива в строку.

     String[] arr={"CSE01A","ECE02B","MECH03C"};

    StringBuilder coursesBuilder = new StringBuilder();
    StringBuilder gradeBuilder = new StringBuilder();
    String[] arr = new String[0];
    for (int i = 0; i < arr.length; i  ) {

        String course = arr[i].substring(0, arr.length - 1);
        String grade = arr[i].substring(arr.length - 1);
        coursesBuilder.append(course);
        gradeBuilder.append("'"   grade   "'");

        boolean hasNext = (i   1) < arr.length;
        if (hasNext) {
            coursesBuilder.append(", ");
            gradeBuilder.append(", ");
        }
    }

    String courses = coursesBuilder.toString();
    String grades = gradeBuilder.toString();
  

split() это метод Sting, который принимает строку и создает массив. Если вы хотите его использовать, вы должны сказать str.split("\s*,\s*") — это безопасно для пробелов.

Но у вас уже есть массив, поэтому вы просто хотите его распечатать. Вы можете использовать Arrays.toString(arr) .

массив уже разделен, это не строка. Для печати вам нужно выполнить цикл по элементам:

 for ( String courseAndGrade : arr ) {
    // split the course and grade:

    System.out.println( ... );
}
  

Ваш список курсов — это не строка, содержащая запятые, поэтому вы не можете просто «разделить» их. Вы можете выполнить итерацию по массиву с кодом, который выглядит следующим образом:

 for(int i=0; i < arr.length; i  ){
    String packedString = arr[i];
}
  

на каждой итерации цикла переменная packedString будет содержать номер вашего курса и оценку (т. Е. CSE01A на первой итерации массива). Итак, вам просто нужно применить метод для распаковки данных. Если оценка всегда состоит из одного символа, вы можете использовать substring для разбора последнего символа и всего, что перед ним, но если у вас есть многосимвольные оценки (например, A-), вам нужно будет сделать что-то более сложное.

Я не решаюсь расширять дальше, поскольку это звучит как домашнее задание.

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

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

 String[] arr = {"CSE01A","ECE02B","MECH03C"};
String[] courses = new String[arr.length];
char[] grades = new char[arr.length];

for (int i = 0; i < arr.length; i  ) {
    courses[i] = arr[i].substring(0, arr[i].length() - 1);
    grades[i] = arr[i].charAt(arr[i].length()-1);           
}
  

В конце у вас будет строка[] с курсами и символ[] с их соответствующими оценками.

Это повторит ваш массив и выведет ваши курсы и оценки:

 StringBuilder courses = new StringBuilder();
StringBuilder grades = new StringBuilder();
String delimiter = "";

for (String s : arr) {
    courses.append(delimiter).append(s.subSequence(0, s.length() - 1));
    grades.append(delimiter).append("'").append(s.substring(s.length() - 1)).append("'");
    delimiter = ",";
}


System.out.println("Courses: "   courses.toString()); // prints CSE01,ECE02,MECH03
System.out.println("Grades: "   grades.toString()); // prints 'A','B','C'
  

Вы могли бы использовать Guava, чтобы упростить обработку преобразований строк и объединить результаты вместе:

 package testCode;

import com.google.common.base.Function;
import com.google.common.base.Joiner;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;

public class TestMain {

    static Joiner joinWithComma = Joiner.on(", ").skipNulls();

    private static String getCourses(Iterable<String> fromArray) {
        return joinWithComma.join(Iterables.transform(fromArray,
                new Function<String, String>() {
                    @Override
                    public String apply(String arg0) {
                        return arg0.substring(0, arg0.length() - 1);
                    }
                }));
    }

    private static String getGrades(Iterable<String> fromArray) {
        return joinWithComma.join(Iterables.transform(fromArray,
                new Function<String, String>() {
                    @Override
                    public String apply(String arg0) {
                        return arg0.substring(arg0.length() - 1, arg0.length());
                    }
                }));
    }

    public static void main(String[] args) {

        String[] arr = { "CSE01A", "ECE02B", "MECH03C" };

        System.out.println(getCourses(Lists.newArrayList(arr)));
        System.out.println(getGrades(Lists.newArrayList(arr)));

    }
}
  

Вывод:

CSE01, ECE02, MECH03
A, B, C

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