{
  "assessmentTests": {
    "java_test": {
      "name": "ਜਾਵਾ ਪਰੀਖਿਆ",
      "desc": "ਮੂਲ ਸਿੰਟੈਕਸ, OOP ਮਕਾਨਿਕਸ, ਕਲੈਕਸ਼ਨ, ਜੈਨਰਿਕਸ, ਅਪਵਾਦ ਅਤੇ ਕੋਰੀਕ ਦੇ ਬਾਰੇ 30 ਸਿਨਾਰੀਓ ਸਵਾਲ — ਦਾ ਪਤਾ ਲਗਾਓ ਕਿ ਕੀ ਤੁਹਾਡਾ ਜਾਵਾ ਉਸ ਸਥਿਤੀ ਨਾਲ ਮਿਲਦਾ ਹੈ ਜੋ ਇੱਕ ਕੰਮ ਦੀ ਪੋਸਟਿੰਗ ਜਾਵਾ ਦਕਸ਼ਤਾ ਦਾ ਮਤਲਬ ਹੈ।",
      "recommendation": "ਤੁਹਾਡੀ ਜਾਵਾ ਹੁਨਰ ਪ੍ਰੋਫਾਈਲ",
      "results": {
        "beginner": {
          "name": "ਸ਼ੁਰੂਆਤੀ",
          "desc": "ਤੁਸੀਂ ਕੰਮ ਕਰਨ ਵਾਲੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਤਰੀਕੇ ਲਿਖ ਸਕਦੇ ਹੋ, ਪਰ ਜੋ ਸਵਾਲ ਤੁਸੀਂ ਗੁਆ ਦਿੱਤੇ ਆਨ ਸਿਰਫ਼ ਸਿੰਟੈਕਸ ਦੀ ਬਜਾਏ ਪਛਾਣ ਅਤੇ ਮੂਲ ਸ਼ਾਮਲ ਹੈ — String == vs .equals, ਨਿਆਰਾ ਕਿਉਂ String(\"x\") ਕਦੀ ਸਤਰ ਪੂਲ ਨੂੰ ਦੁਬਾਰਾ ਵਰਤ ਨਹੀਂ ਕਰਦਾ, ਨਿਆਰਾ ਸੰਖਿਆਤਮਕ ਖੇਤਰ ਬਨਾਮ ਰੈਪਰ ਖੇਤਰ ਕੀ ਮੂਲ ਹੈ। ਇਹ ਭਾਵ ਜਾਵਾ 'ਤੇ ਗ਼ਰੀਬ ਹੋਣਾ ਨਹੀਂ ਹੈ; ਇਹ ਖਾਸ ਨਿਯਮ ਹਨ ਜੋ ਉਹਨਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨੇ ਜਾਵਾ ਸਿਖਲਾ ਪ੍ਰਯਾਸ ਅਤੇ ਗਲਤੀ ਦੁਆਰਾ ਸਿਖਲਾ ਹੈ ਬਜਾਏ ਇਸ ਤਰ੍ਹਾਂ ਹੁੰਦਾ ਹੈ ਕਿ ਸੰਦਰਭ ਅਤੇ ਕੱਚੇ ਅਸਲ ਵਿੱਚ ਕਿ ਬਿਨਾ ਸ਼ਾਮਲ ਸੰਚਾਲਿਤ ਕਰਦਾ ਹੈ। ਪਰ ਇਹ ਕੰਮ 'ਤੇ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ ਕਿਉਂਕਿ ਹਰ ਇੱਕ ਕੋਡ ਕੰਪਾਇਲ, ਚਲਾਇਆ, ਅਤੇ ਸ਼ਾਮੱਤ ਗਲਤ ਕੀ ਗਲਤ ਕਰਨ ਲਾ ਸ਼ਾਮਿਤ ਹੈ।",
          "recommendation": "ਇਸ ਕ੍ਰਮ ਵਿੱਚ ਤਿੰਨ ਗੱਲਾਂ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ: ਦੋ String ਆਬਜੈਕਟਾਂ 'ਤੇ == ਕਿਉਂ ਅੱਖਰਾਂ ਦੀ ਨਹੀਂ ਸਗੋਂ ਸੰਦਰਭ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ (ਅਤੇ .equals ਉਹ ਹੈ ਜਿਸਦੀ ਤੁਹਾਨੂੰ ਲਗਭਗ ਹਮੇਸ਼ਾ ਲੋੜ ਹੁੰਦੀ ਹੈ), int ਓਵਰਫਲੋ ਗਲਤੀ ਸੁੱਟਣ ਦੀ ਬਜਾਏ ਚੁੱਪਚਾਪ ਕਿਵੇਂ ਪਲਟ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਬਿਨਾਂ ਸ਼ੁਰੂ ਕੀਤਾ Integer ਖੇਤਰ null ਕਿਉਂ ਹੁੰਦਾ ਹੈ ਜਦਕਿ int ਖੇਤਰ 0 ਹੁੰਦਾ ਹੈ। Oracle ਦੇ ਅਧਿਕਾਰਤ ਜਾਵਾ ਟਿਊਟੋਰੀਅਲ ਅਤੇ Baeldung ਦੋਵੇਂ ਚੱਲਣਯੋਗ ਉਦਾਹਰਣਾਂ ਨਾਲ ਤਿੰਨੋਂ ਗੱਲਾਂ ਨੂੰ ਕਵਰ ਕਰਦੇ ਹਨ।"
        },
        "intermediate": {
          "name": "ਮੱਧਮਾਨ",
          "desc": "ਤੁਸੀਂ ਰੋਜ਼ ਅਪਲਿਕੇਸ਼ਨ ਕੋਡ ਆਰਾਮ ਨਾਲ ਸੰਭਾਲਿਆ — ਕਲਾਸਾਂ, ਕਲੈਕਸ਼ਨ, ਸਥਿਰ ਨਿਯੰਤ੍ਰਣ ਵਹਾਓ — ਅਤੇ ਰੁਟੀਨ ਫਿਚਰ ਕੰਮ ਦੁਆਰਾ ਸਮੀ ਸ਼ਾਮਤ ਸਵਿਚ ਵਿਚਕਾਰ ਫਾਸਲਾ ਇਸ ਅਸਲ ਪਾ ਰਕਾ ਹੈ ਜੋ ਜਾਵਾ ਦਿਆ ਬੀ ਰਿਪੀ ਸਮਸਤੇ ਅਤੇ ਜੈਨਰਿਕਸ: ਸ਼ਾਮਲ ਰੂਪ ਘਾਮਿਤ ਬਕਾਇਆ ਆਬਜੈਕਟ ਤੁਸੀਂ ਉਮੀਦ ਕਰਦੇ ਹੋ ਦੀ ਜਗਾ, ਨੀ HashMap ਦਾ ਸ਼ੁਮਸ਼ਾਸਲ ਨਿਯਮ ਤੁਮ ਖਾਮੋਸ਼ ਦੁਆਰਾ ਭੂਮਰ, ਨੀ ਅ ConcurrentModificationException ਅ ਹਟਾਕ ਸ਼ੀ ਲਪ ਬਰਾਬਰ। ਇਹਨਾਂ ਬੀ ਉਹ ਤਰਾਂ ਦੀ ਬੁਰੀ ਆ ਜੋ ਇੱਕ ਤੇਜ ਪੜ੍ਹਮਲੀ ਪਾ ਸਕਦੇ ਹਨ ਅਤੇ ਸਿਰਫ ਇੱਕ ਖਾਸ ਰਟਰਾ ਵਖ ਹੇਠ ਜ਼ਾਹਿਰ ਮੋ।",
          "recommendation": "ਮਾਇਨਾ ਕਿਵੇਂ ਕਮਪਲਲਰ ਕੇ ਸਟੈਟਿਕ ਨਨਜ਼ਰ ਆਬਜੈਕਟ ਤੋਂ ਬੁੰਦੇ ਹੈ: ਓਰਲੋਡ ਸਲਾਹ ਅਤੇ ਘਾਮਿਤ-ਖੁਸ਼ੀ ਲੁਕਾ ਬਕਾਇਆ ਘਾਮਿਤ ਨਹੀਂ ਬਲਕਿ ਰਟਾ ਤਰ ਦੀ ਬਜਾਏ, ਨਿਆਰਾ HashMap ਕੋਈ ਸ਼ੁਮਸ਼ਾਸਲ-ਨਿਯਮ ਨਿਆਸ ਨਹੀਂ ਦਿੰਦਾ, ਅਤੇ ਨਿਆਰਾ ਸਿੱਧੇ ਲਿਸਟ ਦੀਬਾਕ ਕਰ ਸਬਵਕਸ਼ ਨਿਰ੍ਬਕਰਾ ਚਾਲੀ ਥ੍ਰੋ ਕਰਦਾ ਹੈ। ਫਿਰ ਜੈਨਰਿਕਸ ਮਿਭਾਲ, ਖਤਰੇ ਜਾਂ ਆਬਰ ਜੋ ਪਹਿਲਾਂ ਕਲੈਕਸ਼ਨ ਜਾਣਦੇ ਹਨ।"
        },
        "advanced": {
          "name": "ਉਨਤ",
          "desc": "ਇਹ ਪੱਧਰ ਹੈ ਜਦ ਜ਼ਿਆਦਾ ਕੰਮ ਪੋਸਟਿਂਗ ਦਾ ਮਤਲਬ ਹੈ \"ਮਜ਼ਬੂਤ Java।\" ਤੁਸੀਂ ਪੜ੍ਹਦੇ ਹੋ ਸਥਿਰ ਬਲੋਕ, ਵਾਕਯੀ ਬਲੋਕ ਅਤੇ ਕਈ ਨਿਰ੍ਮਾਣਕਾਰ ਦੀ ਇੱਕ ਕਲਾਸ ਅਤੇ ਕਿ ਸਮਾਨ ਤਕ ਦੀ ਰੁੱਝਦਾ ਹੈ, ਤੁਸੀਂ ਜਾਣਦੇ ਕਿਉਂ ਫਿਕ ਬਲੌਕ ਖਾਮੋਸ਼ ਰਾ ਸਕਦਾ ਹੈ ਟਰਾਈ ਬਲਾਕ ਦੀ ਆਰਮੀ ਮੁੱਲ, ਅਤੇ ਜੋ ਹਾਥ-ਦੂਬਾਰਾ-ਸੰਸਾਧਨਾਂ ਬਜਾਏ ਵੀ ਮੁਨੀਰ-ਫਿਕ-ਬੰਦ ਕਿਉਂ ਜਾਣਦੇ ਹੋ ਜੋ ਤਕ ਗੋਟ ਦਿੱਤਾ। ਕੋਈ ਸਮਾਤ ਬੈਂਡ ਈ-ਰਿਸਪੈਸ ਟਾਪ ਦੀ ਹਾਂ ਸਾਇਬਰ ਹੈ ਅਤੇ ਈਂਟਰਫੇਸ-ਪੱਧਰ ਭਾਗ ਦਾ ਕਰਮ: ਕੀ ਸੀਡ ਵਾਸਤਵ ਮਿੱਟੀ, ਕੀ ਅਸਥਿਰ ਕਰਦਾ ਹੈ ਅਤੇ ਕਰਨ ਨਹੀਂ ਵਿਸ਼ਾਸ, ਅਤੇ ਨਿਆਰਾ ਸਹੀ ਵਿਧਿ ਹੀਰਾ ਸੁਲਝਾਇਆ।",
          "recommendation": "ਕੋਡ ਦੂਜੇ ਸੂਲ ਅਤੇ ਦੂਜੇ ਈਂਟਰਫੇਸ ਮੂ ਹਿੱਸਿਆਂ ਆਵਾ: ਸਮਾਤ ਵਾਕਯੀ ਤਰੀਕਿਆ ਬਨਾਮ ਆਖ ਸਥਿਰ ਤਰੀਕਿਆ ਕੀ ਅਰਰ ਬਲੌਕ, ਨਿਆਰਾ ਅਸਥਿਰ ਦਿੱਤੀਆਂ ਲੇਕਿਨ ਪ੍ਰਮਾਣੀਕਰਣ ਲੰਬਾ ++, ਅਤੇ ਜਾਵਾ ਇੱਕ ਸਪਸ਼ਟ-ਮਾਨਸਿਕ ਮੁਟਾ ਸੁਲਝਾਪ ਆਪ ਦੁਆਰਾ ਦੀਬਾ। Baeldung ਅਤੇ Java Concurrency ਮਾਨਸਿਕ ਦਾ ਸਮੱਗਰੀ Java Memory Model ਦੇ ਦਾ ਕੁਦਰਤੀ ਅਗਲੀ ਮਰਰ ਕਰਦਾ ਹੈ।"
        },
        "expert": {
          "name": "ਮਾਹਿਰ",
          "desc": "ਤੁਸੀਂ ਉਰਯੁ ਸਕਿਲਡ ਸਰਵ-ਮੂਲ ਸਿੰਟੈਕਸ ਅਤੇ ਕਿਸਮ, OOP ਮਕਾਨਿਕਸ ਅਤੇ ਖੇਤਰ, ਕਲੈਕਸ਼ਨ ਅਤੇ ਜੈਨਰਿਕਸ, ਅਤੇ ਅਪਵਾਦ, ਕੀ, ਅਤੇ ਚਮਤ। ਵਿਹਾਰਿਕ ਰੂਪ ਸੇ, ਮਤਲਬ ਆਬ ਸਥਿਰ ਪਠਨ ਸਕਾ ਅਤੇ ਖੁਲਕ ਕੰਪਾਈਲ ਗਲਤੀ, ਨਿਅਲ ਪਨਮਤਲਵ ਅਦਾ, ਜਾਂ ਖਾਮੋਸ਼ ਗਲਤ ਮੂਲ ਸੂ, ਜਿਸ ਹੈ ਮੁਸ਼ਕਲ ਹੈ ਅਤੇ ਵਧੇਰਾ ਬਾਹੀ। ਇੰਨਤੌ ਵਿੱਚ ਸ਼ਬਦ ਸ਼ਾਮ ਦੀ ਇੱਕ ਅਲੰਕਰਣ ਨਿਰਧਾਰਤ ਨਾਰਦ; ਸੀਮਾ ਸ਼ਾਮ ਸਮਪਤੀ ਜਾਂ ਮੂਲ ਸੰਗਰਹ ਆਸ।",
          "recommendation": "ਰਿਟਰਨ ਹੋ ਖੁਸ਼ੀ ਅਤੇ ਤਾਜ਼ਾ: ਪੜ੍ਹਮਲੀ ਖੁਸ਼ੀ ਡੰਪ ਇਛ ਹੈ ਜੋ ਸ਼ਾਮੁਕ ਜੰਟ ਅਸਥਿਰ, java.util.concurrent ਰੁਕਾ ਅਤੇ ਪਰਮਾਣਾ ਹੁਤਾ ਨਿਯੰਤ ਤੁਹਾਡੇ ਪਛਲੇ, ਸਮ ਤੁਹਾਡੇ ਸੌ ਪੜ੍ਹਕਰ ਇਸ ਅਵੱਲ ਮਾਤ ਯਾਦ ਵਿਲਕੁਲ ਤੁਸੀਂ ਫਿਨਲ ਦੋ ਡੰਪ ਵਿਅਕਤਿਗਤ ਇੱਕ ਜਾਂ ਕੌਨਕਰਸ ਰਿਬੱਬ ਮੁਟਾ ਤੁਹਾਡੇ ਪਛਲੇ ਬਰਤਰਫ਼ ਮਿੱਡ ਦਿੱਤਾ, ਜਿਸ ਸਵਾਲ ਸਵਾਲ ਨਹੀਂ, ਅਤੇ ਸ਼ਬਦ ਖਾ-ਠਲੀ ਡਿਜ਼ਾਈਨ ਜਗ ਲਾਜ਼ ਬਜਾਏ ਮਾਮਲਾ ਦ੍ਰਿ ਲੋੱਛ।"
        }
      },
      "questions": [
        {
          "question": "ਤੁਸੀਂ ਦੋ String ਆਬਜੇਕਟ ਬਣਾਉਂਦੇ ਹੋ: String a = new String(\"cat\"); String b = new String(\"cat\"); a == b ਕੀ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "true — ਇਕੋ ਇੱਕ ਅੱਖਰਾਂ ਵਾਲੀਆਂ String ਲਿਟਰਲ ਹਮੇਸ਼ਾ ਇੱਕ ਪਦਾਰਥ ਹਨ"
            },
            {
              "icon": "",
              "label": "true — new String(...) string pool ਨੂੰ ਮੁੜ ਵਰਤਦਾ ਹੈ, ਇਸਲਈ ਇਕੋ ਸ਼ਬਦ ਹਮੇਸ਼ਾ ਇੱਕ ਪਦਾਰਥ ਸਾਂਝਾ ਕਰਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ compile error — == String ਆਬਜੇਕਟਾਂ ਦੀ ਤੁਲਨਾ ਲਈ ਨਹੀਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ"
            },
            {
              "icon": "",
              "label": "false — new String(...) heap 'ਤੇ ਹਮੇਸ਼ਾ ਇੱਕ ਨਵਾਂ ਪਦਾਰਥ allocate ਕਰਦਾ ਹੈ, ਇਸਲਈ == ਦੋ ਵੱਖਰੇ ਸੰਦਰਭ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਭਾਵੇਂ .equals(b) ਸੱਚ ਵਾਪਸ ਕਰਾ"
            }
          ]
        },
        {
          "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 — autoboxed Integer ਪਦਾਰਥ ਹਮੇਸ਼ਾ ਮੁੱਲ ਚਾਹੇ ਕਾ ਪੁੱਛੋ"
            },
            {
              "icon": "",
              "label": "false ਤਾਂ false — Integer ਆਬਜੇਕਟਾਂ 'ਤੇ == ਹਮੇਸ਼ਾ ਸੰਦਰਭ ਤੁਲਨਾ ਹੈ, ਇਸਲਈ ਬਰਾਬਰ ਮੁੱਲ ਕਦੀ ਮੇਲ ਨਹੀਂ ਖਾਣ"
            },
            {
              "icon": "",
              "label": "true ਤਾਂ false, ਪਰ ਸਿਰਫ ਕਿਉਂਕਿ 200 ਇੱਕ byte ਤੱਕ overflow ਕਰਦਾ ਹੈ — cache ਸੀਮਾ -128..127 ਤੱਕ ਸੰਬੰਧ ਨਹੀਂ ਕਰਦੀ"
            },
            {
              "icon": "",
              "label": "true ਤਾਂ false — autoboxed Integer ਮੁੱਲ -128 ਤੋਂ 127 ਤੱਕ cached ਹਨ ਅਤੇ shared ਹਨ, ਇਸਲਈ 100 ਇੱਕ ਪਦਾਰਥ ਮੁੜ ਵਰਤਦਾ ਹੈ, ਪਰ 200 cache ਤੋਂ ਬਾਹਰ ਹੈ ਅਤੇ ਦੋ ਵੱਖਰੇ ਪਦਾਰਥਾਂ ਵਿੱਚ autobox ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "int max = Integer.MAX_VALUE; System.out.println(max + 1); ਕੀ ਹੁੰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਇਹ integer overflow ਲਈ ਇੱਕ ArithmeticException ਚਲਾਉਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ Integer.MAX_VALUE ਨੂੰ ਮੁੜ ਛਾਪਦਾ ਹੈ, ਕਿਉਂਕਿ Java ਕਿਸਮ ਦੀ ਵੱਧ ਤਰ੍ਹਾਂ clamp ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ Integer.MIN_VALUE ਛਾਪਦਾ ਹੈ — int ਗਣਿਤ ਸ਼ਾਂਤ ਨਾਲ overflow ਤੇ wrap ਕਰਦਾ ਹੈ throw ਕਰਨ ਦੀ ਬਜਾਏ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਇੱਕ compile error ਹੈ — compiler overflow ਨੂੰ ਅਗਾਂਹ ਚਿਨ ਲੈਂਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "System.out.println(0.1 + 0.2 == 0.3); ਇਹ ਕੀ ਛਾਪਦਾ ਹੈ, ਅਤੇ ਕਿਉਂ?",
          "options": [
            {
              "icon": "",
              "label": "false — 0.1, 0.2 ਅਤੇ 0.3 ਬਾਈਨਰੀ floating point ਵਿੱਚ ਬਿਲਕੁਲ represent ਨਹੀਂ ਹੋ ਸਕਦੇ, ਇਸਲਈ sum ਰਾਉਂਡਿੰਗ ਗ਼ਲਤੀ ਰੱਖਦਾ ਹੈ ਜੋ 0.3 ਨੂੰ bit-for-bit ਬਰਾਬਰ ਨਹੀਂ ਬਣਾਉਂਦਾ"
            },
            {
              "icon": "",
              "label": "true — Java double ਗਣਿਤ ਨੂੰ nearest representable decimal ਵਿੱਚ round ਕਰਦਾ ਹੈ ਤੁਲਨਾ ਤੋਂ ਪਹਿਲਾਂ"
            },
            {
              "icon": "",
              "label": "true — ਦੋ decimals ਵਾਲੀ ਕਿਸਮ ਦੇ ਮੁੱਲਾਂ ਦਾ ਜੋੜ ਹਮੇਸ਼ਾ ਸਹੀ ਹੁੰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਇੱਕ exception ਚਲਾਉਂਦਾ ਹੈ, ਕਿਉਂਕਿ == Java ਵਿੱਚ double ਲਈ define ਨਹੀਂ ਹੈ"
            }
          ]
        },
        {
          "question": "ਇੱਕ ਕਲਾਸ ਦੋ instance ਖੇਤਰ declare ਕਰਦੀ ਹੈ initializer ਤੱਕ: int count; ਅਤੇ Integer total; Constructor ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ, ਉਨ੍ਹਾਂ ਦੀਆਂ default ਹਨ ਕੀ?",
          "options": [
            {
              "icon": "",
              "label": "ਦੋਨੋਂ 0 ਵਿੱਚ default, ਕਿਉਂਕਿ Integer field initialization 'ਚ int ਵਿੱਚ autobox ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "count 0 ਹੈ ਅਤੇ total 0 ਹੈ, ਪਹਿਲੀ ਵਾਰ ਪੜ੍ਹੇ ਜਾ ਪੋ ਤੱਕ boxed"
            },
            {
              "icon": "",
              "label": "count 0 ਹੈ ਅਤੇ total null ਹੈ — primitive ਸੰਖਿਆ ਖੇਤਰ zero ਵਿੱਚ default ਹਨ, ਪਰ ਇੱਕ uninitialized wrapper ਸੰਦਰਭ ਖੇਤਰ ਕਿਸੇ ਹੋਰ ਆਬਜੇਕਟ ਸੰਦਰਭ ਵਾਂਗ null ਵਿੱਚ defaults"
            },
            {
              "icon": "",
              "label": "ਦੋਨੋਂ null ਵਿੱਚ default ਹਨ ਜਦ ਤੱਕ explicitly assign ਨਹੀਂ ਕਰਿਆ, ਕਿਉਂਕਿ Java ਕੋਲ implicit ਸੰਖਿਆ defaults ਨਹੀਂ ਹਨ"
            }
          ]
        },
        {
          "question": "ਇੱਕ loop 1000 ਵਾਰ ਚੱਲਦਾ ਹੈ, ਹਰ ਵਾਰ result += \"x\"; ਕਰਦਾ ਹੈ ਇੱਕ String result 'ਤੇ। ਹਰ iteration ਵਿੱਚ hood ਅਧੀਨ ਅਸਲੀ ਕੀ ਹੁੰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਪਿਛਲੇ String ਪਦਾਰਥ ਦੀ ਅੰਦਰਲੀ character array ਨੂੰ ਥਾਂ 'ਤੇ extend ਕਿਆ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "Java automatically ਸੰਚਰਣ ਨੂੰ batch ਕਰਦਾ ਹੈ ਅਤੇ ਸਿਰਫ ਇੱਕ final String ਪਦਾਰਥ allocate ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਇੱਕ ਸਿੰਗਲ StringBuilder.append() ਕਾਲ ਵਿੱਚ compile ਹੁੰਦਾ ਹੈ ਸਾਰੇ 1000 iterations ਵਿੱਚ shared, ਹਰ iteration ਵਿੱਚ ਕੋਈ ਵਾਧਾ ਪਦਾਰਥ allocated ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ ਬਿਲਕੁਲ ਨਵਾਂ String ਪਦਾਰਥ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ result ਨੂੰ ਇਸ ਵੱਲ ਮੁੜ ਨਿਰਦੇਸ਼ਿਤ ਕਰਿਆ ਜਾਂਦਾ ਹੈ — ਪਿਛਲਾ String ਪਦਾਰਥ discarded ਹੈ, ਕਿਉਂਕਿ String immutable ਹੈ ਅਤੇ += ਇਸ ਨੂੰ ਥਾਂ 'ਤੇ modify ਨਹੀਂ ਕਰ ਸਕਦਾ"
            }
          ]
        },
        {
          "question": "final List<String> names = new ArrayList<>(); ਇਨ੍ਹਾਂ 'ਚੋਂ ਕਿਹੜਾ ਸੱਚ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "names.add(\"Ana\") compile ਹੁੰਦਾ ਹੈ ਅਤੇ ਬਿਲਕੁਲ ਕੰਮ ਕਰਦਾ ਹੈ — final ਸਿਰਫ names ਸੰਦਰਭ ਨੂੰ reassign ਕਰਨ ਤੋਂ ਰੋਕਦਾ ਹੈ, ਇਸ ਨੂੰ ਦੱਸਣ ਵਾਲੇ ਪਦਾਰਥ ਨੂੰ mutate ਕਰਨ ਤੋਂ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "names.add(\"Ana\") ਇੱਕ compile error ਹੈ, ਕਿਉਂਕਿ final ਸੂਚੀ ਨੂੰ ਆਪ ਵਧੀ ਅਯੋਗ ਬਣਾ ਦੇਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਸੂਚੀ concurrent writes ਲਈ thread-safe ਹੈ ਕਿਉਂਕਿ ਇਸ ਨੂੰ final declare ਕਰਿਆ ਗਿਆ ਸੀ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ local ਵੇਰੀਏਬਲ 'ਤੇ final ਦਾ ਕੋਈ ਪ੍ਰਭਾਵ ਨਹੀਂ ਹੈ ਜਦ ਤੱਕ ਕਿਸਮ ਆਪ ਵੀ immutable ਨਹੀਂ ਹੈ"
            }
          ]
        },
        {
          "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 — == array ਸੰਦਰਭਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ (ਦੋ ਵੱਖਰੇ array ਪਦਾਰਥ), ਜਦੋਂ Arrays.equals ਤੱਤਾਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "true ਤਾਂ true — arrays ਬਰਾਬਰ ਸਮੱਗਰੀ ਨੂੰ Java ਵਿੱਚ ਇੱਕ ਪਦਾਰਥ ਹਨ"
            },
            {
              "icon": "",
              "label": "false ਤਾਂ false — Arrays.equals ਸਿਰਫ ਆਬਜੇਕਟ arrays ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ, primitive int arrays ਲਈ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "true ਤਾਂ false — arrays 'ਤੇ == ਸਮੱਗਰੀ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ, ਅਤੇ Arrays.equals ਬੇ ਮਤਲਬ ਹੈ"
            }
          ]
        },
        {
          "question": "void show(Object o) { print(\"Object\"); } void show(String s) { print(\"String\"); } Object ref = \"hello\"; show(ref); ਕਿਹੜਾ overload ਚੱਲਦਾ ਹੈ, ਅਤੇ ਕਿਉਂ?",
          "options": [
            {
              "icon": "",
              "label": "show(String) ਚੱਲਦਾ ਹੈ, ਕਿਉਂਕਿ Java overload pick ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਪਦਾਰਥ ਦੀ actual runtime ਕਲਾਸ ਨੂੰ inspect ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "show(Object) ਚੱਲਦਾ ਹੈ — overload resolution ਬਣ ਸਮੇਂ ਵੇਰੀਏਬਲ ਦੀ declared ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਦੁਆਰਾ decide ਹੁੰਦਾ ਹੈ, actual runtime ਪਦਾਰਥ ਦੀ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਇੱਕ compile error ਹੈ — Object ਜਿੱਥੇ ਵਧੇਰੇ specific overload ਹੈ ਉੱਥੇ pass ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ"
            },
            {
              "icon": "",
              "label": "ਦੋਨੋਂ ਵਿਧੀਆਂ ਚੱਲਦੀਆਂ ਹਨ, ਹਰ ਇੱਕ ਵਾਰ, ਕਿਉਂਕਿ Java ਹਰ match ਨੂੰ ਕੋਸ਼ਿਸ਼ ਕਰਕੇ overloads ਨੂੰ resolve ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "Class Base ਕੋਲ static void greet() { print(\"Base\"); } ਹੈ। Class Derived Base ਤੋਂ extends ਕਰਦੀ ਹੈ ਅਤੇ static void greet() { print(\"Derived\"); } ਵੀ declare ਕਰਦੀ ਹੈ। ਤੁਸ ਲਿਖਦੇ ਹੋ: Base ref = new Derived(); ref.greet(); ਕੀ ਪ੍ਰਿੰਟ ਹੁੰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "Derived — static ਵਿਧੀਆਂ instance ਵਿਧੀਆਂ ਵਾਂਗ override ਕਰਦੀਆਂ ਹਨ, actual ਪਦਾਰਥ ਦੀ runtime ਕਿਸਮ ਦੀ ਪਾਲਣਾ ਕਰਦੀਆਂ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਇੱਕ compile error ਹੈ — static ਵਿਧੀਆਂ ਇੱਕ instance ਸੰਦਰਭ ਦੇ ਜ਼ਰੀਏ ਕਾਲ ਨਹੀਂ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ"
            },
            {
              "icon": "",
              "label": "Base — static ਵਿਧੀਆਂ polymorphic ਨਹੀਂ ਹਨ; ਇੱਕ ਸੰਦਰਭ ਦੇ ਜ਼ਰੀਏ ਇੱਕ ਕੋ resolve ਪਾਈ ਸਮੀ ਸੰਦਰਭ ਦੀ ਘੋਸ਼ਿਤ ਕਿਸਮ ਦੁਆਰਾ, ਪਦਾਰਥ ਦੀ actual ਕਿਸਮ ਨਾ"
            },
            {
              "icon": "",
              "label": "Base ਅਤੇ Derived ਦੋਵੇਂ ਪ੍ਰਿੰਟ ਹੁੰਦੇ ਹਨ, ਕਿਉਂਕਿ ਕਾਲ hidden ਅਤੇ hiding ਦੋਨਾਂ ਸੰਸਕਰਣਾਂ ਵਿੱਚ resolve ਹੁੰਦੀ ਹੈ"
            }
          ]
        },
        {
          "question": "ਇੱਕ ਵਿਧੀ ਦੇ ਅੰਦਰ, ਤੁਸ ਲਿਖਦੇ ਹੋ int count = 0; ਤਾਂ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ ਕਿ count ਨੂੰ ਇੱਕ lambda ਤੋਂ ਅੰਦਰ reference ਕਰੋ ਜੋ ਕਿ ਕਿਸੇ ਹੋਰ ਵਿਧੀ ਵਿੱਚ pass ਕਰਿਆ ਗਿਆ ਹੈ। count ਦੇ ਬਾਰੇ ਵਿੱਚ compile ਕਰਨ ਲਈ ਸੱਚ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "count ਪ੍ਰਭਾਵੀ ਤੌਰ 'ਤੇ final ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ — ਸ਼ੁਰੂਆਤੀ ਮੁੱਲ ਤੋਂ ਬਾਅਦ ਕਦੀ reassign ਨਹੀਂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ — ਕਿਉਂਕਿ ਇੱਕ lambda ਇੱਕ snapshot capture ਕਰਦਾ ਹੈ, ਇੱਕ mutable local ਵੇਰੀਏਬਲ ਵਿੱਚ live ਸੰਦਰਭ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "ਕੁਝ ਵੀ ਨਹੀਂ — ਕਿਸੇ ਵੀ local ਵੇਰੀਏਬਲ ਨੂੰ ਲਾਮਿਸ ਅੰਦਰ ਖੁੱਲ੍ਹਾ ਪੜ੍ਹਿਆ ਅਤੇ reassign ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "count ਨੂੰ volatile ਦੇ ਰੂਪ ਵਿੱਚ declare ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਤਾ ਕਿ lambda ਹਮੇਸ਼ਾ ਇਸ ਦੀ ਵਰਤਮਾਨ ਮੁੱਲ ਵੇਖੇ"
            },
            {
              "icon": "",
              "label": "count ਇੱਕ ਖੇਤਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, local ਵੇਰੀਏਬਲ ਨਹੀਂ — lambdas ਸਰਵ ਲਾਕਾਲ ਨਹੀਂ ਕਰ ਸਕਦੇ"
            }
          ]
        },
        {
          "question": "void rename(StringBuilder sb) { sb = new StringBuilder(\"new\"); } ਕੋ StringBuilder original = new StringBuilder(\"old\"); rename(original); ਕਾਲ ਕਿਤਾ ਜਾਂਦਾ ਹੈ। ਕਾਲ ਦੇ ਬਾਅਦ original ਕੀ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "\"new\" ਵਿੱਚ ਬਦਲਦਾ ਹੈ — ਪਦਾਰਥ Java ਵਿੱਚ reference ਦੁਆਰਾ pass ਕਿਏ ਜਾਂਦੇ ਹਨ, ਇਸਲਈ ਪੈਰਾਮੀਟਰ ਨੂੰ reassign ਕਰਨਾ caller ਦੀ ਵੇਰੀਏਬਲ ਨੂੰ ਵੀ ਬਦਲਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "\"new\" ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਸਿਰਫ mutable ਕਿਸਮਾਂ ਲਈ StringBuilder ਦੇ ਵਰਗ, ਪਰ immutable ਕਿਸਮਾਂ ਲਈ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "ਅਜੇ \"old\" — Java ਸੰਦਰਭ ਨੂੰ ਆਪ value ਦੁਆਰਾ pass ਕਰਦਾ ਹੈ, ਇਸਲਈ ਵਿਧੀ ਅੰਦਰ ਪੈਰਾਮੀਟਰ ਨੂੰ reassign ਕਰਨਾ ਸਿਰਫ ਸੰਦਰਭ ਦੀ ਸਥਾਨਕ ਕਾਪੀ ਨੂੰ repoint ਕਰਦਾ ਹੈ, caller ਦੇ original ਨੂੰ ਬਰਕਰਾਰ ਛੱਡ ਕੇ"
            },
            {
              "icon": "",
              "label": "Runtime exception ਪਾਉਂਦਾ ਹੈ, ਕਿਉਂਕਿ sb ਵਿਧੀ ਅੰਦਰ reassign ਕਰਿਆ ਗਿਆ ਸੀ"
            }
          ]
        },
        {
          "question": "ਇੱਕ ਕਲਾਸ ਕੋਲ ਸਥਿਤਿ initializer ਬਲਾਕ, ਇੱਕ instance initializer ਬਲਾਕ, ਅਤੇ ਇੱਕ constructor ਹੈ, ਆਸ ਆਰਡਰ ਵਿੱਚ। ਤੁਸ ਪਿਛੀ ਅੱਧੀ ਤਲ ਦੀ ਚਾਲ ਬਣਾਅ। ਇਨ੍ਹਾਂ ਕੀ ਆਰਡਰ ਵਿੱਚ ਚਲਦੀਆਂ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "Static ਬਲਾਕ ਬਿਲਕੁਲ ਇੱਕ ਵਾਰ ਚੱਲਦਾ ਹੈ, ਪਹਿਲੀ ਵਾਰ ਜਦੋਂ ਕਲਾਸ load ਹੋਵੇ; ਫਿਰ ਹਰ ਪਦਾਰਥ ਲਈ, instance ਬਲਾਕ ਚੱਲਦਾ ਹੈ ਅਤੇ ਫਿਰ constructor body ਚੱਲਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਤਿਨੋਂ ਤਾਜ਼ਾ, ਉਤਸ਼ ਆਰਡਰ ਵਿੱਚ, ਹਰ ਪਦਾਰਥ ਬਣਾਇਆ ਗਿਆ ਹਰ ਲਈ ਚੱਲਦੀਆਂ ਹਨ"
            },
            {
              "icon": "",
              "label": "Constructor ਹਰ ਪਦਾਰਥ ਲਈ ਪਹਿਲਾ ਚੱਲਦਾ ਹੈ, ਫਿਰ instance ਬਲਾਕ, ਤਾਂ static ਬਲਾਕ ਬਿਲਕੁਲ ਅੰਤ ਵਿੱਚ ਇੱਕ ਵਾਰ"
            },
            {
              "icon": "",
              "label": "Static ਬਲਾਕ ਹਰ ਪਦਾਰਥ ਪ੍ਰਤਿ ਇੱਕ ਵਾਰ ਚੱਲਦਾ ਹੈ, ਠੀਕ ਪਹਿਲਾਂ instance ਬਲਾਕ"
            }
          ]
        },
        {
          "question": "ਇੱਕ ਕਲਾਸ ਕੋਲ void log(String s) ਅਤੇ void log(String... args) ਹੈ। ਤੁਸ log(\"hi\") ਕਾਲ ਕਰਦੇ ਹੋ। ਕਿਹੜਾ ਚੱਲਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "log(String... args) — varargs overloads ਦੋਨੋਂ applicable ਹੋਣ ਜਿੰਨੇ ਹਮੇਸ਼ਾ ਪਸੰਦ ਕਰਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਇੱਕ compile error ਹੈ — ਕਾਲ ਦੋ overloads ਵਿਚਕਾਰ ambiguous ਹੈ"
            },
            {
              "icon": "",
              "label": "log(String s) — ਜਦੋਂ ਇੱਕ fixed-arity overload ਬਿਲਕੁਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, Java ਹਮੇਸ਼ਾ ਇਸ ਨੂੰ ਵਾਰਾ overload ਤੋਂ ਅਗਲਾ ਪਸੰਦ ਕਰਦਾ ਹੈ, ਜੋ ਆਖਰੀ ਬਿੰਦੂ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਭੰਡਾਰ ਪੱਕਲ ਸੋਮਯ ਸ਼ਿਤੀ ਆਰਡਰ ਲਗਾਉ"
            }
          ]
        },
        {
          "question": "ਇੱਕ constructor ਦੀ ਪਹਿਲੀ ਲਾਈਨ this(0); ਨੂੰ ਕਾਲ ਕਰਕੇ ਇੱਕੋ ਕਲਾਸ ਵਿੱਚ ਇੱਕ ਹੋਰ constructor ਕਾ ਭੇਜਤਾ ਹੈ। ਇਹ ਕਿੱਥੇ ਦਿਖਾਈ ਦੇਣ ਦੀ ਆਜ਼ਾਦ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "Constructor body ਦਾ ਕਦੇ ਵੀ, ਜਿੰਨੇ ਲੰਬੇ ਪਦਾਰਥ return ਤੋਂ ਪਹਿਲਾਂ ਚੱਲਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ ਪਹਿਲਾ constructor ਦੀ ਦੱਸਿਆ — this() (ਜਾਂ super()) ਪਹਿਲੀ ਲਾਈਨ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਇੱਕ constructor this() ਅਤੇ super() ਦੋਨੋਂ ਨਹੀਂ ਕਾਲ ਕਰ ਸਕਦਾ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ ਆਖਿਰੀ ਸਿਧਤੀ, ਸਮਸਤ ਖੇਤਰ initialization ਪੂਰਾ ਹੋਣ ਤੋਂ ਬਾਅਦ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ constructors ਵਿੱਚ ਬਿਲਕੁਲ ਡਾਲਾ ਦੀ ਅੰਦਾਜ਼ਰਤ, delegate ਕਿਵ ਜਮਾਂ"
            }
          ]
        },
        {
          "question": "ਤੁਸ ਇੱਕ ਸੂਚੀ ਚਾਹ ਕਰਦੇ ਹੋ ਜੋ ਮੁੱਖ ਤਰੀਕੇ ਕਾਰਨ ਕਮੀਨਾਂ ਵਿਖਾ ਬਹੁ ਚਰਵਤ ਹੋਵੇਗੀ, ਅਤੇ ਸਮਿ-ਆਦ ਪੜ੍ਹਨ ਔਸਤ ਨਿਖਾ ਹੈ। ਕਿਹੜਾ ਢੁਕਵਾ structurally, ਅਤੇ ਕਿਉਂ?",
          "options": [
            {
              "icon": "",
              "label": "ArrayList — ਇਸ ਦਾ contiguous backing array ਹਰ ਮਨਾਨ ਬਿਲਕੁਲ front-insertion, linked structure ਤੋਂ ਵੱਡੀ ਬਣਾਉਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਸਮਾਂ, ਕਾਹ ਦੋਨੋਂ List interface implement ਕਰਦੇ ਹਨ ਉਹੀ ਸਮੀਪ ਲਹਬਿੰਦਾਂ ਨਾਲ"
            },
            {
              "icon": "",
              "label": "LinkedList — front 'ਤੇ insert ਕਰਨਾ O(1) ਹੈ ਕਿਉਂਕਿ ਇਹ ਸਿਰਫ ਇੱਕ node ਨੂੰ relink ਕਰਦਾ ਹੈ, ਜਦੋਂ ArrayList ਦੀ ਹਰ ਮੌਜੂਦਾ ਤੱਤ ਨੂੰ ਇੱਕ ਉੱਪਰ ਬਦਲ ਕਰਦਾ ਹੈ, front-insertion ਨੂੰ O(n) ਬਣਾ ਦਿੰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "LinkedList, ਕਿਉਂਕਿ ਇਹ random access O(1) 'ਚ ਅਸੰਭਵ ਕਰਦਾ ਹੈ ਜਦ ArrayList ਨਹੀਂ"
            }
          ]
        },
        {
          "question": "ਤੁਸ ਪੰਜ entries ਇੱਕ plain HashMap 'ਚ ਇੱਕ ਖਾਸ ਆਰਡਰ ਵਿੱਚ ਪਾਅ, ਫਿਰ ਇੱਕ for-each loop ਨਾਲ ਇਸ ਤੇ iterator ਕਰਦੇ ਹੋ। ਤੱਤ ਕਿਸ ਤਰਤੀਬ ਵਿੱਚ ਬਾਹਰ ਨਿਕਲਦੇ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "ਸਮਾਂ ਆਰਡਰ entries ਪਾਉਂਦੇ ਲਗਭਗ ਸਮਾਂ, Java maps ਹਮੇਸ਼ਾ insertion order ਰੱਖਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਕੋਈ ਗ੍ਰੰਥਿਤ ਆਰਡਰ ਬਿਲਕੁਲ ਨਹੀਂ — HashMap ਦਾ iteration order hash bucket placement ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, insertion order ਨਾ, ਅਤੇ ਨਿਕਲਾ ਮਵਰੂਤਤ ਤੱਕ ਬਦਲ ਵੀ ਸਕਦਾ ਹੈ; LinkedHashMap insertion order ਸੁਰਖਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "Key ਦੁਆਰਾ sorted, TreeMap ਦੇ ਤਰਕੀ"
            },
            {
              "icon": "",
              "label": "Insertion order ਦੇ reverse, HashMap internally ਇੱਕ stack ਵਰਤਦਾ"
            }
          ]
        },
        {
          "question": "ਪ੍ਲੇਨ java.util.HashMap ਇੱਕ ਸਮੇਂ ਕਿੰਨੇ null keys ਰੱਖ ਸਕਦਾ ਹੈ, ਅਤੇ ਕਿੰਨੇ null values?",
          "options": [
            {
              "icon": "",
              "label": "No null keys ਅਤੇ no null values ਕਿਸੇ ਵੀ Map ਜਾਪਾਦਾ 'ਚ ਖਾ ਖਾ ਹਰ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "ਜ਼ਿਆਦਾ ਇੱਕ null key, ਅਤੇ ਬੇ ਸਮਾ null values — HashMap ਇੱਕ ਬਿੰਦੂ null key ਲਾਯਕ, Hashtable ਤੋਂ ਭਿੰਨ ਜੋ ਦੋਨੋਂ ਆਜ਼ਾਦ"
            },
            {
              "icon": "",
              "label": "Unlimited null keys ਅਤੇ unlimited null values, null ਕਿਸ ਨੂੰ ਹੋਰ key ਦੇ ਤਮਾਮ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ null key ਅਤੇ ਇੱਕ null value ਅਵਸਰ, ਦੋਨੋਂ ਇੱਕ ਵਿੱਚ ਕਿਪ"
            }
          ]
        },
        {
          "question": "ਤੁਸ ਇੱਕ List ਦੇ ਪਲ for-each loop ਨਾਲ ਅਤੇ list.remove(item) ਦੀ ਕਾਲ loop ਆਚਲਨ ਅੰਦਰ ਸੱਧੇ, ਕੁਝ ਪਰ ਤਮਾਮ ਨਹੀਂ। ਕੀ ਹੁੰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਇਹ ਬਿਲਕੁਲ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ ਬਿਲਕੁਲ intended ਤੱਤ ਨੂੰ ਹਟਾ ਕੇ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਆਚਲ ਤੱਤ ਆਮ, ਪਰ ਹੋਰ ਬਿਨਾਂ error ਪੂਰਾ"
            },
            {
              "icon": "",
              "label": "ਇਹ IndexOutOfBoundsException ਜੇ loop ਤੰਕ ਸ਼ੁਰੂ ਦੇ ਪੁਰਾਣਾ ਸਮਾ ਤਾ"
            },
            {
              "icon": "",
              "label": "ਇਹ ConcurrentModificationException throw ਕਰਦਾ ਹੈ — implicit iterator ਜਦੋਂ list ਦੀ ਬੰਧ ਵਿਧੀ ਪ੍ਰੋਗ੍ਰਾਮ 'ਚ ਸੰਸਾਧਿਤ ਕਰਦਾ ਹੋ ਤਾ ਖੋਜ ਅਰੂ ਰੱਦ; Iterator.remove() ਤੰਕ ਵਰਤਾ ਤੁਰਨਾ ਚਾਹੀਦਾ"
            }
          ]
        },
        {
          "question": "Runtime 'ਚ, ਇੱਕ List<String> list ਦਿੱਤੇ, ਤੁਸ reflection ਜਾ instanceof ਦੁਆਰਾ generic ਪੈਰਾਮੀਟਰ ਦਾ ਅਸਲੀ ਕੀ ਯਕੀਨ ਕਰ ਸਕਦੇ ਹੋ?",
          "options": [
            {
              "icon": "",
              "label": "ਤੁਸ list.getElementType() ਨੂੰ ਕਾਲ ਕਰ ਸਕਦੇ ਹੋ ਕਮਾ String.class runtime 'ਚ ਪ੍ਰਾਪਤ"
            },
            {
              "icon": "",
              "label": "instanceof List<String> compile ਕਰਦਾ ਹੈ ਅਤੇ element type ਨੂੰ ਸਹੀ ਤਰ੍ਹਾਂ ਜਾਂਚਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "JVM type parameter ਨੂੰ hidden metadata ਦੇ ਤੌਰ ਤੇ store ਕਰਦਾ ਹੈ ਜੋ list.getGenericType() ਰਾਹੀਂ accessible ਹੈ"
            },
            {
              "icon": "",
              "label": "ਕੁਝ ਨਹੀਂ — generic type information compile time ਤੇ erase ਹੋ ਜਾਂਦੀ ਹੈ, ਇਸ ਲਈ runtime ਤੇ object ਸਿਰਫ ਇੱਕ List ਹੈ, ਅਤੇ ਇਹ ਜਾਣਨ ਦਾ ਕੋਈ ਤਰੀਕਾ ਨਹੀਂ ਹੈ ਕਿ ਇਹ List<String> ਜਾਂ List<Integer> ਦੇ ਤੌਰ ਤੇ declare ਕੀਤਾ ਗਿਆ ਸੀ"
            }
          ]
        },
        {
          "question": "switch (day) { case 1: case 2: print(\"Weekday\"); break; case 6: print(\"Saturday\"); case 7: print(\"Sunday\"); break; default: print(\"?\"); } ਜੇਕਰ day ਬਰਾਬਰ 6 ਹੈ, ਤਾਂ ਕੀ print ਹੋਵੇਗਾ?",
          "options": [
            {
              "icon": "",
              "label": "ਸਿਰਫ Saturday — switch ਵਿੱਚ ਹਰੇਕ case block ਆਪਣਾ print statement ਦੇ ਬਾਅਦ ਹਮੇਸ਼ਾ ਰੁਕ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ Sunday — matching case 6 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ ਪਰ break ਤੋਂ ਪਹਿਲਾਂ ਸਿਰਫ ਆਖਰੀ matching label execute ਹੁੰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਕੁਝ ਨਹੀਂ print ਹੋਵੇਗਾ, ਕਿਉਂਕਿ day 6 ਦਾ ਕੋਈ matching case ਨਹੀਂ ਹੈ ਜਿਸ ਦਾ ਆਪਣਾ break ਸਿੱਧਾ ਇਸ ਦੇ ਹੇਠਾਂ ਹੋ"
            },
            {
              "icon": "",
              "label": "Saturday ਫਿਰ Sunday — case 6 ਦਾ ਕੋਈ break ਨਹੀਂ ਹੈ, ਇਸ ਲਈ execution ਅਗਲੇ case ਦੇ code ਵਿੱਚ fall through ਕਰ ਜਾਂਦਾ ਹੈ ਅਤੇ ਅੱਗੇ ਵਾਲਾ break hit ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ"
            }
          ]
        },
        {
          "question": "ਇੱਕ Product class ਨੂੰ ਇੱਕ single, ਸਪਸ਼ਟ \"natural\" sort order ਚਾਹੀਦਾ ਹੈ price ਦੇ ਆਧਾਰ ਤੇ, ਅਤੇ ਨਾਲ ਹੀ name ਜਾਂ stock level ਦੇ ਆਧਾਰ ਤੇ codebase ਦੇ ਵੱਖ-ਵੱਖ ਥਾਵਾਂ ਵਿੱਚ sort ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਚਾਹੀਦੀ ਹੈ। ਕਿਹੜਾ ਸਮਨਵਯ ਸਹੀ design ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "Comparable<Product> ਨੂੰ ਤਿੰਨ ਵਾਰ ਵੱਖ-ਵੱਖ implement ਕਰੋ, ਹਰੇਕ ordering ਲਈ ਇੱਕ, ਅਤੇ caller ਨੂੰ ਇਹ ਚੁਣਨ ਦਿਓ ਕਿ ਕਿਹੜਾ compareTo ਚਲਾਂ"
            },
            {
              "icon": "",
              "label": "Comparable<Product> ਨੂੰ natural price ordering ਲਈ implement ਕਰੋ, ਅਤੇ name ਅਤੇ stock-level orderings ਲਈ ਵੱਖ-ਵੱਖ Comparator<Product> instances ਲਿਖੋ ਜੋ ਹੋਰ ਥਾਵਾਂ ਤੇ ਵਰਤੇ ਜਾਣ"
            },
            {
              "icon": "",
              "label": "ਹਰੇਕ ordering ਲਈ ਸਿਰਫ Comparator ਵਰਤੋ, price ਸਮੇਤ, ਕਿਉਂਕਿ Comparable ਦਾ ਇੱਥੇ ਕੋਈ ਫਾਇਦਾ ਨਹੀਂ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ Comparable ਵਰਤੋ ਤਿੰਨ overloaded compareTo methods ਸ਼ਾਮਲ ਕਰਕੇ, ਹਰੇਕ ordering ਲਈ ਇੱਕ"
            }
          ]
        },
        {
          "question": "ਇੱਕ method new FileReader(path) ਨੂੰ call ਕਰਦਾ ਹੈ, ਜੋ IOException ਨੂੰ declare throws ਕਰਦਾ ਹੈ। IOException Exception ਨੂੰ extend ਕਰਦਾ ਹੈ, RuntimeException ਨੂੰ ਨਹੀਂ। ਇਹ compile ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਕੁਝ ਨਹੀਂ — compiler ਇਹ ਸਿਰਫ ਉਨ ਸਗਾ exceptions ਲਈ ਲਾਗੂ ਕਰਦਾ ਹੈ ਜੋ RuntimeException ਨੂੰ extend ਕਰਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਜਾਂ ਤਾਂ IOException ਨੂੰ try/catch ਵਿੱਚ catch ਕਰੋ ਜਾਂ ਆਪਣੇ method ਤੇ IOException ਨੂੰ declare throws ਕਰੋ — checked exceptions ਨੂੰ handle ਜਾਂ explicitly propagate ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, unchecked RuntimeException subclasses ਦੇ ਉਲਟ"
            },
            {
              "icon": "",
              "label": "Call ਨੂੰ RuntimeException ਲਈ try/catch ਵਿੱਚ wrap ਕਰੋ, ਕਿਉਂਕਿ IOException ਆਧੁਨਿਕ Java ਵਿੱਚ automatically unchecked ਹੈ"
            },
            {
              "icon": "",
              "label": "Method ਨੂੰ static ਦੇ ਤੌਰ ਤੇ declare ਕਰੋ — static methods checked exception handling ਤੋਂ exempt ਹਨ"
            }
          ]
        },
        {
          "question": "try (Resource a = new Resource(\"A\"); Resource b = new Resource(\"B\")) { ... } ਦੋ resources ਵਰਤਦਾ ਹੈ ਜੋ AutoCloseable ਨੂੰ implement ਕਰਦੇ ਹਨ। ਜੇਕਰ try block ਆਮ ਤੌਰ ਤੇ ਖਤਮ ਹੋ ਜਾਵੇ, ਤਾਂ ਉਹ ਕਿਸ ਕ੍ਰਮ ਵਿੱਚ ਬੰਦ ਹੋਣ?",
          "options": [
            {
              "icon": "",
              "label": "A ਪਹਿਲਾਂ ਬੰਦ ਹੁੰਦਾ ਹੈ, ਫਿਰ B, declaration order ਨੂੰ match ਕਰਦੇ ਹੋਏ"
            },
            {
              "icon": "",
              "label": "B ਪਹਿਲਾਂ ਬੰਦ ਹੁੰਦਾ ਹੈ, ਫਿਰ A — try-with-resources resources ਨੂੰ ਜਿਸ ਕ੍ਰਮ ਦੇ reverse ਵਿੱਚ ਬੰਦ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਉਹ declare ਕੀਤੇ ਗਏ ਸਨ"
            },
            {
              "icon": "",
              "label": "ਦੋਨੋਂ ਇੱਕ ਸਾਥ ਬੰਦ ਹੁੰਦੇ ਹਨ, ਕਿਉਂਕਿ try-with-resources cleanup ਨੂੰ parallelize ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ B automatically ਬੰਦ ਹੁੰਦਾ ਹੈ — A ਨੂੰ ਅਜੇ ਵੀ finally block ਵਿੱਚ manually ਬੰਦ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "int getValue() { try { return 1; } finally { return 2; } } getValue() ਨੂੰ call ਕਰਨ ਨਾਲ ਕੀ return ਹੁੰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "1 — try block ਦਾ return value ਪਹਿਲਾਂ ਤੋਂ ਹੀ committed ਹੈ finally ਚਲਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਸ ਲਈ finally ਇਸ ਨੂੰ ਨਹੀਂ ਬਦਲ ਸਕਦਾ"
            },
            {
              "icon": "",
              "label": "ਇਹ runtime ਤੇ exception throw ਕਰਦਾ ਹੈ, ਕਿਉਂਕਿ ਇੱਕ method ਦੋ ਥਾਵਾਂ ਤੋਂ return ਨਹੀਂ ਕਰ ਸਕਦਾ"
            },
            {
              "icon": "",
              "label": "2 — finally ਦੇ ਅੰਦਰ ਇੱਕ return statement ਕਿਸੇ ਵੀ return ਨੂੰ override ਅਤੇ replace ਕਰਦਾ ਹੈ ਜੋ ਪਹਿਲਾਂ try block ਤੋਂ ਅੰਗਤ ਵਿੱਚ ਹੈ, ਮੁੱਲ 1 ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਛੱਡ ਦਿੰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਇੱਕ compile error ਹੈ — finally ਵਿੱਚ return statement ਨਹੀਂ ਹੋ ਸਕਦਾ"
            }
          ]
        },
        {
          "question": "try { ... } catch (IOException e) { ... } catch (FileNotFoundException e) { ... }, ਅਤੇ FileNotFoundException IOException ਨੂੰ extend ਕਰਦਾ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਇਹ compile ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਇੱਕ compile error — FileNotFoundException catch block unreachable ਹੈ ਕਿਉਂਕਿ ਪਹਿਲਾ, ਜ਼ਿਆਦਾ general IOException catch block ਪਹਿਲਾਂ ਤੋਂ ਹਰੇਕ FileNotFoundException ਨੂੰ match ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਠੀਕ ਹੈ compile ਹੁੰਦਾ ਹੈ, ਅਤੇ ਜ਼ਿਆਦਾ specific FileNotFoundException block ਚਲਦਾ ਹੈ ਜਦੋਂ ਵੀ ਉਹ exact type throw ਹੁੰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਠੀਕ ਹੈ compile ਹੁੰਦਾ ਹੈ, ਅਤੇ ਦੋਨੋਂ catch blocks FileNotFoundException ਲਈ ਕ੍ਰਮ ਵਿੱਚ ਚਲਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਇਹ compile time ਤੇ ਠੀਕ ਹੈ ਪਰ runtime error throw ਕਰਦਾ ਹੈ ਜਦੋਂ ਪਹਿਲੀ ਵਾਰ FileNotFoundException actually ਹੁੰਦੀ ਹੈ"
            }
          ]
        },
        {
          "question": "ਇੱਕ class ਕੋਲ synchronized instance method process() ਅਤੇ synchronized static method configure() ਹੈ। ਖਾਸ ਤੌਰ ਤੇ, ਹਰ ਇੱਕ ਕੀ lock ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "process() ਉਸ specific object instance ਦੇ monitor ਨੂੰ lock ਕਰਦਾ ਹੈ ਜਿਸ ਤੇ ਇਹ call ਹੁੰਦਾ ਹੈ, ਜਦੋਂ configure() Class object ਖੁਦ ਦੇ monitor ਨੂੰ lock ਕਰਦਾ ਹੈ — ਹਰੇਕ instance ਦੁਆਰਾ shared"
            },
            {
              "icon": "",
              "label": "ਦੋਨੋਂ ਪੂਰੀ JVM ਲਈ ਇੱਕੋ ਜਿਆਦਾ global lock ਲਗਾਉਂਦੇ ਹਨ, instance ਜਾਂ class ਕੋਈ ਫਰਕ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "process() Class object ਨੂੰ lock ਕਰਦਾ ਹੈ, ਅਤੇ configure() ਜਿਆਦਾ instance ਇਸ ਨੂੰ call ਕਰਦਾ ਹੈ ਨੂੰ lock ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਕੋਈ ਵੀ actually ਕੁਝ ਵੀ lock ਨਹੀਂ ਕਰਦਾ ਜਦੋਂ ਤੱਕ ਇੱਕ synchronized block ਵੀ method body ਦੇ ਅੰਦਰ ਨਹੀਂ ਵਰਤਿਆ ਜਾਵੇ"
            }
          ]
        },
        {
          "question": "ਇੱਕ field volatile int counter = 0; declare ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ multiple threads ਇਸ ਤੇ counter++ ਚਲਾਉਂਦੇ ਹਨ concurrently। ਕੀ volatile lost updates ਨੂੰ ਰੋਕਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਹਾਂ — volatile field ਤੇ ਹਰੇਕ operation ਨੂੰ atomic ਬਣਾਉਂਦਾ ਹੈ, increments ਸਮੇਤ"
            },
            {
              "icon": "",
              "label": "ਨਹੀਂ — volatile ਸਿਰਫ ਗ੍ਰੇਨਟੀ ਦਿੰਦਾ ਹੈ ਕਿ reads threads ਤੇ ਤਾਜ਼ਾ write ਵੇਖਦੇ ਹਨ (visibility); counter++ ਇੱਕ read-modify-write ਹੈ multiple steps ਦੇ ਨਾਲ, ਅਤੇ volatile ਉਨ ਸਿੱਖਰ ਨੂੰ atomic ਬਣਾਉਣ ਲਈ ਕੁਝ ਨਹੀਂ ਕਰਦਾ"
            },
            {
              "icon": "",
              "label": "ਹਾਂ, ਪਰ ਸਿਰਫ int ਅਤੇ long fields ਲਈ specifically, JVM 64-bit values ਨੂੰ ਕਿਵੇਂ handle ਕਰਦਾ ਹੈ ਇਸ ਲਈ"
            },
            {
              "icon": "",
              "label": "ਨਹੀਂ, ਅਤੇ volatile primitive types ਜਿਵੇਂ int ਲਈ visibility ਦੀ ਗ੍ਰੇਨਟੀ ਦੇਣ ਵਿੱਚ ਵੀ ਫੇਲ ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "Interface A ਅਤੇ interface B ਹਰ ਇੱਕ ਇੱਕ default method describe() declare ਕਰਦੇ ਹਨ। ਇੱਕ class A ਅਤੇ B ਦੋਵੇਂ implement ਕਰਦਾ ਹੈ ਅਤੇ describe() ਨੂੰ ਆਪ override ਨਹੀਂ ਕਰਦਾ। ਕੀ ਹੁੰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "Compiler automatically interface A ਦਾ version ਚੁਣਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਹ implements clause ਵਿੱਚ ਪਹਿਲਾਂ ਲਿਸਟ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਦੋਨੋਂ versions ਚਲਦੇ ਹਨ, ਇੱਕ ਦੂਜੇ ਦੇ ਬਾਅਦ, ਜਦੋਂ ਵੀ describe() call ਹੁੰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ compile time ਤੇ ਠੀਕ ਹੈ, ਪਰ describe() ਦਾ ਪਹਿਲੀ ਵਾਰ call ਹੋਣ ਤੇ AmbiguousMethodException throw ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ compile error — ਜਦੋਂ ਦੋ interfaces ਇੱਕੋ default method ਦਾ ਯੋਗਦਾਨ ਦਿੰਦੇ ਹਨ, implementing class ਨੂੰ ambiguity ਨੂੰ resolve ਕਰਨ ਲਈ ਆਪ ਇਸ ਨੂੰ override ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਕਿਉਂਕਿ Java ਇਹ ਮੁਹਾਨੇ ਕਿ ਤੁਸੀਂ ਕਿਹੜਾ ਸੀ"
            }
          ]
        },
        {
          "question": "list.stream().filter(x -> x > 0).map(x -> x * 2); ਲਿਖਿਆ ਗਿਆ ਹੈ ਪਰ result ਕਦੀ terminal operation ਜਿਵੇਂ .collect() ਜਾਂ .forEach() ਨੂੰ assign ਨਹੀਂ ਕੀਤਾ ਗਿਆ। ਜਦੋਂ ਇਹ ਲਾਈਨ execute ਹੁੰਦੀ ਹੈ ਤਾਂ ਅਸਲ ਵਿੱਚ ਕੀ ਹੁੰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "List ਦੇ elements ਲਈ ਕੁਝ ਨਹੀਂ ਹੁੰਦਾ — filter ਅਤੇ map lazy intermediate operations ਹਨ ਜੋ ਸਿਰਫ ਇੱਕ pipeline description ਬਣਾਉਂਦੇ ਹਨ; ਇੱਕ terminal operation ਤੋਂ ਬਿਨਾ, ਉਹ pipeline ਕਦੀ actually ਚਲਦੀ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "ਹਰੇਕ element ਤੁਰੰਤ filter ਅਤੇ map ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਬਿਲਕੁਲ ਜਿਵੇਂ ਇੱਕ terminal operation call ਹੋਵੇ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ filter ਤੁਰੰਤ ਚਲਦਾ ਹੈ; map ਨੂੰ defer ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ terminal operation ਪ੍ਰਗਟ ਨਹੀਂ ਹੁੰਦਾ"
            },
            {
              "icon": "",
              "label": "ਇਹ IllegalStateException throw ਕਰਦਾ ਹੈ, ਕਿਉਂਕਿ ਇੱਕ stream pipeline ਨੂੰ compile ਕਰਨ ਲਈ ਇੱਕ terminal operation ਚਾਹੀਦਾ ਹੈ"
            }
          ]
        }
      ],
      "optionOrderVersion": "0154f9576054ad6f"
    }
  },
  "testNames": {
    "java-test": "Java ਟੈਸਟ"
  }
}