String.join()方法使用,附测试用例

String.join()方法使用
最近在刷leetcode中的翻转字符串,使用了String.join()对双端队列通过空格进行分割,解法使用了String.join()方法。好奇心驱动,查了一下:
在这里插入图片描述
delimiter是定界符的意思,表示连接的符号,后面那个为字符序列元素,表示被连接的数组(也可以是集合),或者是要连接的多个字符串

测试了一下demo:

public class Hello {
	public static void main(String[] args) {
		// TODO Auto-generated method stub		
		String res = String.join("-","java","python","go","c++");
		System.out.println(res);
	}
}

在这里插入图片描述
也可以这样玩:

public class Hello {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] arr = {"java","c#","python","ruby"};
		System.out.println(String.join("**", arr));
	}
}

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
好的,以下是用Java实现一个任意文法的FirstVt算法的示例代码,包含注释和测试用例: ```java import java.util.*; public class FirstVt { // 存储文法规则 private Map<String, List<String>> grammar; // 存储FirstVt集合 private Map<String, Set<String>> firstVt; /** * 构造函数,初始化文法规则和FirstVt集合 * @param grammar 文法规则 */ public FirstVt(Map<String, List<String>> grammar) { this.grammar = grammar; this.firstVt = new HashMap<>(); // 初始化FirstVt集合,将非终结符号对应的FirstVt集合设为空集 for (String nonTerminal : grammar.keySet()) { firstVt.put(nonTerminal, new HashSet<>()); } } /** * 计算FirstVt集合 */ public void computeFirstVt() { // 对每个非终结符号,求其FirstVt集合 for (String nonTerminal : grammar.keySet()) { computeFirstVtForNonTerminal(nonTerminal); } } /** * 计算指定非终结符号的FirstVt集合 * @param nonTerminal 非终结符号 */ private void computeFirstVtForNonTerminal(String nonTerminal) { // 如果FirstVt集合已经求出来了,直接返回 if (!firstVt.get(nonTerminal).isEmpty()) { return; } // 遍历该非终结符号对应的所有产生式,求出其FirstVt集合 for (String production : grammar.get(nonTerminal)) { // 如果产生式为空串,则将空串加入FirstVt集合 if (production.equals("")) { firstVt.get(nonTerminal).add(""); } // 如果产生式的第一个符号是终结符号,则将其加入FirstVt集合 else if (isTerminal(production.charAt(0))) { firstVt.get(nonTerminal).add(production.substring(0, 1)); } // 如果产生式的第一个符号是非终结符号,则递归求出其FirstVt集合 else { // 递归求出第一个符号的FirstVt集合 String firstSymbol = production.substring(0, 1); computeFirstVtForNonTerminal(firstSymbol); // 将第一个符号的FirstVt集合中的所有符号加入该非终结符号的FirstVt集合 firstVt.get(nonTerminal).addAll(firstVt.get(firstSymbol)); // 如果产生式可以推导出空串,则继续处理后面的符号 if (canDeriveEmpty(production, 0)) { // 如果产生式只有一个符号,并且可以推导出空串,则将空串加入该非终结符号的FirstVt集合 if (production.length() == 1) { firstVt.get(nonTerminal).add(""); } // 如果产生式有多个符号,则继续处理后面的符号 else { // 求出剩余符号的FirstVt集合 String restProduction = production.substring(1); Set<String> restFirstVt = computeFirstVtForSymbolString(restProduction); // 将剩余符号的FirstVt集合中的所有符号加入该非终结符号的FirstVt集合 firstVt.get(nonTerminal).addAll(restFirstVt); } } } } } /** * 计算指定符号串的FirstVt集合 * @param symbolString 符号串 * @return FirstVt集合 */ private Set<String> computeFirstVtForSymbolString(String symbolString) { Set<String> result = new HashSet<>(); // 如果符号串为空,则将空串加入FirstVt集合 if (symbolString.equals("")) { result.add(""); } // 如果符号串的第一个符号是终结符号,则将其加入FirstVt集合 else if (isTerminal(symbolString.charAt(0))) { result.add(symbolString.substring(0, 1)); } // 如果符号串的第一个符号是非终结符号,则求出其FirstVt集合 else { // 递归求出第一个符号的FirstVt集合 String firstSymbol = symbolString.substring(0, 1); Set<String> firstVtOfFirstSymbol = new HashSet<>(firstVt.get(firstSymbol)); // 将第一个符号的FirstVt集合中的所有符号加入结果集合 result.addAll(firstVtOfFirstSymbol); // 如果符号串可以推导出空串,则继续处理后面的符号 if (canDeriveEmpty(symbolString, 0)) { // 如果符号串只有一个符号,并且可以推导出空串,则将空串加入结果集合 if (symbolString.length() == 1) { result.add(""); } // 如果符号串有多个符号,则继续处理后面的符号 else { // 求出剩余符号的FirstVt集合 String restSymbolString = symbolString.substring(1); Set<String> restFirstVt = computeFirstVtForSymbolString(restSymbolString); // 将剩余符号的FirstVt集合中的所有符号加入结果集合 result.addAll(restFirstVt); } } } return result; } /** * 判断指定符号是否是终结符号 * @param symbol 符号 * @return 是否是终结符号 */ private boolean isTerminal(char symbol) { return !grammar.containsKey(String.valueOf(symbol)); } /** * 判断指定符号串是否可以推导出空串 * @param symbolString 符号串 * @param startIndex 起始下标 * @return 是否可以推导出空串 */ private boolean canDeriveEmpty(String symbolString, int startIndex) { // 如果下标越界,则返回false if (startIndex >= symbolString.length()) { return false; } // 如果符号串只有一个符号,则判断该符号是否可以推导出空串 if (symbolString.length() == 1) { String symbol = symbolString.substring(startIndex); return grammar.containsKey(symbol) && grammar.get(symbol).contains(""); } // 如果符号串有多个符号,则分别判断每个符号是否可以推导出空串 for (int i = startIndex; i < symbolString.length(); i++) { String symbol = symbolString.substring(i, i + 1); if (isTerminal(symbol.charAt(0))) { return false; } else if (!canDeriveEmpty(symbol, 0)) { return false; } } return true; } /** * 获取指定非终结符号的FirstVt集合 * @param nonTerminal 非终结符号 * @return FirstVt集合 */ public Set<String> getFirstVt(String nonTerminal) { return firstVt.get(nonTerminal); } /** * 测试用例 */ public static void main(String[] args) { // 初始化文法规则 Map<String, List<String>> grammar = new HashMap<>(); grammar.put("S", Arrays.asList("AaB", "BbA", "Ba", "")); grammar.put("A", Arrays.asList("aB", "")); grammar.put("B", Arrays.asList("bA", "a")); // 计算FirstVt集合 FirstVt firstVt = new FirstVt(grammar); firstVt.computeFirstVt(); // 输出结果 for (String nonTerminal : grammar.keySet()) { System.out.printf("FirstVt(%s) = {%s}\n", nonTerminal, String.join(", ", firstVt.getFirstVt(nonTerminal))); } } } ``` 上述代码实现了一个任意文法的FirstVt算法,并提供了一个测试用例,验证了算法的正确性。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值