我希望根据两个变量x和y将两个或多个连续字符串连接成一个数组中的一个字符串，这意味着从 x：th 元素，连接，直到我们连接 y 元素。例如，如果一个阵列＆＃39; A＆＃39;元素为：
A = {"europe", "france", "germany", "america"};
x=2;y=2;
//Here, I want to concatenate france and germany as :
A = {"europe", "france germany", "america"};
//Or
x=2,y=3;
A= {"europe", "france germany america"};
喜欢这个。任何人都知道如何在没有复杂编程的情况下完成这项工作？
答案 0 :(得分：6)
最简洁的方法可能是：
构造一个正确大小的数组：
String[] result = new String[A.length - (y-1)];
使用System.arraycopy复制数组的开头和结尾：
System.arraycopy(A, 0, result, 0, x-1);
System.arraycopy(A, x+y-1, result, x+1, A.length-(x+1));
构建连接字符串：
result[x-1] = String.join(" ", Arrays.asList(A).subList(x-1, x-1+y));
（注意：由于撰写日期，可能会出现一个错误）
答案 1 :(得分：2)
这是一个工作脚本，但我不知道你会认为它有多么简单。算法是简单地向下走输入数组，将字符串复制到输出，直到我们到达由x值确定的第一个条目。然后，我们将y个术语的数量连接到一个字符串。最后，我们通过逐个复制剩余的术语来完成。
public static String[] concatenate(String[] input, int x, int y) {
List<String> list = new ArrayList<>();
// just copy over values less than start of x range
for (int i=0; i < x-1; ++i) {
list.add(input[i]);
}
// concatenate y values into a single string
StringBuilder sb = new StringBuilder("");
for (int i=0; i < y; ++i) {
if (i > 0) sb.append(" ");
sb.append(input[x-1+i]);
}
list.add(sb.toString());
// copy over remaining values
for (int i=x+y-1; i < input.length; ++i) {
list.add(input[i]);
}
String[] output = new String[list.size()];
output = list.toArray(output);
return output;
}
String[] input = new String[] {"europe", "france", "germany", "america"};
int x = 2;
int y = 3;
String[] output = concatenate(input, x, y);
for (String str : output) {
System.out.println(str);
}
答案 2 :(得分：1)
这是一个非常简单的程序方法：
private static ArrayList<String> concatenate(String[] strings, int x, int y) {
ArrayList<String> retVal = new ArrayList<>();
StringBuilder builder = new StringBuilder();
int count = y;
boolean concatenated = false;
for (int i = 0 ; i < strings.length ; i++) {
if (i < x - 1 || concatenated) {
retVal.add(strings[i]);
} else {
builder.append(" ");
builder.append(strings[i]);
count--;
if (count == 0) {
retVal.add(builder.toString());
concatenated = true;
}
}
}
return retVal;
}
说明：
x - 1索引或我们已完成连接，请将元素添加到返回值。x - 1但未完成连接，请将该元素添加到字符串构建器中。count == 0表示），请将连接的字符串添加到返回值。答案 3 :(得分：1)
应该使用for循环并保持索引的链接
String[] A = {"europe", "france", "germany", "america"};
String[] new_Array;
// your code goes here
int x=2,y=3;
int start_concat = x-1 ; // to account for array index
int stop_concat = start_concat+y;
new_Array = new String[A.length-y + 1];
for(int i=0; i<=start_concat; i++){
new_Array[i] = A[i];
}
for(int i = start_concat+1 ; i<stop_concat; i++){
new_Array[start_concat] = new_Array[start_concat] + A[i];
}
for(int i =start_concat+1, j=stop_concat ; i< new_Array.length;i++,j++){
new_Array[i] = A[j];
}
for(int i=0; i<new_Array.length; i++){
System.out.println(new_Array[i]);
}
答案 4 :(得分：1)
使用REPEAT (::) API，我们可以利用subList方法以及addAll方法修改列表的特定部分，并将元素插入指定位置的列表中。
除此之外，我们利用String replace方法删除列表的冗余字符串表示，最后将累加器列表转换为字符串数组。
List这样称呼它：
public static String[] concatElements(String[] elements, int start, int count){
List<String> accumulator = new ArrayList<>(Arrays.asList(elements));
List<String> subList = new ArrayList<>(accumulator.subList(--start, start + count));
accumulator.removeAll(subList);
String concatenatedElements = subList.toString()
.replace(",", "")
.replace("[","")
.replace("]", "");
subList = Collections.singletonList(concatenatedElements);
accumulator.addAll(start, subList);
String[] resultSet = new String[accumulator.size()];
for (int i = 0; i < accumulator.size(); i++) {
resultSet [i] = accumulator.get(i);
}
return resultSet;
}
将产生：
System.out.println(Arrays.toString(concatElements(array, 2, 2)));
并像这样调用它：
[europe, france germany, america]
将产生：
System.out.println(Arrays.toString(concatElements(array, 2, 3)));
原样，参数[europe, france germany america]
和start没有验证，但我将其作为练习留给您。
答案 5 :(得分：1)
可能列表。
public static void main(String[] args) {
String arr []= {"europe", "france", "germany", "america"};
int from =1;
int toAdd =3;
int len = arr.length;
if(from+toAdd>len){
//show error
return ;
}
List<String> list = Arrays.asList(arr);
List<String> concatList = list.subList(from, from+toAdd);
StringBuilder sb = new StringBuilder();
for(String st: concatList){
sb.append(st).append(" ");
}
List<String>outList = new ArrayList<>(list.subList(0, from));
outList.add(sb.toString());
if(from+toAdd<len-1){
outList.addAll(list.subList(from+toAdd, list.size()-1));
}
System.out.println(outList);
}
答案 6 :(得分：0)
要在Strings中连接Android，我们可以使用TextUtils.copyOfRange()类。对于其余部分，我们可以使用System.arraycopy()方法来避免循环：
public static String[] concatenate(String[] input,
int from, // starts from 0 position
int number){
String[] res = new String[input.length - number + 1];
int to = from + number;
System.arraycopy(input, 0, res, 0, from);
String[] sub = Arrays.copyOfRange(input, from, to);
String joined = TextUtils.join(" ", sub);
res[from] = joined;
System.arraycopy(input, to, res, from + 1, input.length - to);
return res;
}
答案 7 :(得分：0)
使用java.util.stream库的另一种选择：
这使用IntStream.range来决定输出List的新大小，并生成表示输出序列中索引的int。
然后.mapToObj用于每个输出索引，以决定在每个相应位置放置什么（输出只有连接字符串的单个索引）。
输出基本上有三种可能性 - 由getOrMergeData方法决定：
data[index] data[index + count - 1] Arrays.copyOfRange和string.Join加入需要合并的字符串。class Main {
public static void main(String[] args) {
String [] data = {"europe", "france", "germany", "america"};
int startIndex = 1;
int count = 2;
int newSize = data.length - count + 1;
List<String> output =
IntStream.range(0, newSize)
.mapToObj(n -> Main.getOrJoin(data, startIndex, count, n))
.collect(Collectors.toList());
for (String s : output) {
System.out.println(s);
}
}
private static String getOrJoin(String[] data, int joinIndex, int count, int index) {
if (index < joinIndex) return data[index];
else if (index > joinIndex) return data[index + count - 1];
else {
String[] dataToJoin = Arrays.copyOfRange(data, joinIndex, joinIndex + count);
return String.join(" ", dataToJoin);
}
}
}
输出：
europe
france germany
america