ஜாவா ஜெனரிக்ஸ்: நடைமுறையில் கோண அடைப்புக்குறிகளை எவ்வாறு பயன்படுத்துவது

அறிமுகம்

JSE 5.0 இல் தொடங்கி, ஜாவா மொழியின் ஆயுதக் களஞ்சியத்தில் ஜெனரிக்ஸ் சேர்க்கப்பட்டது.

ஜாவாவில் ஜெனரிக்ஸ் என்றால் என்ன?

ஜெனரிக்ஸ் என்பது ஜெனரிக் புரோகிராமிங்கை செயல்படுத்துவதற்கான ஜாவாவின் சிறப்பு பொறிமுறையாகும் - தரவு மற்றும் வழிமுறைகளை விவரிக்கும் ஒரு வழி, அல்காரிதம்களின் விளக்கத்தை மாற்றாமல் வெவ்வேறு தரவு வகைகளுடன் வேலை செய்ய உங்களை அனுமதிக்கிறது. ஆரக்கிள் இணையதளத்தில் பொதுவானவைகளுக்கு அர்ப்பணிக்கப்பட்ட தனி பயிற்சி உள்ளது: " பாடம் ". ஜெனரிக்ஸைப் புரிந்து கொள்ள, அவை ஏன் தேவைப்படுகின்றன, அவை என்ன கொடுக்கின்றன என்பதை நீங்கள் முதலில் கண்டுபிடிக்க வேண்டும். டுடோரியலின் " ஏன் ஜெனரிக்ஸைப் பயன்படுத்த வேண்டும்? " பகுதியானது, ஒரு ஜோடி நோக்கங்கள் தொகுக்கும் நேரத்தில் வலுவான வகை சரிபார்ப்பு மற்றும் வெளிப்படையான காஸ்ட்களின் தேவையை நீக்குதல் என்று கூறுகிறது. எங்கள் அன்பான டுடோரியல்ஸ்பாயிண்ட் ஆன்லைன் ஜாவா கம்பைலரில் சில சோதனைகளுக்குத் தயாராவோம் . உங்களிடம் பின்வரும் குறியீடு இருப்பதாக வைத்துக்கொள்வோம்:

import java.util.*;
public class HelloWorld {
	public static void main(String []args) {
		List list = new ArrayList();
		list.add("Hello");
		String text = list.get(0) + ", world!";
		System.out.print(text);
	}
}

இந்த குறியீடு சரியாக இயங்கும். ஆனால் முதலாளி எங்களிடம் வந்து "வணக்கம், உலகம்!" என்று சொன்னால் என்ன செய்வது? அதிகமாகப் பயன்படுத்தப்படும் சொற்றொடர் மற்றும் நீங்கள் "ஹலோ" என்று மட்டும் திருப்பி அனுப்ப வேண்டுமா? "உலகம்!" என்று இணைக்கும் குறியீட்டை அகற்றுவோம். இது போதுமான பாதிப்பில்லாததாகத் தெரிகிறது, இல்லையா? ஆனால் தொகுக்கும் நேரத்தில் ஒரு பிழையைப் பெறுகிறோம்:

error: incompatible types: Object cannot be converted to String

பிரச்சனை என்னவென்றால், எங்கள் பட்டியலில் பொருள்கள் சேமிக்கப்படுகின்றன. சரம் என்பது பொருளின் வழித்தோன்றல் (அனைத்து ஜாவா வகுப்புகளும் மறைமுகமாக பொருளைப் பெறுவதால் ), அதாவது நமக்கு வெளிப்படையான நடிகர்கள் தேவை, ஆனால் நாங்கள் ஒன்றைச் சேர்க்கவில்லை. ஒருங்கிணைப்பு செயல்பாட்டின் போது, ​​பொருளைப் பயன்படுத்தி நிலையான String.valueOf(obj) முறை அழைக்கப்படும். இறுதியில், அது ஆப்ஜெக்ட் வகுப்பின் toString முறையை அழைக்கும் . வேறு வார்த்தைகளில் கூறுவதானால், எங்கள் பட்டியலில் ஒரு பொருள் உள்ளது . இதன் பொருள், நமக்கு ஒரு குறிப்பிட்ட வகை ( பொருள் அல்ல ) தேவைப்படும் இடங்களில், நாமே வகை மாற்றத்தைச் செய்ய வேண்டும்:

import java.util.*;
public class HelloWorld {
	public static void main(String []args) {
		List list = new ArrayList();
		list.add("Hello!");
		list.add(123);
		for (Object str : list) {
		    System.out.println("-" + (String)str);
		}
	}
}

இருப்பினும், இந்த விஷயத்தில், பட்டியல் பொருள்களை எடுத்துக்கொள்வதால், அது String s மட்டுமல்ல, Integer களையும் சேமிக்க முடியும் . ஆனால் மிக மோசமான விஷயம் என்னவென்றால், கம்பைலர் இங்கு தவறாக எதையும் பார்க்கவில்லை. இப்போது நாம் ரன் நேரத்தில் ஒரு பிழையைப் பெறுவோம் ("இயக்க நேரப் பிழை" என அறியப்படுகிறது). பிழை இருக்கும்:

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

இது மிகவும் நல்லதல்ல என்பதை நீங்கள் ஒப்புக் கொள்ள வேண்டும். இதற்கெல்லாம் காரணம் கம்பைலர் ஒரு செயற்கை நுண்ணறிவு அல்ல, புரோகிராமரின் நோக்கத்தை எப்போதும் சரியாக யூகிக்கும் திறன் கொண்டது. ஜாவா எஸ்இ 5 ஜெனரிக்ஸை அறிமுகப்படுத்தியது, எங்கள் நோக்கங்களைப் பற்றி கம்பைலரிடம் சொல்லலாம் - நாம் எந்த வகைகளைப் பயன்படுத்தப் போகிறோம் என்பது பற்றி. கம்பைலரிடம் நமக்குத் தேவையானதைச் சொல்லி எங்கள் குறியீட்டை சரிசெய்கிறோம்:

import java.util.*;
public class HelloWorld {
	public static void main(String []args) {
		List<String> list = new ArrayList<>();
		list.add("Hello!");
		list.add(123);
		for (Object str : list) {
		    System.out.println("-" + str);
		}
	}
}

நீங்கள் பார்க்க முடியும் என, எங்களுக்கு இனி ஒரு ஸ்டிரிங் ஒரு நடிகர் தேவை இல்லை . கூடுதலாக, வகை வாதத்தைச் சுற்றியுள்ள கோண அடைப்புக்குறிகள் எங்களிடம் உள்ளன. பட்டியலில் 123ஐ சேர்க்கும் வரியை அகற்றும் வரை, கம்பைலர் வகுப்பை தொகுக்க அனுமதிக்காது, ஏனெனில் இது ஒரு முழு எண் . மேலும் அது நமக்குச் சொல்லும். பலர் ஜெனரிக்ஸை "சின்டாக்டிக் சர்க்கரை" என்று அழைக்கிறார்கள். அவர்கள் சொல்வது சரிதான், ஏனென்றால் பொதுவானவை தொகுக்கப்பட்ட பிறகு, அவை உண்மையில் ஒரே மாதிரியான மாற்றங்களாக மாறும். தொகுக்கப்பட்ட வகுப்புகளின் பைட்கோடைப் பார்ப்போம்: வெளிப்படையான வார்ப்புகளைப் பயன்படுத்தும் ஒன்று மற்றும் ஜெனரிக்ஸைப் பயன்படுத்தும் ஒன்று: தொகுத்த பிறகு, அனைத்து ஜெனிரிக்களும் அழிக்கப்படும். இது " வகை அழிப்பு" என்று அழைக்கப்படுகிறது". வகை அழித்தல் மற்றும் ஜெனரிக்ஸ் ஆகியவை JDK இன் பழைய பதிப்புகளுடன் பின்னோக்கி இணக்கமாக வடிவமைக்கப்பட்டுள்ளன, அதே நேரத்தில் ஜாவாவின் புதிய பதிப்புகளில் வகை வரையறைகளுக்கு உதவ கம்பைலரை அனுமதிக்கிறது.

மூல வகைகள்

ஜெனரிக்ஸைப் பற்றி பேசுகையில், எங்களிடம் எப்போதும் இரண்டு பிரிவுகள் உள்ளன: அளவுருப்படுத்தப்பட்ட வகைகள் மற்றும் மூல வகைகள். மூல வகைகள் என்பது கோண அடைப்புக்குறிக்குள் உள்ள "வகை தெளிவுபடுத்தலை" தவிர்க்கும் வகைகளாகும்: அளவுருக் கொண்ட வகைகளில், "தெளிவு" உள்ளது: நீங்கள் பார்க்கிறபடி, ஸ்கிரீன்ஷாட்டில் அம்புக்குறியால் குறிக்கப்பட்ட அசாதாரண கட்டமைப்பைப் பயன்படுத்தினோம். இது ஜாவா SE 7 இல் சேர்க்கப்பட்ட சிறப்பு தொடரியல் ஆகும். இது " வைரம் " என்று அழைக்கப்படுகிறது. ஏன்? கோண அடைப்புக்குறிகள் ஒரு வைரத்தை உருவாக்குகின்றன: <> . வைர தொடரியல் " வகை அனுமானம் " என்ற கருத்துடன் தொடர்புடையது என்பதையும் நீங்கள் அறிந்து கொள்ள வேண்டும் . எல்லாவற்றிற்கும் மேலாக, கம்பைலர், பார்ப்பது <>வலதுபுறத்தில், அசைன்மென்ட் ஆபரேட்டரின் இடது பக்கத்தைப் பார்க்கிறது, அங்கு மதிப்பு ஒதுக்கப்படும் மாறியின் வகையைக் கண்டறியும். இந்தப் பகுதியில் அது கண்டறிவதன் அடிப்படையில், வலதுபுறத்தில் உள்ள மதிப்பின் வகையைப் புரிந்துகொள்கிறது. உண்மையில், பொதுவான வகை இடதுபுறத்தில் கொடுக்கப்பட்டாலும், வலதுபுறத்தில் கொடுக்கப்பட்டிருந்தால், கம்பைலர் வகையை ஊகிக்க முடியும்:

import java.util.*;
public class HelloWorld {
	public static void main(String []args) {
		List<String> list = new ArrayList();
		list.add("Hello, World");
		String data = list.get(0);
		System.out.println(data);
	}
}

ஆனால் இது புதிய பாணியில் ஜெனரிக்ஸ் மற்றும் பழைய பாணியில் அவை இல்லாமல் கலக்கப்படுகிறது. மேலும் இது மிகவும் விரும்பத்தகாதது. மேலே உள்ள குறியீட்டைத் தொகுக்கும்போது, ​​​​பின்வரும் செய்தியைப் பெறுகிறோம்:

Note: HelloWorld.java uses unchecked or unsafe operations

உண்மையில், நீங்கள் ஒரு வைரத்தை இங்கே சேர்க்க வேண்டியதன் காரணம் புரிந்துகொள்ள முடியாததாகத் தெரிகிறது. ஆனால் இங்கே ஒரு உதாரணம்:

import java.util.*;
public class HelloWorld {
	public static void main(String []args) {
		List<String> list = Arrays.asList("Hello", "World");
		List<Integer> data = new ArrayList(list);
		Integer intNumber = data.get(0);
		System.out.println(data);
	}
}

ArrayList இல் இரண்டாவது கன்ஸ்ட்ரக்டர் உள்ளது, அது ஒரு சேகரிப்பை ஒரு வாதமாக எடுத்துக்கொள்கிறது . மேலும் இங்குதான் ஏதோ ஒரு தீமை மறைந்துள்ளது. வைர தொடரியல் இல்லாமல், அது ஏமாற்றப்படுவதைத் தொகுத்தவருக்குப் புரியவில்லை. வைர தொடரியல் மூலம், அது செய்கிறது. எனவே, விதி #1: எப்போதும் அளவுரு வகைகளுடன் வைர தொடரியல் பயன்படுத்தவும். இல்லையெனில், நாங்கள் மூல வகைகளைப் பயன்படுத்தும் இடத்தில் காணாமல் போகும் அபாயம் உள்ளது. "தேர்வு செய்யப்படாத அல்லது பாதுகாப்பற்ற செயல்பாடுகளைப் பயன்படுத்துகிறது" என்ற எச்சரிக்கைகளை அகற்ற, ஒரு முறை அல்லது வகுப்பில் @SuppressWarnings("சரிபார்க்கப்படாத") சிறுகுறிப்பைப் பயன்படுத்தலாம் . ஆனால் நீங்கள் ஏன் அதைப் பயன்படுத்த முடிவு செய்தீர்கள் என்று சிந்தியுங்கள். விதி எண் ஒன்றை நினைவில் கொள்ளுங்கள். ஒருவேளை நீங்கள் ஒரு வகை வாதத்தைச் சேர்க்க வேண்டும்.

ஜாவா பொதுவான முறைகள்

அளவுரு வகைகளும் திரும்பும் வகையும் அளவுருவாக இருக்கும் முறைகளை உருவாக்க ஜெனரிக்ஸ் உங்களை அனுமதிக்கிறது. ஆரக்கிள் டுடோரியலில் இந்த திறனுக்காக ஒரு தனி பகுதி ஒதுக்கப்பட்டுள்ளது: " பொதுவான முறைகள் ". இந்த டுடோரியலில் கற்பிக்கப்பட்ட தொடரியல் நினைவில் கொள்வது முக்கியம்:

• இது கோண அடைப்புக்குறிக்குள் உள்ள வகை அளவுருக்களின் பட்டியலை உள்ளடக்கியது;
• வகை அளவுருக்களின் பட்டியல் முறையின் திரும்பும் வகைக்கு முன் செல்கிறது.

ஒரு உதாரணத்தைப் பார்ப்போம்:

import java.util.*;
public class HelloWorld {
	
    public static class Util {
        public static <T> T getValue(Object obj, Class<T> clazz) {
            return (T) obj;
        }
        public static <T> T getValue(Object obj) {
            return (T) obj;
        }
    }

    public static void main(String []args) {
		List list = Arrays.asList("Author", "Book");
		for (Object element : list) {
		    String data = Util.getValue(element, String.class);
		    System.out.println(data);
		    System.out.println(Util.<String>getValue(element));
		}
    }
}

நீங்கள் Util வகுப்பைப் பார்த்தால் , அதில் இரண்டு பொதுவான முறைகள் இருப்பதைக் காண்பீர்கள். வகை அனுமானத்தின் சாத்தியத்திற்கு நன்றி, தொகுப்பிக்கு நேரடியாக வகையைக் குறிப்பிடலாம் அல்லது அதை நாமே குறிப்பிடலாம். இரண்டு விருப்பங்களும் எடுத்துக்காட்டில் வழங்கப்பட்டுள்ளன. மூலம், தொடரியல் நீங்கள் அதை பற்றி நினைத்தால் நிறைய அர்த்தமுள்ளதாக இருக்கும். ஒரு பொதுவான முறையை அறிவிக்கும் போது, ​​முறைக்கு முன் வகை அளவுருவைக் குறிப்பிடுகிறோம், ஏனெனில் முறைக்குப் பிறகு வகை அளவுருவை அறிவித்தால், JVM எந்த வகையைப் பயன்படுத்த வேண்டும் என்பதைக் கண்டுபிடிக்க முடியாது. அதன்படி, முதலில் T வகை அளவுருவைப் பயன்படுத்துவோம் என்று அறிவிக்கிறோம் , பின்னர் இந்த வகையைத் திரும்பப் பெறப் போகிறோம் என்று சொல்கிறோம். இயற்கையாகவே, Util.<Integer>getValue(element, String.class) பிழையுடன் தோல்வியடையும்:பொருந்தாத வகைகள்: Class<String>ஐ Class<Integer> ஆக மாற்ற முடியாது . பொதுவான முறைகளைப் பயன்படுத்தும் போது, ​​நீங்கள் எப்போதும் அழிப்பு வகையை நினைவில் கொள்ள வேண்டும். ஒரு உதாரணத்தைப் பார்ப்போம்:

import java.util.*;
public class HelloWorld {
	
    public static class Util {
        public static <T> T getValue(Object obj) {
            return (T) obj;
        }
    }

    public static void main(String []args) {
		List list = Arrays.asList(2, 3);
		for (Object element : list) {
		    System.out.println(Util.<Integer>getValue(element) + 1);
		}
    }
}

இது நன்றாக இயங்கும். ஆனால் கம்பைலர் புரிந்து கொள்ளும் வரையில் மட்டுமே திரும்பும் முறை அழைக்கப்படும் முறை முழு எண் . கன்சோல் வெளியீட்டு அறிக்கையை பின்வரும் வரியுடன் மாற்றவும்:

System.out.println(Util.getValue(element) + 1);

நாங்கள் ஒரு பிழையைப் பெறுகிறோம்:

bad operand types for binary operator '+', first type: Object, second type: int.

வேறு வார்த்தைகளில் கூறுவதானால், வகை அழிப்பு ஏற்பட்டுள்ளது. யாரும் வகையை குறிப்பிடவில்லை என்பதை கம்பைலர் பார்க்கிறார், எனவே வகை பொருள் எனக் குறிக்கப்படுகிறது மற்றும் முறை பிழையுடன் தோல்வியடைகிறது.

பொதுவான வகுப்புகள்

முறைகளை மட்டும் அளவுருவாக மாற்ற முடியாது. வகுப்புகளும் முடியும். ஆரக்கிளின் டுடோரியலின் "பொது வகைகள்" பகுதி இதற்கு அர்ப்பணிக்கப்பட்டுள்ளது. ஒரு உதாரணத்தைக் கருத்தில் கொள்வோம்:

public static class SomeType<T> {
	public <E> void test(Collection<E> collection) {
		for (E element : collection) {
			System.out.println(element);
		}
	}
	public void test(List<Integer> collection) {
		for (Integer element : collection) {
			System.out.println(element);
		}
	}
}

இங்கே எல்லாம் எளிது. நாம் பொதுவான வகுப்பைப் பயன்படுத்தினால், வகை அளவுரு வகுப்பின் பெயருக்குப் பிறகு குறிக்கப்படும். இப்போது முக்கிய முறையில் இந்த வகுப்பின் உதாரணத்தை உருவாக்குவோம் :

public static void main(String []args) {
	SomeType<String> st = new SomeType<>();
	List<String> list = Arrays.asList("test");
	st.test(list);
}

இந்த குறியீடு நன்றாக இயங்கும். எண்களின் பட்டியல் மற்றும் சரங்களின் தொகுப்பு இருப்பதை கம்பைலர் பார்க்கிறார் . ஆனால் வகை அளவுருவை நீக்கிவிட்டு இதைச் செய்தால் என்ன செய்வது:

SomeType st = new SomeType();
List<String> list = Arrays.asList("test");
st.test(list);

நாங்கள் ஒரு பிழையைப் பெறுகிறோம்:

java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer

மீண்டும், இது வகை அழித்தல். வர்க்கம் ஒரு வகை அளவுருவைப் பயன்படுத்தாததால், நாம் ஒரு பட்டியலைக் கடந்துவிட்டதால், List<Integer> கொண்ட முறை மிகவும் பொருத்தமானது என்று கம்பைலர் தீர்மானிக்கிறது . மேலும் ஒரு பிழையால் நாம் தோல்வியடைகிறோம். எனவே, எங்களிடம் விதி #2 உள்ளது: உங்களிடம் பொதுவான வகுப்பு இருந்தால், எப்போதும் வகை அளவுருக்களைக் குறிப்பிடவும்.

கட்டுப்பாடுகள்

பொதுவான முறைகள் மற்றும் வகுப்புகளில் குறிப்பிடப்பட்டுள்ள வகைகளை நாம் கட்டுப்படுத்தலாம். எடுத்துக்காட்டாக, ஒரு கன்டெய்னர் ஒரு எண்ணை மட்டும் வகை வாதமாக ஏற்க வேண்டும் என்று வைத்துக்கொள்வோம் . இந்த அம்சம் ஆரக்கிளின் டுடோரியலின் எல்லைக்குட்பட்ட வகை அளவுருக்கள் பிரிவில் விவரிக்கப்பட்டுள்ளது . ஒரு உதாரணத்தைப் பார்ப்போம்:

import java.util.*;
public class HelloWorld {
	
    public static class NumberContainer<T extends Number> {
        private T number;
    
        public NumberContainer(T number) { this.number = number; }
    
        public void print() {
            System.out.println(number);
        }
    }

    public static void main(String []args) {
		NumberContainer number1 = new NumberContainer(2L);
		NumberContainer number2 = new NumberContainer(1);
		NumberContainer number3 = new NumberContainer("f");
    }
}

நீங்கள் பார்க்கிறபடி, வகை அளவுருவை எண் வகுப்பு/இடைமுகம் அல்லது அதன் வழித்தோன்றல்களுக்குக் கட்டுப்படுத்தியுள்ளோம் . நீங்கள் ஒரு வகுப்பை மட்டுமல்ல, இடைமுகங்களையும் குறிப்பிடலாம் என்பதை நினைவில் கொள்க. உதாரணத்திற்கு:

public static class NumberContainer<T extends Number & Comparable> {

ஜெனரிக்ஸ் வைல்டு கார்டுகளை ஆதரிக்கிறது, அவை மூன்று வகைகளாகப் பிரிக்கப்படுகின்றன:

• மேல் எல்லைகள் கொண்ட வைல்டு கார்டுகள் - < ? எண்ணை நீட்டிக்கிறது >
• வரம்பற்ற வைல்டு கார்டுகள் - < ? >
• கீழ் எல்லைகள் கொண்ட வைல்டு கார்டுகள் - < ? சூப்பர் முழு எண் >

உங்கள் வைல்டு கார்டுகளின் பயன்பாடு கெட்-புட் கொள்கைக்கு இணங்க வேண்டும் . அதை பின்வருமாறு வெளிப்படுத்தலாம்:

• கட்டமைப்பிலிருந்து மதிப்புகளை மட்டும் பெறும்போது நீட்டிக்கப்பட்ட வைல்டு கார்டைப் பயன்படுத்தவும் .
• ஒரு கட்டமைப்பில் மதிப்புகளை மட்டும் வைக்கும்போது சூப்பர் வைல்டு கார்டைப் பயன்படுத்தவும் .
• மேலும் நீங்கள் இருவரும் ஒரு கட்டமைப்பிலிருந்து/இருந்து பெற விரும்பும் போது வைல்டு கார்டைப் பயன்படுத்த வேண்டாம்.

இந்தக் கொள்கையானது உற்பத்தியாளர் விரிவாக்க நுகர்வோர் சூப்பர் (PECS) கொள்கை என்றும் அழைக்கப்படுகிறது. ஜாவாவின் Collections.copy முறைக்கான மூலக் குறியீட்டிலிருந்து ஒரு சிறிய உதாரணம் இங்கே : மேலும் எது வேலை செய்யாது என்பதற்கான சிறிய எடுத்துக்காட்டு இங்கே:

public static class TestClass {
	public static void print(List<? extends String> list) {
		list.add("Hello, World!");
		System.out.println(list.get(0));
	}
}

public static void main(String []args) {
	List<String> list = new ArrayList<>();
	TestClass.print(list);
}

ஆனால் நீங்கள் நீட்டிப்புகளை சூப்பர் என்று மாற்றினால் , எல்லாம் நன்றாக இருக்கும். பட்டியலை அதன் உள்ளடக்கங்களைக் காண்பிப்பதற்கு முன் மதிப்புடன் நாங்கள் நிரப்புவதால் , அது ஒரு நுகர்வோர் . அதன்படி, நாங்கள் சூப்பர் பயன்படுத்துகிறோம்.

பரம்பரை

ஜெனரிக்ஸ் மற்றொரு சுவாரஸ்யமான அம்சத்தைக் கொண்டுள்ளது: பரம்பரை. ஆரக்கிளின் டுடோரியலில் " ஜெனரிக்ஸ், இன்ஹெரிடன்ஸ் மற்றும் சப்டைப்ஸ் " என்பதன் கீழ், ஜெனரிக்ஸிற்கான பரம்பரை வேலை செய்யும் விதம் விவரிக்கப்பட்டுள்ளது . முக்கிய விஷயம் என்னவென்றால், பின்வருவனவற்றை நினைவில் வைத்து அங்கீகரிக்க வேண்டும். நாம் இதைச் செய்ய முடியாது:

List<CharSequence> list1 = new ArrayList<String>();

ஏனென்றால், மரபுரிமையானது ஜெனரிக்ஸுடன் வித்தியாசமாக வேலை செய்கிறது: பிழையுடன் தோல்வியடையும் மற்றொரு சிறந்த உதாரணம் இங்கே:

List<String> list1 = new ArrayList<>();
List<Object> list2 = list1;

மீண்டும், இங்கே எல்லாம் எளிது. சரம் பொருளின் வழித்தோன்றலாக இருந்தாலும் லிஸ்ட்< ஸ்ட்ரிங்> லிஸ்ட் < பொருள்> என்பதன் வழித்தோன்றல் அல்ல . நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்

முடிவுரை

எனவே நாங்கள் எங்கள் நினைவகத்தைப் புதுப்பித்துள்ளோம். அவர்களின் திறன்களை நீங்கள் அரிதாகவே முழுமையாகப் பயன்படுத்தினால், சில விவரங்கள் தெளிவற்றதாக இருக்கும். இந்த சிறிய மதிப்பாய்வு உங்கள் நினைவாற்றலை மேம்படுத்த உதவியிருக்கும் என்று நம்புகிறேன். இன்னும் சிறந்த முடிவுகளுக்கு, பின்வரும் விஷயங்களைப் பற்றி நீங்கள் நன்கு அறிந்திருக்குமாறு நான் கடுமையாக பரிந்துரைக்கிறேன்: