මට නූල් මත ස්විච් ප්‍රකාශය භාවිතා කළ නොහැක්කේ ඇයි?


1004

මෙම ක්‍රියාකාරිත්වය පසුකාලීන ජාවා අනුවාදයකට ඇතුළත් කිරීමට යන්නේද?

ජාවාගේ switchප්‍රකාශය ක්‍රියාත්මක වන තාක්‍ෂණික ක්‍රමයේදී මෙන් මට මෙය කළ නොහැක්කේ මන්දැයි යමෙකුට පැහැදිලි කළ හැකිද ?


195
එය SE 7 හි ඇත. එය ඉල්ලීමෙන් වසර 16 කට පසුවය. download.oracle.com/javase/tutorial/java/nutsandbolts/…
angryITguy

82
ඔවුන්ගේ ඇගයීමේදී සූර්යයා අවංක විය: "Don't hold your breath."lol, bugs.sun.com/bugdatabase/view_bug.do?bug_id=1223179
raffian

3
@ රාෆියන් මම හිතන්නේ ඇය දෙවරක් සුසුම්ලූ නිසා. අවුරුදු 10 කට පමණ පසු ඔවුන් පිළිතුරු දීමට ටිකක් ප්‍රමාද විය. ඇය එවකට ඇගේ මුනුබුරු මිනිබිරියන්ට දිවා ආහාර පෙට්ටි ඇසුරුම් කරනවා විය හැකිය.
WeirdElfB0y

Answers:


1003

Stringනඩු සමඟ මාරුවීම් ප්‍රකාශයන් ජාවා එස්ඊ 7 හි ක්‍රියාත්මක කර ඇත . ප්‍රමාදයට පැහැදිලි හේතුවක් සපයා නැත, නමුත් එය බොහෝ විට කාර්ය සාධනය සමඟ සම්බන්ධ විය යුතුය.

JDK 7 හි ක්‍රියාත්මක කිරීම

විශේෂාංගය දැන් javac "සීනි රහිත" ක්‍රියාවලියක් සමඟ ක්‍රියාත්මක කර ඇත ; ප්‍රකාශනවල Stringනියතයන් භාවිතා කරන පිරිසිදු, ඉහළ මට්ටමේ වාක්‍ය ඛණ්ඩයක් caseසම්පාදනය කරන වේලාවේදී රටාවක් අනුගමනය කරමින් වඩාත් සංකීර්ණ කේතයක් දක්වා පුළුල් වේ. එහි ප්‍රති code ලයක් ලෙස ඇති කේතය සෑම විටම පවතින JVM උපදෙස් භාවිතා කරයි.

නඩු switchසමඟ A Stringසම්පාදනය කිරීමේදී ස්විච දෙකකට පරිවර්තනය වේ. පළමුවැන්න එක් එක් නූල් අද්විතීය පූර්ණ සංඛ්‍යාවක් වෙත සිතියම් ගත කරයි - එහි මුල් ස්විචයේ පිහිටීම. මෙය සිදු කරන්නේ පළමුව ලේබලයේ හැෂ් කේතය මාරු කිරීමෙනි. අනුරූප නඩුව යනු ifනූල් සමානාත්මතාවය පරීක්ෂා කරන ප්‍රකාශයකි; හැෂ් මත isions ට්ටන තිබේ නම්, පරීක්ෂණය කැස්කැඩින් if-else-ifවේ. දෙවන ස්විචය මුල් ප්‍රභව කේතයේ දර්පණය කරයි, නමුත් සිද්ධි ලේබල ඒවායේ අනුරූප ස්ථාන සමඟ ආදේශ කරයි. මෙම පියවර දෙකේ ක්‍රියාවලිය මුල් ස්විචයේ ප්‍රවාහ පාලනය ආරක්ෂා කිරීම පහසු කරයි.

ජේවීඑම් හි ස්විචයන්

වැඩි තාක්‍ෂණික ගැඹුරක් සඳහා switch, ඔබට ස්විච් ප්‍රකාශ සම්පාදනය විස්තර කර ඇති JVM පිරිවිතර වෙත යොමු විය හැකිය . කෙටියෙන් කිවහොත්, ස්විචයක් සඳහා භාවිතා කළ හැකි වෙනස් ජේවීඑම් උපදෙස් දෙකක් තිබේ, එය අවස්ථා වලදී භාවිතා කරන නියතයන්ගේ පරතරය මත පදනම් වේ. දෙකම රඳා පවතින්නේ කාර්යක්ෂමව ක්‍රියාත්මක කිරීම සඳහා එක් එක් සිද්ධිය සඳහා පූර්ණ සංඛ්‍යා නියත භාවිතා කිරීම මත ය.

නියතයන් ense න නම්, ඒවා දර්ශක දර්ශකයක් ලෙස (අවම අගය අඩු කිරීමෙන් පසුව) උපදෙස් දර්ශක වගුවකට - tableswitchඋපදෙස් ලෙස භාවිතා කරයි.

නියතයන් විරල නම්, නිවැරදි නඩුව සඳහා ද්විමය සෙවීමක් සිදු කරයි - lookupswitchඋපදෙස්.

වස්තු switchමත සීනි ඉවත් කිරීමේදී String, උපදෙස් දෙකම භාවිතා කිරීමට ඉඩ ඇත. මෙම lookupswitchනඩුව මුල් ස්ථානය සොයා ගැනීමට එහි පූරක කේත මත පළමු ස්විචය සඳහා සුදුසු වේ. එහි ප්‍රති ing ලයක් වශයෙන් ඕඩිනල් යනු ස්වාභාවික යෝග්‍යතාවයකි tableswitch.

මෙම උපදෙස් දෙකටම එක් එක් සිද්ධිය සඳහා පවරා ඇති පූර්ණ සංඛ්‍යා නියතයන් සම්පාදනය කරන වේලාවට වර්ග කිරීම අවශ්‍ය වේ. ධාවන වේලාවේදී, සාමාන්‍යයෙන් O(1)කාර්ය සාධනය කාර්ය සාධනයට tableswitchවඩා හොඳින් O(log(n))පෙනෙන අතර lookupswitch, අවකාශ-කාල වෙළඳාම සාධාරණීකරණය කිරීමට වගුව ense නද යන්න තීරණය කිරීම සඳහා යම් විශ්ලේෂණයක් අවශ්‍ය වේ. බිල් වෙනර්ස් විසින් මෙය වඩාත් සවිස්තරාත්මකව ආවරණය කරන විශිෂ්ට ලිපියක් ලියා ඇති අතර අනෙකුත් ජාවා ප්‍රවාහ පාලන උපදෙස් දෙස බැලූ බැල්මට පෙනේ.

JDK 7 ට පෙර

JDK 7 ට පෙර, enumආසන්න වශයෙන් Stringපදනම් වූ ස්විචයක් විය හැකිය. මෙය සෑම වර්ගයකම සම්පාදකයා විසින් ජනනය කරන ස්ථිතිකvalueOf ක්‍රමය භාවිතා කරයි enum. උදාහරණයක් වශයෙන්:

Pill p = Pill.valueOf(str);
switch(p) {
  case RED:  pop();  break;
  case BLUE: push(); break;
}

26
නූල් මත පදනම් වූ ස්විචයක් සඳහා හෑෂ් වෙනුවට If-Else-If භාවිතා කිරීම වේගවත් විය හැකිය. අයිතම කිහිපයක් පමණක් ගබඩා කිරීමේදී ශබ්ද කෝෂ තරමක් මිල අධික බව මට පෙනී ගොස් ඇත.
ජොනතන් ඇලන්

84
If-elseif-elseif-elseif-else වේගවත් විය හැකි නමුත් මම පිරිසිදු කේතය 100 න් 99 ගුණයක් ගන්නෙමි. නූල්, වෙනස් කළ නොහැකි නිසා, ඔවුන්ගේ හැෂ් කේතය හැඹිලිගත කරයි, එබැවින් හැෂ් "ගණනය කිරීම" වේගවත් වේ. එහි ඇති ප්‍රයෝජනය කුමක්ද යන්න තීරණය කිරීම සඳහා යමෙකුට පැතිකඩ කේතයක් තිබිය යුතුය.
erickson

21
ස්විචය (නූල්) එකතු කිරීමට එරෙහිව ඇති හේතුව නම්, එය ස්විච් () ප්‍රකාශ වලින් අපේක්ෂා කරන කාර්ය සාධන සහතිකය සපුරාලීමට නොහැකි වීමයි. සංවර්ධකයින් "නොමඟ යැවීමට" ඔවුන්ට අවශ්‍ය නොවීය. අවංකවම මම හිතන්නේ නැහැ ඔවුන් ආරම්භ කිරීම සඳහා ස්විචයේ () ක්‍රියාකාරිත්වය සහතික කළ යුතුයි කියා.
ගිලි

2
ඔබ Pillපදනම් කරගෙන යම් ක්‍රියාමාර්ගයක් ගැනීමට භාවිතා strකරන්නේ නම් str, RED, BLUE පරාසයෙන් පරිබාහිරව අගයන් හැසිරවීමට ඔබට ඉඩ සලසන බැවින්-වෙනත් නම් වඩාත් සුදුසු යැයි මම තර්ක කරමි valueOf. අනවශ්‍ය පොදු කාර්ය එකතු කරන සෑම ගණන් කිරීමේ වර්ගයක්ම. මගේ අත්දැකීම් අනුව, එය valueOfගණනය කිරීමකට පරිවර්තනය කිරීම සඳහා භාවිතා කිරීම අර්ථවත් කර ඇත්තේ පසුකාලීනව නූල් අගයේ ටයිප්සෙෆ් නිරූපණයක් අවශ්‍ය වූයේ නම් පමණි.
මයිල්ස්හැම්ප්සන්

සම්පාදනය සඳහා අගයන් සමූහයක් අංක ඕනෑම යුගල (x, y) තිබේද ටෙස්ට් කිසිදු උත්සාහයක් නම් මම කියන්ට (hash >> x) & ((1<<y)-1)කාගේ සෑම නූල් පැහැදිලි වටිනාකම් යටත් වනු ඇත hashCodeවෙනස් වන අතර, (1<<y)නූල් දෙවරක් වඩා අඩු සංඛ්යාව (හෝ වේ අවම වශයෙන් ඊට වඩා විශාල නොවේ).
සුපර් කැට්

125

ඔබේ කේතයේ ඔබට නූලක් මාරු කළ හැකි ස්ථානයක් තිබේ නම්, ඔබට මාරුවිය හැකි, හැකි අගයන් ගණනය කිරීමක් ලෙස නූල් නැවත ප්‍රතිනිර්මාණය කිරීම වඩා හොඳ විය හැකිය. ඇත්ත වශයෙන්ම, ඔබ ගණන් කළ හැකි අයට අගයන් වල විභව අගයන් සීමා කරයි, ඒවා අපේක්ෂා කළ හැකි හෝ නොවිය හැකිය.

ඇත්ත වශයෙන්ම ඔබේ ගණන් බැලීමේදී 'වෙනත්' සඳහා ප්‍රවේශයක් සහ ස්ට්‍රිං (ස්ට්‍රිං) ක්‍රමයක් තිබිය හැකිය, එවිට ඔබට තිබිය හැකිය

ValueEnum enumval = ValueEnum.fromString(myString);
switch (enumval) {
   case MILK: lap(); break;
   case WATER: sip(); break;
   case BEER: quaff(); break;
   case OTHER: 
   default: dance(); break;
}

4
"එක් ප්‍රමාණයක් සියල්ලටම ගැළපේ" යන විසඳුම ඉදිරිපත් කිරීම සඳහා භාෂා නිර්මාණකරුවෙකු මත යැපීම වෙනුවට එවැනි අවස්ථාවන්හි සංවේදීතාව, අන්වර්ථ නාම ආදිය තීරණය කිරීමට මෙම තාක්ෂණය ඔබට ඉඩ සලසයි.
ඩැරන්

2
ජීබී සමඟ එකඟ වන්න, ඔබ නූල් මාරු කරන්නේ නම් බොහෝ විට එනූම් අවශ්‍ය වේ. මෙම නූල සාමාන්‍යයෙන් නිරූපණය කරන්නේ අනාගතයේදී වෙනස් විය හැකි හෝ වෙනස් නොවිය හැකි අතුරු
මුහුණතකට

18
මෙම ක්‍රමය මනාව ලිවීම සඳහා xefer.com/2006/12/switchonstring බලන්න .
ඩේවිඩ් ෂ්මිට්

Av ඩේවිඩ් ස්කිමිට් ලිවීමට එක් ප්‍රධාන අඩුපාඩුවක් ඇත. එය ඇත්ත වශයෙන්ම මෙතෝඩය මගින් විසි කරන ඒවා වෙනුවට සියලු ව්‍යතිරේකයන් අල්ලා ගනී .
එම්. මිම්පන්

91

පහත දැක්වෙන්නේ අභිරුචි ක්‍රමයක් වෙනුවට ජාවා එනුම් භාවිතා කරමින් ජීබීගේ පෝස්ට් මත පදනම් වූ සම්පූර්ණ උදාහරණයකි.

ජාවා එස්ඊ 7 සහ ඊට පසුව ඔබට ස්විච් ප්‍රකාශයේ ප්‍රකාශනයේ සංගීත වස්තුවක් භාවිතා කළ හැකි බව සලකන්න.

public class Main {

    /**
    * @param args the command line arguments
    */
    public static void main(String[] args) {

      String current = args[0];
      Days currentDay = Days.valueOf(current.toUpperCase());

      switch (currentDay) {
          case MONDAY:
          case TUESDAY:
          case WEDNESDAY:
              System.out.println("boring");
              break;
          case THURSDAY:
              System.out.println("getting better");
          case FRIDAY:
          case SATURDAY:
          case SUNDAY:
              System.out.println("much better");
              break;

      }
  }

  public enum Days {

    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
  }
}

26

පූර්ණ සංඛ්‍යා මත පදනම් වූ ස්විචයන් ඉතා කාර්යක්ෂම කේතයකට ප්‍රශස්තිකරණය කළ හැකිය. වෙනත් දත්ත වර්ග මත පදනම් වූ ස්විචයන් සම්පාදනය කළ හැක්කේ if () ප්‍රකාශ මාලාවකට පමණි.

එම හේතුව නිසා C & C ++ වෙනත් වර්ග සමඟ අර්ථ විරහිත බැවින් පූර්ණ සංඛ්‍යා වර්ග මාරු කිරීමට පමණක් ඉඩ ලබා දේ.

C # හි නිර්මාණකරුවන් තීරණය කළේ කිසිදු වාසියක් නොතිබුණද විලාසිතාව වැදගත් බවය.

ජාවා හි නිර්මාණකරුවන් සිතුවේ සී හි නිර්මාණකරුවන් මෙන් ය.


26
ඕනෑම හැෂ් කළ හැකි වස්තුවක් මත පදනම් වූ ස්විචයන් හැෂ් වගුවක් භාවිතයෙන් ඉතා කාර්යක්ෂමව ක්‍රියාත්මක කළ හැකිය - .NET බලන්න. එබැවින් ඔබේ හේතුව සම්පූර්ණයෙන්ම නිවැරදි නොවේ.
කොන්රාඩ් රුඩොල්ෆ්

ඔව්, මේක තමයි මට තේරෙන්නේ නැහැ. හෑෂ් වස්තූන් දිගු කාලීනව මිල අධික වනු ඇතැයි ඔවුන් බිය වන්නේද?
ඇලෙක්ස් බියර්ඩ්ස්ලි

3
LandNalandial: ඇත්ත වශයෙන්ම, සම්පාදකයාගේ පැත්තෙන් සුළු පරිශ්‍රමයක් දරමින්, එය කිසිසේත් මිල අධික නොවේ, මන්ද නූල් සමූහය දන්නා විට, පරිපූර්ණ හැෂ් එකක් ජනනය කිරීම පහසුය (මෙය .NET විසින් සිදු නොකෙරේ, නමුත්; බොහෝ විට උත්සාහය වටින්නේ නැත).
කොන්රාඩ් රුඩොල්ෆ්

3
Aland නලාන්ඩියල් සහ on කොන්රාඩ් රුඩොල්ෆ් - නූල් හෑරීම (එහි වෙනස් කළ නොහැකි ස්වභාවය නිසා) මෙම ගැටලුවට විසඳුමක් සේ පෙනේ. අවසාන නොවන වස්තූන් සියල්ලටම ඒවායේ හැෂිං කාර්යයන් අභිබවා යා හැකි බව මතක තබා ගත යුතුය. මෙය ස්විචයක අනුකූලතාව සහතික කිරීම සඳහා සම්පාදනය කරන වේලාවේදී අපහසු වේ.
මාර්ටිනටයිම්

2
(සාමාන්‍ය ප්‍රකාශන එන්ජින් මෙන්) ඔබට නූලට ගැලපෙන පරිදි ඩී.එෆ්.ඒ. හෑෂ් කිරීමට වඩා කාර්යක්ෂම විය හැකිය.
නේට් සීකේ

19

String1.7 සිට සෘජු භාවිතය පිළිබඳ උදාහරණයක් ද පෙන්විය හැකිය:

public static void main(String[] args) {

    switch (args[0]) {
        case "Monday":
        case "Tuesday":
        case "Wednesday":
            System.out.println("boring");
            break;
        case "Thursday":
            System.out.println("getting better");
        case "Friday":
        case "Saturday":
        case "Sunday":
            System.out.println("much better");
            break;
    }

}

18

ජේම්ස් කුරන් සංක්ෂිප්තව මෙසේ කියයි: "පූර්ණ සංඛ්‍යා මත පදනම් වූ ස්විචයන් ඉතා කාර්යක්ෂම කේතයකට ප්‍රශස්තිකරණය කළ හැකිය. වෙනත් දත්ත වර්ග මත පදනම් වූ ස්විචයන් සම්පාදනය කළ හැක්කේ if () ප්‍රකාශ මාලාවකට පමණි. එම හේතුව නිසා C & C ++ පූර්ණ සංඛ්‍යා වර්ග මත පමණක් මාරුවීමට ඉඩ දෙයි, එය වෙනත් වර්ග සමඟ අර්ථ විරහිත බැවින්.

මගේ මතය, සහ එය පමණක් වන්නේ, ඔබ ප්‍රාථමික නොවන අය වෙත මාරුවීම ආරම්භ කළ විගසම "==" හා "සමාන" ගැන සිතීම ආරම්භ කළ යුතුය. පළමුවෙන්ම නූල් දෙකක් සංසන්දනය කිරීම තරමක් දිගු ක්‍රියා පටිපාටියක් විය හැකි අතර, ඉහත සඳහන් කර ඇති කාර්ය සාධන ගැටළු එකතු කරයි. දෙවනුව, නූල් මාරුවීමක් තිබේ නම්, නඩුව නොසලකා හරිමින් නූල් මාරු කිරීම, පෙදෙස සලකා බැලීම / නොසලකා හැරීම, රීජෙක්ස් මත පදනම් වූ නූල් මාරු කිරීම සඳහා ඉල්ලුමක් ඇත .... ඒ සඳහා බොහෝ කාලයක් ඉතිරි කළ තීරණයක් මම අනුමත කරමි. ක්‍රමලේඛකයින් සඳහා සුළු කාලයක් වැය කරමින් භාෂා සංවර්ධකයින්.


තාක්ෂණික වශයෙන්, රීජෙක්ස් දැනටමත් "මාරු" වේ, ඒවා මූලික වශයෙන් රාජ්‍ය යන්ත්‍ර පමණක් බැවින්; ඔවුන්ට ඇත්තේ “නඩු” දෙකක් පමණි, matchedසහ not matched. ([නම් කරන ලද කණ්ඩායම් / යනාදිය වැනි දේවල් සැලකිල්ලට නොගැනීම.)
ජාබ්

1
docs.oracle.com/javase/7/docs/technotes/guides/language/… මෙසේ පවසයි: ජාවා සම්පාදකයා සාමාන්‍යයෙන් වඩා කාර්යක්ෂම
විම් ඩෙබ්ලව්

12

ඉහත හොඳ තර්ක හැරුණු විට, switchජාවා හි (සී කාලයට ආපසු) ක්‍රියා පටිපාටික අතීතයේ යල්පැනගිය ඉතිරියක් ලෙස අද බොහෝ දෙනා දකින බව මම එකතු කරමි .

මම මෙම මතය සම්පුර්ණයෙන්ම බෙදා switchනොගනිමි, සමහර අවස්ථාවලදී එහි ප්‍රයෝජනය තිබිය හැකි යැයි මම සිතමි , අවම වශයෙන් එහි වේගය නිසා, කෙසේ වෙතත් එය සමහර කැස්කැඩින් සංඛ්‍යා මාලාවට වඩා හොඳයelse if මා දුටු සමහර ...

නමුත් ඇත්ත වශයෙන්ම, ඔබට ස්විචයක් අවශ්‍ය වන අවස්ථාව දෙස බැලීම වටී, එය තවත් OO මගින් ප්‍රතිස්ථාපනය කළ නොහැකි දැයි බලන්න. උදාහරණයක් ලෙස ජාවා 1.5+ හි එනූම්ස්, සමහර විට හැෂ් ටේබල් හෝ වෙනත් එකතුවක් (සමහර විට මම කනගාටු වෙනවා (නිර්නාමික) පළමු පන්තියේ පුරවැසියෙකු ලෙස, ලුආ හි මෙන් - ස්විචයක් හෝ ජාවාස්ක්‍රිප්ට් නොමැති) හෝ බහුමාපකය පවා නැත.


"පළමු පන්තියේ පුරවැසියෙකු ලෙස අපට (නිර්නාමික) කාර්යයන් නොතිබීම ගැන මම කනගාටු වෙමි" එය තවදුරටත් සත්‍ය නොවේ.
user8397947

ordorukayhan ඔව්, ඇත්තෙන්ම. නමුත් අපි ජාවා හි නවතම අනුවාදයන් වෙත යාවත්කාලීන කළහොත් අපට ඒවා ලබා ගත හැකි බව ලොවට පැවසීමට පසුගිය වසර දහයේ සිට සෑම පිළිතුරකටම අදහස් දැක්වීමට ඔබට අවශ්‍යද? :-D
ෆිල්හෝ

8

ඔබ JDK7 හෝ ඊට වැඩි භාවිතා නොකරන්නේ නම්, ඔබට hashCode()එය අනුකරණය කිරීමට භාවිතා කළ හැකිය . නිසා String.hashCode()සාමාන්යයෙන් ඇත්තේ විවිධ නූල් සඳහා වෙනස් අගයන් නැවත හා සැම විටම සමාන නූල් සඳහා සමාන අගයන් නැවත, එය තරමක් විශ්වසනීය (විවිධ නූල් හැකි @Lii අදහසක් සඳහන් වන පරිදි එම හැෂ් කේතය නිෂ්පාදනය, වැනි "FB"සහ "Ea") බලන්න ප්රලේඛනය .

ඉතින්, කේතය මේ වගේ වනු ඇත:

String s = "<Your String>";

switch(s.hashCode()) {
case "Hello".hashCode(): break;
case "Goodbye".hashCode(): break;
}

ඒ ආකාරයෙන්, ඔබ තාක්ෂණික වශයෙන් අ int.

විකල්පයක් ලෙස, ඔබට පහත කේතය භාවිතා කළ හැකිය:

public final class Switch<T> {
    private final HashMap<T, Runnable> cases = new HashMap<T, Runnable>(0);

    public void addCase(T object, Runnable action) {
        this.cases.put(object, action);
    }

    public void SWITCH(T object) {
        for (T t : this.cases.keySet()) {
            if (object.equals(t)) { // This means that the class works with any object!
                this.cases.get(t).run();
                break;
            }
        }
    }
}

5
වෙනස් නූල් දෙකකට එකම හැෂ් කේතය තිබිය හැක, එබැවින් ඔබ හැෂ් කේතයන් මාරු කළහොත් වැරදි අතු ශාඛාව ගත හැකිය.
ලී

ILii මෙය පෙන්වා දීමට ස්තූතියි! එය කළ නොහැක්කකි, නමුත් එය ක්‍රියාත්මක වනු ඇතැයි මම විශ්වාස නොකරමි. "FB" සහ "Ea" එකම හැෂ් කේතයක් ඇති බැවින් ision ට්ටනයක් සොයාගත නොහැක. දෙවන කේතය බොහෝ විට වඩා විශ්වාසදායකය.
හයිපර් නියුට්‍රිනෝ

මෙම සම්පාදනයන් ගැන මා පුදුමයට පත් වෙමි, caseප්‍රකාශයන් සැමවිටම නියත අගයන් විය යුතු යැයි මම සිතුවෙමි, String.hashCode()එය එසේ නොවේ (ප්‍රායෝගිකව ගණනය කිරීම් කිසි විටෙකත් ජේවීඑම් අතර වෙනස් වී නැතත්).
ස්ටැක්ස්මන්

@ ස්ටැක්ස්මන් එච්එම් සිත්ගන්නා සුළුය, මම එය නිරීක්ෂණය කිරීම නතර කළේ නැත. නමුත් ඔව්, caseප්‍රකාශන අගයන් සම්පාදනය කරන වේලාවේදී තීරණය කළ යුතු නොවේ, එබැවින් එය මනාව ක්‍රියාත්මක වේ.
හයිපර් නියුට්‍රිනෝ

4

වසර ගණනාවක් තිස්සේ අපි මේ සඳහා (n විවෘත මූලාශ්‍ර) පෙර සැකසුම් යන්ත්‍රයක් භාවිතා කර ඇත්තෙමු.

//#switch(target)
case "foo": code;
//#end

පෙර සැකසූ ලිපිගොනු Foo.jpp ලෙස නම් කර ඇති අතර කුහුඹුවන්ගේ පිටපතක් සමඟ Foo.java වෙත සැකසෙනු ඇත.

වාසිය නම් එය 1.0 මත ධාවනය වන ජාවා තුළට සකසනු ලැබේ (සාමාන්‍යයෙන් අපි සහාය දැක්වූයේ 1.4 දක්වා පමණි). එනූම්ස් හෝ වෙනත් ක්‍රියාකාරීත්වයන් සමඟ එය රැවටීම හා සසඳන විට මෙය (නූල් ස්විච ගොඩක්) කිරීම පහසුය - කේතය කියවීමට, නඩත්තු කිරීමට සහ තේරුම් ගැනීමට පහසු විය. IIRC (මේ අවස්ථාවේ සංඛ්‍යාලේඛන හෝ තාක්ෂණික තර්ක ඉදිරිපත් කළ නොහැක) එය ස්වාභාවික ජාවා සමානකම් වලට වඩා වේගවත් විය.

අවාසි නම් ඔබ ජාවා සංස්කරණය නොකිරීම නිසා එය තව ටිකක් වැඩ ප්‍රවාහයක් (සංස්කරණය, ක්‍රියාවලිය, සම්පාදනය / පරීක්ෂණය) සහ IDE එකක් ජාවා සමඟ නැවත සම්බන්ධ වන අතර එය මඳක් කැටි ගැසී ඇත (ස්විචය නම් / වෙනත් තර්කන පියවර මාලාවක් බවට පත්වේ) සහ ස්විච් කේස් අනුපිළිවෙල නඩත්තු නොකෙරේ.

මම එය 1.7+ සඳහා නිර්දේශ නොකරමි, නමුත් ඔබට කලින් ජේවීඑම් ඉලක්ක කරගත් ජාවා වැඩසටහන්ගත කිරීමට අවශ්‍ය නම් එය ප්‍රයෝජනවත් වේ (ජෝ පොදු කලාතුරකින් නවතම ස්ථාපනය කර ඇති බැවින්).

ඔබට එය SVN වෙතින් ලබා ගත හැකිය හෝ කේතය මාර්ගගතව පිරික්සන්න . එය ගොඩනඟා ගැනීමට ඔබට EBuild අවශ්‍ය වේ.


6
සංගීත ස්විචයක් සමඟ කේතය ධාවනය කිරීමට ඔබට 1.7 JVM අවශ්‍ය නොවේ. 1.7 සම්පාදකයා විසින් නූල් ස්විචය කලින් පැවති බයිට් කේතය භාවිතා කරන දෙයක් බවට පත් කරයි.
ඩාවුඩ් ඉබ්න් කරීම්

4

වෙනත් පිළිතුරු වලට අනුව මෙය ජාවා 7 හි එකතු කර ඇති අතර පෙර සංස්කරණ සඳහා විසඳුම් ලබා දී ඇත. මෙම පිළිතුර "ඇයි" යන්නට පිළිතුරු දීමට උත්සාහ කරයි

ජාවා යනු සී ++ හි අධික සංකීර්ණතාවයන්ට ප්‍රතික්‍රියාවකි. එය සරල පිරිසිදු භාෂාවක් ලෙස නිර්මාණය කර ඇත.

සංගීතයට විශේෂ සිද්ධි හැසිරවීමක් ස්වල්පයක් ඇති නමුත් නිර්මාණකරුවන් විශේෂ ආවරණ සහ සින්ටැක්ටික් සීනි ප්‍රමාණය අවම මට්ටමක තබා ගැනීමට උත්සාහ කළ බව මට පැහැදිලිය.

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

1.0 ත් 1.4 ත් අතර භාෂාව එකම මට්ටමක පැවතුනි. ජාවා හි වැඩි දියුණු කිරීම් බොහොමයක් පුස්තකාල පැත්තේ විය.

ජාවා 5 සමඟ සියල්ල වෙනස් වූ විට භාෂාව සැලකිය යුතු ලෙස දීර් was විය. 7 සහ 8 අනුවාදයන්හි තවදුරටත් දීර් ensions කිරීම් අනුගමනය කරන ලදී.


ස්විචය (නූල්) පිළිබඳ ආඛ්‍යානය ඉතිහාසය, කාලරාමුව, සන්දර්භය cpp / cs සමඟ ගැලපේ.
එස්ප්‍රෙසෝ

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

0

JEP 354: JDK-13 හි ස්විච් ප්‍රකාශන (පෙරදසුන) සහ JEP 361: JDK-14 හි ඇති ස්විච් ප්‍රකාශන (සම්මත) ස්විච් ප්‍රකාශය දීර් extend කරනබැවින් එය ප්‍රකාශනයක් ලෙස භාවිතා කළ හැකිය.

දැන් ඔබට පුළුවන්:

  • ස්විච් ප්‍රකාශනයෙන් විචල්‍යය කෙලින්ම පවරන්න ,
  • ස්විච් ලේබලයේ නව ආකාරයක් භාවිතා කරන්න (case L -> ):

    "නඩුව L ->" ස්විච් ලේබලයේ දකුණට ඇති කේතය ප්‍රකාශනයක්, වාරණයක් හෝ (පහසුව සඳහා) විසි කිරීමේ ප්‍රකාශයක් ලෙස සීමා කර ඇත.

  • කොමාවකින් වෙන් කර ඇති එක් අවස්ථාවකට බහු නියතයන් භාවිතා කරන්න,
  • තවද තවත් වටිනාකම් බිඳවැටීම් නොමැත :

    ස්විච් ප්‍රකාශනයකින් වටිනාකමක් ලබා දීම සඳහා, breakඅගය සමඟ ප්‍රකාශය ප්‍රකාශයක් සඳහා අතහැර දමනු ලැබේ yield.

එබැවින් පිළිතුරු වලින් ( 1 , 2 ) නිරූපණය මේ වගේ විය හැකිය:

  public static void main(String[] args) {
    switch (args[0]) {
      case "Monday", "Tuesday", "Wednesday" ->  System.out.println("boring");
      case "Thursday" -> System.out.println("getting better");
      case "Friday", "Saturday", "Sunday" -> System.out.println("much better");
    }

0

ජාවා 11+ හි විචල්‍යයන් සමඟද එය කළ හැකිය. එකම කොන්දේසිය එය නියතයක් විය යුතුය.

උදාහරණයක් වශයෙන්:

final String LEFT = "left";
final String RIGHT = "right";
final String UP = "up";
final String DOWN = "down";

String var = ...;

switch (var) {
    case LEFT:
    case RIGHT:
    case DOWN:
    default:
        return 0;
}

පීඑස්. මම මීට පෙර jdks සමඟ මෙය උත්සාහ කර නැත. එබැවින් පිළිතුර ද එහි සහය දක්වන්නේ නම් කරුණාකර යාවත්කාලීන කරන්න.


-2

එතරම් ලස්සන නැත, නමුත් මෙන්න ජාවා 6 සහ බෙලෝ සඳහා තවත් ක්‍රමයක්:

String runFct = 
        queryType.equals("eq") ? "method1":
        queryType.equals("L_L")? "method2":
        queryType.equals("L_R")? "method3":
        queryType.equals("L_LR")? "method4":
            "method5";
Method m = this.getClass().getMethod(runFct);
m.invoke(this);

-3

එය ග්‍රෝවි හි සුළඟකි; මම භයානක භාජනය කාවැද්දූ අතර groovyමේ සියල්ල සහ තවත් බොහෝ දේ කිරීමට උපයෝගීතා පංතියක් නිර්මාණය කරමි. එය ජාවා හි කිරීමට මා තුළ උද්දීපනයක් ඇති කරයි (මම ව්‍යවසායයේ ජාවා 6 භාවිතා කර හිර වී සිටින බැවින්.)

it.'p'.each{
switch (it.@name.text()){
   case "choclate":
     myholder.myval=(it.text());
     break;
     }}...

9
@SSpoke මෙය ජාවා ප්‍රශ්නයක් වන අතර Groovy පිළිතුර මාතෘකාවෙන් බැහැර වන අතර නිෂ් less ල ප්ලග් එකක් වේ.
මාටින්

12
ගතානුගතික විශාල SW නිවාසවල පවා ජාවා සමඟ ග්‍රෝවි භාවිතා වේ. ජේවීඑම් දැන් භාෂාවකට වඩා භාෂා අ nost ෙයවාදී පරිසරයක් ලබා දෙයි, විසඳුම සඳහා වඩාත් අදාළ ක්‍රමලේඛන ආදර්ශය මිශ්‍ර කර භාවිතා කිරීමට. ඉතින් සමහර විට දැන් මම ක්ලෝජුරේ ස්නිපටයක් එක් කළ යුතුයි තවත් පහත් එකතු කිරීමට :) :)
ඇලෙක්ස් පුන්නන්

1
එසේම, සින්ටැක්ස් ක්‍රියා කරන්නේ කෙසේද? මම හිතන්නේ ග්‍රෝවි වෙනස් ක්‍රමලේඛන භාෂාවක්ද ...? සමාවන්න. මම ග්‍රෝවි ගැන කිසිවක් දන්නේ නැහැ.
හයිපර් නියුට්‍රිනෝ

-4

ඔබ intellij භාවිතා කරන විටද බලන්න:

ගොනුව -> ව්‍යාපෘති ව්‍යුහය -> ව්‍යාපෘතිය

ගොනුව -> ව්‍යාපෘති ව්‍යුහය -> මොඩියුල

ඔබට බහු මොඩියුල ඇති විට මොඩියුල පටිත්තෙහි නිවැරදි භාෂා මට්ටම සැකසීමට වග බලා ගන්න.


1
ඔබේ පිළිතුර ප්‍රශ්නයට අදාළ වන්නේ කෙසේදැයි විශ්වාස නැත. පහත දැක්වෙන ආකාරයේ නූල් ස්විච් ප්‍රකාශයක් ලබා ගත නොහැක්කේ මන්දැයි ඔහු විමසීය: String mystring = "යමක්"; switch (mystring) {case "something" sysout ("මෙහි ඇත"); . . }
දීපක් අගර්වාල්

-8
public class StringSwitchCase { 

    public static void main(String args[]) {

        visitIsland("Santorini"); 
        visitIsland("Crete"); 
        visitIsland("Paros"); 

    } 

    public static void visitIsland(String island) {
         switch(island) {
          case "Corfu": 
               System.out.println("User wants to visit Corfu");
               break; 
          case "Crete": 
               System.out.println("User wants to visit Crete");
               break; 
          case "Santorini": 
               System.out.println("User wants to visit Santorini");
               break; 
          case "Mykonos": 
               System.out.println("User wants to visit Mykonos");
               break; 
         default: 
               System.out.println("Unknown Island");
               break; 
         } 
    } 

} 

8
OP විසින් නූලක් මාරු කරන්නේ කෙසේදැයි විමසන්නේ නැත. JDK7 ට පෙර වාක්‍ය ඛණ්ඩය සීමා කිරීම නිසා ඔහු / ඇය අසන්නේ ඇයි?
HyperNeutrino
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.