ජාවා හි සාමාන්‍ය අරාවක් නිර්මාණය කරන්නේ කෙසේද?

ජාවා ජනක විද්‍යාව ක්‍රියාත්මක කිරීම නිසා ඔබට මෙවැනි කේතයක් තිබිය නොහැක:

public class GenSet<E> {
    private E a[];

    public GenSet() {
        a = new E[INITIAL_ARRAY_LENGTH]; // error: generic array creation
    }
}

වර්ගයේ ආරක්ෂාව පවත්වා ගනිමින් මෙය ක්‍රියාත්මක කරන්නේ කෙසේද?

ජාවා සංසදවල මෙවැනි විසඳුමක් මම දුටුවෙමි:

import java.lang.reflect.Array;

class Stack<T> {
    public Stack(Class<T> clazz, int capacity) {
        array = (T[])Array.newInstance(clazz, capacity);
    }

    private final T[] array;
}

නමුත් මට ඇත්තටම සිදුවන්නේ කුමක්ද යන්න ලැබෙන්නේ නැත.

මට නැවත ප්‍රශ්නයක් ඇසීමට සිදුවේ: ඔබේ GenSet"පරීක්ෂා කර" හෝ "පරීක්ෂා නොකළ" ද? ඒ කියන්නේ මොකද්ද?

• පරීක්ෂා කර ඇත : ශක්තිමත් ටයිප් කිරීම . GenSetඑහි අඩංගු වන්නේ කුමන වර්ගයේ වස්තූන් දැයි පැහැදිලිව දනී (එනම් එහි ඉදිකිරීම්කරු පැහැදිලිවම Class<E>තර්කයක් සමඟ කැඳවනු ලැබූ අතර , ඒවා වර්ග නොවන තර්ක සම්මත කළ විට ක්‍රමවේදයන් ව්‍යතිරේකයක් දමනු ඇත E. බලන්න Collections.checkedCollection.

  -> එවැනි අවස්ථාවක, ඔබ ලිවිය යුත්තේ:

  public class GenSet<E> {
  
      private E[] a;
  
      public GenSet(Class<E> c, int s) {
          // Use Array native method to create array
          // of a type only known at run time
          @SuppressWarnings("unchecked")
          final E[] a = (E[]) Array.newInstance(c, s);
          this.a = a;
      }
  
      E get(int i) {
          return a[i];
      }
  }
  

• පරීක්ෂා නොකළ : දුර්වල ටයිප් කිරීම . තර්කයක් ලෙස සම්මත කරන ලද ඕනෑම වස්තුවක් මත සත්‍ය වශයෙන්ම වර්ගීකරණයක් සිදු නොකෙරේ.

  -> එවැනි අවස්ථාවක ඔබ ලිවිය යුතුය

  public class GenSet<E> {
  
      private Object[] a;
  
      public GenSet(int s) {
          a = new Object[s];
      }
  
      E get(int i) {
          @SuppressWarnings("unchecked")
          final E e = (E) a[i];
          return e;
      }
  }
  

  අරාවෙහි සංරචක වර්ගය පරාමිතිය මකා දැමීම විය යුතු බව සලකන්න :

  public class GenSet<E extends Foo> { // E has an upper bound of Foo
  
      private Foo[] a; // E erases to Foo, so use Foo[]
  
      public GenSet(int s) {
          a = new Foo[s];
      }
  
      ...
  }
  

මේ සියල්ලේ ප්‍රති results ලය වන්නේ ජාවා හි දන්නා සහ හිතාමතාම ජනක විද්‍යාවේ දුර්වලතාවයකි: එය ක්‍රියාත්මක කරනු ලැබුවේ මකාදැමීමෙනි, එබැවින් “සාමාන්‍ය” පංති ක්‍රියාත්මක වන වේලාවේදී කුමන ආකාරයේ තර්කයක් නිර්මාණය කළේදැයි නොදනී. කිසියම් පැහැදිලි යාන්ත්‍රණයක් (වර්ගය පරීක්ෂා කිරීම) ක්‍රියාත්මක නොකරන්නේ නම් ආරක්ෂාව.

ඔබට මෙය කරන්න පුළුවන්:

E[] arr = (E[])new Object[INITIAL_ARRAY_LENGTH];

Effective ලදායී ජාවා හි සාමාන්‍ය එකතුවක් ක්‍රියාත්මක කිරීමේ යෝජිත ක්‍රමවලින් එකක් මෙයයි ; අයිතමය 26 . වර්ග දෝෂ නොමැත, නැවත නැවත අරාව දැමිය යුතු නැත. කෙසේ වෙතත් මෙය අනතුරු ඇඟවීමක් අවුලුවන බැවින් එය අනතුරුදායක විය හැකි අතර එය ප්‍රවේශමෙන් භාවිතා කළ යුතුය. අදහස් වල විස්තර කර ඇති පරිදි, මෙය Object[]දැන් අපගේ E[]වර්ගය ලෙස වෙස්වලාගෙන ඇති අතර අනාරක්ෂිත ලෙස ClassCastExceptionභාවිතා කරන්නේ නම් අනපේක්ෂිත දෝෂ හෝ ඒවා ඇති විය හැකිය .

රීතියක් ලෙස, වාත්තු අරාව අභ්‍යන්තරව භාවිතා කරන තාක් කල් මෙම හැසිරීම ආරක්ෂිත වේ (උදා: දත්ත ව්‍යුහයකට පිටුබලය දීම), සහ සේවාදායක කේතයට ආපසු හෝ නිරාවරණය නොවීම. ඔබට සාමාන්‍ය වර්ගයක පෙළක් වෙනත් කේතයකට ආපසු යැවීමට අවශ්‍ය නම්, Arrayඔබ සඳහන් කරන පරාවර්තන පන්තිය යනු නිවැරදි මාර්ගයයි.

හැකි සෑම තැනකම, ඔබ Listජනක විද්‍යාව භාවිතා කරන්නේ නම්, අරා වලට වඩා s සමඟ වැඩ කිරීමට ඔබට වඩා ප්‍රීතිමත් කාලයක් ලැබෙනු ඇති බව සඳහන් කිරීම වටී . නිසැකවම සමහර විට ඔබට විකල්පයක් නැත, නමුත් එකතු කිරීමේ රාමුව භාවිතා කිරීම වඩා ශක්තිමත් ය.

වර්ගයේ ආරක්ෂාව ආරක්ෂා කරන අතරම ඔබ සොයන ආකාරයේ වර්ගයක් ලබා ගැනීම සඳහා ජනක විද්‍යාව භාවිතා කරන්නේ කෙසේද යන්න මෙන්න (අනෙක් පිළිතුරු වලට වඩා වෙනස්ව, එය ඔබට නැවත Objectඅරාවක් ලබා දෙනු ඇත හෝ සම්පාදනය කරන අවස්ථාවේ අනතුරු ඇඟවීම් ලබා දෙනු ඇත):

import java.lang.reflect.Array;  

public class GenSet<E> {  
    private E[] a;  

    public GenSet(Class<E[]> clazz, int length) {  
        a = clazz.cast(Array.newInstance(clazz.getComponentType(), length));  
    }  

    public static void main(String[] args) {  
        GenSet<String> foo = new GenSet<String>(String[].class, 1);  
        String[] bar = foo.a;  
        foo.a[0] = "xyzzy";  
        String baz = foo.a[0];  
    }  
}

එය අනතුරු ඇඟවීමකින් තොරව සම්පාදනය වන අතර, ඔබට පෙනෙන පරිදි main, ඔබ කුමන වර්ගයක නිදසුනක් GenSetලෙස ප්‍රකාශ කළත් , ඔබට aඑම වර්ගයේ අරාවකට අනුයුක්ත කළ හැකි අතර, ඔබට එම වර්ගයේ aවිචල්‍යයකට මූලද්‍රව්‍යයක් පැවරිය හැකිය , එනම් අරාව සහ අරාවෙහි අගයන් නිවැරදි වර්ගයට අයත් වේ.

ජාවා නිබන්ධනවල සාකච්ඡා කර ඇති පරිදි පන්ති වචනාර්ථය ධාවන කාල ටෝකන ලෙස භාවිතා කිරීමෙන් එය ක්‍රියාත්මක වේ. පංති සාක්ෂරතා සම්පාදකයා විසින් උදාහරණ ලෙස සලකනු ලැබේ java.lang.Class. එකක් භාවිතා කිරීමට, සමඟ පන්තියක නම අනුගමනය කරන්න .class. එබැවින්, පන්තිය නියෝජනය String.classකරන Classවස්තුවක් ලෙස ක්‍රියා කරයි String. මෙය අතුරුමුහුණත්, එනූම්ස්, ඕනෑම මාන අරා (උදා String[].class), ප්‍රාථමික (උදා int.class) සහ මූල පදය void(එනම් void.class) සඳහා ද ක්‍රියා කරයි.

Classම Generic බලපත්රය යටතේ අවසර ලබා ඇත වේ (ලෙස ප්රකාශයට පත් Class<T>කොහේද, Tබව වර්ගය සඳහා කි්රයා Classවර්ගය තේරුම වන්නේ, වස්තුවක් නියෝජනය), String.classයනු Class<String>.

ඒ නිසා, ඔබ වෙනුවෙන් ඉදිකිරීමටත් අයැදින GenSet, ඔබ රැසක් නියෝජනය කරන පළමු වාදය සඳහා පන්ති ප්රායෝගික සමත් GenSetඋදාහරණයක් ප්රකාශිත වර්ගය (උදා: String[].classසඳහා GenSet<String>). වර්ග විචල්‍යයන් සඳහා ප්‍රාථමිකයන් භාවිතා කළ නොහැකි බැවින් ඔබට ප්‍රාථමික පෙළක් ලබා ගත නොහැකි බව සලකන්න.

ඉදිකිරීම්කරු තුළ, ක්‍රමවේදය ඇමතීමෙන්, castසම්මත කරන ලද Objectතර්කය Class, ක්‍රමය හැඳින්වූ වස්තුව නියෝජනය කරන පන්තියට යවයි . පළමු තර්කය ලෙස සම්මත කරන ලද වස්තුව නියෝජනය කරන වර්ගයේ අරාව ලෙසත්, දෙවන තර්කය ලෙස සම්මත කළ නිශ්චිතව දක්වා ඇති දිගටත් newInstance, java.lang.reflect.Arrayප්‍රතිලාභවල ස්ථිතික ක්‍රමය ඇමතීම . මෙම ක්රමය ඉල්ලා ඇති නැවත විසින් නියෝජනය අරාව යන සංරචකය වර්ගය නියෝජනය වස්තුව (උදා: කරන ක්රමය ලෙස හැඳින්වූ වස්තුව සඳහා , නම්, වස්තුව රැසක් නියෝජනය වන්නේ නැත).ObjectClassintgetComponentTypeClassClassString.classString[].classnullClass

එම අවසාන වාක්‍යය සම්පූර්ණයෙන්ම නිවැරදි නොවේ. ඇමතීමෙන් පන්තිය නියෝජනය String[].class.getComponentType()කරන Classවස්තුවක් ආපසු ලබා දෙයි String, නමුත් එහි වර්ගය එසේ Class<?>නොවේ Class<String>, ඒ නිසා ඔබට පහත සඳහන් දේ වැනි දෙයක් කළ නොහැක.

String foo = String[].class.getComponentType().cast("bar"); // won't compile

වස්තුවක් Classආපසු ලබා දෙන සෑම ක්‍රමයක් සඳහාම Classඑයම වේ.

මෙම පිළිතුර පිළිබඳව ජොකිම් සෝවර් කළ ප්‍රකාශය සම්බන්ධයෙන් (ඒ පිළිබඳව මා ගැනම අදහස් දැක්වීමට තරම් කීර්තියක් මා සතුව නැත), වාත්තු කිරීම භාවිතා කිරීම පිළිබඳ උදාහරණය T[]අනතුරු ඇඟවීමක් වනු ඇත, මන්ද එම අවස්ථාවේ දී සම්පාදකයාට වර්ගයේ ආරක්ෂාව සහතික කළ නොහැකි බැවිනි.

ඉන්ගෝගේ අදහස් සම්බන්ධයෙන් සංස්කරණය කරන්න:

public static <T> T[] newArray(Class<T[]> type, int size) {
   return type.cast(Array.newInstance(type.getComponentType(), size));
}

ආරක්ෂිත ටයිප් කරන එකම පිළිතුර මෙයයි

E[] a;

a = newArray(size);

@SafeVarargs
static <E> E[] newArray(int length, E... array)
{
    return Arrays.copyOf(array, length);
}

වැඩි මානයන් දක්වා විස්තාරණය කිරීම සඳහා, []'සහ මානයන්හි පරාමිතීන් එක් කරන්න newInstance()( Tවර්ග පරාමිතියකි, clsa Class<T>, d1හරහා d5පූර්ණ සංඛ්‍යා වේ):

T[] array = (T[])Array.newInstance(cls, d1);
T[][] array = (T[][])Array.newInstance(cls, d1, d2);
T[][][] array = (T[][][])Array.newInstance(cls, d1, d2, d3);
T[][][][] array = (T[][][][])Array.newInstance(cls, d1, d2, d3, d4);
T[][][][][] array = (T[][][][][])Array.newInstance(cls, d1, d2, d3, d4, d5);

විස්තර Array.newInstance()සඳහා බලන්න.

ජාවා 8 හි, අපට ලැම්බඩා හෝ ක්‍රම යොමුව භාවිතා කරමින් යම් ආකාරයක සාමාන්‍ය අරාව නිර්මාණය කළ හැකිය. මෙය පරාවර්තක ප්‍රවේශයට සමාන වේ (එය a පසු කරයි Class), නමුත් මෙහිදී අපි පරාවර්තනය භාවිතා නොකරමු.

@FunctionalInterface
interface ArraySupplier<E> {
    E[] get(int length);
}

class GenericSet<E> {
    private final ArraySupplier<E> supplier;
    private E[] array;

    GenericSet(ArraySupplier<E> supplier) {
        this.supplier = supplier;
        this.array    = supplier.get(10);
    }

    public static void main(String[] args) {
        GenericSet<String> ofString =
            new GenericSet<>(String[]::new);
        GenericSet<Double> ofDouble =
            new GenericSet<>(Double[]::new);
    }
}

උදාහරණයක් ලෙස, මෙය භාවිතා කරන්නේ <A> A[] Stream.toArray(IntFunction<A[]>).

මෙය නිර්නාමික පංති භාවිතයෙන් ජාවා 8 ට පෙර කළ හැකි නමුත් එය වඩාත් කරදරකාරී ය.

මෙය Java ලදායී ජාවා, 2 වන සංස්කරණය , 25 වන අයිතමයේ 5 වන පරිච්ඡේදයේ (ජනක විද්‍යාව) ආවරණය කර ඇත ... අරා සඳහා ලැයිස්තු මනාප

ඔබගේ කේතය ක්‍රියා නොකරනු ඇත, එය පරීක්ෂා නොකළ අනතුරු ඇඟවීමක් ජනනය කළද (පහත දැක්වෙන විවරණයෙන් ඔබට එය යටපත් කළ හැකිය:

@SuppressWarnings({"unchecked"})

කෙසේ වෙතත්, අරාව වෙනුවට ලැයිස්තුවක් භාවිතා කිරීම වඩා හොඳය.

OpenJDK ව්‍යාපෘති අඩවියේ මෙම දෝෂය / විශේෂාංගය පිළිබඳ සිත්ගන්නා සංවාදයක් ඇත .

පංති තර්කය ඉදිකිරීම්කරු වෙත යැවීමට ඔබට අවශ්‍ය නැත. මේක උත්සාහ කරන්න.

public class GenSet<T> {
    private final T[] array;
    @SuppressWarnings("unchecked")
    public GenSet(int capacity, T... dummy) {
        if (dummy.length > 0)
            throw new IllegalArgumentException(
              "Do not provide values for dummy argument.");
        Class<?> c = dummy.getClass().getComponentType();
        array = (T[])Array.newInstance(c, capacity);
    }
    @Override
    public String toString() {
        return "GenSet of " + array.getClass().getComponentType().getName()
            + "[" + array.length + "]";
    }
}

සහ

GenSet<Integer> intSet = new GenSet<>(3);
System.out.println(intSet);
System.out.println(new GenSet<String>(2));

ප්‍රති result ලය:

GenSet of java.lang.Integer[3]
GenSet of java.lang.String[2]

ජාවා ජනක විද්‍යාව ක්‍රියාත්මක වන්නේ සම්පාදනය කරන වේලාවේ වර්ග පරීක්ෂා කිරීමෙන් සහ සුදුසු කැස්ට් ඇතුළු කිරීමෙන් ය, නමුත් සම්පාදනය කරන ලද ලිපිගොනු වල වර්ග මකා දමයි . මෙමඟින් ජනක පුස්තකාල තේරුම් ගත නොහැකි කේතයක් මඟින් භාවිතා කළ හැකිය (එය හිතාමතාම සැලසුම් තීරණයක් විය) නමුත් එයින් අදහස් කරන්නේ ක්‍රියාත්මක වන වේලාවේ වර්ගය කුමක්දැයි ඔබට සාමාන්‍යයෙන් සොයාගත නොහැකි බවයි.

රාජ්ය Stack(Class<T> clazz,int capacity)ඉදිකිරීමටත් පන්ති තොරතුරු, ඉන් අදහස් වන්නේ, ලකුණු අවස්ථාවේ දී පංති වස්තුව සම්මත කිරීමට ඔබ අවශ්ය වේ එය අවශ්ය බව කේතය කිරීමට ක්රියාත්මක වීමේදී එහි දක්වා එළඹිය නොහැක. හා Class<T>ආකෘති පත්රය සම්පාදකවරයා ඔබ සමත් පන්ති වස්තුව අදවන ටී උපපංතිය, ටී ක superclass නොවේ වර්ගයක් ටී සඳහා පන්තියේ වස්තුව වේ, නමුත් හරියටම ටී බව පරීක්ෂා කරන බව අදහස්

මෙයින් අදහස් කරන්නේ ඔබට ඔබේ ඉදිකිරීම්කරු තුළ සුදුසු වර්ගයේ අරාව වස්තුවක් නිර්මාණය කළ හැකි බවයි, එයින් අදහස් වන්නේ ඔබ ඔබේ එකතුවෙහි ගබඩා කරන වස්තූන්ගේ වර්ගය එකතු කිරීමට එකතු කරන මොහොතේදී ඒවායේ වර්ග පරීක්ෂා කරනු ඇති බවයි.

හායි, ත්‍රෙඩ් එක මැරුණත්, මම මේ ගැන ඔබේ අවධානය යොමු කරන්න කැමතියි:

සම්පාදනය කරන වේලාවේදී වර්ග පරීක්ෂා කිරීම සඳහා ජනක විද්‍යාව භාවිතා කරයි:

• එබැවින් අරමුණ වන්නේ ඔබට අවශ්‍ය දේ පැමිණෙන්නේද යන්න පරීක්ෂා කිරීමයි.
• ඔබ ආපසු එන්නේ පාරිභෝගිකයාට අවශ්‍ය දෙයයි.
• මෙය පරීක්ෂා කරන්න:

ඔබ සාමාන්‍ය පන්තියක් ලියන විට යතුරු ලියනය කිරීමේ අනතුරු ඇඟවීම් ගැන කරදර නොවන්න. ඔබ එය භාවිතා කරන විට කරදර වන්න.

මෙම විසඳුම ගැන කුමක් කිව හැකිද?

@SafeVarargs
public static <T> T[] toGenericArray(T ... elems) {
    return elems;
}

එය ක්‍රියාත්මක වන අතර සත්‍ය වීමට තරම් සරල නැත. අඩුපාඩුවක් තිබේද?

මෙම කේතය දෙසද බලන්න:

public static <T> T[] toArray(final List<T> obj) {
    if (obj == null || obj.isEmpty()) {
        return null;
    }
    final T t = obj.get(0);
    final T[] res = (T[]) Array.newInstance(t.getClass(), obj.size());
    for (int i = 0; i < obj.size(); i++) {
        res[i] = obj.get(i);
    }
    return res;
}

එය ඕනෑම ආකාරයක වස්තුවක ලැයිස්තුවක් එකම වර්ගයේ අරාවකට පරිවර්තනය කරයි.

මට වැඩ කරන ඉක්මන් හා පහසු ක්‍රමයක් මම සොයාගෙන ඇත. මම මෙය ජාවා ජේඩීකේ 8 හි පමණක් භාවිතා කර ඇති බව සලකන්න. එය පෙර සංස්කරණ සමඟ ක්‍රියා කරයිදැයි මම නොදනිමි.

නිශ්චිත වර්ගයේ පරාමිතියක සාමාන්‍ය පෙළක් අපට ක්ෂණිකව දැක්විය නොහැකි වුවද, අපට දැනටමත් නිර්මාණය කර ඇති අරාව සාමාන්‍ය පන්ති සාදන්නෙකුට ලබා දිය හැකිය.

class GenArray <T> {
    private T theArray[]; // reference array

    // ...

    GenArray(T[] arr) {
        theArray = arr;
    }

    // Do whatever with the array...
}

දැන් ප්‍රධාන වශයෙන් අපට එවැනි අරා නිර්මාණය කළ හැකිය:

class GenArrayDemo {
    public static void main(String[] args) {
        int size = 10; // array size
        // Here we can instantiate the array of the type we want, say Character (no primitive types allowed in generics)
        Character[] ar = new Character[size];

        GenArray<Character> = new Character<>(ar); // create the generic Array

        // ...

    }
}

ඔබේ අරා සමඟ වැඩි නම්යතාවයක් සඳහා ඔබට සම්බන්ධිත ලැයිස්තුවක් භාවිතා කළ හැකිය. Java.util.ArrayList පන්තියේ ඇති අරේලිස්ට් සහ වෙනත් ක්‍රම.

උදාහරණය වන්නේ අරාව නිර්මාණය කිරීම සඳහා ජාවා පරාවර්තනය භාවිතා කිරීමයි. යතුරු ලියනය කිරීම ආරක්ෂිත නොවන බැවින් මෙය කිරීම සාමාන්‍යයෙන් නිර්දේශ නොකරයි. ඒ වෙනුවට, ඔබ කළ යුත්තේ අභ්‍යන්තර ලැයිස්තුවක් භාවිතා කිරීම පමණක් වන අතර අරාව කිසිසේත් වළකින්න.

සාරධර්ම ලැයිස්තුවක් පසු කරමින් ...

public <T> T[] array(T... values) {
    return values;
}

සරල ස්වයංක්‍රීය පරීක්ෂණ උපයෝගීතාවයක් සඳහා සමත් වූ පංතියක් පරාවර්තකව ක්ෂණිකව තහවුරු කිරීම සඳහා මම මෙම කේත ස්නිපටය සෑදුවෙමි.

Object attributeValue = null;
try {
    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }
    else if(!clazz.isInterface()){
        attributeValue = BeanUtils.instantiateClass(clazz);
    }
} catch (Exception e) {
    logger.debug("Cannot instanciate \"{}\"", new Object[]{clazz});
}

මෙම කොටස සැලකිල්ලට ගන්න:

    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }

අරාව ආරම්භ කිරීම සඳහා Array.newInstance (අරාව පන්තිය, අරාවෙහි ප්‍රමාණය) . පන්තිය ප්‍රාථමික (int.class) සහ වස්තුව (Integer.class) යන දෙකම විය හැකිය.

බීන් යුටිල්ස් වසන්තයේ කොටසකි.

ඇත්ත වශයෙන්ම එසේ කිරීමට පහසුම ක්‍රමය නම්, පහත දැක්වෙන උදාහරණය මෙන් වස්තු සමූහයක් නිර්මාණය කර ඔබේ අපේක්ෂිත වර්ගයට දැමීමයි.

T[] array = (T[])new Object[SIZE];

එහිදී SIZEනියත වන අතර, Tමේ වර්ගයේ හඳුනාගැනීමේ

වෙනත් පුද්ගලයින් විසින් යෝජනා කරන ලද බලහත්කාරයෙන් මා වෙනුවෙන් වැඩ නොකළ අතර නීති විරෝධී වාත්තු කිරීම හැර.

කෙසේ වෙතත්, මෙම ව්‍යාජ වාත්තු කිරීම හොඳින් ක්‍රියාත්මක විය:

Item<K>[] array = new Item[SIZE];

අයිතමය යනු සාමාජිකයා අඩංගු මා විසින් අර්ථ දක්වා ඇති පන්තියකි:

private K value;

මේ ආකාරයෙන් ඔබට K වර්ගයේ පෙළක් (අයිතමයේ වටිනාකම පමණක් තිබේ නම්) හෝ පන්ති අයිතමයේ අර්ථ දැක්වීමට අවශ්‍ය ඕනෑම සාමාන්‍ය වර්ගයක් ලැබේ.

ඔබ පළ කළ උදාහරණයේ සිදුවන්නේ කුමක්ද යන ප්‍රශ්නයට වෙනත් කිසිවෙකු පිළිතුරු දී නොමැත.

import java.lang.reflect.Array;

class Stack<T> {
    public Stack(Class<T> clazz, int capacity) {
        array = (T[])Array.newInstance(clazz, capacity);
    }

    private final T[] array;
}

අනෙක් අය පවසා ඇති පරිදි සම්පාදනය කිරීමේදී ජනක විද්‍යාව “මකා දමනු ලැබේ”. එබැවින් ධාවන වේලාවේදී ජනකයක උදාහරණයක් එහි සංරචක වර්ගය කුමක්දැයි නොදනී. එයට හේතුව historical තිහාසික ය, සූර්යයාට අවශ්‍ය වූයේ පවතින අතුරු මුහුණත (මූලාශ්‍රය සහ ද්විමය යන දෙකම) බිඳ නොගෙන ජනකතා එකතු කිරීමට ය.

අනෙක් අතට අරා නැහැ වීමේදී සංරචක වර්ගය දන්නවා.

මෙම උදාහරණය ගැටළුව වටා ක්‍රියා කරන්නේ ඉදිකිරීම්කරු (වර්ගය දන්නා) ලෙස හඳුන්වන කේතය පන්තියට අවශ්‍ය වර්ගය පවසන පරාමිතියක් පසුකර යාමෙනි.

එබැවින් යෙදුම පන්තිය වැනි දෙයක් සමඟ ගොඩනගනු ඇත

Stack<foo> = new Stack<foo>(foo.class,50)

සංරචක වර්ගය කුමක්දැයි ඉදිකිරීම්කරු දැන් (ධාවන වේලාවේදී) දන්නා අතර පරාවර්තන API හරහා අරාව තැනීමට එම තොරතුරු භාවිතා කළ හැකිය.

Array.newInstance(clazz, capacity);

අවසාන වශයෙන් අපට ටයිප් කාස්ට් එකක් තිබේ, මන්ද යත්, ආපසු ලබා දුන් අරාව Array#newInstance()නිවැරදි වර්ගය බව අප දැන සිටියත් සම්පාදකයාට දැනගත නොහැකි බැවිනි (අප දන්නා වුවත්).

මෙම විලාසිතාව තරමක් කැත නමුත් සමහර විට එය ඕනෑම වේලාවක (අරා නිර්මාණය කිරීම, හෝ ඒවායේ සංරචක වර්ගය පිළිබඳ අවස්ථා නිර්මාණය කිරීම ආදිය) ක්‍රියාත්මක වන වේලාවේදී ඒවායේ සංරචක වර්ගය දැන ගැනීමට අවශ්‍ය සාමාන්‍ය වර්ග නිර්මාණය කිරීම සඳහා අවම නරක විසඳුම විය හැකිය.

මෙම ගැටලුවට යම් ආකාරයක වැඩක් මට හමු විය.

පහත පේළිය සාමාන්‍ය අරාව සෑදීමේ දෝෂයක් විසි කරයි

List<Person>[] personLists=new ArrayList<Person>()[10];

කෙසේ වෙතත් මම List<Person>වෙනම පන්තියකට සම්බන්ධ කළහොත් එය ක්‍රියාත්මක වේ.

import java.util.ArrayList;
import java.util.List;


public class PersonList {

    List<Person> people;

    public PersonList()
    {
        people=new ArrayList<Person>();
    }
}

ඔබට පුද්ගල ලැයිස්තුවේ පන්තියේ පුද්ගලයින් හෙළිදරව් කළ හැකිය. පහත දැක්වෙන රේඛාව මඟින් ඔබට List<Person>සෑම අංගයකම අරා එකක් ලබා දෙනු ඇත . වෙනත් වචන වලින් කිවහොත් List<Person>.

PersonList[] personLists=new PersonList[10];

මා වැඩ කරමින් සිටි යම් කේතයක මට මේ වගේ දෙයක් අවශ්‍ය වූ අතර එය ක්‍රියාත්මක කිරීමට මා කළේ මෙයයි. මෙතෙක් ගැටළු නොමැත.

ඔබට වස්තු අරාවක් සාදා එය සෑම තැනකම E වෙත දමන්න. ඔව්, එය කිරීමට එය ඉතා පිරිසිදු ක්‍රමයක් නොවන නමුත් එය අවම වශයෙන් ක්‍රියාත්මක විය යුතුය.

මේක උත්සාහ කරන්න.

private int m = 0;
private int n = 0;
private Element<T>[][] elements = null;

public MatrixData(int m, int n)
{
    this.m = m;
    this.n = n;

    this.elements = new Element[m][n];
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            this.elements[i][j] = new Element<T>();
        }
    }
}

මේ සඳහා පහසු, අවුල් සහගත ක්‍රියාමාර්ගයක් වනුයේ ඔබේ ප්‍රධාන පන්තියේ ඇතුළත දෙවන “දරන්නා” පන්තියක් කැදැල්ල කර ඔබේ දත්ත රඳවා ගැනීමට එය භාවිතා කිරීමයි.

public class Whatever<Thing>{
    private class Holder<OtherThing>{
        OtherThing thing;
    }
    public Holder<Thing>[] arrayOfHolders = new Holder<Thing>[10]
}

සමහර විට මෙම ප්‍රශ්නයට සම්බන්ධ නැති නමුත් මම generic array creationභාවිතා කිරීමේදී " " දෝෂය ලබා ගනිමින් සිටියදී

Tuple<Long,String>[] tupleArray = new Tuple<Long,String>[10];

මම පහත සඳහන් කෘති (සහ මා වෙනුවෙන් වැඩ කළෙමි) සමඟ @SuppressWarnings({"unchecked"}):

 Tuple<Long, String>[] tupleArray = new Tuple[10];

මෙම කේතය gen ලදායී ජනක අරාවක් නිර්මාණය කරයිදැයි මම කල්පනා කරමි.

public T [] createArray(int desiredSize){
    ArrayList<T> builder = new ArrayList<T>();
    for(int x=0;x<desiredSize;x++){
        builder.add(null);
    }
    return builder.toArray(zeroArray());
}

//zeroArray should, in theory, create a zero-sized array of T
//when it is not given any parameters.

private T [] zeroArray(T... i){
    return i;
}

සංස්කරණය කරන්න: සමහර විට එවැනි අරාවක් නිර්මාණය කිරීමේ විකල්ප ක්‍රමයක් නම්, ඔබට අවශ්‍ය ප්‍රමාණය දැනගෙන කුඩා නම්, අවශ්‍ය “ශුන්‍ය” ගණන ශුන්‍ය අරා විධානයට පෝෂණය කිරීම විය හැකිද?

පැහැදිලිවම මෙය createArray කේතය භාවිතා කිරීම තරම් බහුකාර්ය නොවේ.

ඔබට කාස්ට් එකක් භාවිතා කළ හැකිය:

public class GenSet<Item> {
    private Item[] a;

    public GenSet(int s) {
        a = (Item[]) new Object[s];
    }
}

සාමාන්‍ය පෙළක් ආරම්භ කිරීමට ඇති නොහැකියාව මඟහරවා ගැනීම සඳහා මම සැබවින්ම සුවිශේෂී විසඳුමක් සොයා ගතිමි. ඔබ කළ යුත්තේ ටී වැනි සාමාන්‍ය විචල්‍යයට අනුව පන්තියක් නිර්මාණය කිරීමයි:

class GenericInvoker <T> {
    T variable;
    public GenericInvoker(T variable){
        this.variable = variable;
    }
}

ඉන්පසු ඔබේ අරාව පන්තියේදී එය එසේ ආරම්භ කරන්න:

GenericInvoker<T>[] array;
public MyArray(){
    array = new GenericInvoker[];
}

ආරම්භ කිරීම new Generic Invoker[]අනවසරයෙන් ගැටළුවක් ඇති කරයි නමුත් ඇත්ත වශයෙන්ම කිසිදු ගැටළුවක් නොවිය යුතුය.

අරාවෙන් ලබා ගැනීම සඳහා ඔබ අරාව [i] අමතන්න .එහි වෙනස් විය හැකිය:

public T get(int index){
    return array[index].variable;
}

අරාව ප්‍රතිප්‍රමාණනය කිරීම වැනි ඉතිරිය Arrays.copyOf () සමඟ කළ හැකිය:

public void resize(int newSize){
    array = Arrays.copyOf(array, newSize);
}

එකතු කිරීමේ ශ්‍රිතය මෙසේ එකතු කළ හැකිය:

public boolean add(T element){
    // the variable size below is equal to how many times the add function has been called 
    // and is used to keep track of where to put the next variable in the array
    arrays[size] = new GenericInvoker(element);
    size++;
}

Vnportnoy ට අනුව වාක්‍ය ඛණ්ඩය

GenSet<Integer> intSet[] = new GenSet[3];

පුරවා ගැනීම සඳහා ශුන්‍ය යොමු දැක්වීම් සමූහයක් නිර්මාණය කරයි

for (int i = 0; i < 3; i++)
{
   intSet[i] = new GenSet<Integer>();
}

වර්ගය ආරක්ෂිතයි.

private E a[];
private int size;

public GenSet(int elem)
{
    size = elem;
    a = (E[]) new E[size];
}

සාමාන්‍ය අරා නිර්මාණය ජාවා හි තහනම් නමුත් ඔබට එය එසේ කළ හැකිය

class Stack<T> {
private final T[] array;
public Stack(int capacity) {
    array = (T[]) new Object[capacity];
 }
}