Autoboxing at unboxing sa Java

Sa artikulong ito titingnan natin ang isang tampok sa Java na tinatawag na autoboxing/unboxing . Ang autoboxing at unboxing ay isang function ng pag-convert ng mga primitive na uri sa mga uri ng object at vice versa. Ang buong proseso ay awtomatikong ginagawa ng Java Runtime Environment (JRE). Ngunit dapat kang mag-ingat kapag ipinapatupad ang pagpapaandar na ito, dahil... Maaari itong makaapekto sa pagganap ng iyong programa.

Panimula

Sa mga bersyon sa ibaba ng JDK 1.5, hindi madaling i-convert ang mga primitive na uri ng data gaya ng int, char, float, doublesa kanilang mga klase ng wrapper na Integer, Character, Float, Double. Simula sa JDK 5, ang functionality na ito, na nagko-convert ng mga primitive na uri sa katumbas na mga bagay, ay awtomatikong ipinapatupad. Ang ari-arian na ito ay kilala bilang Autoboxing . Ang baligtad na proseso, ayon sa pagkakabanggit, ay Unboxing , i.e. ang proseso ng pag-convert ng mga bagay sa kanilang kaukulang mga primitive na uri. Ang halimbawang code para sa autoboxing at unboxing ay ibinigay sa ibaba: Autoboxing

Integer integer = 9;

Pag-unbox

int in = 0;
in = new Integer(9);

Kailan ginagamit ang auto packing at unpacking? Ang Autoboxing ay ginagamit ng Java compiler sa ilalim ng mga sumusunod na kondisyon:

• Kapag ang isang halaga ng isang primitive na uri ay ipinasa sa isang pamamaraan bilang isang parameter ng pamamaraan, na inaasahan ang isang bagay ng kaukulang klase ng wrapper.
• Kapag ang isang halaga ng primitive na uri ay itinalaga sa isang variable ng kaukulang klase ng wrapper.

Isaalang-alang ang sumusunod na halimbawa: Listahan 1: Simpleng code na nagpapakita ng autoboxing

public int sumEvenNumbers(List<Integer> intList ) {
int sum = 0;
for (Integer i: intList )
if ( i % 2 == 0 )
sum += i;
return sum;
}

Bago ang jdk 1.5, ang code sa itaas ay maaaring magdulot ng error sa compilation dahil ang natitirang operator % at unary plus += ay hindi mailapat sa isang klase ng wrapper. Ngunit sa jdk 1.5 at sa itaas ang code na ito ay nag-compile nang walang mga error, na nagko-convert ng Integer sa int. Ang pag-unbox ay ginagamit ng Java compiler sa ilalim ng mga sumusunod na kondisyon:

• Kapag ang isang bagay ay ipinasa bilang isang parameter sa isang pamamaraan na umaasa sa isang kaukulang primitive na uri.
• Kapag ang isang bagay ay itinalaga sa isang variable ng kaukulang primitive na uri.

Isaalang-alang ang sumusunod na halimbawa: Listahan 2: Simpleng code na nagpapakita ng pag-unbox

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

public class UnboxingCheck {

public static void main(String[] args) {
Integer in = new Integer(-8);

// 1. Распаковка через вызов метода
int absVal = absoluteValue(in);
System.out.println("absolute value of " + in + " = " + absVal);

List<Double> doubleList = new ArrayList<Double>();

// Автоупаковка через вызов метода
doubleList.add(3.1416);

// 2. Распаковка через присвоение
double phi = doubleList.get(0);
System.out.println("phi = " + phi);
}

public static int absoluteValue(int i) {
return (i < 0) ? -i : i;
}
}

Ang autoboxing at unboxing ay nagbibigay-daan sa developer na magsulat ng code na madaling basahin at maunawaan. Ang sumusunod na talahanayan ay nagpapakita ng mga primitive na uri ng data at ang kanilang mga katumbas na bagay sa wrapper. Talahanayan 1: Mga primitive na uri at katumbas na mga klase ng wrapper na may mga operator ng paghahambing Ang Autoboxing at pag-unbox ay maaaring gamitin sa mga operator ng paghahambing. Ang sumusunod na snippet ng code ay naglalarawan kung paano ito nangyayari: Listahan 3: Sample code na nagpapakita ng autoboxing at pag-unbox sa isang operator ng paghahambing

public class BoxedComparator {
  public static void main(String[] args) {
      Integer in = new Integer(25);
      if (in < 35)
          System.out.println("Value of int = " + in);
  }
}

Ang pag-autopack at pag-unpack kapag nag-overload ng isang paraan Ang pag-autopack at pag-unpack ay ginagawa kapag nag-overload ng isang paraan batay sa mga sumusunod na panuntunan:

• "Natatalo" ng pagpapalawak ang packaging sa isang sitwasyon kung saan may pagpipilian sa pagitan ng pagpapalawak at packaging; mas mainam ang pagpapalawak.

Listahan 4: Sample code na nagpapakita ng benepisyo ng overloading

public class WideBoxed {
  public class WideBoxed {
  static void methodWide(int i) {
       System.out.println("int");
   }

  static void methodWide( Integer i ) {
      System.out.println("Integer");
  }

  public static void main(String[] args) {
      short shVal = 25;
      methodWide(shVal);
  }
 }
}

Output ng programa - uriint

• Ang pagpapalawak ay lumalampas sa variable na bilang ng mga argumento Sa isang sitwasyon kung saan ito ay nagiging isang pagpipilian sa pagitan ng pagpapalawak at variable na bilang ng mga argumento, ang pagpapalawak ay mas kanais-nais.

Listahan 5: Sample code na nagpapakita ng benepisyo ng overloading

public class WideVarArgs {

    static void methodWideVar(int i1, int i2) {
      System.out.println("int int");
    }

    static void methodWideVar(Integer... i) {
       System.out.println("Integers");
    }

   public static void main( String[] args) {
       short shVal1 = 25;
      short shVal2 = 35;
     methodWideVar( shVal1, shVal2);
   }
  }

• Ang pag-iimpake ay nakakatalo sa variable na bilang ng mga argumento Sa isang sitwasyon kung saan ito ay nagiging isang pagpipilian sa pagitan ng pag-iimpake at variable na bilang ng mga argumento, ang pag-iimpake ay mas mainam.

Listahan 6: Sample code na nagpapakita ng benepisyo ng overloading

public class BoxVarargs {
     static void methodBoxVar(Integer in) {
         System.out.println("Integer");
     }

     static void methodBoxVar(Integer... i) {
         System.out.println("Integers");
     }
     public static void main(String[] args) {
         int intVal1 = 25;
         methodBoxVar(intVal1);
    }
}

Dapat mong isaisip ang mga sumusunod na bagay habang ginagamit ang Auto Packing: Tulad ng alam natin, ang bawat magandang feature ay may disbentaha. Ang auto packaging ay walang pagbubukod sa bagay na ito. Ilang mahahalagang tala na dapat tandaan ng developer kapag ginagamit ang feature na ito:

• Ang paghahambing ng mga bagay sa ==operator na ' ' ay maaaring nakakalito, dahil maaari itong ilapat sa mga primitive na uri at bagay. Kapag inilapat ang operator na ito sa mga bagay, talagang inihahambing nito ang mga sanggunian sa mga bagay, hindi ang mga bagay mismo.

Listahan 7: Sample code na nagpapakita ng paghahambing.

public class Comparator {
   public static void main(String[] args) {
     Integer istInt = new Integer(1);
       Integer secondInt = new Integer(1);

       if (istInt == secondInt) {
         System.out.println("both one are equal");

       } else {
          System.out.println("Both one are not equal");
      }
   }
}

• Paghahalo ng mga bagay at primitive na uri sa equality at relational operator. Kung ihahambing natin ang isang primitive na uri sa isang bagay, kung gayon ang bagay ay hindi naka-box, na maaaring magtapon NullPointerExceptionkung ang bagay null.
• Pag-cache ng bagay. Lumilikha ang pamamaraan valueOf()ng isang lalagyan ng mga primitive na bagay na ini-cache nito. Dahil ang mga halaga ay naka-cache sa hanay -128 hanggang 127, kasama, ang mga naka-cache na bagay na ito ay maaaring magkaiba ang kilos.
• Pagkasira ng pagganap. Ang pag-autobox o pag-unbox ay nagpapababa sa pagganap ng application dahil lumilikha ito ng hindi gustong bagay na pumipilit sa tagakolekta ng basura na tumakbo nang mas madalas.

Mga Kakulangan ng AutoBoxing Kahit na ang AutoBoxing ay may ilang mga pakinabang, mayroon itong mga sumusunod na disadvantages: Listahan 8: Sample code na nagpapakita ng isyu sa pagganap.

public int sumEvenNumbers(List intList) {
          int sum = 0;
          for (Integer i : intList) {
              if (i % 2 == 0) {
                  sum += i;
              }
          }
         return sum;
   }

Sa seksyong ito ng code, sum +=i palalawakin ito sa sum = sum + i. Simula sa +operator na ' ', magsisimulang mag-unbox ang JVM dahil +hindi mailalapat ang operator na ' ' sa isang bagay na Integer. At pagkatapos ay ang resulta ay naka-autopack pabalik. Bago ang JDK 1.5, intmagkaiba ang mga uri ng data at Integer. Sa kaso ng overloading ng pamamaraan, ang dalawang uri na ito ay ginamit nang walang mga problema. Sa pagdating ng awtomatikong pag-iimpake/pag-unpack, ito ay naging mas mahirap. Ang isang halimbawa nito ay ang overloaded na paraan remove()sa ArrayList. Ang klase ArrayListay may dalawang paraan ng pagtanggal - remove(index)at remove(object). Sa kasong ito, hindi magaganap ang overloading ng pamamaraan at tatawagin ang kaukulang pamamaraan na may naaangkop na mga parameter.

Konklusyon

Ang Autoboxing ay isang mekanismo para sa tahasang pag-convert ng mga primitive na uri ng data sa kaukulang mga klase ng wrapper (mga bagay). Ang compiler ay gumagamit ng paraan valueOf()upang i-convert ang mga primitive na uri sa mga bagay, at ang mga pamamaraan IntValue(), doubleValue()atbp., upang makuha ang mga primitive na uri ng object. Kino-convert ng Autoboxing ang boolean type booleansa Boolean, byteto Byte, charto Character, floatto Float, intto Integer, longto Long, shortto Short. Ang pag-unpack ay nangyayari sa baligtad na direksyon. Orihinal na artikulo