continue的具体实现

本文通过两个示例对比了在C语言中使用continue语句的影响。详细解释了continue如何改变循环流程,避免了无限循环的发生,并阐述了for循环各部分的作用。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

先看下面一个代码;

#include <stdio.h>
int main(){

for(int i=1;i<=70;i++){
printf("%d\n",i);
if(i==15){
i=1;

}
i++;
}
}

#include <stdio.h>
int main(){

for(int i=1;i<=70;i++){
printf("%d\n",i);
if(i==15){
i=1;
continue;
}
i++;
}
}



这两段代码有什么区别吗?,,当然有,区别很大,一个会永远循环,一个则不会,

要理解continue在这里的用处先要理解for循环,,,for循环的三个句子,

第一个句子,是刚刚进入for循环的时候会有的操作,第二个句子是每次循环开始时候的验证,最后一个句子,可以理解为刮号前的最后一段话

只要还运行这个循环不管怎么执行,最后一个判断都是会有的,所以我们的continue可以理解为,刚刚好跳到这段话的前面开始执行。

for:

{第一个条件语句

while(第二个语句){;

{我们的代码段}

{continue跳到这个位置;第三个语句}//这一段我们实际上是看不到的,但是这样有助于理解,就是相当于for循环给我们加上的一句话,他永远在我们可视的代码后面

}

}



AntPathMatcher是Spring框架中的一个工具类,它提供了对Ant风格路径匹配的支持。它的具体实现如下: ```java public class AntPathMatcher { // Ant风格路径分隔符 private static final String PATH_SEPARATOR = "/"; // Ant风格路径分隔符 private static final char PATH_SEPARATOR_CHAR = '/'; // 单字符通配符 private static final char SINGLE_CHAR = '?'; // 多字符通配符 private static final char MULTI_CHAR = '*'; // 匹配路径时是否区分大小写 private final boolean caseSensitive; public AntPathMatcher() { this(true); } public AntPathMatcher(boolean caseSensitive) { this.caseSensitive = caseSensitive; } /** * 判断指定的路径是否匹配模式. */ public boolean match(String pattern, String path) { if (path.startsWith(PATH_SEPARATOR) != pattern.startsWith(PATH_SEPARATOR)) { return false; } String[] pattDirs = tokenizePattern(pattern); String[] pathDirs = tokenizePath(path); int pattIdxStart = 0; int pattIdxEnd = pattDirs.length - 1; int pathIdxStart = 0; int pathIdxEnd = pathDirs.length - 1; // 处理路径中前缀部分 while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) { String pattDir = pattDirs[pattIdxStart]; if (MULTI_CHAR == pattDir.charAt(0)) { break; } if (!matchStrings(pattDir, pathDirs[pathIdxStart])) { return false; } pattIdxStart++; pathIdxStart++; } if (pathIdxStart > pathIdxEnd) { // 如果路径已经比较完了 if (pattIdxStart > pattIdxEnd) { // 如果模式也已经比较完了 return (pattern.endsWith(PATH_SEPARATOR) == path.endsWith(PATH_SEPARATOR)); } if (pattIdxStart == pattIdxEnd && MULTI_CHAR == pattDirs[pattIdxStart].charAt(0) && path.endsWith(PATH_SEPARATOR)) { return true; } for (int i = pattIdxStart; i <= pattIdxEnd; i++) { if (MULTI_CHAR == pattDirs[i].charAt(0)) { return true; } } return false; } else if (pattIdxStart > pattIdxEnd) { return false; } // 处理路径中后缀部分 while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) { String pattDir = pattDirs[pattIdxEnd]; if (MULTI_CHAR == pattDir.charAt(0)) { break; } if (!matchStrings(pattDir, pathDirs[pathIdxEnd])) { return false; } pattIdxEnd--; pathIdxEnd--; } if (pathIdxStart > pathIdxEnd) { // 如果路径已经比较完了 while (pattIdxStart <= pattIdxEnd) { if (MULTI_CHAR == pattDirs[pattIdxEnd].charAt(0)) { pattIdxEnd--; continue; } return false; } return true; } while (pattIdxStart != pattIdxEnd && pathIdxStart <= pathIdxEnd) { int patIdxTmp = -1; for (int i = pattIdxStart + 1; i <= pattIdxEnd; i++) { if (MULTI_CHAR == pattDirs[i].charAt(0)) { patIdxTmp = i; break; } } if (patIdxTmp == pattIdxStart + 1) { pattIdxStart++; continue; } int patLength = (patIdxTmp - pattIdxStart - 1); int strLength = (pathIdxEnd - pathIdxStart + 1); int foundIdx = -1; strLoop: for (int i = 0; i <= strLength - patLength; i++) { for (int j = 0; j < patLength; j++) { String subPat = pattDirs[pattIdxStart + j + 1]; String subStr = pathDirs[pathIdxStart + i + j]; if (!matchStrings(subPat, subStr)) { continue strLoop; } } foundIdx = pathIdxStart + i; break; } if (foundIdx == -1) { return false; } pattIdxStart = patIdxTmp; pathIdxStart = foundIdx + patLength; } for (int i = pattIdxStart; i <= pattIdxEnd; i++) { if (MULTI_CHAR == pattDirs[i].charAt(0)) { continue; } if (!matchStrings(pattDirs[i], pathDirs[pathIdxStart])) { return false; } pathIdxStart++; } return true; } /** * 判断两个字符串是否匹配. */ private boolean matchStrings(String pattern, String str) { return getStringMatcher(pattern, str).matches(); } /** * 将模式字符串分隔成目录. */ private String[] tokenizePattern(String pattern) { if (pattern == null) { return new String[0]; } return tokenizeToStringArray(pattern, PATH_SEPARATOR, false, true); } /** * 将路径字符串分隔成目录. */ private String[] tokenizePath(String path) { if (path == null) { return new String[0]; } return tokenizeToStringArray(path, PATH_SEPARATOR, false, true); } /** * 创建字符串匹配器. */ private StringMatcher getStringMatcher(String pattern, String str) { if (caseSensitive) { return new AntPathStringMatcher(pattern, str); } else { return new AntPathStringMatcher(pattern.toLowerCase(), str.toLowerCase()); } } /** * 将字符串分隔成数组. */ private static String[] tokenizeToStringArray(String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens) { StringTokenizer st = new StringTokenizer(str, delimiters); List<String> tokens = new ArrayList<String>(); while (st.hasMoreTokens()) { String token = st.nextToken(); if (trimTokens) { token = token.trim(); } if (!ignoreEmptyTokens || token.length() > 0) { tokens.add(token); } } return tokens.toArray(new String[tokens.size()]); } } ``` AntPathMatcher类的主要方法是`match`方法,它使用了一些辅助方法来实现Ant风格的路径匹配。 在`match`方法中,首先处理路径中的前缀,然后处理路径中的后缀,最后处理路径中剩余的部分。在处理前缀和后缀时,如果遇到`*`通配符,就跳过当前部分的匹配,继续处理下一部分。在处理剩余部分时,如果遇到`*`通配符,就在路径中查找匹配的部分。如果找到了,就将匹配的部分从路径中删除,继续匹配下一个部分;如果找不到,就返回false。 在实现Ant风格的匹配时,AntPathMatcher使用了一些特殊的字符,例如`?`表示匹配单个字符,`*`表示匹配任意个字符。它还支持路径分隔符的匹配,例如`/`可以匹配路径中的分隔符。 总的来说,AntPathMatcher实现了一种简单而灵活的路径匹配算法,可以满足大多数情况下的路径匹配需求。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值