{
  "assessmentTests": {
    "java_test": {
      "name": "જાવા ટેસ્ટ",
      "desc": "મુખ્ય સિન્ટેક્સ, OOP મિકેનિક્સ, કલેક્શન્સ, જેનરિક્સ, એક્સેપ્શન્સ અને કન્કરન્સી પર 30 દૃશ્ય-આધારિત પ્રશ્નો — જાણો કે શું તમારી જાવા કુશળતા જોબ પોસ્ટિંગમાં જાવા પ્રાવીણ્યના અર્થ સાથે મેળ ખાય છે.",
      "recommendation": "તમારી જાવા કુશળતાની પ્રોફાઇલ",
      "results": {
        "beginner": {
          "name": "પ્રારંભિક",
          "desc": "તમે કાર્યરત ક્લાસ અને મેથડ લખી શકો છો, પરંતુ તમે જે પ્રશ્નો ચૂકી ગયા તે સિન્ટેક્સને બદલે ઓળખ અને ડિફોલ્ટ્સની આસપાસ કેન્દ્રિત છે — String == વિરુદ્ધ .equals, શા માટે new String(\"x\") ક્યારેય સ્ટ્રિંગ પૂલનો ફરીથી ઉપયોગ કરતું નથી, ન્યુમેરિક ફિલ્ડનું ડિફોલ્ટ મૂલ્ય શું હોય છે વિરુદ્ધ રેપર ફિલ્ડ. આમાંથી કંઈ પણ જાવામાં ખરાબ હોવા વિશે નથી; આ તે ચોક્કસ નિયમો છે જે એવા લોકોને ગૂંચવે છે જેમણે રેફરન્સ અને પ્રિમિટિવ્સ ખરેખર કેવી રીતે કામ કરે છે તેના બદલે ટ્રાયલ અને એરર દ્વારા ભાષા શીખી છે. તે કામ પર મહત્વપૂર્ણ છે કારણ કે દરેક તે જગ્યા છે જ્યાં કોડ કમ્પાઇલ થાય છે, ચાલે છે, અને શાંતિથી ખોટું કામ કરે છે.",
          "recommendation": "આ ક્રમમાં ત્રણ વસ્તુઓથી પ્રારંભ કરો: શા માટે બે String ઑબ્જેક્ટ્સ પર == રેફરન્સની તુલના કરે છે, અક્ષરોની નહીં (અને .equals તે છે જે તમે લગભગ હંમેશા ઇચ્છો છો), કેવી રીતે int ઓવરફ્લો એક્સેપ્શન ફેંકવાને બદલે શાંતિથી રેપ થાય છે, અને શા માટે અનઇનિશિયલાઇઝ્ડ Integer ફિલ્ડનું ડિફોલ્ટ મૂલ્ય null હોય છે જ્યારે int ફિલ્ડનું ડિફોલ્ટ 0 હોય છે. ઓરેકલના સત્તાવાર જાવા ટ્યુટોરિયલ્સ અને Baeldung બંને આ ત્રણેયને ચલાવી શકાય તેવા ઉદાહરણો સાથે આવરી લે છે."
        },
        "intermediate": {
          "name": "મધ્યમ",
          "desc": "તમે રોજિંદા એપ્લિકેશન કોડને આરામથી સંભાળી શકો છો — ક્લાસ, કલેક્શન, સીધો કંટ્રોલ ફ્લો — અને રૂટિન ફીચર વર્કથી ધીમા નહીં પડો. અહીંથી એડવાન્સ્ડ સુધીનું અંતર મોટે ભાગે એ છે કે જ્યારે જાવાના નિયમો કોન્કરન્સી અને જેનરિક્સ સાથે ક્રિયાપ્રતિક્રિયા કરે છે ત્યારે શું થાય છે: તમે અપેક્ષા રાખેલા ઓબ્જેક્ટને બદલે જાહેર કરેલા પ્રકાર દ્વારા ઉકેલાયેલી સ્ટેટિક મેથડ, તમે શાંતિથી જેના પર આધાર રાખ્યો હતો તે HashMap ઇટરેશન ઓર્ડર, લૂપની મધ્યમાં આઇટમ દૂર કરવાથી આવતી ConcurrentModificationException. આ એવા પ્રકારના બગ્સ છે જે ઝડપી વાંચનમાંથી પસાર થઈ જાય છે અને ફક્ત ચોક્કસ રનટાઇમ સ્થિતિમાં જ દેખાય છે.",
          "recommendation": "કમ્પાઇલરનો તમારા કોડ વિશેનો સ્ટેટિક દૃષ્ટિકોણ જે ચાલે છે તેનાથી કેવી રીતે અલગ છે તેના પર ધ્યાન કેન્દ્રિત કરો: રનટાઇમ પ્રકારને બદલે જાહેર કરેલા પ્રકાર દ્વારા ઓવરલોડ રિઝોલ્યુશન અને સ્ટેટિક-મેથડ હાઇડિંગ, શા માટે HashMap ઇટરેશન-ઓર્ડરની કોઈ ગેરંટી આપતું નથી, અને શા માટે ઇટરેટ કરતી વખતે સીધી લિસ્ટમાં ફેરફાર કરવાથી ConcurrentModificationException આવે છે. પછી જેનરિક્સ ઇરેઝર, કારણ કે તે એવા લોકોને પણ ગૂંચવે છે જેઓ પહેલાથી જ કલેક્શનને વ્યક્તિગત રીતે જાણે છે."
        },
        "advanced": {
          "name": "એડવાન્સ્ડ",
          "desc": "આ તે સ્તર છે જે મોટાભાગની જોબ પોસ્ટિંગ્સ “સ્ટ્રોંગ જાવા” દ્વારા સૂચવે છે. તમે સ્ટેટિક બ્લોક્સ, ઇન્સ્ટન્સ બ્લોક્સ અને બહુવિધ કન્સ્ટ્રક્ટર્સ સાથેનો ક્લાસ વાંચો છો અને તેઓ જે ચોક્કસ ક્રમમાં ચાલશે તેની આગાહી કરી શકો છો, તમે જાણો છો કે શા માટે finally બ્લોક શાંતિથી try બ્લોકની રિટર્ન વેલ્યુને કાઢી શકે છે, અને તમે મેન્યુઅલ finally-close ને બદલે try-with-resources નો ઉપયોગ કરો છો કારણ કે તમે જાણો છો કે તે તમને ઓર્ડરિંગની ગેરંટી આપે છે. આ બેન્ડને ટોચથી જે અલગ પાડે છે તે કામની કોન્કરન્ટ અને ઇન્ટરફેસ-લેવલ બાજુ છે: synchronized ખરેખર શું લોક કરે છે, volatile શું ગેરંટી આપે છે અને શું નથી આપતું, અને ડિફોલ્ટ-મેથડના વિરોધાભાસો કેવી રીતે ઉકેલાય છે.",
          "recommendation": "એવા ભાગોમાં આગળ વધો જે અન્ય થ્રેડ્સ અને અન્ય ઇન્ટરફેસ પણ સ્પર્શે છે તે કોડને સુરક્ષિત કરે છે: synchronized ઇન્સ્ટન્સ મેથડ શું લોક કરે છે અને synchronized સ્ટેટિક મેથડ શું લોક કરે છે તેની વચ્ચેનો તફાવત, શા માટે volatile વિઝિબિલિટી આપે છે પરંતુ counter++ માટે એટોમિસિટી નથી આપતું, અને જાવા તમને ડિફોલ્ટ-મેથડ ડાયમંડને જાતે ઉકેલવા માટે કેવી રીતે દબાણ કરે છે. Baeldung અને Java Concurrency in Practice ની જાવા મેમરી મોડેલ પરની સામગ્રી બંને માટે સ્વાભાવિક રીતે આગળનું પગલું છે."
        },
        "expert": {
          "name": "નિષ્ણાત",
          "desc": "તમે દરેક વિભાગમાં ટોચનો સ્કોર કર્યો છે — કોર સિન્ટેક્સ અને ટાઇપ્સ, OOP મિકેનિક્સ અને સ્કોપ, કલેક્શન્સ અને જેનરિક્સ, અને એક્સેપ્શન્સ, કોન્કરન્સી અને ઇડિયમ્સ. વ્યવહારિક રીતે, તેનો અર્થ એ છે કે તમને કોઈ અજાણ્યા વ્યક્તિનો ક્લાસ આપી શકાય છે અને તમે સમજાવી શકો છો કે કમ્પાઇલ એરર, રનટાઇમ એક્સેપ્શન, અથવા શાંતિથી ખોટી વેલ્યુ શા માટે થાય છે, ફક્ત સિન્ટેક્સ શું કહે છે તે જ નહીં, જે વધુ મુશ્કેલ અને વધુ મૂલ્યવાન કૌશલ્ય છે. આ સ્તરે ભાષા પોતે ભાગ્યે જ મર્યાદિત પરિબળ હોય છે; મર્યાદા સામાન્ય રીતે કોન્કરન્સી ડિઝાઇન અથવા તેની નીચેના ડેટાનો આકાર હોય છે.",
          "recommendation": "હવે વળતર ડિઝાઇન અને નિદાનમાં છે: હેંગને ડેડલોક માનતા પહેલા થ્રેડ ડમ્પ વાંચવું, synchronized, java.util.concurrent લોક્સ અને એટોમિક્સ વચ્ચે ડિફોલ્ટને બદલે ટ્રેડઓફ તરીકે પસંદગી કરવી, અને સ્ટ્રીમ-પાઇપલાઇન ડિઝાઇન જે આકસ્મિક રીતે નહીં પણ હેતુપૂર્વક આળસુ રહે છે. જો તમને કોઈ ભૂમિકા માટે સ્ક્રીન કરવામાં આવી રહ્યા હોય, તો જાવા ફીચર્સનું નામ લેવાને બદલે પ્રોડક્શનમાં તમને મળેલી કોન્કરન્સી બગનું વર્ણન કરો, જેમ કે ચૂકી ગયેલી happens-before એજ અથવા ConcurrentModificationException — તે ફક્ત શબ્દભંડોળ જ નહીં, પણ તર્ક પણ દર્શાવે છે."
        }
      },
      "questions": [
        {
          "question": "તમે બે String ઓબ્જેક્ટ બનાવો છો: String a = new String(\"cat\"); String b = new String(\"cat\"); a == b નું મૂલ્યાંકન શું થશે?",
          "options": [
            {
              "icon": "",
              "label": "સાચું"
            },
            {
              "icon": "",
              "label": "તે JVM ના સ્ટ્રિંગ-પૂલ સેટિંગ પર આધાર રાખે છે"
            },
            {
              "icon": "",
              "label": "કમ્પાઇલ એરર"
            },
            {
              "icon": "",
              "label": "ખોટું"
            }
          ]
        },
        {
          "question": "Integer x = 100; Integer y = 100; System.out.println(x == y); પછી Integer x2 = 200; Integer y2 = 200; System.out.println(x2 == y2); આ બે લાઇન શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "true પછી true"
            },
            {
              "icon": "",
              "label": "ખોટું પછી ખોટું"
            },
            {
              "icon": "",
              "label": "તે કમ્પાઇલ થતું નથી"
            },
            {
              "icon": "",
              "label": "true પછી false"
            }
          ]
        },
        {
          "question": "int max = Integer.MAX_VALUE; System.out.println(max + 1); શું થશે?",
          "options": [
            {
              "icon": "",
              "label": "તે ArithmeticException ફેંકશે"
            },
            {
              "icon": "",
              "label": "તે ફરીથી Integer.MAX_VALUE પ્રિન્ટ કરશે"
            },
            {
              "icon": "",
              "label": "તે Integer.MIN_VALUE પ્રિન્ટ કરશે"
            },
            {
              "icon": "",
              "label": "કમ્પાઇલ એરર"
            }
          ]
        },
        {
          "question": "System.out.println(0.1 + 0.2 == 0.3); આ શું પ્રિન્ટ કરશે, અને શા માટે?",
          "options": [
            {
              "icon": "",
              "label": "false, કારણ કે 0.1 અને 0.2 બાઈનરી ફ્લોટિંગ પોઈન્ટમાં ચોક્કસ નથી"
            },
            {
              "icon": "",
              "label": "true, કારણ કે જાવા ડબલ સરવાળાને નજીકના દશાંશમાં રાઉન્ડ કરે છે"
            },
            {
              "icon": "",
              "label": "true, કારણ કે બે-દશાંશ મૂલ્યો ડબલમાં ચોક્કસ રીતે ઉમેરાય છે"
            },
            {
              "icon": "",
              "label": "અચોક્કસ સરખામણી માટે તે ArithmeticException ફેંકશે"
            }
          ]
        },
        {
          "question": "એક ક્લાસ કોઈ ઇનિશિયલાઇઝર વિના બે ઇન્સ્ટન્સ ફીલ્ડ જાહેર કરે છે: int count; અને Integer total; કન્સ્ટ્રક્ટર ચાલતા પહેલા, તેમની ડિફોલ્ટ વેલ્યુ શું હશે?",
          "options": [
            {
              "icon": "",
              "label": "બંને 0 છે"
            },
            {
              "icon": "",
              "label": "બંનેને અસાઇન ન થાય ત્યાં સુધી કોઈ વેલ્યુ નથી"
            },
            {
              "icon": "",
              "label": "count 0 છે અને total null છે"
            },
            {
              "icon": "",
              "label": "બંને null છે"
            }
          ]
        },
        {
          "question": "એક લૂપ 1000 વખત ચાલે છે, દરેક વખતે String result પર result += \"x\"; કરે છે. દરેક ઇટરેશનમાં ખરેખર શું થાય છે?",
          "options": [
            {
              "icon": "",
              "label": "હાલના String ની કેરેક્ટર એરે તેની જગ્યાએ જ વિસ્તૃત થાય છે"
            },
            {
              "icon": "",
              "label": "જાવા બધા કોન્કેટેનેશનને એક અંતિમ String માં બેચ કરે છે"
            },
            {
              "icon": "",
              "label": "એક StringBuilder બધા 1000 ઇટરેશનમાં શેર કરવામાં આવે છે"
            },
            {
              "icon": "",
              "label": "એક નવો String બનાવવામાં આવે છે અને result ને અસાઇન કરવામાં આવે છે"
            }
          ]
        },
        {
          "question": "final List<String> names = new ArrayList<>(); આમાંથી કયું સાચું છે?",
          "options": [
            {
              "icon": "",
              "label": "names.add(\"Ana\") કમ્પાઇલ થાય છે અને કામ કરે છે"
            },
            {
              "icon": "",
              "label": "names.add(\"Ana\") કમ્પાઇલ થતું નથી"
            },
            {
              "icon": "",
              "label": "લિસ્ટ કોન્કરન્ટ રાઇટ્સ માટે સુરક્ષિત છે"
            },
            {
              "icon": "",
              "label": "final ની લોકલ વેરિયેબલ પર કોઈ અસર થતી નથી"
            }
          ]
        },
        {
          "question": "int[] a = {1, 2, 3}; int[] b = {1, 2, 3}; System.out.println(a == b); System.out.println(Arrays.equals(a, b)); આ બે લાઇન શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "false પછી true"
            },
            {
              "icon": "",
              "label": "true પછી true"
            },
            {
              "icon": "",
              "label": "ખોટું પછી ખોટું"
            },
            {
              "icon": "",
              "label": "તે કમ્પાઇલ થતું નથી"
            }
          ]
        },
        {
          "question": "void show(Object o) { print(\"Object\"); } void show(String s) { print(\"String\"); } Object ref = \"hello\"; show(ref); કયો ઓવરલોડ ચાલશે, અને શા માટે?",
          "options": [
            {
              "icon": "",
              "label": "show(String), કારણ કે ઓબ્જેક્ટનો રનટાઇમ ક્લાસ String છે"
            },
            {
              "icon": "",
              "label": "show(Object), કારણ કે ઓવરલોડ જાહેર કરેલા પ્રકારમાંથી પસંદ કરવામાં આવે છે"
            },
            {
              "icon": "",
              "label": "એક પણ નહીં; કોલ અસ્પષ્ટ છે અને કમ્પાઇલ થતો નથી"
            },
            {
              "icon": "",
              "label": "બંને ચાલે છે, દરેક એકવાર, કારણ કે દરેક ઓવરલોડ મેચ થાય છે"
            }
          ]
        },
        {
          "question": "ક્લાસ Base માં static void greet() { print(\"Base\"); } છે. ક્લાસ Derived, Base ને એક્સટેન્ડ કરે છે અને static void greet() { print(\"Derived\"); } પણ જાહેર કરે છે. તમે લખો છો: Base ref = new Derived(); ref.greet(); શું પ્રિન્ટ થશે?",
          "options": [
            {
              "icon": "",
              "label": "Derived"
            },
            {
              "icon": "",
              "label": "તે કમ્પાઇલ થતું નથી"
            },
            {
              "icon": "",
              "label": "મૂળ"
            },
            {
              "icon": "",
              "label": "Base, પછી Derived"
            }
          ]
        },
        {
          "question": "એક મેથડની અંદર, તમે int count = 0; લખો છો અને પછી બીજી મેથડને પાસ કરેલા લેમ્બડાની અંદરથી count ને રેફરન્સ કરવાનો પ્રયાસ કરો છો. આ કમ્પાઇલ થાય તે માટે count વિશે શું સાચું હોવું જોઈએ?",
          "options": [
            {
              "icon": "",
              "label": "તે ફાઇનલ અથવા અસરકારક રીતે ફાઇનલ હોવું જોઈએ"
            },
            {
              "icon": "",
              "label": "કંઈ નહીં; કોઈપણ લોકલ કામ કરશે"
            },
            {
              "icon": "",
              "label": "તે volatile જાહેર થયેલું હોવું જોઈએ"
            },
            {
              "icon": "",
              "label": "તે ફીલ્ડ હોવું જોઈએ, લોકલ નહીં"
            }
          ]
        },
        {
          "question": "void rename(StringBuilder sb) { sb = new StringBuilder(\"new\"); } ને StringBuilder original = new StringBuilder(\"old\"); rename(original); તરીકે કોલ કરવામાં આવે છે. કોલ પછી original શું હશે?",
          "options": [
            {
              "icon": "",
              "label": "તે “new” છે"
            },
            {
              "icon": "",
              "label": "તે null છે"
            },
            {
              "icon": "",
              "label": "તે હજી પણ “old” છે"
            },
            {
              "icon": "",
              "label": "એક રનટાઇમ એક્સેપ્શન ફેંકાય છે"
            }
          ]
        },
        {
          "question": "એક ક્લાસમાં એક સ્ટેટિક ઇનિશિયલાઇઝર બ્લોક, એક ઇન્સ્ટન્સ ઇનિશિયલાઇઝર બ્લોક, અને એક કન્સ્ટ્રક્ટર છે, તે સોર્સ ક્રમમાં. તમે આ ક્લાસના બે ઓબ્જેક્ટ એક પછી એક બનાવો છો. આ કયા ક્રમમાં ચાલશે?",
          "options": [
            {
              "icon": "",
              "label": "સ્ટેટિક બ્લોક એકવાર; પછી, દરેક ઓબ્જેક્ટ માટે, ઇન્સ્ટન્સ બ્લોક પછી કન્સ્ટ્રક્ટર"
            },
            {
              "icon": "",
              "label": "દરેક ઓબ્જેક્ટ માટે, ત્રણેય સોર્સ ક્રમમાં ચાલે છે"
            },
            {
              "icon": "",
              "label": "દરેક ઓબ્જેક્ટ માટે, કન્સ્ટ્રક્ટર પછી ઇન્સ્ટન્સ બ્લોક; સ્ટેટિક બ્લોક અંતમાં એકવાર"
            },
            {
              "icon": "",
              "label": "દરેક ઓબ્જેક્ટ દીઠ એકવાર સ્ટેટિક બ્લોક, પછી ઇન્સ્ટન્સ બ્લોક, પછી કન્સ્ટ્રક્ટર"
            }
          ]
        },
        {
          "question": "એક ક્લાસમાં void log(String s) અને void log(String... args) છે. તમે log(\"hi\") ને કૉલ કરો છો. કયું ચાલશે?",
          "options": [
            {
              "icon": "",
              "label": "log(String... args)"
            },
            {
              "icon": "",
              "label": "એક કમ્પાઇલ એરર: કૉલ અસ્પષ્ટ છે"
            },
            {
              "icon": "",
              "label": "log(String s)"
            },
            {
              "icon": "",
              "label": "જે પણ ઓવરલોડ પહેલા જાહેર કરવામાં આવે છે"
            }
          ]
        },
        {
          "question": "એક કન્સ્ટ્રક્ટરની પ્રથમ લાઇન this(0); ને કૉલ કરે છે જેથી તે જ ક્લાસમાં બીજા કન્સ્ટ્રક્ટરને ડેલિગેટ કરી શકે. આ ક્યાં દેખાવાની મંજૂરી છે?",
          "options": [
            {
              "icon": "",
              "label": "બોડીમાં ગમે ત્યાં, કન્સ્ટ્રક્ટર રિટર્ન થાય તે પહેલાં"
            },
            {
              "icon": "",
              "label": "ફક્ત કન્સ્ટ્રક્ટરના પ્રથમ સ્ટેટમેન્ટ તરીકે"
            },
            {
              "icon": "",
              "label": "ફક્ત કન્સ્ટ્રક્ટરના છેલ્લા સ્ટેટમેન્ટ તરીકે"
            },
            {
              "icon": "",
              "label": "ફક્ત delegate કીવર્ડ સાથે ચિહ્નિત કન્સ્ટ્રક્ટરમાં"
            }
          ]
        },
        {
          "question": "તમારે એક એવી લિસ્ટની જરૂર છે જેમાં આગળના ભાગમાં ખૂબ જ વારંવાર એલિમેન્ટ્સ ઉમેરવામાં આવશે, અને રેન્ડમ-એક્સેસ રીડ્સ ભાગ્યે જ થાય છે. કયું વધુ સારું માળખાકીય ફિટ છે, અને શા માટે?",
          "options": [
            {
              "icon": "",
              "label": "ArrayList, કારણ કે તેની બેકિંગ એરે ફ્રન્ટ ઇન્સર્ટ્સને સૌથી ઝડપી બનાવે છે"
            },
            {
              "icon": "",
              "label": "કોઈપણ એક, કારણ કે બંને સમાન ગેરંટી સાથે List ને લાગુ કરે છે"
            },
            {
              "icon": "",
              "label": "LinkedList, કારણ કે ફ્રન્ટ ઇન્સર્શન O(n) ને બદલે O(1) છે"
            },
            {
              "icon": "",
              "label": "LinkedList, કારણ કે તે O(1) રેન્ડમ એક્સેસ આપે છે"
            }
          ]
        },
        {
          "question": "તમે એક સાદા HashMap માં ચોક્કસ ક્રમમાં પાંચ એન્ટ્રીઓ દાખલ કરો છો, પછી તેના પર for-each લૂપ સાથે ઇટરેટ કરો છો. એન્ટ્રીઓ કયા ક્રમમાં બહાર આવે છે?",
          "options": [
            {
              "icon": "",
              "label": "ઇન્સર્શન ક્રમ"
            },
            {
              "icon": "",
              "label": "કોઈ ગેરંટીકૃત ક્રમ નથી"
            },
            {
              "icon": "",
              "label": "કી દ્વારા સૉર્ટ કરેલ"
            },
            {
              "icon": "",
              "label": "વિપરીત ઇન્સર્શન ક્રમ"
            }
          ]
        },
        {
          "question": "એક સાદું java.util.HashMap એક સાથે કેટલી null કી અને કેટલી null વેલ્યુ રાખી શકે છે?",
          "options": [
            {
              "icon": "",
              "label": "કોઈ નલ કી અને કોઈ નલ વેલ્યુ નહીં"
            },
            {
              "icon": "",
              "label": "એક નલ કી, ગમે તેટલી નલ વેલ્યુ"
            },
            {
              "icon": "",
              "label": "ગમે તેટલી null કી અથવા વેલ્યુ"
            },
            {
              "icon": "",
              "label": "એક નલ કી અને એક નલ વેલ્યુ"
            }
          ]
        },
        {
          "question": "તમે for-each લૂપ સાથે List ને ઇટરેટ કરો છો અને લૂપ બોડીની અંદરથી સીધા લિસ્ટ પર list.remove(item) ને કૉલ કરો છો, કેટલાક પરંતુ બધા એલિમેન્ટ્સ પર નહીં. શું થાય છે?",
          "options": [
            {
              "icon": "",
              "label": "તે બરાબર ઇચ્છિત એલિમેન્ટ્સને દૂર કરે છે"
            },
            {
              "icon": "",
              "label": "તે તેમને દૂર કરે છે, પરંતુ લૂપ સમાપ્ત થયા પછી જ"
            },
            {
              "icon": "",
              "label": "તે IndexOutOfBoundsException ફેંકે છે"
            },
            {
              "icon": "",
              "label": "તે ConcurrentModificationException ફેંકે છે"
            }
          ]
        },
        {
          "question": "રનટાઇમ પર, List<String> list આપેલ હોય, તો તમે તેના જેનરિક ટાઇપ પેરામીટર વિશે રિફ્લેક્શન અથવા instanceof દ્વારા ખરેખર શું નક્કી કરી શકો છો?",
          "options": [
            {
              "icon": "",
              "label": "list.getElementType() String.class રિટર્ન કરે છે"
            },
            {
              "icon": "",
              "label": "instanceof List<String> એલિમેન્ટ ટાઇપ તપાસે છે"
            },
            {
              "icon": "",
              "label": "JVM તેને getGenericType() દ્વારા વાંચી શકાય તેવા મેટાડેટા તરીકે રાખે છે"
            },
            {
              "icon": "",
              "label": "એલિમેન્ટ ટાઇપ વિશે કંઈ નહીં"
            }
          ]
        },
        {
          "question": "switch (day) { case 1: case 2: print(\"Weekday\"); break; case 6: print(\"Saturday\"); case 7: print(\"Sunday\"); break; default: print(\"?\"); } જો day 6 હોય, તો શું પ્રિન્ટ થાય છે?",
          "options": [
            {
              "icon": "",
              "label": "ફક્ત Saturday"
            },
            {
              "icon": "",
              "label": "ફક્ત Sunday"
            },
            {
              "icon": "",
              "label": "Saturday, Sunday, પછી ?"
            },
            {
              "icon": "",
              "label": "Saturday, પછી Sunday"
            }
          ]
        },
        {
          "question": "એક Product ક્લાસને કિંમત દ્વારા એક જ, સ્પષ્ટ “નેચરલ” સૉર્ટ ઓર્ડરની જરૂર છે, ઉપરાંત કોડબેઝમાં જુદી જુદી જગ્યાએ નામ અથવા સ્ટોક લેવલ દ્વારા પણ સૉર્ટ કરવાની ક્ષમતા. કયું સંયોજન યોગ્ય ડિઝાઇન છે?",
          "options": [
            {
              "icon": "",
              "label": "Comparable<Product> ને ત્રણ અલગ અલગ વાર લાગુ કરો"
            },
            {
              "icon": "",
              "label": "કિંમત માટે Comparable, ઉપરાંત નામ અને સ્ટોક માટે અલગ Comparators"
            },
            {
              "icon": "",
              "label": "નામ માટે Comparable, ઉપરાંત કિંમત અને સ્ટોક માટે Comparators"
            },
            {
              "icon": "",
              "label": "ત્રણ ઓવરલોડેડ compareTo મેથડ્સ સાથે એક Comparable"
            }
          ]
        },
        {
          "question": "એક મેથડ new FileReader(path) ને કૉલ કરે છે, જે throws IOException જાહેર કરે છે. IOException એ Exception ને વિસ્તારે છે, RuntimeException ને નહીં. આને કમ્પાઇલ કરવા માટે તમારે શું કરવું જોઈએ?",
          "options": [
            {
              "icon": "",
              "label": "કંઈ નહીં; તે લખ્યા મુજબ કમ્પાઇલ થાય છે"
            },
            {
              "icon": "",
              "label": "IOException ને કેચ કરો અથવા throws IOException જાહેર કરો"
            },
            {
              "icon": "",
              "label": "કૉલની આસપાસ RuntimeException ને કેચ કરો"
            },
            {
              "icon": "",
              "label": "મેથડને static જાહેર કરો"
            }
          ]
        },
        {
          "question": "try (Resource a = new Resource(\"A\"); Resource b = new Resource(\"B\")) { ... } AutoCloseable લાગુ કરતા બે રિસોર્સનો ઉપયોગ કરે છે. જો try બ્લોક સામાન્ય રીતે સમાપ્ત થાય, તો તે કયા ક્રમમાં બંધ થાય છે?",
          "options": [
            {
              "icon": "",
              "label": "ઘોષણાના ક્રમમાં, A પછી B"
            },
            {
              "icon": "",
              "label": "પહેલા B, પછી A"
            },
            {
              "icon": "",
              "label": "બંને એક જ સમયે"
            },
            {
              "icon": "",
              "label": "ફક્ત B આપમેળે બંધ થાય છે"
            }
          ]
        },
        {
          "question": "int getValue() { try { return 1; } finally { return 2; } } getValue() ને કૉલ કરવાથી શું રિટર્ન થાય છે?",
          "options": [
            {
              "icon": "",
              "label": "1"
            },
            {
              "icon": "",
              "label": "તે એક એક્સેપ્શન ફેંકે છે"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "તે કમ્પાઇલ થતું નથી"
            }
          ]
        },
        {
          "question": "try { ... } catch (IOException e) { ... } catch (FileNotFoundException e) { ... }, અને FileNotFoundException એ IOException ને વિસ્તારે છે. જ્યારે તમે આને કમ્પાઇલ કરવાનો પ્રયાસ કરો છો ત્યારે શું થાય છે?",
          "options": [
            {
              "icon": "",
              "label": "અપ્રાપ્ય બીજા કેચ માટે કમ્પાઇલ એરર"
            },
            {
              "icon": "",
              "label": "તે કમ્પાઇલ થાય છે; FileNotFoundException બ્લોક તે ટાઇપને હેન્ડલ કરે છે"
            },
            {
              "icon": "",
              "label": "તે કમ્પાઇલ થાય છે, અને બંને કેચ બ્લોક ક્રમમાં ચાલે છે"
            },
            {
              "icon": "",
              "label": "તે કમ્પાઇલ થાય છે પરંતુ FileNotFoundException પર રનટાઇમ પર નિષ્ફળ જાય છે"
            }
          ]
        },
        {
          "question": "એક ક્લાસમાં એક સિંક્રોનાઇઝ્ડ ઇન્સ્ટન્સ મેથડ process() અને એક સિંક્રોનાઇઝ્ડ સ્ટેટિક મેથડ configure() છે. દરેક એક ખાસ કરીને શું લૉક કરે છે?",
          "options": [
            {
              "icon": "",
              "label": "process() ઇન્સ્ટન્સને લૉક કરે છે; configure() Class ઓબ્જેક્ટને લૉક કરે છે"
            },
            {
              "icon": "",
              "label": "બંને એક ગ્લોબલ JVM-વાઇડ લૉકને લૉક કરે છે"
            },
            {
              "icon": "",
              "label": "process() Class ઓબ્જેક્ટને લૉક કરે છે; configure() કૉલર ઇન્સ્ટન્સને લૉક કરે છે"
            },
            {
              "icon": "",
              "label": "બંને અંદર સિંક્રોનાઇઝ્ડ બ્લોક વિના કંઈપણ લૉક કરતા નથી"
            }
          ]
        },
        {
          "question": "એક ફીલ્ડ volatile int counter = 0; તરીકે જાહેર કરવામાં આવ્યું છે, અને બહુવિધ થ્રેડ્સ તેના પર એક સાથે counter++ ચલાવે છે. શું volatile અહીં ખોવાયેલા અપડેટ્સને અટકાવે છે?",
          "options": [
            {
              "icon": "",
              "label": "હા"
            },
            {
              "icon": "",
              "label": "No"
            },
            {
              "icon": "",
              "label": "ફક્ત int અને long ફીલ્ડ્સ માટે"
            },
            {
              "icon": "",
              "label": "ફક્ત જો ફીલ્ડ static પણ હોય"
            }
          ]
        },
        {
          "question": "ઇન્ટરફેસ A અને ઇન્ટરફેસ B દરેક એક ડિફોલ્ટ મેથડ describe() જાહેર કરે છે. એક ક્લાસ A અને B બંનેને લાગુ કરે છે અને describe() ને પોતે ઓવરરાઇડ કરતું નથી. શું થાય છે?",
          "options": [
            {
              "icon": "",
              "label": "A નું વર્ઝન ચાલે છે, કારણ કે A પહેલા લિસ્ટેડ છે"
            },
            {
              "icon": "",
              "label": "બંને વર્ઝન ચાલે છે, એક પછી એક"
            },
            {
              "icon": "",
              "label": "તે કમ્પાઇલ થાય છે પરંતુ કૉલ કરવામાં આવે ત્યારે એક્સેપ્શન ફેંકે છે"
            },
            {
              "icon": "",
              "label": "એક કમ્પાઇલ એરર સિવાય કે ક્લાસ describe() ને ઓવરરાઇડ કરે"
            }
          ]
        },
        {
          "question": "list.stream().filter(x -> x > 0).map(x -> x * 2); લખેલું છે પરંતુ પરિણામ ક્યારેય .collect() અથવા .forEach() જેવા ટર્મિનલ ઓપરેશનને સોંપવામાં આવતું નથી. જ્યારે આ લાઇન એક્ઝિક્યુટ થાય છે ત્યારે ખરેખર શું થાય છે?",
          "options": [
            {
              "icon": "",
              "label": "કંઈ નહીં; પાઇપલાઇન ક્યારેય ચાલતી નથી"
            },
            {
              "icon": "",
              "label": "દરેક એલિમેન્ટ તરત જ ફિલ્ટર અને મેપ થાય છે"
            },
            {
              "icon": "",
              "label": "ફક્ત ફિલ્ટર ચાલે છે; મેપ ટર્મિનલ ઓપરેશનની રાહ જુએ છે"
            },
            {
              "icon": "",
              "label": "તે IllegalStateException ફેંકે છે"
            }
          ]
        }
      ],
      "optionOrderVersion": "9d7b97ef6cccf4e2"
    }
  },
  "testNames": {
    "java-test": "જાવા ટેસ્ટ"
  }
}