Итак, скажем, у меня есть строка с именем x, которая = «Hello world». Я хочу как-то сделать так, чтобы эти два слова переворачивались и вместо этого отображалось «world Hello». Я не очень хорошо разбираюсь в циклах или массивах и, очевидно, новичок. Могу ли я как-то добиться этого, разделив мою строку? Если да, то как? Если нет, то как я мог это сделать? Помощь приветствуется, спасибо!
Как перевернуть два слова в строке, Java
Ответы (7)
1) разбить строку на массив String
в пространстве.
String myArray[] = x.split(" ");
2) Создать новую строку со словами в обратном порядке от массива.
String newString = myArray[1] + " " + myArray[0];
Бонусные баллы за использование StringBuilder
вместо конкатенации.
StringBuilder
, полезно знать об этом и о подводных камнях использования конкатенации строк в java. Учитывая очевидный начальный уровень ОП, было бы неплохо, если бы он научился раньше, прежде чем он укусит его;)
- person Brian Roach; 11.01.2012
StringBuilder
вместо +
.
- person Stephen C; 11.01.2012
System.out.println(reverseWords("Owlstead is 01 very \"strange bïrd\"!"));
чтобы получить !"bïrd strange" very 01 is owlsteaD
- person Maarten Bodewes; 11.01.2012
String abc = "Hello world";
String cba = abc.replace( "Hello world", "world Hello" );
abc = "This is a longer string. Hello world. My String";
cba = abc.replace( "Hello world", "world Hello" );
Если хотите, вы также можете взорвать свою строку:
String[] pieces = abc.split(" ");
for( int i=0; i<pieces.length-1; ++i )
if( pieces[i]=="Hello" && pieces[i+1]=="world" ) swap(pieces[i], pieces[i+1]);
Есть много других способов сделать это. Будьте осторожны с заглавными буквами. Вы можете использовать .toUpperCase() в своих операторах if, а затем сделать соответствующие условные операторы прописными, но оставить результаты с их исходной заглавной буквой и т. д.
Вот решение:
import java.util.*;
public class ReverseWords {
public String reverseWords(String phrase) {
List<String> wordList = Arrays.asList(phrase.split("[ ]"));
Collections.reverse(wordList);
StringBuilder sbReverseString = new StringBuilder();
for(String word: wordList) {
sbReverseString.append(word + " ");
}
return sbReverseString.substring(0, sbReverseString.length() - 1);
}
}
Приведенное выше решение было написано мной для Google Code Jam, а также опубликовано здесь: Обратные слова — GCJ 2010
Просто используйте этот метод, вызовите его и передайте строку, которую вы хотите разделить
static String reverseWords(String str) {
// Specifying the pattern to be searched
Pattern pattern = Pattern.compile("\\s");
// splitting String str with a pattern
// (i.e )splitting the string whenever their
// is whitespace and store in temp array.
String[] temp = pattern.split(str);
String result = "";
// Iterate over the temp array and store
// the string in reverse order.
for (int i = 0; i < temp.length; i++) {
if (i == temp.length - 1) {
result = temp[i] + result;
} else {
result = " " + temp[i] + result;
}
}
return result;
}
В зависимости от ваших точных требований вы можете разделить другие формы пробелов (табуляции, несколько пробелов и т. д.):
static Pattern p = Pattern.compile("(\\S+)(\\s+)(\\S+)");
public String flipWords(String in)
{
Matcher m = p.matcher(in);
if (m.matches()) {
// reverse the groups we found
return m.group(3) + m.group(2) + m.group(1);
} else {
return in;
}
}
Если вы хотите получить более сложную информацию, см. документацию по шаблону http://docs.oracle.com/javase/6/docs/api/java/util/regex/Pattern.html
Попробуйте следующее:
String input = "how is this";
List<String> words = Arrays.asList(input.split(" "));
Collections.reverse(words);
String result = "";
for(String word : words) {
if(!result.isEmpty()) {
result += " ";
}
result += word;
}
System.out.println(result);
Вывод:
this is how
Слишком много?
private static final Pattern WORD = Pattern.compile("^(\\p{L}+)");
private static final Pattern NUMBER = Pattern.compile("^(\\p{N}+)");
private static final Pattern SPACE = Pattern.compile("^(\\p{Z}+)");
public static String reverseWords(final String text) {
final StringBuilder sb = new StringBuilder(text.length());
final Matcher wordMatcher = WORD.matcher(text);
final Matcher numberMatcher = NUMBER.matcher(text);
final Matcher spaceMatcher = SPACE.matcher(text);
int offset = 0;
while (offset < text.length()) {
wordMatcher.region(offset, text.length());
numberMatcher.region(offset, text.length());
spaceMatcher.region(offset, text.length());
if (wordMatcher.find()) {
final String word = wordMatcher.group();
sb.insert(0, reverseCamelCase(word));
offset = wordMatcher.end();
} else if (numberMatcher.find()) {
sb.insert(0, numberMatcher.group());
offset = numberMatcher.end();
} else if (spaceMatcher.find()) {
sb.insert(0, spaceMatcher.group(0));
offset = spaceMatcher.end();
} else {
sb.insert(0, text.charAt(offset++));
}
}
return sb.toString();
}
private static final Pattern CASE_REVERSAL = Pattern
.compile("(\\p{Lu})(\\p{Ll}*)(\\p{Ll})$");
private static String reverseCamelCase(final String word) {
final StringBuilder sb = new StringBuilder(word.length());
final Matcher caseReversalMatcher = CASE_REVERSAL.matcher(word);
int wordEndOffset = word.length();
while (wordEndOffset > 0 && caseReversalMatcher.find()) {
sb.insert(0, caseReversalMatcher.group(3).toUpperCase());
sb.insert(0, caseReversalMatcher.group(2));
sb.insert(0, caseReversalMatcher.group(1).toLowerCase());
wordEndOffset = caseReversalMatcher.start();
caseReversalMatcher.region(0, wordEndOffset);
}
sb.insert(0, word.substring(0, wordEndOffset));
return sb.toString();
}