जावा में मेल खाने वाला पैटर्न लागू करना

कई आधुनिक भाषाएं भाषा स्तर पर मेल खाते पैटर्न का समर्थन करती हैं। जावा वर्तमान में पैटर्न मिलान का समर्थन नहीं करता है, लेकिन आशा है कि भविष्य में चीजें बदल सकती हैं।

नमूना के साथ तुलना डेवलपर को यह समझने योग्य छोड़ते समय कोड को अधिक लचीले और अधिक सुंदर ढंग से लिखने का अवसर देती है।

Java 8 की क्षमताओं का उपयोग करते हुए, आप लाइब्रेरी के रूप में कुछ पैटर्न की विशेषताओं को लागू कर सकते हैं। इस मामले में, आप कथन और अभिव्यक्ति दोनों का उपयोग कर सकते हैं।

लगातार पैटर्न स्थिरांक के साथ समानता के लिए जाँच करने की अनुमति देता है। जावा में, एक स्विच आपको समान संख्याओं, गणनाओं और तारों की जांच करने की अनुमति देता है। लेकिन कभी-कभी मैं समान () पद्धति का उपयोग करके वस्तुओं के स्थिरांक की समानता की जांच करना चाहता हूं।

switch (data) { case new Person("man") -> System.out.println("man"); case new Person("woman") -> System.out.println("woman"); case new Person("child") -> System.out.println("child"); case null -> System.out.println("Null value "); default -> System.out.println("Default value: " + data); }; 

विभिन्न ब्रांचिंग विकल्पों के लिए, आपको मैचों () पद्धति के ओवरलोड का उपयोग करने की आवश्यकता है। इसलिए, इस समय, पुस्तकालय 6 स्थिरांक के साथ एक चर के मूल्यों की जांच करने की क्षमता का समर्थन करता है।

 import org.kl.state.Else; import org.kl.state.Null; import static org.kl.pattern.ConstantPattern.matches; matches(data, new Person("man"), () -> System.out.println("man"); new Person("woman"), () -> System.out.println("woman"); new Person("child"), () -> System.out.println("child"); Null.class, () -> System.out.println("Null value "), Else.class, () -> System.out.println("Default value: " + data) ); 

ट्यूपल पैटर्न आपको एक साथ स्थिरांक के साथ कई परिवर्तनों की समानता की जांच करने की अनुमति देता है।

 switch (side, width) { case "top", 25 -> System.out.println("top"); case "bottom", 30 -> System.out.println("bottom"); case "left", 15 -> System.out.println("left"); case "right", 15 -> System.out.println("right"); case null -> System.out.println("Null value "); default -> System.out.println("Default value "); }; 

फिलहाल, पुस्तकालय 4 चर और 6 शाखाओं को निर्दिष्ट करने की क्षमता का समर्थन करता है।

 import org.kl.state.Else; import org.kl.state.Null; import static org.kl.pattern.TuplePattern.matches; matches(side, width, "top", 25, () -> System.out.println("top"); "bottom", 30, () -> System.out.println("bottom"); "left", 15, () -> System.out.println("left"); "right", 15, () -> System.out.println("right"); Null.class, () -> System.out.println("Null value"), Else.class, () -> System.out.println("Default value") ); 

टाइप टेस्ट पैटर्न आपको एक साथ टाइप करने और वेरिएबल के मान को निकालने की अनुमति देता है। जावा में, इसके लिए हमें पहले टाइप की जाँच करनी होगी, टाइप करना होगा और फिर इसे एक नए वेरिएबल में असाइन करना होगा।

 switch (data) { case Integer i -> System.out.println(i * i); case Byte b -> System.out.println(b * b); case Long l -> System.out.println(l * l); case String s -> System.out.println(s * s); case null -> System.out.println("Null value "); default -> System.out.println("Default value: " + data); }; 

फिलहाल, पुस्तकालय 6 प्रकारों के साथ एक चर के मूल्यों की जांच करने की क्षमता का समर्थन करता है।

 import org.kl.state.Else; import org.kl.state.Null; import static org.kl.pattern.VerifyPattern.matches; matches(data, Integer.class, i -> { System.out.println(i * i); }, Byte.class, b -> { System.out.println(b * b); }, Long.class, l -> { System.out.println(l * l); }, String.class, s -> { System.out.println(s * s); }, Null.class, () -> { System.out.println("Null value "); }, Else.class, () -> { System.out.println("Default value: " + data); } ); 

गार्ड पैटर्न आपको एक साथ टाइप करने और शर्तों की जांच करने की अनुमति देता है।

 switch (data) { case Integer i && i != 0 -> System.out.println(i * i); case Byte b && b > -1 -> System.out.println(b * b); case Long l && l < 5 -> System.out.println(l * l); case String s && !s.empty() -> System.out.println(s * s); case null -> System.out.println("Null value "); default -> System.out.println("Default: " + data); }; 

फिलहाल, पुस्तकालय 6 प्रकारों और स्थितियों के साथ एक चर के मूल्यों की जांच करने की क्षमता का समर्थन करता है।

 import org.kl.state.Else; import org.kl.state.Null; import static org.kl.pattern.GuardPattern.matches; matches(data, Integer.class, i -> i != 0, i -> { System.out.println(i * i); }, Byte.class, b -> b > -1, b -> { System.out.println(b * b); }, Long.class, l -> l == 5, l -> { System.out.println(l * l); }, Null.class, () -> { System.out.println("Null value "); }, Else.class, () -> { System.out.println("Default value: " + data); } ); 

स्थिति के लेखन को सरल बनाने के लिए, डेवलपर तुलना के लिए निम्नलिखित कार्यों का उपयोग कर सकता है: कम / एलटी, अधिक से अधिक / gt, कमTOOEEqual / le, अधिक से अधिकThanOrEqual / जीई,
बराबर / eq, notEqual / ne। और शर्तों को छोड़ने के लिए, आप कोशिश कर सकते हैं: हमेशा / हाँ, कभी नहीं / नहीं।

 matches(data, Integer.class, ne(0), i -> { System.out.println(i * i); }, Byte.class, gt(-1), b -> { System.out.println(b * b); }, Long.class, eq(5), l -> { System.out.println(l * l); }, Null.class, () -> { System.out.println("Null value "); }, Else.class, () -> { System.out.println("Default value: " + data); } ); 

Deconstruction पैटर्न आपको एक साथ प्रकार से मेल खाने और ऑब्जेक्ट को घटकों में विघटित करने की अनुमति देता है। जावा में, इसके लिए हमें पहले टाइप करने की जरूरत है, एक प्रकार कास्ट करना है, इसे एक नए वैरिएबल को असाइन करना है, और उसके बाद ही गेटर्स के माध्यम से क्लास के फील्ड्स को एक्सेस करना है।

 let (int w, int h) = figure; switch (figure) { case Rectangle(int w, int h) -> out.println("square: " + (w * h)); case Circle(int r) -> out.println("square: " + (2 * Math.PI * r)); default -> out.println("Default square: " + 0); }; for ((int w, int h) : listFigures) { System.out.println("square: " + (w * h)); } 

फिलहाल, पुस्तकालय 3 प्रकारों के साथ एक चर के मूल्यों की जांच करने की क्षमता का समर्थन करता है और ऑब्जेक्ट को 3 घटकों में विघटित करता है।

 import org.kl.state.Else; import static org.kl.pattern.DeconstructPattern.matches; import static org.kl.pattern.DeconstructPattern.foreach; import static org.kl.pattern.DeconstructPattern.let; Figure figure = new Rectangle(); let(figure, (int w, int h) -> { System.out.println("border: " + w + " " + h)); }); matches(figure, Rectangle.class, (int w, int h) -> out.println("square: " + (w * h)), Circle.class, (int r) -> out.println("square: " + (2 * Math.PI * r)), Else.class, () -> out.println("Default square: " + 0) ); foreach(listRectangles, (int w, int h) -> { System.out.println("square: " + (w * h)); }); 

इसके अलावा, एक घटक प्राप्त करने के लिए, एक कक्षा में एक या एक से अधिक विध्वंसकारी विधियां होनी चाहिए। इन विधियों को एनोटेशन एक्सट्रैक्ट के साथ लेबल किया जाना चाहिए।
सभी पैरामीटर खुले होने चाहिए। चूंकि प्राइमिटिव्स को संदर्भ द्वारा एक विधि में पारित नहीं किया जा सकता है, इसलिए आपको प्रिमिटिव इंटर्फ़, फ्लोटरीफ़, आदि के लिए रैपर का उपयोग करने की आवश्यकता है।

 import org.kl.type.IntRef; ... @Extract public void deconstruct(IntRef width, IntRef height) { width.set(this.width); height.set(this.height); } 

जावा 11 का उपयोग करते हुए, आप प्रकार के डिकंस्ट्रक्टिंग मापदंडों का अनुमान लगा सकते हैं।

 Figure figure = new Rectangle(); let(figure, (var w, var h) -> { System.out.println("border: " + w + " " + h)); }); matches(figure, Rectangle.class, (var w, var h) -> out.println("square: " + (w * h)), Circle.class, (var r) -> out.println("square: " + (2 * Math.PI * r)), Else.class, () -> out.println("Default square: " + 0) ); foreach(listRectangles, (var w, var h) -> { System.out.println("square: " + (w * h)); }); 

संपत्ति पैटर्न आपको एक साथ प्रकार से मेल खाने और वर्ग के क्षेत्रों को उनके नामों से एक्सेस करने की अनुमति देता है। सभी क्षेत्रों को प्रदान करने के बजाय, आप उन क्षेत्रों तक पहुंच सकते हैं जिनकी आपको किसी भी क्रम में आवश्यकता है।

 let (w: int w, h:int h) = figure; switch (figure) { case Rect(w: int w == 5, h: int h == 10) -> out.println("sqr: " + (w * h)); case Rect(w: int w == 10, h: int h == 15) -> out.println("sqr: " + (w * h)); case Circle (r: int r) -> out.println("sqr: " + (2 * Math.PI * r)); default -> out.println("Default sqr: " + 0); }; for ((w: int w, h: int h) : listRectangles) { System.out.println("square: " + (w * h)); } 

फिलहाल, पुस्तकालय 3 प्रकारों के साथ एक चर के मूल्यों की जांच करने की क्षमता का समर्थन करता है और ऑब्जेक्ट को 3 घटकों में विघटित करता है।

 import org.kl.state.Else; import static org.kl.pattern.PropertyPattern.matches; import static org.kl.pattern.PropertyPattern.foreach; import static org.kl.pattern.PropertyPattern.let; import static org.kl.pattern.PropertyPattern.of; Figure figure = new Rectangle(); let(figure, of("w", "h"), (int w, int h) -> { System.out.println("border: " + w + " " + h)); }); matches(figure, Rect.class, of("w", 5, "h", 10), (int w, int h) -> out.println("sqr: " + (w * h)), Rect.class, of("w", 10, "h", 15), (int w, int h) -> out.println("sqr: " + (w * h)), Circle.class, of("r"), (int r) -> out.println("sqr: " + (2 * Math.PI * r)), Else.class, () -> out.println("Default sqr: " + 0) ); foreach(listRectangles, of("x", "y"), (int w, int h) -> { System.out.println("square: " + (w * h)); }); 

नामकरण क्षेत्रों को सरल बनाने के लिए आप दूसरी विधि का भी उपयोग कर सकते हैं।

 Figure figure = new Rect(); let(figure, Rect::w, Rect::h, (int w, int h) -> { System.out.println("border: " + w + " " + h)); }); matches(figure, Rect.class, Rect::w, Rect::h, (int w, int h) -> out.println("sqr: " + (w * h)), Circle.class, Circle::r, (int r) -> out.println("sqr: " + (2 * Math.PI * r)), Else.class, () -> System.out.println("Default sqr: " + 0) ); foreach(listRectangles, Rect::w, Rect::h, (int w, int h) -> { System.out.println("square: " + (w * h)); }); 

स्थिति पैटर्न आपको एक साथ टाइप करने के लिए अनुमति देता है और घोषणा क्रम में फ़ील्ड के मूल्य की जांच करता है। जावा में, इसके लिए हमें पहले प्रकार की जांच करने की आवश्यकता है, इसे एक प्रकार पर कास्ट करें, इसे एक नए चर में असाइन करें, और उसके बाद ही गेटर्स के माध्यम से वर्ग के क्षेत्रों तक पहुंचें और समानता की जांच करें।

 switch (data) { case Circle(5) -> System.out.println("small circle"); case Circle(15) -> System.out.println("middle circle"); case null -> System.out.println("Null value "); default -> System.out.println("Default value: " + data); }; 

फिलहाल, पुस्तकालय 6 प्रकारों के साथ एक चर के मूल्यों की जांच करने और एक साथ 4 क्षेत्रों की जांच करने की क्षमता का समर्थन करता है।

 import org.kl.state.Else; import org.kl.state.Null; import static org.kl.pattern.PositionPattern.matches; import static org.kl.pattern.PositionPattern.of; matches(data, Circle.class, of(5), () -> { System.out.println("small circle"); }, Circle.class, of(15), () -> { System.out.println("middle circle"); }, Null.class, () -> { System.out.println("Null value "); }, Else.class, () -> { System.out.println("Default value: " + data); } ); 

इसके अलावा, यदि डेवलपर कुछ फ़ील्ड्स की जांच नहीं करना चाहता है, तो इन फ़ील्ड को @Exclude एनोटेशन के साथ चिह्नित किया जाना चाहिए। इन क्षेत्रों को अंतिम घोषित किया जाना चाहिए।

 class Circle { private int radius; @Exclude private int temp; } 

स्टेटिक पैटर्न आपको एक साथ टाइप करने की अनुमति देता है और फैक्ट्री के तरीकों का उपयोग करके ऑब्जेक्ट को डिकॉन्स्ट्रक्ट करता है।

 Optional some = ...; switch (some) { case Optional.empty() -> System.out.println("empty value"); case Optional.of(var v) -> System.out.println("value: " + v); default -> System.out.println("Default value"); }; 

फिलहाल, पुस्तकालय 6 प्रकारों के साथ एक चर के मूल्यों की जांच करने और 3 घटकों में ऑब्जेक्ट को विघटित करने की क्षमता का समर्थन करता है।

 import org.kl.state.Else; import static org.kl.pattern.StaticPattern.matches; import static org.kl.pattern.StaticPattern.of; Optional some = ...; matches(figure, Optinal.class, of("empty"), () -> System.out.println("empty value"), Optinal.class, of("of") , (var v) -> System.out.println("value: " + v), Else.class, () -> System.out.println("Default value") ); 

उसी समय, घटक प्राप्त करने के लिए, कक्षा में एक या एक से अधिक विघटनकारी विधियां होनी चाहिए, एक्सट्रैक्ट एनोटेशन लेबल।

 @Extract public void of(IntRef value) { value.set(this.value); } 

अनुक्रम पैटर्न डेटा अनुक्रमों को संसाधित करना आसान बनाता है।

 List<Integer> list = ...; switch (list) { case Ranges.head(var h) -> System.out.println("list head: " + h); case Ranges.tail(var t) -> System.out.println("list tail: " + t); case Ranges.empty() -> System.out.println("Empty value"); default -> System.out.println("Default value"); }; 

पुस्तकालय का उपयोग करते हुए, आप निम्नानुसार लिख सकते हैं।

 import org.kl.state.Else; import org.kl.range.Ranges; import static org.kl.pattern.SequencePattern.matches; List<Integer> list = ...; matches(figure, Ranges.head(), (var h) -> System.out.println("list head: " + h), Ranges.tail(), (var t) -> System.out.println("list tail: " + t), Ranges.empty() () -> System.out.println("Empty value"), Else.class, () -> System.out.println("Default value") ); 

इसके अलावा, कोड को सरल बनाने के लिए, आप निम्नलिखित कार्यों का उपयोग कर सकते हैं।

 import static org.kl.pattern.CommonPattern.with; import static org.kl.pattern.CommonPattern.when; Rectangle rect = new Rectangle(); with(rect, it -> { it.setWidth(5); it.setHeight(10); }); when( side == Side.LEFT, () -> System.out.println("left value"), side == Side.RIGHT, () -> System.out.println("right value") ); 

जैसा कि आप देख सकते हैं कि पैटर्न मिलान एक शक्तिशाली उपकरण है जो कोड लिखना बहुत आसान बनाता है। लैम्ब्डा एक्सप्रेशंस, मेथड रेफरेंस और लैम्ब्डा मापदंडों के प्रकारों की व्युत्पत्ति का उपयोग करके, आप भाषा के बहुत माध्यमों से पैटर्न के मिलान की संभावनाओं का अनुकरण कर सकते हैं।

पुस्तकालय का स्रोत कोड खुला है और जीथब पर उपलब्ध है।