คอฟฟี่เบรค #221. สามวิธีในการค้นหาองค์ประกอบในอาร์เรย์ Java Java Thread Local คืออะไรและใช้งานอย่างไร

สามวิธีในการค้นหาองค์ประกอบในอาร์เรย์ Java

ที่มา: Asyncq โพสต์นี้จะช่วยให้คุณเข้าใจวิธีต่างๆ ในการค้นหาองค์ประกอบในอาร์เรย์ใน Java ได้ดีขึ้น การค้นหาองค์ประกอบเฉพาะในชุดค่าเป็นการดำเนินการทั่วไปและใช้บ่อยมากในการพัฒนาซอฟต์แวร์ มีแนวทางที่แตกต่างกันในการแก้ปัญหานี้ ตั้งแต่แบบง่ายไปจนถึงแบบปรับให้เหมาะสม มาดูพวกเขากันดีกว่า

ป้อนข้อมูล

อาร์เรย์อินพุตประกอบด้วยข้อมูล id ดั้งเดิม และเราจำเป็นต้องทราบว่ามี id->3 หรือไม่

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

วิธีที่ 1 (ง่าย)

1. เราจะไปที่องค์ประกอบทั้งหมดของอาร์เรย์ ทีละองค์ประกอบ
2. นอกจากนี้ เรายังติดตามสถานะขององค์ประกอบเป้าหมายหากมีอยู่ในอาร์เรย์
3. ทันทีที่เราพบองค์ประกอบนี้ เราจะเปลี่ยนสถานะจากfalseเป็นtrue
4. หลังจากการวนซ้ำเสร็จสิ้น เราจะส่งคืนแฟล็กสถานะ

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

โซลูชันนี้ใช้งานได้แต่ไม่ได้มีประสิทธิภาพมากนัก หากคุณดูที่ เงื่อนไข ifคุณจะรู้ว่าเรากำลังทดสอบเงื่อนไขนี้สำหรับองค์ประกอบทั้งหมด สมมติว่าองค์ประกอบที่เรากำลังมองหาคือองค์ประกอบแรก แต่ลูปของเราจะยังคงทำงานต่อไปสำหรับองค์ประกอบทั้งหมด ที่นี่จะเป็นการดีกว่าหากออกจากลูปทันทีที่เราพบองค์ประกอบ เมื่อทำเช่นนี้ เราจะประหยัดการคำนวณเมื่อองค์ประกอบที่เราต้องการไม่อยู่ในตำแหน่งสุดท้าย

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

คุณสามารถทำให้โค้ดของคุณกระชับยิ่งขึ้นได้โดยใช้return เราสามารถคืนค่าเป็นจริงได้ทันทีที่เราเห็นองค์ประกอบที่เราต้องการ ไม่เช่นนั้นเราจะคืนค่าเท็จทันทีที่การวนซ้ำเสร็จสมบูรณ์ และเราไม่จำเป็นต้องสร้างและรักษาตัวแปรสถานะ

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

วิธีที่ 2

1. เราสามารถใช้ArrayListที่มีวิธีการที่โดยค่าเริ่มต้นจะค้นหาองค์ประกอบเป้าหมายในรายการ
2. เนื่องจากวิธีนี้มีให้โดยListเราจึงต้องแปลงอาร์เรย์ดั้งเดิมของเราให้เป็นรายการ
3. เราสามารถใช้สตริงแลมบ์ดาเส้นเดียวที่จะแปลงค่าดั้งเดิมเป็นประเภทอ็อบเจ็กต์และสร้างรายการจากมัน
   

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

4. เราสามารถใช้ Java 8 Stream API เพื่อทำให้โค้ดของเราทำงานได้และสั้นลงมาก
5. เพื่อให้เข้าใจว่า Stream API ทำงานอย่างไรกับสตรีม เราจำเป็นต้องแปลงอาร์เรย์อินพุตของเราให้เป็นสตรีม
6. Arrays.streamรับอาร์เรย์อินพุตและแปลงเป็นสตรีม
7. ตอนนี้เรามี threads แล้ว เราก็สามารถใช้วิธีที่มี ประโยชน์ได้มากมาย หนึ่งในนั้นคือanyMatch ส่งคืนองค์ประกอบที่ตรงกับภาคแสดง(id == inputId )
8. ทั้งหมดนี้ทำให้โค้ดของเราสั้นลงและอ่านง่ายขึ้นมาก
   

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

วิธีที่ 3 (ปรับให้เหมาะสม)

ใช่ โค้ดที่แสดงด้านบนใช้งานได้และอ่านง่าย แต่เรายังต้องดูและเปรียบเทียบแต่ละองค์ประกอบในสตรีม

1. หากหน่วยความจำไม่ใช่ปัญหาและเราต้องการปรับการคำนวณให้เหมาะสม สิ่งหนึ่งที่เราทำได้คือการสร้างชุดจากอาร์เรย์อินพุต
2. เราสามารถใช้โค้ดรูปแบบการ ทำงานอีกครั้งเพื่อแปลงอาร์เรย์ดั้งเดิมเป็นSet
3. ตอนนี้เรามีSetแล้ว เราสามารถค้นหาองค์ประกอบในช่วงเวลาคงที่ได้

ส

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

โบนัส

การค้นหาองค์ประกอบเดียวถือได้ว่าเป็นการดำเนินการทั่วไป แต่การค้นหาองค์ประกอบหลายรายการในอาร์เรย์จะพบบ่อยกว่า ในกรณีนี้ ถ้าเราไม่ใช้Setเราจะมีสองลูป และความซับซ้อนของเวลาจะเพิ่มขึ้นเพื่อคูณความยาวของคอลเลกชันทั้งสอง ด้านล่างนี้เป็นตัวอย่างที่เราแปลงอาร์เรย์ตัวใดตัวหนึ่งเป็นชุด จากนั้นวนซ้ำอาร์เรย์อื่นและทำการค้นหาในการดำเนินการชุด ด้วยการทำเช่นนี้เราจะเพิ่มหน่วยความจำและในขณะเดียวกันก็ประหยัดการคำนวณ

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();

Java Thread Local คืออะไร และใช้งานอย่างไร

แหล่งที่มา: สื่อ ในบทความนี้ เราจะดูที่ Java Thread Localและวิธีใช้งานอย่างมีประสิทธิภาพในแอปพลิเคชัน Java ของคุณ Java Thread Localเป็นคุณสมบัติอันทรงพลังที่ช่วยให้นักพัฒนาสามารถสร้างตัวแปรสำหรับเธรดที่ระบุเท่านั้น ซึ่งหมายความว่าแต่ละเธรดสามารถมีสำเนาของตัวแปรของตัวเองได้ และการเปลี่ยนแปลงที่ทำกับตัวแปรในเธรดหนึ่งจะไม่ส่งผลกระทบต่อค่าของตัวแปรในเธรดอื่น

Thread Local คืออะไร

Thread Localเป็นคลาสใน Java API ที่ช่วยให้คุณสามารถสร้างตัวแปรที่อยู่ในเธรดเฉพาะได้ นั่นคือ แต่ละเธรดมีสำเนาของตัวแปรของตัวเอง และการเปลี่ยนแปลงที่ทำกับตัวแปรในเธรดหนึ่งจะไม่ส่งผลต่อค่าของตัวแปรในเธรดอื่น สิ่งนี้ทำให้Thread Localเป็นโซลูชันในอุดมคติสำหรับการจัดเก็บข้อมูลเฉพาะเธรด เช่น ข้อมูลการตรวจสอบผู้ใช้ การเชื่อมต่อฐานข้อมูล หรือข้อมูลเฉพาะเธรดอื่น ๆ

Thread Local ทำงานอย่างไรใน Java

หากต้องการใช้Thread Localในแอปพลิเคชัน Java ของคุณ คุณต้องสร้างอินสแตนซ์ของ คลาส Thread Localก่อน ซึ่งสามารถทำได้โดยการเรียก ตัวสร้าง ThreadLocalซึ่งจะสร้างอินสแตนซ์ใหม่ของคลาสนี้ ถัดไป โดยการสร้าง วัตถุThread Localคุณสามารถใช้มันเพื่อจัดเก็บและดึงข้อมูลเฉพาะของเธรดได้ นี่คือตัวอย่างวิธีใช้Thread Localในแอปพลิเคชัน Java ของคุณ:

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();
  }
}

ในตัวอย่างนี้ เราสร้าง อ็อบเจ็กต์ Thread Local ชื่อthreadLocalประเภทString นอกจากนี้เรายังสร้างสองวิธี: set()และget() ที่ช่วยให้เราสามารถจัด เก็บและดึงค่าของ ตัวแปร Thread Local หากต้องการจัดเก็บค่าใน ตัวแปร Thread Localเราเพียงเรียกเมธอดset()และส่งผ่านค่าที่เราต้องการจัดเก็บ ตัวอย่างเช่น เราสามารถเรียกMyThreadLocalClass.set("Hello, World!")เพื่อจัดเก็บสตริง“Hello, World!” ใน ตัวแปร Thread Local หากต้องการรับค่าของ ตัวแปร Thread Localเราเพียงเรียก เมธอด get( ) ตัวอย่างเช่น เราสามารถเรียกString value = MyThreadLocalClass.get()เพื่อรับค่าของ ตัวแปร Thread Local

คำแนะนำสำหรับการทำงานกับ Thread Local

แม้ว่าThread Localอาจเป็นเครื่องมือที่มีประสิทธิภาพในแอปพลิเคชัน Java ของคุณ แต่สิ่งสำคัญคือต้องใช้อย่างถูกต้องเพื่อหลีกเลี่ยงปัญหาที่อาจเกิดขึ้น ต่อไปนี้เป็นแนวทางบางประการที่ควรคำนึงถึงเมื่อใช้Thread Local :

1. ใช้Thread Localเมื่อจำเป็นเท่านั้น: สำหรับข้อมูลเฉพาะเธรดเท่านั้น หากข้อมูลไม่เฉพาะเจาะจงเธรด จะต้องจัดเก็บด้วยวิธีอื่น
2. หลีกเลี่ยงการใช้หน่วยความจำมากเกินไป: Thread Localอาจใช้หน่วยความจำจำนวนมากหากไม่ได้ใช้อย่างระมัดระวัง อย่าลืมล้าง ตัวแปรThread Localเมื่อไม่จำเป็นอีกต่อไปเพื่อหลีกเลี่ยงการใช้หน่วยความจำมากเกินไป
3. ใช้Thread Localด้วยความระมัดระวังในสภาพแวดล้อมแบบมัลติเธรด: สิ่งสำคัญคือต้องเข้าใจความเสี่ยงและข้อจำกัดที่อาจเกิดขึ้น อย่าลืมทดสอบโค้ดของคุณอย่างละเอียดเพื่อให้แน่ใจว่าThread Localทำงานตามที่คาดไว้ในสภาพแวดล้อมเฉพาะของคุณ

บทสรุป

Java Thread Localเป็นเครื่องมือที่ยอดเยี่ยมที่ช่วยให้นักพัฒนาสามารถสร้างตัวแปรสำหรับเธรดที่ระบุเท่านั้น การใช้Thread Localคุณสามารถจัดเก็บข้อมูลเฉพาะเธรดได้ เช่น ข้อมูลการตรวจสอบผู้ใช้ การเชื่อมต่อฐานข้อมูล หรือข้อมูลเฉพาะเธรดอื่น ๆ แม้ว่าThread Localสามารถเป็นเครื่องมือที่มีประสิทธิภาพได้ แต่สิ่งสำคัญคือต้องใช้อย่างถูกต้องเพื่อหลีกเลี่ยงปัญหาที่อาจเกิดขึ้น เมื่อปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุดและทดสอบโค้ดของคุณ คุณจะสามารถใช้โค้ดดังกล่าวได้อย่างมีประสิทธิภาพเพื่อปรับปรุงประสิทธิภาพและความน่าเชื่อถือของแอปพลิเคชัน Java ของคุณ