{
  "assessmentTests": {
    "java_test": {
      "name": "ஜாவா தேர்வு",
      "desc": "அடிப்படை சிண்டாக்ஸ், பொருள்நோக்கு நிரலாக்க இயங்குமுறைகள், கலெக்ஷன்கள், ஜெனரிக்ஸ், எக்செப்ஷன்கள் மற்றும் கான்கரன்சி பற்றிய 30 சூழல் சார்ந்த கேள்விகள் — வேலை அறிவிப்பு ஜாவா புலமை என்று குறிப்பிடுவதற்கு உங்கள் ஜாவா அறிவு பொருந்துகிறதா என்பதைக் கண்டறியுங்கள்.",
      "recommendation": "உங்கள் ஜாவா திறன் புரொஃபைல்",
      "results": {
        "beginner": {
          "name": "தொடக்கநிலை",
          "desc": "நீங்கள் இயங்கும் கிளாஸ்களையும் மெத்தட்களையும் எழுத முடியும், ஆனால் நீங்கள் தவறவிட்ட கேள்விகள் சிண்டாக்ஸை விட அடையாளம் மற்றும் இயல்புநிலை மதிப்புகளைச் சுற்றியே குவிந்துள்ளன — ஸ்ட்ரிங்கில் == என்பதற்கும் ஈக்வல்ஸ் என்பதற்கும் உள்ள வேறுபாடு, “x” என்ற ஸ்ட்ரிங்கை new கொண்டு உருவாக்கினால் அது ஏன் ஒருபோதும் ஸ்ட்ரிங் பூலை மீண்டும் பயன்படுத்துவதில்லை, எண் வகை ஃபீல்டுக்கும் ரேப்பர் ஃபீல்டுக்கும் இயல்புநிலை மதிப்பு என்ன என்பது. இவற்றில் எதுவும் ஜாவாவில் நீங்கள் மோசமாக இருப்பதைப் பற்றியது அல்ல; ரெஃபரன்ஸ்களும் பிரிமிடிவ்களும் உள்ளுக்குள் உண்மையில் எப்படி இயங்குகின்றன என்பதிலிருந்து அல்லாமல், முயன்று தவறிக் கற்றுக்கொள்வதன் மூலம் இந்த மொழியைக் கற்றவர்களைத் தடுமாறச் செய்யும் குறிப்பிட்ட விதிகள் இவை. இவை பணியிடத்தில் முக்கியம், ஏனெனில் ஒவ்வொன்றும் குறியீடு கம்பைல் ஆகி, இயங்கி, அமைதியாகத் தவறானதைச் செய்யும் இடமாகும்.",
          "recommendation": "இந்த வரிசையில் மூன்று விஷயங்களுடன் தொடங்குங்கள்: இரண்டு ஸ்ட்ரிங் ஆப்ஜெக்ட்களில் == ஏன் எழுத்துகளை அல்ல, ரெஃபரன்ஸ்களையே ஒப்பிடுகிறது (நீங்கள் கிட்டத்தட்ட எப்போதும் விரும்புவது ஈக்வல்ஸ் மெத்தட்தான்), இன்ட் ஓவர்ஃப்ளோ விதிவிலக்கை எழுப்பாமல் அமைதியாக எப்படிச் சுற்றி வருகிறது, தொடக்க மதிப்பு இடப்படாத இன்டிஜர் ஃபீல்டு ஏன் null ஆகவும், இன்ட் ஃபீல்டு ஏன் 0 ஆகவும் இயல்புநிலை பெறுகிறது. ஆரக்கிளின் அதிகாரப்பூர்வ ஜாவா பயிற்சிக் கையேடுகளும் பெல்டங்கும் இம்மூன்றையும் இயக்கிப் பார்க்கக்கூடிய எடுத்துக்காட்டுகளுடன் விளக்குகின்றன."
        },
        "intermediate": {
          "name": "இடைநிலை",
          "desc": "கிளாஸ்கள், கலெக்ஷன்கள், எளிய கட்டுப்பாட்டு ஓட்டம் போன்ற அன்றாட அப்ளிகேஷன் குறியீட்டை நீங்கள் சௌகரியமாகக் கையாளுகிறீர்கள் — வழக்கமான அம்சப் பணிகளால் உங்கள் வேகம் குறையாது. இங்கிருந்து மேம்பட்ட நிலை வரையிலான இடைவெளி பெரும்பாலும், ஜாவாவின் விதிகள் கன்கரன்சி மற்றும் ஜெனரிக்ஸுடன் இணையும்போது என்ன நடக்கிறது என்பதில் உள்ளது: நீங்கள் எதிர்பார்த்த ஆப்ஜெக்ட்டால் அல்லாமல், அறிவிக்கப்பட்ட வகையால் தீர்மானிக்கப்படும் ஸ்டாட்டிக் மெத்தட்; நீங்கள் அறியாமலே நம்பியிருந்த ஹாஷ்மேப் இட்டரேஷன் வரிசை; லூப்பின் நடுவே ஒரு உருப்படியை நீக்குவதால் வரும் கன்கரண்ட்மாடிஃபிகேஷன் எக்செப்ஷன். விரைவாகப் படித்துப் பார்க்கும்போது தப்பிவிடும், குறிப்பிட்ட ரன்டைம் நிலையில் மட்டுமே வெளிப்படும் பிழைகள் இவையே.",
          "recommendation": "உங்கள் குறியீடு பற்றிய கம்பைலரின் ஸ்டாட்டிக் பார்வை உண்மையில் இயங்குவதிலிருந்து எவ்வாறு வேறுபடுகிறது என்பதில் கவனம் செலுத்துங்கள்: ரன்டைம் வகையால் அல்லாமல் அறிவிக்கப்பட்ட வகையால் நடக்கும் ஓவர்லோட் தீர்வு மற்றும் ஸ்டாட்டிக்-மெத்தட் மறைப்பு, ஹாஷ்மேப் ஏன் இட்டரேஷன்-வரிசைக்கு உத்தரவாதம் தருவதில்லை, இட்டரேட் செய்யும்போதே லிஸ்ட்டை நேரடியாக மாற்றினால் ஏன் கன்கரண்ட்மாடிஃபிகேஷன் எக்செப்ஷன் எழுகிறது. பிறகு ஜெனரிக்ஸ் எரேஷர் — ஏனெனில் கலெக்ஷன்களைத் தனித்தனியாக ஏற்கெனவே அறிந்தவர்களையும் அது தடுமாறச் செய்கிறது."
        },
        "advanced": {
          "name": "உயர்நிலை",
          "desc": "பெரும்பாலான வேலை அறிவிப்புகள் “வலுவான ஜாவா” என்பதன் மூலம் குறிப்பிடும் நிலை இதுவே. ஸ்டாட்டிக் பிளாக்குகள், இன்ஸ்டன்ஸ் பிளாக்குகள் மற்றும் பல கன்ஸ்ட்ரக்டர்கள் கொண்ட கிளாஸைப் படித்து, அவை இயங்கும் சரியான வரிசையை உங்களால் முன்கூட்டியே சொல்ல முடியும்; ஃபைனலி பிளாக் ஒரு ட்ரை பிளாக்கின் திரும்பும் மதிப்பை அமைதியாக நிராகரிக்க முடியும் என்பது உங்களுக்குத் தெரியும்; கைமுறை ஃபைனலி-குளோஸை விட ட்ரை-வித்-ரிசோர்ஸஸை நாடுகிறீர்கள், ஏனெனில் அது தரும் வரிசை உத்தரவாதம் உங்களுக்குத் தெரியும். இந்த நிலையை உயர்ந்த நிலையிலிருந்து பிரிப்பது பணியின் கன்கரன்ட் மற்றும் இன்டர்ஃபேஸ் அளவிலான பகுதி: சின்க்ரனைஸ்டு உண்மையில் எதைப் பூட்டுகிறது, வோலட்டைல் எதற்கு உத்தரவாதம் தருகிறது, எதற்குத் தருவதில்லை, மற்றும் டீஃபால்ட்-மெத்தட் முரண்பாடுகள் எவ்வாறு தீர்க்கப்படுகின்றன.",
          "recommendation": "பிற த்ரெட்களும் பிற இன்டர்ஃபேஸ்களும் தொடும் குறியீட்டைப் பாதுகாக்கும் பகுதிகளில் ஆழமாகச் செல்லுங்கள்: சின்க்ரனைஸ்டு இன்ஸ்டன்ஸ் மெத்தட் எதைப் பூட்டுகிறது என்பதற்கும், சின்க்ரனைஸ்டு ஸ்டாட்டிக் மெத்தட் எதைப் பூட்டுகிறது என்பதற்கும் உள்ள வேறுபாடு, counter++ என்பதற்கு வோலட்டைல் விசிபிலிட்டியைத் தருகிறது ஆனால் அடாமிசிட்டியைத் தருவதில்லை ஏன், மற்றும் டீஃபால்ட்-மெத்தட் டயமண்ட் சிக்கலைக் கையால் தீர்க்குமாறு ஜாவா உங்களை எவ்வாறு கட்டாயப்படுத்துகிறது. ஜாவா மெமரி மாடல் குறித்த பெல்டங் மற்றும் ஜாவா கன்கரன்சி இன் பிராக்டீஸ் நூலின் உள்ளடக்கம் இவ்விரண்டுக்கும் இயல்பான அடுத்த நிறுத்தம்."
        },
        "expert": {
          "name": "நிபுணர்",
          "desc": "ஒவ்வொரு பிரிவிலும் நீங்கள் உச்ச மதிப்பெண் பெற்றீர்கள் — அடிப்படை சிண்டாக்ஸ் மற்றும் வகைகள், பொருள்நோக்கு நிரலாக்க இயக்கமுறைகள் மற்றும் ஸ்கோப், கலெக்ஷன்கள் மற்றும் ஜெனரிக்ஸ், எக்ஸெப்ஷன்கள், கன்கரன்சி மற்றும் இடியம்கள். நடைமுறையில், அறிமுகமில்லாத ஒருவரின் கிளாஸை உங்களிடம் கொடுத்தால், சிண்டாக்ஸ் என்ன செய்ய வேண்டும் என்று சொல்கிறது என்பதை மட்டுமல்லாமல், காம்பைல் பிழை, ரன்டைம் எக்ஸெப்ஷன் அல்லது அமைதியாக ஏற்படும் தவறான மதிப்பு ஏன் நிகழ்கிறது என்பதையும் உங்களால் விளக்க முடியும்; இது கடினமான, அதிக மதிப்புள்ள திறன். இந்த நிலையில் மொழியே அரிதாகவே தடையாக இருக்கும்; தடை பொதுவாக கன்கரன்சி வடிவமைப்பு அல்லது அதன் அடியில் உள்ள தரவின் வடிவமைப்பாக இருக்கும்.",
          "recommendation": "இப்போது பலன்கள் வடிவமைப்பிலும் பிரச்சினை கண்டறிதலிலும் உள்ளன: ஒரு ஹேங் என்பது டெட்லாக் என்று கருதுவதற்கு முன் த்ரெட் டம்ப்பைப் படிப்பது, சின்க்ரனைஸ்டு, ஜாவா யூட்டில் கன்கரண்ட் லாக்குகள், அணுநிலை வகைகள் ஆகியவற்றுக்கு இடையே தேர்வதை இயல்புநிலைத் தேர்வாக அல்லாமல் ஒரு சமரசமாகக் கருதுவது, தற்செயலாக அல்லாமல் வேண்டுமென்றே லேசியாக இருக்கும் ஸ்ட்ரீம்-பைப்லைன் வடிவமைப்பு. ஒரு பணிக்கான தேர்வு வடிகட்டலில் இருந்தால், ஜாவா அம்சங்களின் பெயர்களைச் சொல்வதற்குப் பதிலாக, தவறவிடப்பட்ட ஹேப்பன்ஸ்-பிஃபோர் இணைப்பு அல்லது நீங்கள் புரொடக்ஷனில் கண்டறிந்த கன்கரண்ட்மாடிஃபிகேஷன் எக்செப்ஷன் போன்ற ஒரு கன்கரன்சி பிழையை விவரியுங்கள் — அது சொல்வளத்தை மட்டுமல்ல, சிந்தனையையும் வெளிப்படுத்துகிறது."
        }
      },
      "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": "உண்மை, ஏனெனில் ஜாவா டபுள் கூட்டுத்தொகைகளை அருகிலுள்ள தசம மதிப்புக்கு ரவுண்ட் செய்கிறது"
            },
            {
              "icon": "",
              "label": "உண்மை, ஏனெனில் இரண்டு தசம இடங்கள் கொண்ட மதிப்புகள் டபுளில் துல்லியமாகக் கூடுகின்றன"
            },
            {
              "icon": "",
              "label": "துல்லியமற்ற ஒப்பீட்டுக்காக இது ArithmeticException-ஐ எறியும்"
            }
          ]
        },
        {
          "question": "ஒரு கிளாஸ் தொடக்க மதிப்பு இல்லாமல் இரண்டு இன்ஸ்டன்ஸ் ஃபீல்டுகளை அறிவிக்கிறது: int count; மற்றும் Integer total; கன்ஸ்ட்ரக்டர் இயங்குவதற்கு முன், அவற்றின் இயல்புநிலை மதிப்புகள் என்ன?",
          "options": [
            {
              "icon": "",
              "label": "இரண்டும் 0"
            },
            {
              "icon": "",
              "label": "ஒதுக்கப்படும் வரை இரண்டுக்கும் மதிப்பு இல்லை"
            },
            {
              "icon": "",
              "label": "கவுண்ட் என்பது 0, டோட்டல் என்பது null"
            },
            {
              "icon": "",
              "label": "இரண்டும் null"
            }
          ]
        },
        {
          "question": "ஒரு லூப் 1000 முறை இயங்குகிறது; ஒவ்வொரு முறையும் String வகை result மீது result += “x”; செய்யப்படுகிறது. ஒவ்வொரு இட்டரேஷனிலும் உள்ளுக்குள் உண்மையில் என்ன நடக்கிறது?",
          "options": [
            {
              "icon": "",
              "label": "இருக்கும் String-இன் கேரக்டர் அரே அதே இடத்தில் நீட்டிக்கப்படுகிறது"
            },
            {
              "icon": "",
              "label": "ஜாவா அனைத்து இணைப்புகளையும் ஒரே இறுதி String-ஆகத் தொகுக்கிறது"
            },
            {
              "icon": "",
              "label": "ஒரு StringBuilder அனைத்து 1000 இட்டரேஷன்களிலும் பகிரப்படுகிறது"
            },
            {
              "icon": "",
              "label": "ஒரு புதிய ஸ்ட்ரிங் உருவாக்கப்பட்டு 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": "டெரைவ்டு"
            },
            {
              "icon": "",
              "label": "இது காம்பைல் ஆகாது"
            },
            {
              "icon": "",
              "label": "அடிப்படை"
            },
            {
              "icon": "",
              "label": "பேஸ், பிறகு டெரைவ்டு"
            }
          ]
        },
        {
          "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": "நீங்கள் ஒரு சாதாரண ஹாஷ்மேப்பில் குறிப்பிட்ட வரிசையில் ஐந்து என்ட்ரிகளைச் செருகி, பிறகு ஃபார்-ஈச் லூப் மூலம் அதை இட்டரேட் செய்கிறீர்கள். என்ட்ரிகள் எந்த வரிசையில் வெளிவருகின்றன?",
          "options": [
            {
              "icon": "",
              "label": "செருகிய வரிசை"
            },
            {
              "icon": "",
              "label": "உத்தரவாதமான வரிசை இல்லை"
            },
            {
              "icon": "",
              "label": "கீ அடிப்படையில் வரிசைப்படுத்தப்பட்டது"
            },
            {
              "icon": "",
              "label": "செருகிய வரிசையின் எதிர்வரிசை"
            }
          ]
        },
        {
          "question": "ஒரு சாதாரண ஜாவா.யூட்டில்.ஹாஷ்மேப் ஒரே நேரத்தில் எத்தனை கீகளையும், எத்தனை மதிப்புகளையும் null ஆக வைத்திருக்க முடியும்?",
          "options": [
            {
              "icon": "",
              "label": "கீகளிலும் மதிப்புகளிலும் null அனுமதி இல்லை"
            },
            {
              "icon": "",
              "label": "ஒரு கீ null ஆகலாம்; மதிப்புகள் எத்தனை வேண்டுமானாலும் அவ்வாறே ஆகலாம்"
            },
            {
              "icon": "",
              "label": "எத்தனை null கீகள் அல்லது மதிப்புகளும்"
            },
            {
              "icon": "",
              "label": "ஒரு கீயும் ஒரு மதிப்பும் மட்டுமே null ஆகலாம்"
            }
          ]
        },
        {
          "question": "ஒரு List-ஐ for-each லூப் மூலம் இட்டரேட் செய்து, லூப் பாடிக்குள்ளிருந்து சில உறுப்புகளுக்கு மட்டும், எல்லாவற்றுக்கும் அல்ல, 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": "சனிக்கிழமை, ஞாயிற்றுக்கிழமை, பிறகு ?"
            },
            {
              "icon": "",
              "label": "சனிக்கிழமை, பிறகு ஞாயிற்றுக்கிழமை"
            }
          ]
        },
        {
          "question": "ஒரு Product கிளாஸுக்கு விலையின் அடிப்படையில் ஒரே, தெளிவான “இயல்பான” வரிசைமுறை தேவை; மேலும் குறியீட்டுத் தொகுப்பின் வெவ்வேறு இடங்களில் பெயர் அல்லது இருப்பு அளவின் அடிப்படையிலும் வரிசைப்படுத்தும் திறனும் தேவை. எந்தக் கூட்டுச் சேர்க்கை சரியான வடிவமைப்பு?",
          "options": [
            {
              "icon": "",
              "label": "Comparable<Product>-ஐ மூன்று முறை தனித்தனியாகச் செயல்படுத்துங்கள்"
            },
            {
              "icon": "",
              "label": "விலைக்கு கம்பேரபிள், பெயர் மற்றும் இருப்புக்குத் தனித்தனி கம்பேரேட்டர்கள்"
            },
            {
              "icon": "",
              "label": "பெயருக்கு கம்பேரபிள், விலை மற்றும் இருப்புக்கு கம்பேரேட்டர்கள்"
            },
            {
              "icon": "",
              "label": "மூன்று ஓவர்லோட் செய்யப்பட்ட கம்பேர்டூ மெத்தட்களுடன் ஒரு கம்பேரபிள்"
            }
          ]
        },
        {
          "question": "ஒரு மெத்தட் new FileReader(path)-ஐ அழைக்கிறது; அது throws IOException என அறிவிக்கிறது. IOException என்பது Exception-ஐ விரிவுபடுத்துகிறது, RuntimeException-ஐ அல்ல. இது காம்பைல் ஆக நீங்கள் என்ன செய்ய வேண்டும்?",
          "options": [
            {
              "icon": "",
              "label": "எதுவும் தேவையில்லை; எழுதியபடியே காம்பைல் ஆகும்"
            },
            {
              "icon": "",
              "label": "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": "அடைய முடியாத இரண்டாவது catch-க்கான காம்பைல் பிழை"
            },
            {
              "icon": "",
              "label": "இது காம்பைல் ஆகும்; FileNotFoundException பிளாக் அந்த வகையைக் கையாளும்"
            },
            {
              "icon": "",
              "label": "இது காம்பைல் ஆகும், இரண்டு catch பிளாக்குகளும் வரிசையாக இயங்கும்"
            },
            {
              "icon": "",
              "label": "இது காம்பைல் ஆகும், ஆனால் FileNotFoundException வரும்போது ரன்டைமில் தோல்வியடையும்"
            }
          ]
        },
        {
          "question": "ஒரு கிளாஸில் synchronized இன்ஸ்டன்ஸ் மெத்தட் process() மற்றும் synchronized ஸ்டாட்டிக் மெத்தட் configure() உள்ளன. இவை ஒவ்வொன்றும் குறிப்பாக எதைப் பூட்டுகின்றன?",
          "options": [
            {
              "icon": "",
              "label": "process() இன்ஸ்டன்ஸைப் பூட்டுகிறது; configure() Class ஆப்ஜெக்ட்டைப் பூட்டுகிறது"
            },
            {
              "icon": "",
              "label": "இரண்டும் JVM முழுவதுக்குமான ஒரே குளோபல் லாக்கைப் பூட்டுகின்றன"
            },
            {
              "icon": "",
              "label": "process() Class ஆப்ஜெக்ட்டைப் பூட்டுகிறது; configure() அழைப்பாளர் இன்ஸ்டன்ஸைப் பூட்டுகிறது"
            },
            {
              "icon": "",
              "label": "உள்ளே synchronized பிளாக் இல்லாமல் இரண்டில் எதுவும் எதையும் பூட்டாது"
            }
          ]
        },
        {
          "question": "ஒரு ஃபீல்டு volatile int counter = 0; என அறிவிக்கப்பட்டுள்ளது, பல த்ரெட்கள் அதன் மீது counter++ -ஐ ஒரே நேரத்தில் இயக்குகின்றன. இங்கே volatile இழந்த அப்டேட்களைத் தடுக்குமா?",
          "options": [
            {
              "icon": "",
              "label": "ஆம்"
            },
            {
              "icon": "",
              "label": "No"
            },
            {
              "icon": "",
              "label": "இன்ட் மற்றும் லாங் ஃபீல்டுகளுக்கு மட்டும்"
            },
            {
              "icon": "",
              "label": "ஃபீல்டு static ஆகவும் இருந்தால் மட்டும்"
            }
          ]
        },
        {
          "question": "இன்டர்ஃபேஸ் A மற்றும் இன்டர்ஃபேஸ் B ஒவ்வொன்றும் describe() என்ற டீஃபால்ட் மெத்தடை அறிவிக்கின்றன. ஒரு கிளாஸ் A மற்றும் B இரண்டையும் செயல்படுத்துகிறது; ஆனால் அந்த மெத்தடைத் தானே ஓவர்ரைடு செய்யவில்லை. என்ன நடக்கும்?",
          "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": "ஜாவா தேர்வு"
  }
}