javastring查找
⑴ java怎麼查找字元串中是否包含某個欄位
方法：
1、描述：java.lang.String.contains() 方法返回true，當且僅當此字元串包含指定的char值序列
2、聲明：如下圖
⑵ java中在String中查找某字的下標值並循環輸出
//不是特別明白你循環輸出的意思，如果只是要找到下標的話，用String類的indexOf方法就可以了
//按你的意思寫了一下，代碼中包括對indexOf方法的使用，你看一下吧。
public class StringFun {
public static void main(String[] args) {
String str="每次和小朋友玩捉迷藏的時候，我總是等他們先藏好，我就回家。";
System.out.println(str.indexOf("和"));
System.out.println(str.indexOf("小朋友"));
stringFun('次',str);
}
/**
* 求出c字元在str串中的下標並以循環的方式輸出str串
*/
private static void stringFun(char c, String str) {
boolean flag=true;
int index=-1; //用於保存初次比中的下標值
char[] chars=str.toCharArray();
for(int i=0;i<chars.length;i++) {
if(chars[i]==c&&flag) {
index=i;
flag=false;
}
System.out.print(chars[i]);
}
if(index!=-1) System.out.println("\n'"+c+"'字元在串中初次出現的下標為:"+index);
else System.out.println("\n'"+c+"'字元未在串中出現過");
}
}
⑶ 如何用java String 查找字元個數
import java.util.Scanner;
public class test3 {
public static void main(String [] args){
System.out.print("inuput : ");
Scanner input=new Scanner(System.in);
int [] digit =new int[256];
String inputString = input.next();
//為了避免在輸入的時候錯誤的鍵入了空格和table，進行一下處理
//以空格為分隔符分割字元串
String [] strings=inputString.split(" ");
String inputString1="";
//將分割後的字元串重新連接起來
for(String str : strings){
inputString1+=str;
}
//以table為分隔符分割字元串
strings=inputString.split(" ");
//將分割後的字元串重新連接起來
String inputString2="";
for(String str : strings){
inputString2+=str;
}
String returnString="";
for (int i = 0; i < inputString2.length(); i++) {
digit[inputString.charAt(i)-'!']++;
//將重復的字元輸出，這里為什麼是2呢有人會問重復次數也可以大於2啊？
//是因為大於2的在2的時候已經被輸出，為了避免重復次數大於2的字元被重復輸出，所以這里只能是2
if(digit[inputString.charAt(i)-'!']==2){
returnString+=inputString.charAt(i);
}
}
System.out.print(returnString);
}
}
樓主算是問對人了
馬上給答案
樓主雖然我這個最終目的不是統計每個字元的個數，但是代碼裡面已經實現了這個功能，只要稍作修改就可以，我的主要功能是輸出重復的字元！
希望我給的代碼樓主還滿意
⑷ JAVA中如何查找字元串
問題很簡單：
1.首先，你的數據源是數組，那麼要想對每一個值作操作，必須遍歷，所以就有如下代碼：
for(int i=0;i<A.length;i++){
...
}
2.在循環當中，數組中的每一個正在遍歷的元素，就是：A[i];
3.String是java的一個字元串處理類，他有一個非常好用的方法就是，
public boolean startsWith(String prefix)，測試此字元串是否以指定的前綴開始。 所以：A[i].startsWith("C")如果返回true，那麼他就是以C開頭的。
4.綜上所述，實現很簡單，完成代碼如下：
public class Test{
public static void main(String[] args){
String[] A ={"CSDF","FDS","CFDSA","DFS","FET"};
for(int i=0;i<A.length;i++){
if(A[i].startsWith("C")){
System.out.println(A[i]);
}
}
}
}
總結：
臨時寫的，代碼沒有經過測試，但敢保證其正確性的幾率很大，祝你成功。
⑸ java中怎麼實現查找某個數組里的string值
如何檢查一個未排序的數組中是否包含某個特定值，這是一個在Java中非常實用並且頻繁使用的操作。另外，這也是Stack
Overflow上面非常受關注的問題。在得票數最多的答案中，可以看到，檢查數組中是否包含特定值可以用多種不同的方式實現，但是時間復雜度差別很大。
下面，我將為大家展示各種方法及其需要花費的時間。
1.檢查數組中是否包含特定值的四種不同方法
1）使用List：
public static boolean useList(String[] arr, String targetValue) {
return Arrays.asList(arr).contains(targetValue);
}
2）使用Set：
public static boolean useSet(String[] arr, String targetValue) {
Set<String> set = new HashSet<String>(Arrays.asList(arr));
return set.contains(targetValue);
}
3）使用一個簡單循環：
public static boolean useLoop(String[] arr, String targetValue) {
for(String s: arr){
if(s.equals(targetValue))
return true;
}
return false;
}
4）使用Arrays.binarySearch()：
註：下面的代碼是錯誤的，這樣寫出來僅僅為了理解方便。binarySearch()只能用於已排好序的數組中。所以，你會發現下面結果很奇怪。
public static boolean useArraysBinarySearch(String[] arr, String targetValue) {
int a = Arrays.binarySearch(arr, targetValue);
if(a > 0)
return true;
else
return false;
}
2.時間復雜度
通過下面的這段代碼可以近似比較幾個方法的時間復雜度。雖然分別搜索一個大小為5、1K、10K的數組是不夠精確的，但是思路是清晰的。
public static void main(String[] args) {
String[] arr = new String[] { "CD", "BC", "EF", "DE", "AB"};
//use list
long startTime = System.nanoTime();
for (int i = 0; i < 100000; i++) {
useList(arr, "A");
}
long endTime = System.nanoTime();
long ration = endTime - startTime;
System.out.println("useList: " + ration / 1000000);
//use set
startTime = System.nanoTime();
for (int i = 0; i < 100000; i++) {
useSet(arr, "A");
}
endTime = System.nanoTime();
ration = endTime - startTime;
System.out.println("useSet: " + ration / 1000000);
//use loop
startTime = System.nanoTime();
for (int i = 0; i < 100000; i++) {
useLoop(arr, "A");
}
endTime = System.nanoTime();
ration = endTime - startTime;
System.out.println("useLoop: " + ration / 1000000);
//use Arrays.binarySearch()
startTime = System.nanoTime();
for (int i = 0; i < 100000; i++) {
useArraysBinarySearch(arr, "A");
}
endTime = System.nanoTime();
ration = endTime - startTime;
System.out.println("useArrayBinary: " + ration / 1000000);
}
結果：
useList: 13
useSet: 72
useLoop: 5
useArraysBinarySearch: 9
對於長度為1K的數組：
String[] arr = new String[1000];
Random s = new Random();
for(int i=0; i< 1000; i++){
arr[i] = String.valueOf(s.nextInt());
}
結果：
1
2
3
4
useList: 112
useSet: 2055
useLoop: 99
useArrayBinary: 12
對於長度為10K的數組：
String[] arr = new String[10000];
Random s = new Random();
for(int i=0; i< 10000; i++){
arr[i] = String.valueOf(s.nextInt());
}
結果：
useList: 1590
useSet: 23819
useLoop: 1526
useArrayBinary: 12
很明顯，使用簡單循環的方法比使用其他任何集合效率更高。許多開發者會使用第一種方法，但是它並不是高效的。將數組壓入Collection類型中，需要首先將數組元素遍歷一遍，然後再使用集合類做其他操作。
如果使用Arrays.binarySearch()方法，數組必須是已排序的。由於上面的數組並沒有進行排序，所以該方法不可使用。
實際上，如果你需要藉助數組或者集合類高效地檢查數組中是否包含特定值，一個已排序的列表或樹可以做到時間復雜度為O(log(n))，hashset可以達到O(1)。
⑹ JAVA中怎樣在一個字元串中查找給定的子字元串
調用類java.lang.String
的以下方法都可以：
public int indexOf(String str)
返回指定子字元串在此字元串中第一次出現處的索引。
參數：
str - 任意字元串。
返回：
如果字元串參數作為一個子字元串在此對象中出現，則返回第一個這種子字元串的第一個字元的索引；如果它不作為一個子字元串出現，則返回 -1。
public int indexOf(String str,int fromIndex)
返回指定子字元串在此字元串中第一次出現處的索引，從指定的索引開始。
參數：
str - 要搜索的子字元串。
fromIndex - 開始搜索的索引位置。
返回：
指定子字元串在此字元串中第一次出現處的索引，從指定的索引開始。
public int lastIndexOf(String str)
返回指定子字元串在此字元串中最右邊出現處的索引。將最右邊的空字元串 "" 視為出現在索引值 this.length() 處。
參數：
str - 要搜索的子字元串。
返回：
如果字元串參數作為一個子字元串在此對象中出現一次或多次，則返回最後一個這種子字元串的第一個字元。如果它不作為一個子字元串出現，則返回 -1。
public int lastIndexOf(String str,int fromIndex)
返回指定子字元串在此字元串中最後一次出現處的索引，從指定的索引開始反向搜索。
參數：
str - 要搜索的子字元串。
fromIndex - 開始搜索的索引位置。
返回：
指定子字元串在此字元串中最後一次出現處的索引。