Java 字符串中所有出现字符的索引
下面的代码将打印2Java 字符串中所有出现字符的索引,java,loops,indexing,character,Java,Loops,Indexing,Character,下面的代码将打印2 String word = "bannanas"; String guess = "n"; int index; System.out.println( index = word.indexOf(guess) ); 我想知道如何获得字符串“bannanas”中“n”(“guess”)的所有索引 预期结果是:[2,3,5] String string = "bannanas"; ArrayList<Integer> list = new ArrayLis
String word = "bannanas";
String guess = "n";
int index;
System.out.println(
index = word.indexOf(guess)
);
我想知道如何获得字符串“bannanas”中“n”(“guess”)的所有索引
预期结果是:[2,3,5]
String string = "bannanas";
ArrayList<Integer> list = new ArrayList<Integer>();
char character = 'n';
for(int i = 0; i < string.length(); i++){
if(string.charAt(i) == character){
list.add(i);
}
}
或作为数组:
list.toArray();
尝试以下操作(现在末尾不打印-1!)
这将打印位置列表,该列表末尾没有
-1
它也可以作为for
循环执行:
for (int index = word.indexOf(guess);
index >= 0;
index = word.indexOf(guess, index + 1))
{
System.out.println(index);
}
[注意:如果guess
长度可以超过一个字符,那么通过分析guess
字符串,可以比上述循环更快地循环word
。这种方法的基准是。但是,似乎不存在有利于使用这种方法的条件。]试试这个
String input = "GATATATGCG";
String substring = "G";
String temp = input;
String indexOF ="";
int tempIntex=1;
while(temp.indexOf(substring) != -1)
{
int index = temp.indexOf(substring);
indexOF +=(index+tempIntex)+" ";
tempIntex+=(index+1);
temp = temp.substring(index + 1);
}
Log.e("indexOf ","" + indexOF);
String str = "helloslkhellodjladfjhello";
String findStr = "hello";
System.out.println(StringUtils.countMatches(str, findStr));
另外,如果你想在一个字符串中找到一个字符串的所有索引
int index = word.indexOf(guess);
while (index >= 0) {
System.out.println(index);
index = word.indexOf(guess, index + guess.length());
}
这可以通过迭代
myString
并将从indexOf()中的index
参数移位来实现:
我也有这个问题,直到我想出这个方法
public static int[] indexesOf(String s, String flag) {
int flagLen = flag.length();
String current = s;
int[] res = new int[s.length()];
int count = 0;
int base = 0;
while(current.contains(flag)) {
int index = current.indexOf(flag);
res[count] = index + base;
base += index + flagLen;
current = current.substring(current.indexOf(flag) + flagLen, current.length());
++ count;
}
return Arrays.copyOf(res, count);
}
此方法可用于查找字符串中任意长度的任何标志的索引,例如:
public class Main {
public static void main(String[] args) {
int[] indexes = indexesOf("Hello, yellow jello", "ll");
// Prints [2, 9, 16]
System.out.println(Arrays.toString(indexes));
}
public static int[] indexesOf(String s, String flag) {
int flagLen = flag.length();
String current = s;
int[] res = new int[s.length()];
int count = 0;
int base = 0;
while(current.contains(flag)) {
int index = current.indexOf(flag);
res[count] = index + base;
base += index + flagLen;
current = current.substring(current.indexOf(flag) + flagLen, current.length());
++ count;
}
return Arrays.copyOf(res, count);
}
}
我想出了一个拆分字符串的类。最后提供了一个简短的测试
SplitStringUtils.smartSplitToSorterstring(String str,int-maxLen,int-maxParts)
将按空格分割而不打断单词,如果可能,则将根据maxLen按索引分割
提供用于控制拆分方式的其他方法:bruteSplitLimit(字符串str,int-maxLen,int-maxParts)
,spaceSplit(字符串str,int-maxLen,int-maxParts)
公共类SplitStringUtils{
公共静态字符串[]SmartSplitToSorterString(字符串str、int-maxLen、int-maxParts){
if(str.length()maxLen*maxParts){
返回bruteSplitLimit(str、maxLen、maxParts);
}
字符串[]res=spaceSplit(str、maxLen、maxParts);
如果(res!=null){
返回res;
}
返回bruteSplitLimit(str、maxLen、maxParts);
}
公共静态字符串[]bruteSplitLimit(字符串str、int-maxLen、int-maxParts){
String[]brutearl=bruteSplit(str,maxLen);
String[]ret=Arrays.stream(brutarr)
.限制(最大部分)
.collect(收集器.toList())
.toArray(新字符串[maxParts]);
返回ret;
}
公共静态字符串[]bruteSplit(字符串名称,int-maxLen){
List res=new ArrayList();
int start=0;
int end=maxLen;
使用Java9(end时,可以使用以下方法:-
List<Integer> indexes = IntStream
.iterate(word.indexOf(c), index -> index >= 0, index -> word.indexOf(c, index + 1))
.boxed()
.collect(Collectors.toList());
System.out.printlnt(indexes);
List index=IntStream
.iterate(word.indexOf(c),index->index>=0,index->word.indexOf(c,index+1))
.boxed()
.collect(Collectors.toList());
系统输出打印(索引);
这是一个java 8解决方案
public int[] solution (String s, String subString){
int initialIndex = s.indexOf(subString);
List<Integer> indexList = new ArrayList<>();
while (initialIndex >=0){
indexList.add(initialIndex);
initialIndex = s.indexOf(subString, initialIndex+1);
}
int [] intA = indexList.stream().mapToInt(i->i).toArray();
return intA;
}
public int[]解决方案(字符串s,字符串子字符串){
int initialIndex=s.indexOf(子字符串);
列表索引列表=新的ArrayList();
而(初始索引>=0){
添加(初始索引);
initialIndex=s.indexOf(子字符串,initialIndex+1);
}
int[]intA=indexList.stream().mapToInt(i->i.toArray();
返回intA;
}
这可以通过Java 9使用正则表达式以函数方式完成:
Pattern.compile(Pattern.quote(guess)) // sanitize input and create pattern
.matcher(word) // create matcher
.results() // get the MatchResults, Java 9 method
.map(MatchResult::start) // get the first index
.collect(Collectors.toList()) // collect found indices into a list
);
下面是Kotlin解决方案,它使用扩展方法将此逻辑作为新方法添加到CharSequence
API中:
// Extension method
fun CharSequence.indicesOf(input: String): List<Int> =
Regex(Pattern.quote(input)) // build regex
.findAll(this) // get the matches
.map { it.range.first } // get the index
.toCollection(mutableListOf()) // collect the result as list
// call the methods as
"Banana".indicesOf("a") // [1, 3, 5]
//扩展方法
fun CharSequence.indicatesof(输入:字符串):列表=
Regex(Pattern.quote(input))//构建Regex
.findAll(此)//获取匹配项
.map{it.range.first}//获取索引
.toCollection(mutableListOf())//将结果收集为列表
//将这些方法称为
“香蕉”。表示“a”)/[1,3,5]
Java8+
要查找字符串
中特定字符的所有索引,可以创建一个包含所有索引的索引,并对其进行筛选
import java.util.stream.Collectors;
import java.util.stream.IntStream;
//...
String word = "bannanas";
char search = 'n';
//To get List of indexes:
List<Integer> indexes = IntStream.range(0, word.length())
.filter(i -> word.charAt(i) == search).boxed()
.collect(Collectors.toList());
//To get array of indexes:
int[] indexes = IntStream.range(0, word.length())
.filter(i -> word.charAt(i) == search).toArray();
import java.util.stream.collector;
导入java.util.stream.IntStream;
//...
字符串word=“bannanas”;
字符搜索='n';
//要获取索引列表,请执行以下操作:
列表索引=IntStream.range(0,word.length())
.filter(i->word.charAt(i)=search.boxed()
.collect(Collectors.toList());
//要获取索引数组,请执行以下操作:
int[]索引=IntStream.range(0,word.length())
.filter(i->word.charAt(i)=search.toArray();
总体思路是正确的,但是word.substring(word)
无法编译。:PStill有一个问题:它会连续打印2。天哪,我需要对我在这里发布的所有内容进行javac。您总是同时打印-1end@Peter非常感谢您的回答,这似乎是对的,但实际上这是我使用Java的第一天,所以我对最终结果有点困惑,这似乎输出了-1,我不知道非常理解为什么!谢谢!!@Trufa:它总是在结尾处打印-1,因为indexOf
在找不到字符时返回-1。@Trufa-它在结尾处打印-1
的原因是do
循环执行主体,然后在中发现索引==-1
,而@ColinD我得到的部分是,我不明白的是,函数发生了什么,它“循环”通过单词寻找字符的出现,直到找到为止,它再也找不到正确的地方了?然后打印最后一个索引,它是未找到的(-1),是这样吗?(我不知道结果是否正确)这适用于在较大字符串中计算子字符串的实例,但不会返回匹配项的索引。虽然此代码可能会回答此问题,但提供有关如何和/或为什么解决此问题的其他上下文将提高答案的长期值。这并不能回答此问题。此问题需要一个所有子字符串的列表这并不能回答这个问题&而且,StringUtils有多个提供者。使用哪个库
public class Main {
public static void main(String[] args) {
int[] indexes = indexesOf("Hello, yellow jello", "ll");
// Prints [2, 9, 16]
System.out.println(Arrays.toString(indexes));
}
public static int[] indexesOf(String s, String flag) {
int flagLen = flag.length();
String current = s;
int[] res = new int[s.length()];
int count = 0;
int base = 0;
while(current.contains(flag)) {
int index = current.indexOf(flag);
res[count] = index + base;
base += index + flagLen;
current = current.substring(current.indexOf(flag) + flagLen, current.length());
++ count;
}
return Arrays.copyOf(res, count);
}
}
public class SplitStringUtils {
public static String[] smartSplitToShorterStrings(String str, int maxLen, int maxParts) {
if (str.length() <= maxLen) {
return new String[] {str};
}
if (str.length() > maxLen*maxParts) {
return bruteSplitLimit(str, maxLen, maxParts);
}
String[] res = spaceSplit(str, maxLen, maxParts);
if (res != null) {
return res;
}
return bruteSplitLimit(str, maxLen, maxParts);
}
public static String[] bruteSplitLimit(String str, int maxLen, int maxParts) {
String[] bruteArr = bruteSplit(str, maxLen);
String[] ret = Arrays.stream(bruteArr)
.limit(maxParts)
.collect(Collectors.toList())
.toArray(new String[maxParts]);
return ret;
}
public static String[] bruteSplit(String name, int maxLen) {
List<String> res = new ArrayList<>();
int start =0;
int end = maxLen;
while (end <= name.length()) {
String substr = name.substring(start, end);
res.add(substr);
start = end;
end +=maxLen;
}
String substr = name.substring(start, name.length());
res.add(substr);
return res.toArray(new String[res.size()]);
}
public static String[] spaceSplit(String str, int maxLen, int maxParts) {
List<Integer> spaceIndexes = findSplitPoints(str, ' ');
List<Integer> goodSplitIndexes = new ArrayList<>();
int goodIndex = -1;
int curPartMax = maxLen;
for (int i=0; i< spaceIndexes.size(); i++) {
int idx = spaceIndexes.get(i);
if (idx < curPartMax) {
goodIndex = idx;
} else {
goodSplitIndexes.add(goodIndex+1);
curPartMax = goodIndex+1+maxLen;
}
}
if (goodSplitIndexes.get(goodSplitIndexes.size()-1) != str.length()) {
goodSplitIndexes.add(str.length());
}
if (goodSplitIndexes.size()<=maxParts) {
List<String> res = new ArrayList<>();
int start = 0;
for (int i=0; i<goodSplitIndexes.size(); i++) {
int end = goodSplitIndexes.get(i);
if (end-start > maxLen) {
return null;
}
res.add(str.substring(start, end));
start = end;
}
return res.toArray(new String[res.size()]);
}
return null;
}
private static List<Integer> findSplitPoints(String str, char c) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == c) {
list.add(i);
}
}
list.add(str.length());
return list;
}
}
public static void main(String[] args) {
String [] testStrings = {
"123",
"123 123 123 1123 123 123 123 123 123 123",
"123 54123 5123 513 54w567 3567 e56 73w45 63 567356 735687 4678 4678 u4678 u4678 56rt64w5 6546345",
"1345678934576235784620957029356723578946",
"12764444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444",
"3463356 35673567567 3567 35 3567 35 675 653 673567 777777777777777777777777777777777777777777777777777777777777777777"
};
int max = 35;
int maxparts = 2;
for (String str : testStrings) {
System.out.println("TEST\n |"+str+"|");
printSplitDetails(max, maxparts);
String[] res = smartSplitToShorterStrings(str, max, maxparts);
for (int i=0; i< res.length;i++) {
System.out.println(" "+i+": "+res[i]);
}
System.out.println("===========================================================================================================================================================");
}
}
static void printSplitDetails(int max, int maxparts) {
System.out.print(" X: ");
for (int i=0; i<max*maxparts; i++) {
if (i%max == 0) {
System.out.print("|");
} else {
System.out.print("-");
}
}
System.out.println();
}
List<Integer> indexes = IntStream
.iterate(word.indexOf(c), index -> index >= 0, index -> word.indexOf(c, index + 1))
.boxed()
.collect(Collectors.toList());
System.out.printlnt(indexes);
public int[] solution (String s, String subString){
int initialIndex = s.indexOf(subString);
List<Integer> indexList = new ArrayList<>();
while (initialIndex >=0){
indexList.add(initialIndex);
initialIndex = s.indexOf(subString, initialIndex+1);
}
int [] intA = indexList.stream().mapToInt(i->i).toArray();
return intA;
}
Pattern.compile(Pattern.quote(guess)) // sanitize input and create pattern
.matcher(word) // create matcher
.results() // get the MatchResults, Java 9 method
.map(MatchResult::start) // get the first index
.collect(Collectors.toList()) // collect found indices into a list
);
// Extension method
fun CharSequence.indicesOf(input: String): List<Int> =
Regex(Pattern.quote(input)) // build regex
.findAll(this) // get the matches
.map { it.range.first } // get the index
.toCollection(mutableListOf()) // collect the result as list
// call the methods as
"Banana".indicesOf("a") // [1, 3, 5]
import java.util.stream.Collectors;
import java.util.stream.IntStream;
//...
String word = "bannanas";
char search = 'n';
//To get List of indexes:
List<Integer> indexes = IntStream.range(0, word.length())
.filter(i -> word.charAt(i) == search).boxed()
.collect(Collectors.toList());
//To get array of indexes:
int[] indexes = IntStream.range(0, word.length())
.filter(i -> word.charAt(i) == search).toArray();