从java中由（,, - ）分隔的给定字符串获取数据

我有一个像这样的字符串"5006,3030,8080-8083"。从java中由（,, - ）分隔的给定字符串获取数据

我要分开每个元素从字符串：

这里是我的代码：

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]); 
    } 
}

有没有更好的解决方案或简化我的代码的任何类？

我也希望数字按升序排列。

来源

2015-10-13 Labeo

1.拆分它2.添加这些数字来排序集合。 – Satya

看起来没问题。为了改进你的代码：1.定义i，j in为循环'（for int i = 0 ..）'。 2.对于内部迭代使用'for（int j = start; j <= finish; j ++）...' – Natalia

他已经在使用它了。我不认为代码可以做得更好。 – Tunaki

试试这个代码：

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]

来源

2015-10-13 12:15:05

-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); 
     } 
    }

来源

2015-10-13 12:07:14 Jure

......这是*不是他想要的输出。没有明确说明，但从示例（期望）输出清楚地表示连字符意味着范围。 –

我看到它知道他想要什么。你是对的。 – Jure

修复了代码，以便现在发出正确的输出。 – Jure

你是好去;您可以使用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));

更新（从评论）：
号现在进行排序。

来源

2015-10-13 12:17:40 dsharew

您没有订购号码。 – Jure

@Jure确定我会修改我的答案，但是他所需的输出没有排序 – dsharew

我也希望数字按升序排列。

这给您的整个程序增添了一个意想不到的麻烦，因为一旦您意识到即印即用不再适用，您需要从头开始。

首先要做的是挑选合适的表示。看来，你所代表的整数的范围，所以通过定义这些类开始：

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，包括打印数量，但这需要合并两个范围。有效地完成这项工作有一个很好的数据结构。它被称为range tree。如果您的输入预计很大，您应该考虑使用范围树表示法。

来源

2015-10-13 12:21:19 dasblinkenlight

祝贺您真正阅读问题并发现OP要求他们按顺序排列！ –

@ chiastic-security :) :) :)如果不是那么麻烦，整个问题将成为迁移到codereview.stackexchange.com的绝佳选择。 – dasblinkenlight

试试这个

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);

来源

2015-10-13 12:26:23

此代码假定所有整数都是正的。

public static void main(String[] args) { 
    String testValue="5006,3030,8080-8083"; 

    Integer[]result=parseElements(testValue); 

    for (Integer i:result){ 
     System.out.println(i); 
    } 
} 

/** 
* NumberList is a string of comma-separated elements that are either integers, or a range of integers of the form a-b. 
* @param numberList 
* @return all the integers in the list, and in ranges in the list, in a sorted list 
*/ 
private static Integer[] parseElements(String integerList) { 
    ArrayList<Integer> integers=new ArrayList<Integer>(); 
    String[] csvs=integerList.split(","); 
    for(String csv : csvs){ 
     if(csv.contains("-")){ 
      String[] range=csv.split("-"); 
      Integer left=Integer.decode(range[0]); 
      Integer right=Integer.decode(range[1]); 
      for(Integer i=left;i<=right;i++){ 
       integers.add(i); 
      } 
     } else { 
      integers.add(Integer.decode(csv)); 
     } 
    } 
    Collections.sort(integers); 
    return integers.toArray(new Integer[0]); 
}

来源

2015-10-13 12:52:20

与Java 8个流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()); 
}

来源

2015-10-13 14:54:26 Thierry

使用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>，它将数字以升序排列。

来源

2015-10-13 15:20:24

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); 
    }

来源

2015-10-14 09:38:50

从java中由（,, - ）分隔的给定字符串获取数据

回答

相关问题