我有一个像"5006,3030,8080-8083"这样的字符串。
我希望每个元素与String分开：
5006
3030
8080
8081
8082
8083
这是我的代码：
int i=0,j=0;
String delim = "[,]";
String hyphon = "[-]";
String example = "5006,3030,8080-8083";
String p[] = example.split(delim);
int len = p.length;
for(i=0;i<len;i++) {
String ps[]=p[i].split(hyphon);
if(ps.length>1) {
int start = Integer.parseInt(ps[0]);
int finish = Integer.parseInt(ps[1]);
int diff = finish-start+1;
for(j=0;j<diff;j++) {
System.out.println(start+j);
}
} else if(ps.length==1) {
System.out.println(ps[0]);
}
}
有没有更好的解决方案或任何简化我的代码的类？
我也希望这些数字按升序排列。
答案 0 :(得分：4)
试试这段代码：
public static void main(String[] args) {
String input = "5006,3030,8080-8083";
List<Integer> list = new ArrayList<Integer>();
String[] numbers = input.split(",");
for (String s : numbers) {
if (s.contains("-")) {
String[] range = s.split("-");
int from = Integer.parseInt(range[0]);
int to = Integer.parseInt(range[1]);
for (int i = from; i <= to; i++) {
list.add(i);
}
}
else {
list.add(Integer.parseInt(s));
}
}
System.out.println("in asc order");
Collections.sort(list);
System.out.println(list.toString());
System.out.println("in desc order");
Collections.reverse(list);
System.out.println(list.toString());
}
我的输出：
in asc order
[3030, 5006, 8080, 8081, 8082, 8083]
in desc order
[8083, 8082, 8081, 8080, 5006, 3030]
答案 1 :(得分：2)
你很高兴;您可以使用enhanced for loop和while循环来最小化计数器变量。
String example = "5006,3030,8080-8083";
String[] parts=example.split(",")
ArrayList<Integer> numbers = new ArrayList<Integer>();
for(String part: parts)
{
if(part.contains("-"))
{
String subParts[]=part.split("-");
int start = Integer.parseInt(subParts[0]);
int finish = Integer.parseInt(subParts[1]);
while(start <= finish)
{
numbers.add(start);
System.out.println(start++);
}
}
else {
System.out.println(part);
numbers.add(Integer.parseInt(part));
}
}
Integer[] sortedNumbers = new Integer[numbers.size()];
sortedNumbers = Arrays.sort(numbers.toArray(sortedNumbers));
更新（来自评论）：
数字现在排序。
答案 2 :(得分：2)
我也希望这些数字按升序排列。
这会给整个程序带来意想不到的变化，因为一旦你意识到随时随地打印，你就需要从头开始。
首先要做的是选择合适的代表。您似乎表示整数范围，因此首先要为它们定义一个类：
class IntRange : Comparable<IntRange> {
private int low, high;
public int getLow() {return low;}
public int getHigh() {return high;}
public IntRange(int low, int high) {
// Add range check to see if low <= high
this.low = low; this.high = high;
}
public IntRange(int point) {low = high = point;}
@Override
public void print() {
for (int i = low ; i <= high ; i++) {
System.out.println(i);
}
}
@Override
public int compareTo(IntRange other) {
...
}
}
现在，您可以使用代码在[,]上拆分，然后拆分[-]，构建IntRange，并将其放入ArrayList<IntRange>。之后，您可以使用sort()方法对范围进行排序，并按所需顺序打印它们。
但是等等，你的问题远不止眼睛。想想这样的输入会发生什么：
1,5,3-7,6
应该在哪里打印5和6？在3-7之前或之后打印它是不好的，所以诀窍是删除范围内的点。
但即使这不是全部：你对这个输入做了什么？
1-5,3-7
您应该打印数字1到7（包括1和7），但这需要合并两个范围。有效地执行此操作有一个良好的数据结构。它被称为range tree。如果您的输入预计很大，则应考虑使用范围树表示。
答案 3 :(得分：1)
试试这个
String str = "5006,3030,8080-8083";
String[] array = str.split(",");
String ans = "";
for(int i = 0; i < array.length; i++){
if(array[i].contains("-")){
String[] array2 = array[i].split("-");
int start = Integer.parseInt(array2[0]);
int end = Integer.parseInt(array2[array2.length - 1]);
for(int j = start; j <= end; j++){
ans = ans + j + ",";
}
}
else{
ans = ans + array[i] + ",";
}
}
System.out.print(ans);
答案 4 :(得分：1)
此代码假设所有整数均为正数。
task = raw_input("would you like to encrypt or decrypt\r\n:- ").lower()
答案 5 :(得分：0)
使用java 8 stream api：
public static void main(String[] args) {
String s = "5006,3030,8080-8083";
Arrays.stream(s.split(","))
.flatMap(el -> el.contains("-") ? rangeToStream(el) : Stream.of(Integer.valueOf(el)))
.sorted()
.forEachOrdered(e -> System.out.println(e));
}
private static Stream<? extends Integer> rangeToStream(String el) {
AtomicInteger[] bounds = Arrays.stream(el.split("-")).map(e -> new AtomicInteger(Integer.parseInt(e))).toArray(size -> new AtomicInteger[2]);
return Arrays.stream(new Integer[bounds[1].get() - bounds[0].get() + 1]).map(e -> bounds[0].getAndIncrement());
}
答案 6 :(得分：0)
使用Guava's functional idioms，您可以以声明方式实现此，从而避免使用详细的命令式 for循环。首先声明一个标记化函数，它将逗号分隔的字符串中的每个标记转换为Iterable<Integer>：
private static final Function<String, Iterable<Integer>> TOKENIZER =
new Function<String, Iterable<Integer>>() {
/**
* Converts each token (e.g. "5006" or "8060-8083") in the input string
* into an Iterable<Integer>; either a ContiguousSet or a List with a
* single element
*/
@Override
public Iterable<Integer> apply(String token) {
if (token.contains("-")) {
String[] range = token.trim().split("-");
return ContiguousSet.create(
Range.closed(Integer.parseInt(range[0]),
Integer.parseInt(range[1])),
DiscreteDomain.integers());
} else {
return Arrays.asList(Integer.parseInt(token.trim()));
}
}
};
然后将该函数应用于输入：
String input = "5006,3030,8080-8083";
Iterable<String> tokens = Splitter.on(',').trimResults().split(input);
SortedSet<Integer> numbers = Sets.newTreeSet();
Iterables.addAll(numbers,
// concat flattens the Iterable<Iterable<Integer>>
// into an Iterable<Integer>
Iterables.concat(Iterables.transform(tokens, TOKENIZER)));
由于所有逻辑基本上都编码到Function中，客户端代码只需要将字符串标记为Iterable<String>（Splitter），然后应用Function }通过Iterables.transform，使用Iterables.concat展平转换结果，最后将结果Iterable<Integer>添加到SortedSet<Integer>中，以保持数字按升序排列。
答案 7 :(得分：0)
U可以编写类似这样的代码 -
String s="5006,3030,8080-8083";
String s2[]=s.split(",");
List<Integer> li= new ArrayList<Integer>();
List<Integer> numbers= new ArrayList<Integer>();
for(int i=0;i<s2.length;i++){
if(s2[i].contains("-")){
li.add(i);
}
else{
numbers.add(Integer.parseInt(s2[i]));
}
}
for(Integer i:li){
String str=s2[i];
String strArr[]=str.split("-");
for(int j=Integer.parseInt(strArr[0]);j<=Integer.parseInt(strArr[1]);j++){
numbers.add(j);
}
}
Collections.sort(numbers);
for(Integer k:numbers){
System.out.println(k);
}
答案 8 :(得分：-1)
public static void main(String[] args)
{
String example = "5006,3030,8080-8083";
String[] splitString = example.split(",");
List<Integer> soretedNumbers = new ArrayList<>();
for(String str : splitString)
{
String[] split2 = str.split("-");
if(split2.length == 1)
{
soretedNumbers.add(Integer.parseInt(str));
}
else
{
int num1 = Integer.parseInt(split2[0]);
int num2 = Integer.parseInt(split2[1]);
for(int i = num1;i <= num2; i++)
{
soretedNumbers.add(i);
}
}
}
Collections.sort(soretedNumbers);
for(int i : soretedNumbers)
{
System.out.println(i);
}
}