参数解析

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

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        List<String> list = new ArrayList<>();

        for (int i = 0; i < s.length(); i++) {
            StringBuilder sb = new StringBuilder();
            //不是空格就继续遍历
            while (i < s.length() && s.charAt(i) != ' ') {
                //如果是开始双引号，需要找到结束双引号
                if (s.charAt(i) == '"') {
                    //双引号不加到字符串中，所以移动到下一个字符
                    i++;
                    //只要不是结束双引号，就继续遍历
                    while (s.charAt(i) != '"') {
                        sb.append(s.charAt(i));
                        i++;
                    }
                } else {
                    //不是双引号就加到字符串里
                    sb.append(s.charAt(i));
                }
                i++;
            }
            //遇到空格且有参数，则保存
            if (sb.length() > 0) {
                list.add(sb.toString());
            }
        }

        System.out.println(list.size());
        for (String p : list) {
            System.out.println(p);
        }
        
    }
}

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

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        ArrayList<String> list = new ArrayList<>();

        int i = 0;
        while (i < s.length()) {
            if (s.charAt(i) == '"') {          // " " 里的参数
                i++;
                String ss = "";
                while (s.charAt(i) != '"') {
                    ss += s.charAt(i);
                    i++;
                }
                i++;
                list.add(ss);
            } else if (s.charAt(i) != ' ') {   // 空格 分开的参数
                String ss = "";
                while (i < s.length() && s.charAt(i) != ' ') {
                    ss += s.charAt(i);
                    i++;
                }
                list.add(ss);
            }
            while (i < s.length() && s.charAt(i) == ' ') {  // 过滤空格
                i++;
            }
        }

        System.out.println(list.size());
        list.forEach(e-> {System.out.println(e);});
    }
}

看上去很高级的API

import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        List<String> cmd = new ArrayList<>();
        while (s.contains("\"")) {
            String u = s.substring(0, s.indexOf("\""));
            cmd.addAll(Arrays.stream(u.split(" ")).collect(Collectors.toList()));
            s = s.substring(s.indexOf("\"")+1);
            cmd.add(s.substring(0, s.indexOf("\"")));
            s = s.substring(s.indexOf("\"")+1);
        }
        cmd.addAll(Arrays.stream(s.split(" ")).collect(Collectors.toList()));
        cmd = cmd.stream().filter(e->!e.equals("")).collect(Collectors.toList());
        System.out.println(cmd.size());
        for (String seq : cmd) {
            System.out.println(seq);
        }
    }
}

public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String target = in.nextLine();
            //通过书引号“分割字符串
            String [] strs = target.split("\"");

            ArrayList<String> list = new ArrayList<>();
            for (int i = 0; i < strs.length; i++) {
                //偶数项为不带引号的字符串集
                if(i%2==0){
                    String [] tem;
                    //偶数项除第一项，都以分隔符开头，在结果数组的开头会包含一个空的前导子字符串需要处理掉
                    if(i==0){tem=strs[i].split(" ");}
                    else tem = strs[i].substring(1).split(" ");
                    for (int j = 0; j < tem.length; j++) {
                        list.add(tem[j]);
                    }
                }
                //奇数项为带引号的字符串
                if(i%2==1){
                    list.add(strs[i]);
                }
            }
            System.out.println(list.size());
            for (int i = 0; i <list.size() ; i++) {
                System.out.println(list.get(i));
            }
        }

    }
}

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

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String a = in.nextLine();
            String[] str1 = a.split(" ");
            List<String> list = new ArrayList<>();
            for (int i = 0; i < str1.length; i++) {
                if (str1[i].startsWith("\"")) {
                    StringBuilder s = new StringBuilder();
                    if (!str1[i].endsWith("\"")) {
                        s.append(str1[i], 1, str1[i].length());
                        while (!str1[++i].endsWith("\"")) {
                            s.append(" ").append(str1[i]);
                        }
                        s.append(" ").append(str1[i], 0, str1[i].length() - 1);
                    } else {
                        s.append(str1[i], 1, str1[i].length() - 1);
                    }
                    list.add(s.toString());
                } else {
                    list.add(str1[i]);
                }
            }
            System.out.println(list.size());
            list.forEach(System.out::println);
        }
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        //分别记录引号和参数的数量
        int count = 0;
        int num = 0;
        StringBuilder b = new StringBuilder();
        for(int i = 0; i < str.length(); i++){
            char c = str.charAt(i);
            b.append(c);
            if(c == ' ' && count % 2 == 0){
                b.append('\n');
                num++;
            }else if(c == '\"'){
                count++;
            }
        }
        System.out.println(num+1);
        System.out.println(b.toString().replace("\"", ""));
    }
}

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();

        ArrayList<String> list = new ArrayList<>();
        StringBuilder sb = new StringBuilder();
        // 记录单引号的个数
        int count = 0;
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            if (c == '\"') {
                count++;
            }

            if (c == ' ' && count % 2 == 0) {
                // 去除引号后添加到集合中
                String replace = sb.toString().replace("\"", "");
                list.add(replace);
                sb.delete(0, sb.length());
            } else {
                sb.append(c);
            }
        }

        // 添加最后一个，并去除引号
        list.add(sb.toString().replace("\"", ""));

        // 打印结果
        System.out.println(list.size());
        for (String s : list) {
            System.out.println(s);
        }
    }
}

import java.util.*;
//空间复杂度爆炸
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] str=sc.nextLine().split(" ");
        List<String> list=new ArrayList<>();
        int count=0;
        int begin=0;
        int end=0;
        for(int i=0;i<str.length;i++){
            if(!str[i].contains("\"")&&count==0){
                list.add(str[i]);
            }else if(!str[i].contains("\"")&&count==1){
                continue;
            }else if(str[i].startsWith("\"")&&count==0&&(!str[i].endsWith("\""))){
                begin=i;
                count++;
                continue;
            }else if(str[i].endsWith("\"")&&count==1&&(!str[i].startsWith("\""))){
                end=i;
                count=0;
                StringBuffer stbb=new StringBuffer(str[begin]);
                stbb.deleteCharAt(0);
                StringBuffer stbe=new StringBuffer( str[end]);
                stbe.deleteCharAt(str[end].length()-1);
                str[begin]=stbb.toString();
                str[end]=stbe.toString();
                StringBuffer stb=new StringBuffer();
                for(int j=begin;j<end;j++){
                    stb.append(str[j]+" ");
                }
                stb.append(str[end]);
                list.add(stb.toString());
            }else if(str[i].endsWith("\"")&&count==0&&str[i].startsWith("\"")){
                StringBuffer stbn=new StringBuffer(str[i]);
                stbn.deleteCharAt(str[i].length()-1);
                stbn.deleteCharAt(0);
                list.add(stbn.toString());
            }
        }
        System.out.println(list.size());
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}

import java.io.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = br.readLine();
        //n个命令参数有间有n-1空格，所以count从1开始
        int count = 1;
        //记录"的个数
        int flag = 0;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);
            // 遇到"flag++
            if (ch == '\"') {
                flag++;
                continue;
            }
            //非空字符则拼接
            if (ch != ' ') sb.append(ch);
            //flag % 2 == 0即"d的个数为0或偶数，说明此空字符在命令的末尾
            //或在反"的后面，需要换行
            if (ch == ' ' && flag % 2 == 0) {
                sb.append("\n");
                count++;
            }
            //flag % 2 ！= 0即"的个数为奇数，说明此空字符在""内，直接拼接字符
            if (ch == ' ' && flag % 2 != 0) sb.append(ch);
        }
        System.out.println(count + "\n" + sb.toString());
    }
}

import java.util.*;
public class Main {
    public static void main(String[]args){
        Scanner scan=new Scanner(System.in);
        String str=scan.nextLine();
        int count=0;//计数
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)=='"'){
                do{
                    i++;
                }while(str.charAt(i)!='"');
            }
            if(str.charAt(i)==' '){
                count++;
            }

        }
        //输出解析的参数个数
        System.out.println(count+1);
        //接下来输出各个参数
        //找一个标志来表示是双引号内部元素
        // boolean flag=false;
        boolean flag=true;
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)=='"'){
                flag=!flag;
            }
            //非空格和引号外的都输出
            if(str.charAt(i)!='"'&&str.charAt(i)!=' '){
                System.out.print(str.charAt(i));
            }
            //引号内的空格
            if(str.charAt(i)==' '&&flag==false){
                System.out.print(str.charAt(i));
            }
            //换行
            if(str.charAt(i)==' '&&flag==true){
                System.out.println();
            }
        }
    }

}

自己写。递归。

import java.util.*;

public class Main {
    public static List<String> res = new ArrayList<>(); //保存分解后的参数
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String str = in.nextLine();
            count(str);
            System.out.println(res.size());
            for (String s : res) {
                System.out.println(s);
            }
        }
    }
    public static void count(String str) {
        if (str == null) { 
            return;
        }
        int i = str.indexOf("\"");
        if (i > 0) { //如果有引号
            String sub1 = str.substring(0, i);
            count(sub1);//将引号之前的部分分解出来单独分析
            String sub2 = str.substring(i + 1);//删除前引号以及前面的部分,也就是说保留前引号后面的部分
            int j = sub2.indexOf("\"");//找到对应的后引号的坐标
            String sub3 = sub2.substring(0, j);//截取前后引号中间的内容
            res.add(sub3);//将前后引号中间的内容添加到结果中
            if (j + 2 < sub2.length()) { //判断后引号后面是否还有内容，如果有就进行下一轮判断
                count(sub2.substring(j + 2));
            }
        } else {  //如果没有引号，则按空格分解，依次添加到结果中
            String[] strs = str.split(" ");
            for (String s : strs) {
                res.add(s);
            }
        }
    }
}

用一个变量来记录遇到冒号的次数就行，遇到第二次就置零；
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 获取输入的字符串
        String str = in.nextLine();
        // 定义一个集合，用于存储解析的参数
        List<String> strLists = new ArrayList<>();
        // 对字符串进行参数解析
        stringAnalysis(str, strLists);
        // 输出结果
        System.out.println(strLists.size());
        strLists.forEach(p-> {
            System.out.println(p);
        });
    }
    /**
     * 对输入的字符串进行解析.
     */
    private static void stringAnalysis(String str, List<String> strLists) {
        // 定义一个字符串，用来表示解析的字符串
        String analysisStr = "";
        // 定义一个变量，用于存储遇到冒号的次数
        int count = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) != ' ' && str.charAt(i) != '"') {
                // 如果遇到的不为空格,也不是冒号，则添加
                analysisStr = analysisStr + str.charAt(i);
            } else if (str.charAt(i) == ' ' && count == 0) {
                // 遇到空格，但不是冒号内的，则将analysisStr添加到列表，并重置
                if (!analysisStr.equals("")) {
                    strLists.add(analysisStr);
                    analysisStr = "";
                }
            } else if (str.charAt(i) == ' ' && count != 0) {
                // 如果遇到冒号中的空格，还是要添加
                analysisStr = analysisStr + str.charAt(i);
            } else if (str.charAt(i) == '"') {
                if (count == 0 ) {
                    // 如果第一次遇到冒号，先将字符串重置
                    analysisStr = "";
                }
                count = count + 1;
                if (count == 2) {
                    // 第二次遇到，冒号，先将前一次解析添加，然后重置
                    strLists.add(analysisStr);
                    count = 0;
                    analysisStr = "";
                }
            }
        }
        if (!analysisStr.equals("")) {
            // 循环完，将最后一个添加到列表
            strLists.add(analysisStr);
        }
    }
}