कोलन (:) ऑपरेटर क्या करता है?

Question 1

जाहिरा तौर पर जावा में कई मायनों में एक कोलन का उपयोग किया जाता है। किसी को भी यह क्या होता है समझा?

उदाहरण के लिए यहाँ:

String cardString = "";
for (PlayingCard c : this.list)  // <--
{
    cardString += c + "\n";
}

आप इस for-eachलूप को अलग तरीके से कैसे लिखेंगे ताकि इसमें शामिल न हों :?

Question 2

जावा कोड में कई स्थानों पर कोलन का उपयोग किया जाता है:

1) जंप-आउट लेबल ( ट्यूटोरियल ):

label: for (int i = 0; i < x; i++) {
    for (int j = 0; j < i; j++) {
        if (something(i, j)) break label; // jumps out of the i loop
    }
} 
// i.e. jumps to here

2) टर्नरी स्थिति ( ट्यूटोरियल ):

int a = (b < 4)? 7: 8; // if b < 4, set a to 7, else set a to 8

3) प्रत्येक लूप ( ट्यूटोरियल ) के लिए:

String[] ss = {"hi", "there"}
for (String s: ss) {
    print(s); // output "hi" , and "there" on the next iteration
}

4) अभिकथन ( गाइड ):

int a = factorial(b);
assert a >= 0: "factorial may not be less than 0"; // throws an AssertionError with the message if the condition evaluates to false

5) स्विच स्टेटमेंट ( ट्यूटोरियल ) में मामला :

switch (type) {
    case WHITESPACE:
    case RETURN:
        break;
    case NUMBER:
        print("got number: " + value);
        break;
    default:
        print("syntax error");
}

6) विधि संदर्भ ( ट्यूटोरियल )

class Person {
   public static int compareByAge(Person a, Person b) {
       return a.birthday.compareTo(b.birthday);
   }}
}

Arrays.sort(persons, Person::compareByAge);

Question 3

कोई "कोलन" ऑपरेटर नहीं है, लेकिन दो स्थानों में कोलन दिखाई देता है:

1: टर्नरी ऑपरेटर में, जैसे:

int x = bigInt ? 10000 : 50;

इस मामले में, टर्नरी ऑपरेटर भावों के लिए 'अगर' के रूप में कार्य करता है। अगर bigInt सच है, तो x को इसके लिए 10000 दिए जाएंगे। यदि नहीं, तो 50. यहाँ उपनिवेश का अर्थ है "और"।

2: प्रत्येक लूप में:

double[] vals = new double[100];
//fill x with values
for (double x : vals) {
    //do something with x
}

यह बदले में प्रत्येक मान के लिए x सेट करता है। इसलिए यदि वैल में [१०, २०.३, ३०, ...] सम्‍मिलित है, तो पहले पुनरावृत्ति पर x १० होगा, दूसरे पर २०.३, आदि।

नोट: मैं कहता हूं कि यह एक ऑपरेटर नहीं है क्योंकि यह सिर्फ सिंटैक्स है। यह अपने आप में किसी भी अभिव्यक्ति में प्रकट नहीं हो सकता है, और यह सिर्फ मौका है कि दोनों के लिए प्रत्येक और टर्नरी ऑपरेटर एक बृहदान्त्र का उपयोग करते हैं।

Question 4

बस जोड़ने के लिए, जब प्रत्येक लूप में उपयोग किया जाता है, तो ":" को मूल रूप से "इन" के रूप में पढ़ा जा सकता है।

इसलिए

for (String name : names) {
    // remainder omitted
}

पढ़ा जाना चाहिए "प्रत्येक नाम के लिए नाम में ..."

Question 5

आप इसे कैसे लिखेंगे- प्रत्येक लूप को एक अलग तरीके से लिखा जाएगा ताकि ":" शामिल न हो?

यह मानते हुए कि listएक Collectionउदाहरण है ...

public String toString() {
   String cardString = "";
   for (Iterator<PlayingCard> it = this.list.iterator(); it.hasNext(); /**/) {
      PlayingCard c = it.next();
      cardString = cardString + c + "\n";
   }
}

मुझे पांडित्य बिंदु जोड़ना चाहिए :जो इस संदर्भ में ऑपरेटर नहीं है। एक ऑपरेटर एक अभिव्यक्ति में एक ऑपरेशन करता है, और ( ... )एक forबयान के अंदर सामान एक अभिव्यक्ति नहीं है ... जेएलएस के अनुसार।

Question 6

यह वस्तुओं की एक सूची पर पुनरावृति करने के लिए छोरों के लिए उपयोग किया जाता है।

for (Object o: list)
{
    // o is an element of list here
}

इसे for <item> in <list>पायथन में एक के रूप में सोचो ।

Question 7

आपके विशिष्ट मामले में,

String cardString = "";
for (PlayingCard c : this.list)  // <--
{
    cardString = cardString + c + "\n";
}

this.listएक संग्रह (सूची, सेट, या सरणी) है, और यह कोड cसंग्रह के प्रत्येक तत्व को असाइन करता है।

तो, अगर this.listएक संग्रह {"2S", "3H", "4S"} थे, तो cardStringअंत में यह होगा:

2S
3H
4S

Question 8

आप इसे आमतौर पर टर्नरी असाइनमेंट ऑपरेटर में देखते हैं;

वाक्य - विन्यास

variable =  `condition ? result 1 : result 2;`

उदाहरण:

boolean isNegative = number > 0 ? false : true;

जो प्रकृति में "समतुल्य" है यदि अन्य के लिए

if(number > 0){
    isNegative = false;
}
else{
    isNegative = true;
}

विभिन्न पोस्टरों द्वारा दिए गए उदाहरणों के अलावा,

आप यह भी उपयोग कर सकते हैं: एक ब्लॉक के लिए एक लेबल को इंगित करने के लिए जिसे आप जारी रखने और तोड़ने के साथ संयोजन में उपयोग कर सकते हैं।

उदाहरण के लिए:

public void someFunction(){
     //an infinite loop
     goBackHere: { //label
          for(int i = 0; i < 10 ;i++){
               if(i == 9 ) continue goBackHere;
          }
     }
}

Question 9

यह तीन बार "कुछ" स्ट्रिंग को प्रिंट करता है।

JLabel[] labels = {new JLabel(), new JLabel(), new JLabel()};                   

for ( JLabel label : labels )                  
 {              
   label.setText("something");  

 panel.add(label);             
 }

Question 10

चूंकि लूप के लिए अधिकांश बहुत समान हैं, जावा प्रत्येक लूप के लिए बुलाया लूप लिखने के लिए आवश्यक कोड की मात्रा को कम करने के लिए एक शॉर्टकट प्रदान करता है।

यहाँ प्रत्येक लूप के लिए संक्षिप्त उदाहरण दिया गया है:

for (Integer grade : quizGrades){
      System.out.println(grade);
 }

उपरोक्त उदाहरण में, बृहदान्त्र (:) को "इन" के रूप में पढ़ा जा सकता है। प्रत्येक लूप के लिए पूरी तरह से "क्विजग्रैड्स में प्रत्येक इंटेगर तत्व (जिसे ग्रेड कहा जाता है) के लिए पढ़ा जा सकता है, ग्रेड के मूल्य का प्रिंट आउट लें।"

Question 11

इसका उपयोग नए छोटे हाथ में / पाश के लिए किया जाता है

final List<String> list = new ArrayList<String>();
for (final String s : list)
{
   System.out.println(s);
}

और टर्नरी ऑपरेटर

list.isEmpty() ? true : false;

Question 12

बृहदान्त्र वास्तव में के साथ संयोजन के रूप में मौजूद है ?

int minVal = (a < b) ? a : b;

के बराबर है:

int minval;
if(a < b){ minval = a;} 
else{ minval = b; }

प्रत्येक लूप के लिए भी:

for(Node n : List l){ ... }

सचमुच:

for(Node n = l.head; n.next != null; n = n.next)

Question 13

बृहदान्त्र प्रत्येक लूप के लिए उपयोग कर रहा है, इस उदाहरण का प्रयास करें,

import java.util.*;

class ForEachLoop
{
       public static void main(String args[])
       {`enter code here`
       Integer[] iray={1,2,3,4,5};
       String[] sray={"ENRIQUE IGLESIAS"};
       printME(iray);
       printME(sray);

       }
       public static void printME(Integer[] i)
       {           
                  for(Integer x:i)
                  {
                    System.out.println(x);
                  }
       }
       public static void printME(String[] i)
       {
                   for(String x:i)
                   {
                   System.out.println(x);
                   }
       }
}