java中使用逗号delimeter分割字符串数组

我有一个字符串数组-->

string[]arr={“CSE01A”、“ECE02B”、“MECH03C”}

现在我必须打印课程=
CSE01、ECE02、MECH03
等级=
'A'，'B'，'C'

我尝试使用逗号分隔符使用split（），但这对字符串数组不起作用

请告诉我如何执行此操作。
您不需要拆分，必须将数组元素合并为字符串

    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();

String[]arr={“CSE01A”、“ECE02B”、“MECH03C”}；
StringBuilder coursesBuilder=新建StringBuilder（）；
StringBuilder gradeBuilder=新的StringBuilder（）；
字符串[]arr=新字符串[0]；
对于（int i=0；i
split（）
是Sting接受字符串并创建数组的方法。如果你想使用它，你应该说
str.split（\\s*，\\s*”）
-这对空格是安全的

但您已经有了数组，所以您只想打印它。您可以使用
数组。toString（arr）
数组已拆分，它不是字符串。为了进行打印，您需要在元素之间循环：

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

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

这是因为您要拆分的内容中没有逗号分隔符

您需要循环遍历数组元素并获取每个字符串的最后一个字符

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, ", "));

List courses=new ArrayList（）；
列表等级=新的ArrayList（）；
用于（字符串s:arr）{
int l=s.长度（）；
添加（s.子字符串（0，l-1））；
添加（s.子串（l-1））；
}
System.out.println（StringUtils.join（courses，“，”）；
System.out.println（StringUtils.join（grades，“，”）；
Java的split（）获取一个字符串并将其拆分为一个数组，例如（“abc，def，ghi”）。split（“，”）提供一个带有“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);
}

您的课程列表不是包含逗号的字符串，因此您不能简单地“拆分”它们。您可以使用如下代码迭代数组：

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

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);           
}

for（int i=0；i

在循环的每次迭代中，变量packedString将包含您的课程号和成绩（即数组的第一次迭代中的CSE01A）。因此，您只需要应用一种方法来解压缩数据。如果等级总是只有一个字符，那么可以使用子字符串解析出最后一个字符及其前面的所有字符，但是如果有多个字符等级（例如a-），则需要执行更复杂的操作

我不太愿意进一步扩展，因为这听起来像是家庭作业
 问题是，您没有为每门课程设置分隔符，课程和成绩在同一个字符串中

既然你知道分数已经到了最后，你可以做一些简单的事情，比如：

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

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);           
}

String[]arr={“CSE01A”、“ECE02B”、“MECH03C”}；
String[]courses=新字符串[arr.length]；
字符[]等级=新字符[arr.length]；
对于（int i=0；i

最后，您将有一个包含课程的字符串[]和一个包含各自成绩的字符[]。
这将遍历您的数组并输出您的课程和成绩：

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'

您可以使用来帮助简化处理字符串转换和将结果缝合在一起的工作：

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)));

    }
}

包测试代码；
导入com.google.common.base.Function；
导入com.google.common.base.Joiner；
导入com.google.common.collect.Iterables；
导入com.google.common.collect.list；
公共类TestMain{
静态Joiner joinWithComma=Joiner.on（“，”）.skipNulls（）；
私有静态字符串getCourses（Iterable fromArray）{
返回joinWithComma.join（Iterables.transform（fromArray，
新函数（）{
@凌驾
公共字符串应用（字符串arg0）{
返回arg0.substring（0，arg0.length（）-1）；
}
}));
}
私有静态字符串getGrades（Iterable fromArray）{
返回joinWithComma.join（Iterables.transform（fromArray，
新函数（）{
@凌驾
公共字符串应用（字符串arg0）{
返回arg0.substring（arg0.length（）-1，arg0.length（））；
}
}));
}
公共静态void main（字符串[]args）{
字符串[]arr={“CSE01A”、“ECE02B”、“MECH03C”}；
System.out.println（getCourses（list.newArrayList（arr））；
System.out.println（getGrades（list.newArrayList（arr））；
}
}

输出：

CSE01、ECE02、MECH03

A、 B，C

不过，我有一种感觉，对于迭代数组和字符串操作来说，这可能是一个简单的家庭作业。
split（）并不像你想象的那样，它接受一个字符串并将其拆分为一个数组。所有这些字符串都遵循相同的模式吗？也就是说，3+个字母，2个数字，1个字母，你想让字符串一直到最后一个字母，最后一个字母在单独的字符串中？你只需要迭代数组的内容。split（）拆分字符串本身。输出值中项目之间的逗号是否正确？编辑注意：修订导致答案毫无意义；我回滚了它。Arrays.toString（arr）将打印数组，但它不会提供