Mbalikake Array ing Jawa

Array asring digunakake ing coding lan minangka cara kanggo nyimpen sawetara nilai saka jinis sing padha ing siji variabel. Bisa uga ana akeh alasan kenapa coder pengin mbalikke array. Sampeyan bisa uga kudu mbalikke array, contone, nalika logika masalah kudu miwiti karo unsur pungkasan. Ing kasus iki, laku paling apik kanggo nindakake kuwalikan lan banjur nggunakake array mbalikke yen perlu ing kode. Kajaba iku, mbalikke array minangka tugas sing populer banget ing wawancara Java Juniors.

Cara mbalikke Array

Ana akeh cara kanggo mbalikke array, lan ing kene kita nimbang 5. Kanggo Opsi 1, array dibalik nggunakake array tambahan sing diisi kanthi urutan munggah saka mburi array asli (mudhun), ing Pilihan 2 minangka pembalikan ing panggonan. digawa metu ngendi unsur Uploaded ing awal lan pungkasan diganti liwat, ing Pilihan 3, cara mbalikke () saka framework Collections digunakake kanggo nindakake kuwalikan, ing Pilihan 4, List.add () lan List.remove () digunakake, lan pungkasane, ing Pilihan 5, rekursi digunakake.

Opsi 1: Mbalikake Array nggunakake Array Tambahan

Ayo kita nulis cara prasaja kanggo mbalikke array nggunakake array tambahan . Opsi iki nggunakake array tambahan sing diisi diwiwiti karo unsur pungkasan saka array asli kanthi urutan mudhun, yaiku unsur sing pisanan padha karo unsur pungkasan ing array asli, sing kapindho padha karo sing kapindho saka pungkasan lan sateruse. terus nganti array tambahan diisi.

import java.util.Arrays;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {7, 8, 9, 10, 11};
       System.out.println("Array : " + Arrays.toString(array)); // print array

       // Call function to get reversed array
       int[] reversedArray = reverse(array);
       System.out.println("Reversed array : " + Arrays.toString(reversedArray)); // print reversed array
   }

   // Method returns a new reversed array, based on the array which was passed to it.
   static int[] reverse(int[] array) {
       int[] newArray = new int[array.length];

       for (int i = 0; i < array.length; i++) {
           newArray[array.length - 1 - i] = array[i];
       }

       return newArray;
   }
}

Ing conto iki, kita nulis cara sing mbalikke array lan ngasilake array sing dibalikake anyar, adhedhasar array sing diterusake. array diumumake ing utama lan banjur metode, mbalikke , diarani. Argumentasi kanggo metode kasebut yaiku array. Ing cara mbalikke , array anyar, newArray , digawe lan ukurane padha karo array , mung kosong. A kanggo daur ulang digunakake kanggo ngisi newArray lan ngoperasikake kabeh dawa array. Iki rampung kanthi miwiti karo unsur pisanan saka array lan nemtokake menyang unsur pungkasan saka newArray, banjur njupuk unsur kapindho array kita lan nemtokake menyang unsur pungkasan kapindho newArray , lan sateruse; newArray diisi mundur. Nalika daur ulang for rampung, newArray wis kebak lan minangka mbalikke saka array .

Opsi 2: Nyetak Unsur Array ing Urutan Reverse

Kanggo pilihan iki kanggo mbalikke Uploaded, ora perlu nggunakake array tambahan, lan ora diowahi menyang dhaftar Uploaded. Nanging, unsur array dilebokake ing urutan terbalik . Iki tegese padha, nyatane, diganti. Unsur kapisan diganti karo unsur pungkasan, unsur kapindho diganti karo unsur kaloro saka pungkasan, lan sateruse. A kanggo daur ulang digunakake lan yen iki wis rampung, array bakal wis mbalikke. Kode katon kaya iki:

import java.util.Arrays;
/*
reversing an array in-place
*/
public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       arrayReverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//arrayReverse is a method that reverses array in-place
   static void arrayReverse(int[] array) {
       for (int i = 0; i < array.length / 2; i++) {
           int temp = array[i];
           array[i] = array[array.length - i - 1];
           array[array.length - i - 1] = temp;
       }
   }
}

Array asli dicithak minangka String nggunakake Arrays.toString(array) , banjur array kita diterusake minangka argumen menyang mbalikke . Ing cara mbalikke ing loop for , variabel, temp, digawe lan digunakake. Ing daur ulang , urutan mbalikke ditindakake kanthi telung langkah:

1. nemtokake unsur pisanan kanggo temp
2. nemtokake unsur pungkasan menyang unsur pisanan
3. nemtokake suhu kanggo unsur pungkasan

Iki banjur dileksanakake maneh wektu iki kanggo unsur kapindho lan liya saka unsur pungkasan, lan ing. Iki ditindakake kanggo unsur-unsur urutan urutan nanging daur ulang mung nganti setengah ukuran array. Ateges unsur-unsur ing ujung-ujung array diganti. Cara iki bakal mlaku kaping pindho luwih cepet tinimbang cara nggunakake loop kanggo saka 0 nganti ukuran. Minangka asil urutan mbalikke saka array wis ngrambah lan kita ditampilake carane print array ing urutan mbalikke lan nilai sing dicithak metu:

Pilihan 3: Nggunakake Collections.reverse()

Ing Jawa, cara mbalikke , kang minangka bagéan saka framework Collections ana, bisa digunakake kanggo mbalikke array. Ayo digunakake kanggo nindakake kuwalikan.

import java.util.Arrays;
import java.util.Collections;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//method that reverses an array
   static void reverse(Integer[] array) {
       Collections.reverse(Arrays.asList(array));
   }
}

Utamane , array digawe lan diisi minangka array Integer kanthi 5 nomer. Banjur dicithak minangka dhaptar nggunakake Arrays.asList(array) banjur fungsi kasebut, mbalikke , diarani lan array diterusake minangka argumen menyang fungsi iki. Ing mbalikke , Collections.reverse digunakake, lan iki digunakake ing dhaftar Uploaded, Arrays.asList(array) , tinimbang Uploaded dhewe. Banjur ing langkah sabanjure kita bakal nuduhake carane print array ing urutan mbalikke nggunakake System.out.println , lan wektu iki saben unsur dicithak metu ing baris sing padha:

Opsi 4: Mbalikake Array nggunakake List.add() lan List.remove()

Ing pilihan anyar iki, List.add () lan List.remove () digunakake kanggo nindakake kuwalikan. Cara kerjane yaiku array diowahi dadi dhaptar lan unsur pungkasan saka dhaptar dibusak lan dilebokake ing wiwitan dhaptar. Sawise kabeh dhaptar wis diulang maneh, dhaptar anyar minangka pembalikan saka sing asli. Ing cara utama () , array digawe dumadi saka 5 nomer. Banjur negara asli saka Uploaded wis outputted kanggo console. Larik iki banjur dilebokake minangka argumen kanggo metode, mbalikke () . Cara iki bisa digunakake kanthi ngilangi unsur pungkasan lan nglebokake ing ngarep array. Pungkasan, status array anyar (diwalikke) dikirim menyang konsol. Ing mbalikke ()cara, Uploaded ditulis kanggo Dhaftar liwat Arrays.asList (array) , supaya bisa nambah () lan mbusak () cara kanggo nindakake kuwalikan. Cara iki bisa digunakake kanthi ngilangi unsur pungkasan lan nglebokake ing ngarep array. Langkah mbalikke () nggunakake minangka nderek. Iki nggunakake daur ulang kanggo nindakake pembalikan unsur-unsur dhaptar. Iku nindakake iki dening initialising variabel i . Kaping pisanan, i disetel kanggo 0. Nalika i = 0 , unsur ing list.size () - 1 ing dhaftar dibusak, lan iki bakal tansah dadi unsur pungkasan wiwit i <list.size () - 1. Wiwit cara mbusak () ngasilake unsur sing wis dibusak, unsur iki saiki ditambahake menyang dhaptar ing indeks i = 0 , IE, dipasang ing wiwitan. Sisan saka dhaptar banjur dipindhah menyang tengen nanging dhaptar anyar isih nduweni jumlah unsur sing padha, yaiku ukuran . Nerusake eksekusi kanggo daur ulang kanthi nilai sabanjure i , i = 1 , langkah-langkah sing padha ditindakake supaya unsur pungkasan dibusak lan dilebokake ing nomer ing i = 1 lan dhaptar pindhah menyang sisih tengen. Iki terus nganti nilai tambahan pungkasan i lan kabeh unsur ing dhaptar wis diganti. Ing kaloro kanggounsur daur ulang saka dhaftar karo indeks i disetel kanggo unsur Uploaded karo indeks i ngendi aku saka 0 kanggo list.size () - 1 . Kanggo ngringkes, langkah-langkah sing digunakake yaiku :

1. aku = 0
2. mbusak unsur ing list.size () - 1
3. unsur insert, sing ana ing list.size() - 1 , ing i = 0
4. tambahan i
5. baleni langkah 2 nganti 4 (kanthi nilai anyar kanggo i ing langkah 3) nganti nilai tambahan pungkasan saka i digunakake

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

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }

   static void reverse(Integer[] array) {
       List list = new ArrayList<>(Arrays.asList(array));

       for (int i = 0; i < list.size() - 1; i++) {
           list.add(i, list.remove(list.size() - 1));
       }

       for (int i = 0; i < list.size(); i++) {
           array[i] = list.get(i);
       }
   }
}

Kode iki menehi output:

Opsi 5: Mbalikake Array kanthi Rekursi

Cara rekursi digunakake akeh ing coding lan bisa digunakake kanggo nggawe metode sing efisien babagan cara mbalikke array. Ing pilihan iki, Uploaded diowahi menyang dhaftar lan banjur kode dadi menyang cara mbalikke () saben-saben njabut unsur pungkasan ing mburi dhaftar lan dhaftar wis nilai dibusak ditambahake ing urutan mbalikke. Kaya ing cara sadurunge, array digawe saka 5 nomer. Banjur diterusake minangka argumen menyang fungsi kasebut, mbalikke () . Ing mbalikke () bab pisanan sing wis rampung kanggo nguripake Uploaded menyang dhaftar lan mriksa ing ukuran dhaftar. Yen mung nduweni siji unsur utawa null banjur cara rampung lan bali. Yen ora, unsur pisanan dibusak, nanging disalin menyang Integer, nilai . Cara mbalikke () banjur disebut maneh lan recursion wiwit maneh. Nalika fungsi wis mlebu, langkah padha digawa metu, ukuran mriksa ngendi, yen dhaftar luwih saka 1 langkah sabanjure bakal mbusak unsur pisanan lan banjur nindakake recursion maneh. Nalika ukuran dhaftar 1, mbalikke () bali menyang ngendi iku disebut saka banjur dhaftar wis saben Nilai ditambahake kanggo mbangun munggah menyang mbalikke pas dhaftar asli.

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

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       List list = new ArrayList<>(Arrays.asList(array));
       reverse(list);
       System.out.println("Array after reverse : " + Arrays.toString(list.toArray()));
   }

   public static void reverse(List list) {
       if (list== null || list.size() <= 1) {
           return;
       }

       Integer value = list.remove(0);

       reverse(list);

       list.add(value);
   }
}

Outpute yaiku:

Kesimpulan

Dadi ing kene kita wis ndeleng 5 cara kanggo mbalikke array. Opsi 3, sing nggunakake framework Collections, mbokmenawa cara sing paling apik kanggo nggunakake wiwit Collections.reverse wis ana, nyoba lan dites, fungsi Jawa. Mesthi wae opsi liyane bisa digunakake, utamane nalika sinau, nanging umume metode standar, yen ana, sing paling apik amarga biasane dioptimalake lan diuji. Nanging, sampeyan bisa nggawe dhewe cara iki amarga iki latihan coding sing apik lan bakal mbantu sampeyan sukses ing wawancara kanggo Java Junior.