從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中由（,, - ）分隔的給定字符串獲取數據

回答

相關問題