ජාවා හි නූලක් බෙදන්නේ කෙසේද

මට "004-034556"නූල් දෙකක් ඇත, මට නූල් දෙකකට බෙදීමට අවශ්‍යයි:

string1="004";
string2="034556";

ඒ කියන්නේ පළමු නූලට පෙර අක්ෂර අඩංගු වන '-'අතර දෙවන නූලට පසුව අක්ෂර අඩංගු වේ '-'. මට ද අවශ්‍ය වන්නේ එම නූල එහි තිබේද '-'යන්නයි. එසේ නොවේ නම්, මම ව්යතිරේකයක් විසි කරමි. මට මෙය කළ හැක්කේ කෙසේද?

සුදුසු ක්‍රමය භාවිතා කරන්න : String#split().

String string = "004-034556";
String[] parts = string.split("-");
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556

මෙය නිත්‍ය ප්‍රකාශනයක් අවශ්‍ය බව සලකන්න , එබැවින් අවශ්‍ය නම් විශේෂ අක්ෂර වලින් ගැලවීමට මතක තබා ගන්න .

එහි ඇති ඇල ඉර: විශේෂ අර්ථ සමග අක්ෂර 12 ක් \, බැධී ^ඩොලරය ලකුණක් $, මෙම කාල හෝ තිතක් ., සිරස් තීරුව හෝ නල සංකේතය |, ප්රශ්නය ලකුණ ?එම තරු ලකුණ හෝ තරු *, ධන ලකුණ +, විවෘත වරහන (, භාරගන්නා අවසන් වරහන ), සහ ආරම්භක හතරැස් වරහන [, ආරම්භක වක්‍ර වරහන {, මෙම විශේෂ අක්ෂර බොහෝ විට "මෙටාචරැක්ටර්ස්" ලෙස හැඳින්වේ.

ඒ නිසා, ඔබ උදා කාලය / තිතක් මත බෙදී කිරීමට අවශ්ය නම් ."යන අරුත ඇති ' ඕනෑම චරිතයක් regex දී", භාවිත කිරීම හෝ පසු ඇල ඉර\ එසේ වැනි තනි විශේෂ චරිතයක් පැන split("\\."), හෝ භාවිතා චරිතය පන්ති[] එසේ වගේ ප්රායෝගික චරිතය (ව) නියෝජනය කිරීමට split("[.]"), හෝ භාවිතා Pattern#quote()කිරීමට මුළු නූලෙන් එලෙසම පැන යන්න split(Pattern.quote(".")).

String[] parts = string.split(Pattern.quote(".")); // Split on period.

නූලෙහි යම් අක්ෂර (ය) අඩංගු දැයි කල්තියා පරීක්ෂා කිරීම සඳහා භාවිතා කරන්න String#contains().

if (string.contains("-")) {
    // Split it.
} else {
    throw new IllegalArgumentException("String " + string + " does not contain -");
}

සටහන, මෙය සාමාන්‍ය ප්‍රකාශනයක් නොගනී. ඒ සඳහා භාවිතා String#matches()කරන්න.

එහි ප්‍රති parts ලයක් වශයෙන් ඇති කොටස්වල බෙදීම් ස්වභාවය රඳවා ගැනීමට ඔබ කැමති නම්, ධනාත්මක පෙනුමක් භාවිතා කරන්න . ඔබට බෙදීම් චරිතය වම් අතෙහි කෙළවර වීමට අවශ්‍ය නම් ?<=, රටාව මත කණ්ඩායම් උපසර්ගයක් මඟින් ධනාත්මක බැල්මක් භාවිතා කරන්න .

String string = "004-034556";
String[] parts = string.split("(?<=-)");
String part1 = parts[0]; // 004-
String part2 = parts[1]; // 034556

බෙදීම් චරිතය දකුණු පැත්තේ කෙළවර වීමට ඔබට අවශ්‍ය නම් ?=, රටාව මත සමූහය උපසර්ග කිරීමෙන් ධනාත්මක පෙනුම භාවිතා කරන්න .

String string = "004-034556";
String[] parts = string.split("(?=-)");
String part1 = parts[0]; // 004
String part2 = parts[1]; // -034556

එහි ප්‍රති ing ලයක් ලෙස ලැබෙන කොටස් ගණන සීමා කිරීමට ඔබ කැමති නම්, ඔබට split()ක්‍රමයේ 2 වන තර්කය ලෙස අපේක්ෂිත අංකය සැපයිය හැකිය .

String string = "004-034556-42";
String[] parts = string.split("-", 2);
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556-42

නූල කෙලින්ම සැකසීමට විකල්පයක් වනුයේ අල්ලා ගැනීමේ කණ්ඩායම් සමඟ නිත්‍ය ප්‍රකාශනයක් භාවිතා කිරීමයි. ආදානයට වඩා නවීන අවහිරතා ඇඟවීමට එය සරල කරවන වාසිය මෙයයි. නිදසුනක් ලෙස, පහත දැක්වෙන්නේ නූල කොටස් දෙකකට බෙදෙන අතර දෙකම ඉලක්කම් වලින් පමණක් සමන්විත වන බව සහතික කරයි:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

class SplitExample
{
    private static Pattern twopart = Pattern.compile("(\\d+)-(\\d+)");

    public static void checkString(String s)
    {
        Matcher m = twopart.matcher(s);
        if (m.matches()) {
            System.out.println(s + " matches; first part is " + m.group(1) +
                               ", second part is " + m.group(2) + ".");
        } else {
            System.out.println(s + " does not match.");
        }
    }

    public static void main(String[] args) {
        checkString("123-4567");
        checkString("foo-bar");
        checkString("123-");
        checkString("-4567");
        checkString("123-4567-890");
    }
}

මෙම අවස්ථාවෙහිදී රටාව සවි කර ඇති බැවින්, එය කල්තියා සම්පාදනය කර ස්ථිතික සාමාජිකයෙකු ලෙස ගබඩා කළ හැකිය (උදාහරණයේ පන්ති පැටවීමේ වේලාවේදී ආරම්භ කරන ලදි). නිත්‍ය ප්‍රකාශනය:

(\d+)-(\d+)

වරහන් මඟින් අල්ලා ගන්නා කණ්ඩායම් දක්වයි; Regexp හි එම කොටස හා ගැලපෙන නූල පෙන්වා ඇති පරිදි Match.group () ක්‍රමයට ප්‍රවේශ විය හැකිය. Matching d ගැලපීම් සහ තනි දශම සංඛ්‍යා, සහ + යන්නෙහි අර්ථය “පෙර ප්‍රකාශනයේ එකක් හෝ වැඩි ගණනක් ගැලපීම). - විශේෂ අර්ථයක් නැත, එබැවින් ආදානයේ එම අක්‍ෂරයට ගැලපේ. ඔබට බැක්ස්ලෑෂ් දෙවරක් ගැලවී යා යුතු බව සලකන්න. මෙය ජාවා නූලක් ලෙස ලිවීමේදී තවත් උදාහරණ කිහිපයක්:

([A-Z]+)-([A-Z]+)          // Each part consists of only capital letters 
([^-]+)-([^-]+)            // Each part consists of characters other than -
([A-Z]{2})-(\d+)           // The first part is exactly two capital letters,
                           // the second consists of digits

String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

මෙය ඔබේ නූල කොටස් 2 කට බෙදා ඇත. අරාවෙහි පළමු අංගය වනුයේ ඊට පෙර ඇති දෑ -අඩංගු වන අතර අරාවෙහි 2 වන මූලද්‍රව්‍යය ඔබේ නූලෙන් පසුව අඩංගු වේ -.

අරාවෙහි දිග 2 නොවේ නම්, එම නූල ආකෘතියේ නොතිබුණි : string-string.

පන්තියේ split()ක්‍රමය බලන්න String.

https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#split-java.lang.String-int-

String[] out = string.split("-");

ඔබට අවශ්‍ය දේ කළ යුතුයි. සංගීත පන්තියට නූල් සමඟ ක්‍රියා කිරීමට බොහෝ ක්‍රම තිබේ.

// This leaves the regexes issue out of question
// But we must remember that each character in the Delimiter String is treated
// like a single delimiter        

public static String[] SplitUsingTokenizer(String subject, String delimiters) {
   StringTokenizer strTkn = new StringTokenizer(subject, delimiters);
   ArrayList<String> arrLis = new ArrayList<String>(subject.length());

   while(strTkn.hasMoreTokens())
      arrLis.add(strTkn.nextToken());

   return arrLis.toArray(new String[0]);
}

ජාවා 8 සමඟ:

    List<String> stringList = Pattern.compile("-")
            .splitAsStream("004-034556")
            .collect(Collectors.toList());

    stringList.forEach(s -> System.out.println(s));

අවශ්‍යතා අර්ථ නිරූපණය සඳහා ඉඩ ඉතිරි කර ඇත. ක්‍රමයක් ලිවීමට මම නිර්දේශ කරමි,

public final static String[] mySplit(final String s)

මෙම ශ්‍රිතය සංයුක්ත කරයි. ඇත්ත වශයෙන්ම ඔබට ක්‍රියාත්මක කිරීම සඳහා අනෙක් පිළිතුරු වල සඳහන් පරිදි String.split (..) භාවිතා කළ හැකිය.

ආදාන නූල් සහ අපේක්ෂිත ප්‍රති results ල සහ හැසිරීම සඳහා ඔබ ඒකක පරීක්ෂණ කිහිපයක් ලිවිය යුතුය.

හොඳ පරීක්ෂණ අපේක්ෂකයින්ට ඇතුළත් විය යුත්තේ:

 - "0022-3333"
 - "-"
 - "5555-"
 - "-333"
 - "3344-"
 - "--"
 - ""
 - "553535"
 - "333-333-33"
 - "222--222"
 - "222--"
 - "--4555"

ඒ අනුව පරීක්ෂණ ප්‍රති results ල නිර්වචනය කිරීමෙන් ඔබට හැසිරීම නියම කළ හැකිය.

උදාහරණයක් ලෙස, "-333"නැවත පැමිණිය යුතු නම් [,333]හෝ එය දෝෂයක් නම්. "333-333-33"වෙන් කළ හැකිද? [333,333-33] or [333-333,33]නැත්නම් එය දෝෂයක්ද? සහ යනාදි.

ඔබටත් මේ ආකාරයට උත්සාහ කළ හැකිය

 String concatenated_String="hi^Hello";

 String split_string_array[]=concatenated_String.split("\\^");

උපකල්පනය, එය

• ඔබේ භේදය සඳහා ඔබට සාමාන්‍ය ප්‍රකාශන අවශ්‍ය නොවේ
• ඔබ දැනටමත් ඔබගේ යෙදුමේ අපාචේ කොමන්ස් ලැන්ග් භාවිතා කරයි

පහසුම ක්‍රමය නම් StringUtils # split (java.lang.String, char) භාවිතා කිරීමයි. ඔබට සාමාන්‍ය ප්‍රකාශන අවශ්‍ය නොවන්නේ නම් එය ජාවා විසින් සපයන ලද ඒවාට වඩා පහසුය. එහි අත්පොත පවසන පරිදි, එය මේ ආකාරයට ක්‍රියා කරයි:

A null input String returns null.

 StringUtils.split(null, *)         = null
 StringUtils.split("", *)           = []
 StringUtils.split("a.b.c", '.')    = ["a", "b", "c"]
 StringUtils.split("a..b.c", '.')   = ["a", "b", "c"]
 StringUtils.split("a:b:c", '.')    = ["a:b:c"]
 StringUtils.split("a b c", ' ')    = ["a", "b", "c"]

සාමාන්‍යයෙන් එහි භාවිතා කළ හැකි බොහෝ දේ අඩංගු බැවින් මම කොමොන්ග්-ලැන්ග් භාවිතා කිරීමට නිර්දේශ කරමි. කෙසේ වෙතත්, භේදයක් කිරීම හැර වෙන කිසිවක් සඳහා ඔබට එය අවශ්‍ය නොවන්නේ නම්, ඔබම ක්‍රියාත්මක කිරීම හෝ රීජෙක්ස් වලින් ගැලවීම වඩා හොඳ විකල්පයකි.

ඔබට බෙදීමට අවශ්‍ය චරිතය හෝ නූල් මත පදනම්ව නූල් බෙදිය හැකි org.apache.commons.lang.StringUtils හි බෙදීම් ක්‍රමය භාවිතා කරන්න .

ක්‍රම අත්සන:

public static String[] split(String str, char separatorChar);

ඔබේ නඩුවේදී, ඔබට "-" ඇති විට නූලක් බෙදීමට අවශ්‍යය.

ඔබට සරලව පහත පරිදි කළ හැකිය:

String str = "004-034556";

String split[] = StringUtils.split(str,"-");

ප්‍රතිදානය:

004
034556

ඔබේ නූලෙහි -නොපවතී නම් , එය ලබා දී ඇති නූල නැවත ලබා දෙයි, එවිට ඔබට කිසිදු ව්‍යතිරේකයක් නොලැබේ.

සාරාංශගත කිරීම සඳහා: ජාවා හි නූලක් බෙදීමට අවම වශයෙන් ක්‍රම පහක්වත් තිබේ:

1. String.split ():

   String[] parts ="10,20".split(",");

2. Pattern.compile (regexp) .splitAsStream (ආදානය):

   List<String> strings = Pattern.compile("\\|")
         .splitAsStream("010|020202")
         .collect(Collectors.toList());

3. StringTokenizer (උරුමය පන්තිය):

   StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", ".");
   while(strings.hasMoreTokens()){
       String substring = strings.nextToken();
       System.out.println(substring);
   }

4. ගූගල් ගුවා ස්ප්ලිටරය:

   Iterable<String> result = Splitter.on(",").split("1,2,3,4");

5. Apache Commons StringUtils:

   String[] strings = StringUtils.split("1,2,3,4", ",");

එබැවින් ඔබට අවශ්‍ය දේ අනුව ඔබට හොඳම විකල්පය තෝරා ගත හැකිය, උදා: ආපසු එන වර්ගය (අරාව, ලැයිස්තුව, හෝ නැවත යෙදිය හැකි).

මෙන්න මෙම ක්‍රම පිළිබඳ විශාල දළ විශ්ලේෂණයක් සහ වඩාත් පොදු උදාහරණ (තිත, කප්පාදුව, ප්‍රශ්නාර්ථ ලකුණ ආදියෙන් බෙදන්නේ කෙසේද)

අවම සම්පත පරිභෝජනය කරන වේගවත්ම ක්‍රමය මෙය විය හැකිය:

String s = "abc-def";
int p = s.indexOf('-');
if (p >= 0) {
    String left = s.substring(0, p);
    String right = s.substring(p + 1);
} else {
  // s does not contain '-'
}

Regex භාවිතා කරමින් බහු අක්ෂර සහිත නූල් බෙදීම

public class StringSplitTest {
     public static void main(String args[]) {
        String s = " ;String; String; String; String, String; String;;String;String; String; String; ;String;String;String;String";
        //String[] strs = s.split("[,\\s\\;]");
        String[] strs = s.split("[,\\;]");
        System.out.println("Substrings length:"+strs.length);
        for (int i=0; i < strs.length; i++) {
            System.out.println("Str["+i+"]:"+strs[i]);
        }
     }
  }

ප්‍රතිදානය:

Substrings length:17
Str[0]:
Str[1]:String
Str[2]: String
Str[3]: String
Str[4]: String
Str[5]: String
Str[6]: String
Str[7]:
Str[8]:String
Str[9]:String
Str[10]: String
Str[11]: String
Str[12]:
Str[13]:String
Str[14]:String
Str[15]:String
Str[16]:String

නමුත් සියලු JDK අනුවාද හරහා එකම ප්‍රතිදානය බලාපොරොත්තු නොවන්න. පළමු ශුන්‍ය නූල් නොසලකා හරින ලද සමහර ජේඩීකේ අනුවාදවල එක් දෝෂයක් මා දැක ඇත. මෙම දෝෂය නවතම JDK අනුවාදයේ නොමැත, නමුත් එය JDK 1.7 ප්‍රමාද අනුවාද සහ 1.8 මුල් සංස්කරණ අතර සමහර අනුවාද වල පවතී.

සරල භාවිත අවස්ථා සඳහා String.split()එම කාර්යය කළ යුතුය. ඔබ ගුආවා භාවිතා කරන්නේ නම්, ස්ප්ලිටර් පංතියක් ද ඇත, එමඟින් විවිධ නූල් මෙහෙයුම් දම්වැල් දැමීමට ඉඩ දෙන අතර චාර්මැචර්ට සහය දක්වයි :

Splitter.on('-')
       .trimResults()
       .omitEmptyStrings()
       .split(string);

public class SplitTest {

    public static String[] split(String text, String delimiter) {
        java.util.List<String> parts = new java.util.ArrayList<String>();

        text += delimiter;

        for (int i = text.indexOf(delimiter), j=0; i != -1;) {
            String temp = text.substring(j,i);
            if(temp.trim().length() != 0) {
                parts.add(temp);
            }
            j = i + delimiter.length();
            i = text.indexOf(delimiter,j);
        }

        return parts.toArray(new String[0]);
    }


    public static void main(String[] args) {
        String str = "004-034556";
        String delimiter = "-";
        String result[] = split(str, delimiter);
        for(String s:result)
            System.out.println(s);
    }
}

පහත දැක්වෙන ප්‍රකාශය භාවිතා කිරීමෙන් ඔබට පේළියකින් රේඛාවක් බෙදිය හැකිය:

String textStr[] = yourString.split("\\r?\\n");

පහත දැක්වෙන ප්‍රකාශය භාවිතා කිරීමෙන් ඔබට යටි ඉරක් / අක්ෂරයකින් බෙදිය හැකිය:

String textStr[] = yourString.split("-");

import java.io.*;

public class BreakString {

  public static void main(String args[]) {

    String string = "004-034556-1234-2341";
    String[] parts = string.split("-");

    for(int i=0;i<parts.length;i++) ｛
      System.out.println(parts[i]);
    }
  }
}

ඔබට Split () භාවිතා කළ හැකිය:

import java.io.*;

public class Splitting
{

    public static void main(String args[])
    {
        String Str = new String("004-034556");
        String[] SplittoArray = Str.split("-");
        String string1 = SplittoArray[0];
        String string2 = SplittoArray[1];
    }
}

වෙනත්, ඔබට StringTokenizer භාවිතා කළ හැකිය:

import java.util.*;
public class Splitting
{
    public static void main(String[] args)
    {
        StringTokenizer Str = new StringTokenizer("004-034556");
        String string1 = Str.nextToken("-");
        String string2 = Str.nextToken("-");
    }
}

ඔබ සැබවින්ම සලකා බැලිය යුතු ක්‍රම දෙකක් තිබේ.

එක් අක්ෂර පරිසීමකයක් සඳහා String.split භාවිතා කරන්න හෝ ඔබ කාර්ය සාධනය ගැන තැකීමක් නොකරයි

කාර්ය සාධනය ගැටළුවක් නොවේ නම්, හෝ පරිසීමකය යනු සාමාන්‍ය ප්‍රකාශන විශේෂ අක්ෂරයක් නොවන තනි අක්ෂරයක් නම් (එනම්, එකක් නොවේ .$|()[{^?*+\) එවිට ඔබට භාවිතා කළ හැකිය String.split.

String[] results = input.split(",");

ඉහත ලැයිස්තුවේ නොව පරිමිතිය තනි අක්ෂරයක් නම් නිත්‍ය ප්‍රකාශනයක් භාවිතා කිරීමෙන් වළක්වා ගැනීමට බෙදීම් ක්‍රමයට ප්‍රශස්තිකරණයක් ඇත. එසේ නොමැති නම්, එය නිත්‍ය ප්‍රකාශනයක් සම්පාදනය කළ යුතු අතර මෙය පරිපූර්ණ නොවේ.

සංකීර්ණ පරිසීමකයක් භාවිතා කරන්නේ නම් Pattern.split භාවිතා කර රටාව සකස් කරන්න.

කාර්ය සාධනය ගැටළුවක් නම් සහ ඔබේ පරිසීමකය ඉහත එකක් නොවේ නම්, ඔබට නැවත භාවිතා කළ හැකි නිත්‍ය ප්‍රකාශන රටාවක් පූර්ව සම්පාදනය කළ යුතුය.

// Save this somewhere
Pattern pattern = Pattern.compile("[,;:]");

/// ... later
String[] results = pattern.split(input);

මෙම අවසාන විකල්පය තවමත් නව Matcherවස්තුවක් නිර්මාණය කරයි . ඔබට මෙම වස්තුව හැඹිලිගත කර උපරිම ක්‍රියාකාරීත්වය සඳහා එක් එක් ආදානය සඳහා එය නැවත සැකසිය හැක, නමුත් එය තරමක් සංකීර්ණ වන අතර නූල් ආරක්ෂිත නොවේ.

මෙය කළ හැකි එක් ක්‍රමයක් නම්, එක් එක් ලූපය සඳහා නූල් හරහා ධාවනය කර අවශ්‍ය බෙදීම් අක්‍ෂරය භාවිතා කිරීමයි.

public class StringSplitTest {

    public static void main(String[] arg){
        String str = "004-034556";
        String split[] = str.split("-");
        System.out.println("The split parts of the String are");
        for(String s:split)
        System.out.println(s);
    }
}

ප්‍රතිදානය:

The split parts of the String are:
004
034556

කරුණාකර StringTokenizer පන්තිය භාවිතා නොකරන්න , එය අනුකූලතා හේතූන් මත රඳවාගෙන ඇති පැරණි පන්තියක් වන අතර එහි භාවිතය නව කේතයකින් අධෛර්යමත් වේ. අනෙක් අය යෝජනා කළ පරිදි අපට බෙදීම් ක්‍රමය භාවිතා කළ හැකිය.

String[] sampleTokens = "004-034556".split("-");
System.out.println(Arrays.toString(sampleTokens));

අපේක්ෂා කළ පරිදි එය මුද්‍රණය වේ:

[004, 034556]

මෙම පිළිතුරේ දී ජාවා 8 හි ක්‍රමවේදය සඳහා සිදුවීsplit ඇති එක් වෙනසක් ද පෙන්වා දීමට කැමැත්තෙමි . මෙම සංගීත # භේදය () ක්රමය භාවිතා කරයි Pattern.split, සහ දැන් එය ප්රතිඵලයක් අරා ආරම්භයේ දී හිස් නූල් ඉවත් කරනු ඇත. ජාවා 8 සඳහා වන ලේඛනවල මෙම වෙනස සැලකිල්ලට ගන්න :

ආදාන අනුක්‍රමය ආරම්භයේ දී ධනාත්මක-පළල ගැලපීමක් ඇති විට, එහි ප්‍රති ing ලයක් ලෙස ඇති අරාව ආරම්භයේ දී හිස් ප්‍රමුඛ උපස්ථරයක් ඇතුළත් වේ. ආරම්භයේ දී ශුන්‍ය පළල ගැලපීමක් කෙසේ වෙතත් එවැනි හිස් ප්‍රමුඛ උපස්ථරයක් නිපදවන්නේ නැත.

එය පහත උදාහරණය සඳහා අදහස් කරයි:

String[] sampleTokensAgain = "004".split("");
System.out.println(Arrays.toString(sampleTokensAgain));

අපට නූල් තුනක් ලැබෙනු ඇත: [0, 0, 4]ජාවා 7 සහ ඊට පෙර මෙන් හතරක් නොවේ. මේ හා සමාන ප්‍රශ්නයක්ද පරීක්ෂා කරන්න .

දෙදෙනෙකු එය සාක්ෂාත් කරගත හැකි ආකාර දෙකක් මෙන්න.

මාර්ගය 1: ඔබට විශේෂ අක්ෂරයකින් අංක දෙකක් බෙදිය යුතු බැවින් ඔබට රීජෙක්ස් භාවිතා කළ හැකිය

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TrialClass
{
    public static void main(String[] args)
    {
        Pattern p = Pattern.compile("[0-9]+");
        Matcher m = p.matcher("004-034556");

        while(m.find())
        {
            System.out.println(m.group());
        }
    }
}

මාර්ගය 2: නූල් බෙදීමේ ක්‍රමය භාවිතා කිරීම

public class TrialClass
{
    public static void main(String[] args)
    {
        String temp = "004-034556";
        String [] arrString = temp.split("-");
        for(String splitString:arrString)
        {
            System.out.println(splitString);
        }
    }
}

කිසියම් ආකාරයක පරිසීමක තිබේද යන්න ඔබට කොටස් දෙකකට හෝ වැඩි ගණනකට බෙදීමට StringTokenizer භාවිතා කළ හැකිය:

StringTokenizer st = new StringTokenizer("004-034556", "-");
while(st.hasMoreTokens())
{
    System.out.println(st.nextToken());
}

Javadoc පිළිබඳ පන්තියේ split()ක්‍රමය බලන්න String.

https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#split(java.lang.String)

String data = "004-034556-1212-232-232";
int cnt = 1;
for (String item : data.split("-")) {
        System.out.println("string "+cnt+" = "+item);
        cnt++;
}

බෙදීම් නූල් සඳහා මෙහි බොහෝ උදාහරණ නමුත් මම කුඩා කේත ප්‍රශස්තිකරණය කර ඇත.

String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

string1=004 // sTemp[0];
string2=034556//sTemp[1];

මට අවශ්‍ය වූයේ ජාවා සාදන ලද කාර්යයන් භාවිතා කිරීම වෙනුවට ඇල්ගොරිතමයක් ලිවීමට ය:

public static List<String> split(String str, char c){
    List<String> list = new ArrayList<>();
    StringBuilder sb = new StringBuilder();

    for (int i = 0; i < str.length(); i++){
        if(str.charAt(i) != c){
            sb.append(str.charAt(i));
        }
        else{
            if(sb.length() > 0){
                list.add(sb.toString());
                sb = new StringBuilder();
            }
        }
    }

    if(sb.length() >0){
        list.add(sb.toString());
    }
    return list;
}

ඔබට ක්රමය භාවිතා කළ හැකිය split:

public class Demo {
    public static void main(String args[]) {
        String str = "004-034556";

        if ((str.contains("-"))) {
            String[] temp = str.split("-");
            for (String part:temp) {
                System.out.println(part);
            }
        }
        else {
            System.out.println(str + " does not contain \"-\".");
        }
    }
}

නූලක් බෙදීමට String.split (regex) භාවිතා කරයි. පහත උදාහරණ සමාලෝචනය කරන්න:

String data = "004-034556";
String[] output = data.split("-");
System.out.println(output[0]);
System.out.println(output[1]);

ප්‍රතිදානය

004
034556

සටහන:

මෙම භේදය (රීජෙක්ස්) රීජෙක්ස් තර්කයක් ලෙස ගනී. කාල පරිච්ඡේදය / තිත වැනි රීජෙක්ස් විශේෂ අක්ෂර වලින් ගැලවීමට මතක තබා ගන්න.

String s="004-034556";
for(int i=0;i<s.length();i++)
{
    if(s.charAt(i)=='-')
    {
        System.out.println(s.substring(0,i));
        System.out.println(s.substring(i+1));
    }
}

සෑම කෙනෙකුම සඳහන් කළ පරිදි, භේදය () යනු ඔබේ නඩුවේ භාවිතා කළ හැකි හොඳම විකල්පයයි. විකල්ප ක්‍රමයක් උපස්ථර () භාවිතා කළ හැකිය.

නූලක් බෙදීමට, භාවිතා කරන්න String.split(regex):

String phone = "004-034556";
String[] output = phone.split("-");
System.out.println(output[0]);
System.out.println(output[1]);

ප්‍රතිදානය:

004
034556