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 - 开始搜索的索引位置。
返回：
指定子字符串在此字符串中最后一次出现处的索引。