Getting data from a given string, separated by (, -) in java

Question

I have a line like this "5006,3030,8080-8083".

I want each element separately from String:

5006
3030
8080
8081
8082
8083

Here is my code:

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

Is there a better solution or any class that simplifies my code?

I also need numbers in ascending order.

Answer 1

Try this code:

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

}

My conclusion:

in asc order
[3030, 5006, 8080, 8081, 8082, 8083]
in desc order
[8083, 8082, 8081, 8080, 5006, 3030]

Answer 2

You will go well; You can minimize counter variables by using the extended loop and while loop.

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

---

Refresh (from comment):
Now the numbers are sorted.

Answer 3

.

, , , , .

, , . , , :

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 , . . . , , .

Answer 4

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

Answer 5

, .

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

Answer 6

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

Answer 7

Guava, , , -. , - 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>, .

Answer 8

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

Answer 9

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