⑴ java 實現字元串通配符
^private static boolean wildMatch(String pattern, String str) {
pattern = toJavaPattern(pattern);
return java.util.regex.Pattern.matches(pattern, str);
}
private static String toJavaPattern(String pattern) {
String result = "^";
char metachar[] = { '$', '^', '[', ']', '(', ')', '{', '|', '*', '+', '?', '.', '//' };
for (int i = 0; i < pattern.length(); i++) {
char ch = pattern.charAt(i);
boolean isMeta = false;
for (int j = 0; j < metachar.length; j++) {
if (ch == metachar[j]) {
result += "/" + ch;
isMeta = true;
break;
}
}
if (!isMeta) {
if (ch == '*') {
result += ".*";
} else {
result += ch;
}
}
}
result += "$";
return result;
}
public static void main(String[] args) {
test("*", "toto");
test("toto.java", "tutu.java");
test("12345", "1234");
test("1234", "12345");
test("*f", "");
test("***", "toto");
test("*.java", "toto.");
test("*.java", "toto.jav");
test("*.java", "toto.java");
test("abc*", "");
test("a*c", "abbbbbccccc");
test("abc*xyz", "abcxxxyz");
test("*xyz", "abcxxxyz");
test("abc**xyz", "abcxxxyz");
test("abc**x", "abcxxx");
test("*a*b*c**x", "aaabcxxx");
test("abc*x*yz", "abcxxxyz");
test("abc*x*yz*", "abcxxxyz");
test("a*b*c*x*yf*z*", "aabbccxxxeeyffz");
test("a*b*c*x*yf*zze", "aabbccxxxeeyffz");
test("a*b*c*x*yf*ze", "aabbccxxxeeyffz");
test("a*b*c*x*yf*ze", "aabbccxxxeeyfze");
test("*LogServerInterface*.java", "_LogServerInterfaceImpl.java");
test("abc*xyz", "abcxyxyz");
}
private static void test(String pattern, String str) {
System.out.println(pattern+" " + str + " =>> " + wildMatch(pattern, str));
}
⑵ 文件刪除時支持通配符 Java
package org.example;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class FileUtil {
/**
* 刪除指定目錄下符合指定<param>pattern</param>的文件或目錄
* @param path
* 指定的目錄
* @param pattern
* 要刪除的目標，可以含通配符(*)
* 如：x*d\*.bak，為指定目錄下以x開頭d結尾的目錄下的所有bak文件
* @return
* true, 沒有錯誤；false， 發生了錯誤
*/
public static boolean delete(String path, String pattern) throws Exception {
if( path == null || pattern == null )
throw new IllegalArgumentException("參數為空");
boolean result = true;
File root = new File(path);
if( !root.isDirectory() || !root.exists() )
throw new IllegalArgumentException("不是目錄或者目錄不存在");
List<File> folderBuffer = new ArrayList<File>();
folderBuffer.add(root);
String[] ps = pattern.split("\\" + File.separator);
for(int i = 0; i < ps.length; i ++) {
List<File> tmpList = new ArrayList<File>();
while(folderBuffer.size() > 0) {
File folder = folderBuffer.remove(0);
List<File> fileMatched = applyPattern(folder, ps[i]);
tmpList.addAll(fileMatched);
}
folderBuffer.addAll(tmpList);
if( folderBuffer.size() == 0 )
return true;
}
for(int i = 0; i < folderBuffer.size(); i ++) {
boolean r = deleteFile(folderBuffer.get(i));
if( !r )
return r;
}
return result;
}
private static boolean deleteFile(File f) {
trace("DELETE: " + f.getPath());
if( f.isFile() )
return f.delete();
// 目錄也有可能滿足通配符！
// 是否執行刪除帶有文件的目錄？自己判斷，這里直接刪，不管成功失敗
return f.delete();
}
/**
* 將含通配符（*）的字元串轉變成正則表達式
* @param pattern
* @return
* @remark
* 這里做得比較簡單，只是替換了"."和"*"，實際情況可能還有其他字元需要替換
*/
private static Pattern createPattern(String pattern) {
String _pattern = pattern.replaceAll("\\.", "\\\\.").replaceAll("\\*", ".*");
Pattern p = Pattern.compile(_pattern, Pattern.CASE_INSENSITIVE);
return p;
}
private static List<File> applyPattern(File folder, String pattern) {
List<File> list = new ArrayList<File>();
if( folder == null || folder.isFile() || pattern == null )
return list; // 空List
Pattern p = createPattern(pattern);
File[] files = folder.listFiles();
for(int i = 0; i < files.length; i ++) {
File file = files[i];
String name = file.getName();
Matcher m = p.matcher(name);
if( m.matches() ) {
list.add(file);
trace("[ M] Folder: " + folder + ", Pattern: " + pattern +
", File: " + name + " <-----Matched----");
}
else {
trace("[NM] Folder: " + folder + ", Pattern: " + pattern +
", File: " + name);
}
}
return list;
}
private static void trace(String message) {
System.out.println(message);
}
public static void main(String[] args) throws Exception {
trace("警告：請按照您自己的要求修改程序，風險自負。");
FileUtil.delete("F:\\temp", "*x1\\*.exe");
}
}
⑶ java class<>是什麼意思
List list = "......";
Student stu = new Student();
stu = list.get(0);
System.out.println(stu.getName());
上面的代碼等同於下面，其實就是版泛型。權
List <Student>list = "....";
System.out.println(list.get(0).getName());
⑷ java 通配符匹配字元串
我記得在String類中有一個matches(reg)方法，可以加正則表達式判定是否符合要求，
String string ="110_1565121651.tmp";
boolean flag=string.matches("110_[0-9]+\\.tmp");
System.out.println("flag="+flag);
試下是不是這版樣，我了是初學權者，如不對，請見諒。
⑸ java程序中調用帶通配符*的unix系統命令
*這個已經是很頑固的問題了,如果不愛用ListFile的話
可以變通下
find .-name "test" -exec rm -f {} \;
⑹ 在java中，〈extends A 〉與〈T extends A〉有什麼區別
這是泛型嘛，泛型簡單的意思就是說，你不知道你想要的這個類具體是啥，但是你可以知道這個類的相關子類或者父類
所以從上面的觀點來看，<? extends A> 和 <T extends A>是沒啥區別的
例如下面這個兩個方法表達的意思是一樣的，都表示參數是一個集合，這個集合可能包含著A或者A的任何子類
publicvoidsomeMethod(List<?extendsA>list);
publicvoidsomeMethod(List<TextendsA>list);
這是一種情況，但是相比而言，一個類中，多處方法都需要這個泛型的時候，<T extends A>要比<? extends A> 方便的多，就像在代碼里，你聲明了一個變數後，你就可以在這個變數的代碼塊里任何地方調用，同理<T extends A>就像是聲明了一個泛型變數T，這個T是一個A或者A的子類，然後這個變數T在所能用的范圍之內，你都可以直接用T表示，不用再寫<? extends A>或者<T extends A>，比如：
//前面定義了T，後面參數就可以用T表示了
public<TextendsA>voidsome(List<T>t);
上面是方法里，這個范圍比較窄，放在類里，效果更明顯，比如：
publicclassB<TextendsA>{
//一個A類或者A子類的變數
privateTa;
//一個方法
publicvoidsome(List<T>list);
}所以可以看到，差別也不太大
⑺ java 集合中泛型通配符 用了之後就不能添加 元素了 為什麼
首先泛型是用來約束的（或者說是規范化），泛型的本質是參數化類型，不是用來通配的（這個說法也不完全對），這個概念一定不要混淆了。
你添加的元素是String類型的，那麼你的代碼就得這樣：
ArrayList<String>arr=newArrayList<String>();
或者：
List<String>arr=newArrayList<String>();//多態，推薦使用
再或者：
Listarr=newArrayList();
ArrayListarr=newArrList();//這兩種沒有用泛型，編譯器會提示警告
用上面1和2方式的話，你的arr集合就只能存放String類型對象，3沒有用泛型，什麼類型的對象都可以存放。只是取出來的時候，會要類型轉換，這個過程很容易出錯。
希望我的回答能對你有所幫助，榮幸之至。
⑻ java通配符類型
如果是類引入的通配符，那麼指的是」*「，
如：import java.util.*;表示的是引入util包下的所有類；
如果是查找的通配符，那麼指的是」*「，
如：*.java;表示的是查找後綴為java的所有文件；
如果是泛型中的通配符，那麼指的是」<T>「;
如：List<T> list = new ArayList<T>()；表示定義了一個通配的list對象，可以代表任何對象的list。
⑼ java泛型無界通配符和原生的區別什麼
無界通配符<?>看起來意味著「任何事物」，因此使用無界通配符好像等價於使用原生類型。實際上，List表示「持有任何Object類型的原生List」，而List<?>表示「具有某種特定類型的非原生List