Coffee break #221. Tatlong paraan upang makahanap ng isang elemento sa isang array ng Java. Ano ang Java Thread Local at kung paano ito gamitin

Tatlong paraan upang makahanap ng isang elemento sa isang array ng Java

Source: Asyncq Tutulungan ka ng post na ito na mas maunawaan ang iba't ibang paraan upang maghanap ng elemento sa isang array sa Java. Ang paghahanap ng isang tiyak na elemento sa isang hanay ng mga halaga ay isang napaka-pangkaraniwan at madalas na ginagamit na operasyon sa pagbuo ng software. Mayroong iba't ibang mga diskarte upang malutas ang problemang ito, mula sa simple hanggang sa na-optimize. Tingnan natin sila.

Input ang data

Ang input array ay naglalaman ng primitive id data at kailangan nating malaman kung naglalaman ito ng id->3.

int[] ids = { 1,2,13,14,15,3,10,11,12,4,5,6,7,8,9 };
int inputId = 3;

Paraan 1 (simple)

1. Binibisita namin ang lahat ng mga elemento ng array, isang elemento sa isang pagkakataon.
2. Bilang karagdagan, sinusubaybayan namin ang estado ng target na elemento kung mayroon ito sa array.
3. Sa sandaling mahanap namin ang elementong ito, inililipat namin ang katayuan mula false patungo sa true .
4. Matapos makumpleto ang loop, ibabalik namin ang flag ng status.

boolean valExist = false;
for (int id : ids) {
   if (inputId == id) {
             valExist = true;
   }
}
return valExist;

Gumagana ang solusyon na ito, ngunit hindi ito masyadong mabisa. Kung titingnan mo ang if condition , malalaman mo na sinusubok namin ang kundisyong ito para sa lahat ng elemento. Sabihin nating ang elementong hinahanap natin ay ang unang elemento, ngunit ang ating loop ay patuloy pa ring tatakbo para sa lahat ng elemento. Dito magiging mas matalinong lumabas sa loop sa sandaling mahanap natin ang elemento. Sa paggawa nito, makakatipid kami sa mga kalkulasyon kapag ang elementong hinahanap namin ay wala sa huling posisyon.

boolean valExist = false;
for (int id : ids) {
    if (inputId == id) {
                valExist = true;
                break;
     }
}
return valExist;

Maaari mong gawing mas maigsi ang iyong code sa pamamagitan ng paggamit ng return . Maaari kaming magbalik ng true sa sandaling makita namin ang elementong hinahanap namin, kung hindi, ibabalik namin ang false sa sandaling makumpleto ang loop. At hindi namin kailangang lumikha at magpanatili ng isang variable ng estado.

for (int id : ids) {
      if (inputId == id) {
                return true;
       }
  }
  return false;

Paraan 2

1. Maaari kaming gumamit ng ArrayList na naglalaman ng paraan na bilang default ay naghahanap ng target na elemento sa listahan.
2. Dahil ang paraang ito ay ibinigay ng List , kailangan naming i-convert ang aming primitive array sa isang listahan.
3. Maaari kaming gumamit ng isang string ng lambda na nagko-convert ng primitive sa isang uri ng bagay at gumagawa ng isang listahan mula dito.
   

   return Arrays.asList(Arrays.stream(ids).boxed().toArray())
                 .contains(inputId);

4. Magagamit namin ang Java 8 Stream API para gawing functional at mas maikli ang aming code.
5. Upang maunawaan kung paano gumagana ang Stream API sa mga stream, kailangan naming i-convert ang aming input array sa isang stream.
6. Kinukuha ng Arrays.stream ang input array at kino-convert ito sa mga stream.
7. Ngayon na mayroon na kaming mga thread, maaari kaming gumamit ng maraming kapaki-pakinabang na pamamaraan, isa na rito ang anyMatch . Ibinabalik nito ang elementong tumutugma sa panaguri (id == inputId) .
8. Ang lahat ng ito ay ginagawang mas maikli at mas madaling basahin ang aming code.
   

   return Arrays.stream(ids)
             .anyMatch(id -> id == inputId);

Paraan 3 (na-optimize)

Oo, gumagana ang code na ipinapakita sa itaas at madaling basahin, ngunit kailangan pa rin naming bisitahin at ikumpara ang bawat elemento sa stream.

1. Kung ang memorya ay hindi isang isyu at gusto naming i-optimize ang mga kalkulasyon, kung gayon ang isa sa mga bagay na maaari naming gawin dito ay lumikha ng isang set mula sa input array.
2. Muli naming magagamit ang functional style code upang i-convert ang primitive array sa isang Set .
3. Ngayon na mayroon na tayong Set , maaari tayong maghanap ng elemento sa isang pare-parehong yugto ng panahon.

S

et<Integer> idsSet = Arrays.stream(ids).boxed().collect(Collectors.toSet());
return idsSet.contains(inputId);

Bonus

Ang paghahanap para sa isang elemento ay maaaring ituring na isang karaniwang operasyon, ngunit mas karaniwan ay ang paghahanap ng maraming elemento sa isang array. Sa kasong ito, kung hindi namin gagamitin ang Set , magkakaroon kami ng dalawang loop at tataas ang pagiging kumplikado ng oras upang i-multiply ang haba ng dalawang koleksyon. Nasa ibaba ang isang halimbawa kung saan kino-convert namin ang isa sa mga array bilang isang set at pagkatapos ay umulit sa kabilang array at nagsasagawa ng paghahanap sa set na operasyon. Sa paggawa nito, pinapataas namin ang memorya at kasabay nito ay nakakatipid sa mga kalkulasyon.

int[] targetIds = { 1, 3, 6, 88, 999, 34, 44, 55};
int[] ids = { 1,2,13,14,15,3,10,11,12,4,5,6,7,8,9 };


Set<Integer> idsSet = Arrays.stream(ids).boxed().collect(Collectors.toSet());
return Arrays.stream(targetIds)
            .boxed()
            .filter(id -> !idsSet.contains(id))
            .mapToInt(a -> a)
            .toArray();

Ano ang Java Thread Local at kung paano ito gamitin

Source: Medium Sa artikulong ito, titingnan natin ang Java Thread Local at kung paano ito epektibong gamitin sa iyong mga Java application. Ang Java Thread Local ay isang malakas na feature na nagbibigay-daan sa mga developer na lumikha ng mga variable para lamang sa isang partikular na thread. Nangangahulugan ito na ang bawat thread ay maaaring magkaroon ng sarili nitong kopya ng isang variable, at ang mga pagbabagong ginawa sa isang variable sa isang thread ay hindi makakaapekto sa halaga nito sa isa pang thread.

Ano ang Thread Local

Ang Thread Local ay isang klase sa Java API na nagbibigay-daan sa iyong lumikha ng mga variable na lokal sa isang partikular na thread. Iyon ay, ang bawat thread ay may sariling kopya ng variable, at ang mga pagbabagong ginawa sa isang variable sa isang thread ay hindi makakaapekto sa halaga nito sa isa pang thread. Ginagawa nitong perpektong solusyon ang Thread Local para sa pag-iimbak ng data na partikular sa thread gaya ng impormasyon sa pagpapatunay ng user, mga koneksyon sa database, o anumang iba pang impormasyong partikular sa thread.

Paano Gumagana ang Thread Local sa Java

Upang magamit ang Thread Local sa iyong Java application, kailangan mo munang lumikha ng isang halimbawa ng klase ng Thread Local . Magagawa ito sa pamamagitan ng pagtawag sa ThreadLocal constructor , na lilikha ng bagong instance ng klase na ito. Susunod, sa pamamagitan ng paggawa ng Thread Local object , magagamit mo ito upang mag-imbak at kumuha ng data na tukoy sa thread. Narito ang isang halimbawa kung paano gamitin ang Thread Local sa iyong Java application:

public class MyThreadLocalClass {
  private static final ThreadLocal<String> threadLocal = new ThreadLocal<>();

  public static void set(String value) {
    threadLocal.set(value);
  }

  public static String get() {
    return threadLocal.get();
  }
}

Sa halimbawang ito, gumawa kami ng Thread Local object na tinatawag na threadLocal ng uri ng String . Gumawa rin kami ng dalawang paraan: set() at get() na nagbibigay-daan sa amin na iimbak at kunin ang halaga ng Thread Local variable . Para mag-imbak ng value sa isang Thread Local variable , tawagan lang namin ang set() na paraan at ipasa ang value na gusto naming i-store. Halimbawa, maaari naming tawagan ang MyThreadLocalClass.set("Hello, World!") upang iimbak ang string na "Hello, World!" sa Thread Local variable . Upang makuha ang halaga ng Thread Local variable , tawagan lang namin ang get() method . Halimbawa, maaari naming tawagan ang String value = MyThreadLocalClass.get() para makuha ang value ng Thread Local variable .

Mga rekomendasyon para sa pagtatrabaho sa Thread Local

Bagama't ang Thread Local ay maaaring maging isang makapangyarihang tool sa iyong mga Java application, mahalagang gamitin ito nang tama upang maiwasan ang mga potensyal na problema. Narito ang ilang alituntuning dapat tandaan kapag gumagamit ng Thread Local :

1. Gumamit lamang ng Thread Local kung kinakailangan: para lamang sa data na tukoy sa thread. Kung ang data ay hindi partikular sa thread, dapat itong iimbak sa ibang paraan.
2. Iwasan ang labis na paggamit ng memorya: Maaaring kumonsumo ng malaking halaga ng memory ang Thread Local kung hindi maingat na gagamitin. Siguraduhing i-clear ang Thread Local variable kapag hindi na kailangan ang mga ito para maiwasan ang labis na paggamit ng memory.
3. Gamitin ang Thread Local nang may pag-iingat sa mga multi-threaded na kapaligiran: mahalagang maunawaan ang mga potensyal na panganib at limitasyon. Siguraduhing subukang mabuti ang iyong code upang matiyak na gumagana ang Thread Local gaya ng inaasahan sa iyong partikular na kapaligiran.

Konklusyon

Ang Java Thread Local ay isang mahusay na tool na nagbibigay-daan sa mga developer na lumikha ng mga variable para lamang sa isang partikular na thread. Gamit ang Thread Local , maaari kang mag-imbak ng data na partikular sa thread, gaya ng impormasyon sa pagpapatunay ng user, mga koneksyon sa database, o iba pang impormasyong partikular sa thread. Bagama't maaaring maging isang makapangyarihang tool ang Thread Local , mahalagang gamitin ito nang tama upang maiwasan ang mga potensyal na problema. Sa pamamagitan ng pagsunod sa pinakamahuhusay na kagawian at pagsubok sa iyong code, mabisa mo itong magagamit upang mapabuti ang pagganap at pagiging maaasahan ng iyong mga Java application.