การเปลี่ยนแปลงใน Java อธิบาย [ด้วยตัวอย่างการเข้ารหัส]

เผยแพร่แล้ว: 2020-11-24

JAVA ได้รับการพัฒนาโดย James Gosling ที่ Sun Microsystems ในปี 1995 การใช้ JAVA นักพัฒนาสามารถสร้างแอปพลิเคชันที่เสถียร ปลอดภัย และยืดหยุ่นได้ ซึ่งสามารถทำงานได้บนเกือบทุกแพลตฟอร์ม รวมถึงระบบปฏิบัติการที่ใช้ Linux, Windows และ macOS

คุณสมบัติ Write Once, Run Always ของ JAVA (หรือที่รู้จักในชื่อ WORA) ยังช่วยลดความจำเป็นในการคอมไพล์โค้ดใหม่ที่ได้รับการคอมไพล์อย่างน่าพอใจในครั้งเดียวแล้ว ความเก่งกาจของ JAVA ทำให้เป็นภาษาในอุดมคติในการรวมการทำงานเชิงตรรกะและคณิตศาสตร์ที่ซับซ้อนในตัวเข้ากับแอปพลิเคชันข้ามแพลตฟอร์มเกือบทุกประเภท

ข้อดีของการใช้ JAVA เพื่อพัฒนาเว็บแอป ต่างจากสภาพแวดล้อมการพัฒนาเว็บทางเลือกอื่น (หรือที่นิยม) ขยายไปถึงเสาหลักสามประการของประโยชน์ของแอปพลิเคชันที่ยั่งยืน ได้แก่:

ไวยากรณ์ JAVA นั้นง่ายต่อการเรียนรู้และปรับให้เข้ากับได้ง่าย และเหมาะสำหรับผู้เขียนโค้ดในทุกระดับของความเร็วและความซับซ้อน สิ่งนี้ทำให้ JAVA เป็นเดิมพันที่ปลอดภัยสำหรับทีมพัฒนาที่อาจมีการเปลี่ยนแปลงบุคลากรบ่อยครั้ง เวลาที่ใช้สำหรับทรัพยากรใหม่ในการปรับตัวเองให้เข้ากับแพลตฟอร์มการพัฒนาทั่วไป (JAVA) เป็นหนึ่งในอุตสาหกรรมที่น้อยที่สุด
JAVA เป็นภาษาการเขียนโปรแกรมเชิงวัตถุระดับสูง ซึ่งทำให้เป็นแบบโมดูลาร์อย่างสมบูรณ์ในแนวทาง และทำให้นักพัฒนาสามารถสร้างส่วนโค้ดที่นำกลับมาใช้ใหม่ได้ตามหน้าที่ ซึ่งจะช่วยลดความพยายาม ไลบรารีขนาดใหญ่ของฟังก์ชันในตัวยังช่วยลดการพึ่งพาปลั๊กอินระดับอุดมศึกษาอื่น ๆ หรือส่วนเสริมของคอมไพเลอร์ สคริปต์ ฯลฯ ซึ่งจะทำให้ JAVA ใช้เวลาในการใช้งานน้อยที่สุด
JAVA ผสมผสานสิ่งที่ดีที่สุดของโลกทั้งหมดเข้าด้วยกันโดยไม่ขึ้นกับแพลตฟอร์มตามที่กล่าวไว้ข้างต้น เว็บแอปพลิเคชันที่พัฒนาขึ้นใน JAVA สามารถย้ายจากระบบปฏิบัติการหนึ่งไปยังอีกระบบหนึ่งได้อย่างง่ายดายโดยไม่สูญเสียฟังก์ชันการทำงาน และเป็นยูทิลิตี้ที่ประเมินค่าไม่ได้ในสภาพแวดล้อมการพัฒนาใดๆ

แง่มุมหนึ่งที่ทำให้ JAVA มีกำไรมากในฐานะที่เป็นแพลตฟอร์มการพัฒนาสำหรับเว็บ การพึ่งพาการใช้งานขั้นต่ำ และ ไวยากรณ์ทางคณิตศาสตร์ ของ มันสามารถใช้ประโยชน์ได้อย่างเต็มที่เพื่อดำเนินการคำสั่งทางคณิตศาสตร์หรือตรรกะเกือบทุกอย่างเพียงแค่เรียกใช้ฟังก์ชันในตัวโดยมีค่าขั้นต่ำเพิ่มเติม การปรับแต่ง

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

ในบทช่วยสอนนี้ เราจะเรียนรู้วิธีพยายามเปลี่ยนรูปแบบใน JAVA โดยการจัดเก็บอักขระตัวแรกของสตริงในตำแหน่ง "ที่ติดตาม" ของสตริง และเรียกใช้ฟังก์ชัน generatePermutation() เพื่อสุ่มรูปแบบต่างๆ กับตัวแปร อื่นๆ ทั้งหมด อักขระในสตริง

อ่าน: คำถามและคำตอบสัมภาษณ์ Java

สารบัญ

การเรียงสับเปลี่ยนใน Java — แนวคิดของ Backtracking Algorithm
ดำเนินการเรียงสับเปลี่ยนใน JAVA — อัลกอริธึมแบบเรียกซ้ำเพื่อย้อนรอยและสลับ
ทำการเรียงสับเปลี่ยนใน JAVA — โค้ดตัวอย่าง:
ทำการเรียงสับเปลี่ยนใน JAVA — ผลลัพธ์ที่ได้มาจากโค้ดตัวอย่าง:
บทสรุป

การเรียงสับเปลี่ยนใน Java — แนวคิดของ Backtracking Algorithm

ในการหาวิธีแก้ไขปัญหาการ เปลี่ยนแปลงนี้ใน JAVA ก่อนอื่น เราต้องทำความคุ้นเคยกับแนวคิดที่ได้รับการยอมรับอย่างกว้างขวางในชุมชนการพัฒนาเว็บ เป็น อัลกอริธึม อั ลกอริธึมการ ย้อนรอย เป็นกระบวนการแบบเรียกซ้ำซึ่งขึ้นอยู่กับการแก้ไขอักขระหนึ่งตัวของสตริงที่กำหนดเป็นระยะ และรวมเข้ากับการเรียงสับเปลี่ยนที่เป็นไปได้ทั้งหมดของอักขระอื่นๆ ทั้งหมด และทำซ้ำขั้นตอนนี้ด้วยอักขระในทุกตำแหน่งของสตริงทีละรายการ เพื่อให้ได้ค่าสูงสุด (และเป็นไปได้ทั้งหมด) จำนวนรูปแบบสำหรับสตริงนั้น

อัลกอริธึมของการเรียงสับเปลี่ยนใน JAVA นี้เข้าใจง่ายขึ้นในบริบทของสตริงที่กำหนดซึ่งมีอักขระสามตัว สมมติว่าอักขระสามตัวนี้ในสตริงที่กำหนดคือ A, B และ C

ขั้นตอนแรกในการดำเนินการ เรียงสับเปลี่ยนนี้ใน JAVA คือการเริ่มต้นด้วยการแก้ไขอักขระหนึ่งตัว (เราจะเริ่มต้นด้วยการแก้ไขอักขระที่มีอยู่ในตำแหน่งแรกเสมอ) จากนั้นจึงทำการสลับกับอักขระที่เหลือทั้งหมด โดยรวมอักขระเหล่านี้กับอักขระดั้งเดิม ( คงที่) อักขระ

ตัวอย่างเช่น ในตัวอย่างสตริง ABC เราจะทำการ วนซ้ำ สาม สตริงแรกโดยแก้ไขอักขระ A (ซึ่งเป็น อักขระตัว จากนั้นเราก็มาถึงชุดค่าผสมต่อไปนี้ : ABC , BAC และ CBA

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

ABC
ACB
BAC
BCA
CBA
แท็กซี่
ในโค้ดตัวอย่าง/ส่วนผลลัพธ์ที่ต้องการซึ่งอยู่ท้ายบทความนี้ เราจะเปลี่ยนความพยายามในการเปลี่ยนลำดับใน JAVA ให้เป็นโค้ดที่อ่านง่าย และด้วยเหตุนี้จึงเห็นการเรียงสับเปลี่ยนที่คำนวณแบบเรียลไทม์
ดำเนินการเรียงสับเปลี่ยนใน JAVA — อัลกอริธึมแบบเรียกซ้ำเพื่อย้อนรอยและสลับ
สรุปโดยย่อของกระบวนการที่จะใช้สตริงสุ่มและดำเนินการเปลี่ยนลำดับอย่างละเอียดใน JAVA สามารถอธิบายได้ด้วยอัลกอริธึมแบบเรียกซ้ำทีละขั้นตอนต่อไปนี้:

คำจำกัดความของสตริง – ขั้นแรก กำหนดสตริง คุณสามารถเลือกยอมรับสตริงสุ่มเป็นตัวแปรอินพุตได้เสมอ แต่เพื่อความชัดเจนของวัตถุประสงค์และความพยายาม เราจะใช้สตริง ABC ที่กำหนดไว้ล่วงหน้าในตัวอย่างนี้
การแก้ไขอักขระ – แก้ไขอักขระหนึ่งตัว (เริ่มต้นด้วยอักขระในตำแหน่งแรกและดำเนินการสลับกับอักขระที่เหลือทั้งหมด)
createPermutation() – เรียกใช้และใช้เอาต์พุตจากฟังก์ชัน generatePermutation() สำหรับอักขระที่เหลือทั้งหมด
Recursive Backtracking – ดำเนินการตามอัลกอริธึม "backtracking" และทำการสลับอักขระแบบวนซ้ำจนกว่าโค้ดของคุณจะถึงจุดสิ้นสุดของสตริง (ในตัวอย่างปัจจุบันของเราจนถึง C)
ทำการเรียงสับเปลี่ยนใน JAVA — โค้ดตัวอย่าง:
PermuteString คลาสสาธารณะ {

//กำหนดฟังก์ชันเพื่อสลับอักขระที่ตำแหน่ง i กับอักขระทั้งหมดที่ตำแหน่ง j
สแตติกสตริงสาธารณะ swapString (สตริง a, int i, int j) {
// คำจำกัดความของอักขระสำหรับอักขระคงที่ในสตริง
ถ่าน[] b =a.toCharArray();
ถ่าน ch;
// ทำการสลับในขั้นตอนต่อไป
ch = ข[i];
b[i] = b[j];
b[j] = ช;
ส่งคืน String.valueOf(b);
}โมฆะคงที่สาธารณะ main(String[] args)

{
//กำหนดสตริงเริ่มต้น ABC
สตริง str = “ABC”;
//นับความยาวของสตริง
int len = str.length();
//พิมพ์การสุ่มทั้งหมด
System.out.println("ต่อไปนี้คือการเรียงสับเปลี่ยนที่เป็นไปได้ทั้งหมดของสตริง ABC: ");
สร้างการเปลี่ยนแปลง (str, 0, len);
}
//กำหนดฟังก์ชันเพื่อสร้างการเรียงสับเปลี่ยนที่เป็นไปได้ทั้งหมดของสตริง

โมฆะคงที่สาธารณะ generatePermutation (String str, int start, int end)
{
// พิมพ์พีชคณิตทั้งหมด
ถ้า (เริ่มต้น == end-1)
System.out.println(str);
อื่น
{
สำหรับ (int i = start; i < end; i++)
{
//แก้ไขอักขระเพื่อสลับสตริง
str = swapString(str,เริ่ม,i);
//เรียกฟังก์ชัน generatePermutation() แบบเรียกซ้ำสำหรับอักขระที่เหลือทั้งหมด generatePermutation(str,start+1,end);
//ทำอัลกอริธึมย้อนรอยเพื่อสลับอักขระอีกครั้ง
str = swapString(str,เริ่ม,i);
}
}
}
}
ทำการเรียงสับเปลี่ยนใน JAVA — ผลลัพธ์ที่ได้มาจากโค้ดตัวอย่าง:
เมื่อคุณคอมไพล์และรันตัวอย่างนี้ ผลลัพธ์ที่ต้องการควรมีลักษณะดังนี้:
ต่อไปนี้คือการเรียงสับเปลี่ยนที่เป็นไปได้ทั้งหมดของสตริง ABC:
ABC
ACB
BAC
BCA
CBA
แท็กซี่
ต้องอ่าน: โครงการและหัวข้อ Java ที่น่าสนใจ
บทสรุป
เราหวังว่าคุณจะพบว่าบทช่วยสอนนี้เพื่อทำการเรียงสับเปลี่ยนใน JAVA มีประโยชน์
หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับ Java, OOP และการพัฒนาซอฟต์แวร์ฟูลสแตก โปรดดูประกาศนียบัตร PG ของ upGrad & IIIT-B ด้านการพัฒนาซอฟต์แวร์ฟูลสแตก ซึ่งออกแบบมาสำหรับมืออาชีพที่ทำงานและมีการฝึกอบรมที่เข้มงวดมากกว่า 500 ชั่วโมง 9 + โครงการและการมอบหมาย สถานะศิษย์เก่า IIIT-B โครงการหลักในทางปฏิบัติและความช่วยเหลือด้านงานกับ บริษัท ชั้นนำ
เตรียมความพร้อมสู่อาชีพแห่งอนาคต
การเรียนรู้ที่เชื่อถือได้ในอุตสาหกรรม - ใบรับรองที่เป็นที่ยอมรับในอุตสาหกรรม
เรียนรู้เพิ่มเติม