جاوا 8 میں لوپس سے چھٹکارا حاصل کرنا

جاوا 8 میں متعارف کرایا گیا فنکشنل اسٹائل زبان میں ایک بہترین اضافہ ہے۔ اب جاوا خالص OOP نہیں ہے، اب یہ OOP اور فنکشنل پروگرامنگ کا ہائبرڈ ہے۔ یہ ایک گیم چینجر ہے اور ہمیں ان تبدیلیوں کو جذب کرنے کے لیے اپنے OOP دماغ کو تبدیل کرنے کی ضرورت ہے۔ لیکن ہم ان تبدیلیوں کو کیوں قبول کریں؟ جب ہم خالص OOP کا استعمال کرتے ہوئے مسئلہ کو حل کر سکتے ہیں تو ہم ایک فعال انداز کے ساتھ چلنے کی کوشش میں وقت کیوں ضائع کریں؟

• جاوا 8 میں متعارف کرایا گیا فنکشنل انداز کاروباری منطق اور کوڈ کے درمیان فرق کو کم کرنے میں ہماری مدد کرتا ہے۔ یہ ہمیں ایک اعلی سطح پر قدرتی بہاؤ میں کہانی سنانے کی اجازت دیتا ہے۔ یہ کہنے کے بجائے کہ آپ یہ کیسے کرنا چاہتے ہیں، آپ کہہ سکتے ہیں کہ آپ کیا کرنا چاہتے ہیں۔

• کوڈ صاف اور زیادہ جامع ہو جاتا ہے۔

• اعلی آرڈر کے افعال ہمیں اجازت دیتے ہیں:

  • فنکشنز کو دوسرے فنکشنز میں بھیجیں۔
  • دوسرے افعال کے اندر فنکشنز بنائیں
  • دوسرے افعال سے افعال واپس کریں۔

  یہ جاوا کے لیے ایک بڑی جیت ہے، جہاں ہمیں ایسا کرنے کے لیے اشیاء بھیجنے، تخلیق کرنے اور واپس کرنے کی ضرورت ہے۔ ہم کوڈ لکھنے کے قابل ہو جائیں گے جو زیادہ قابل اعتماد، توجہ مرکوز، اور دوبارہ استعمال کرنے میں آسان ہے۔

• لیمبڈاس کا شکریہ، ہم سست حساب کر سکتے ہیں۔ جب لیمبڈا ایکسپریشن کو میتھڈ آرگیومنٹ کے طور پر بھیجا جاتا ہے، تو کمپائلر اس کا اندازہ کرے گا جب اسے طریقہ کار میں بلایا جائے گا۔ یہ عام طریقہ کار کے دلائل سے مختلف ہے، جن کا فوری جائزہ لیا جاتا ہے۔

• لیمبڈاس تحریری یونٹ ٹیسٹوں کو تفریحی بناتا ہے۔ وہ ہمیں ہلکے وزن کے ٹیسٹ بنانے کی اجازت دیتے ہیں جو صاف، سائز میں چھوٹے اور لکھنے میں تیز ہوں۔ ہم لیمبڈاس کا استعمال کرتے ہوئے ٹیسٹ کے تحت کوڈ کو جڑ سے اکھاڑ پھینک سکتے ہیں۔ یہ ہمیں جانچنے کی اجازت دیتا ہے کہ تمام قسم کے منظرنامے کوڈ کو کیسے متاثر کریں گے۔

• سیکھنے کے لیے نئے نمونے۔

• اور بہت کچھ!

لیکن کافی پانی، اس مضمون میں ہم روایتی سائیکلوں کے متبادل حل پر ایک نظر ڈالیں گے۔ بلاشبہ، سائیکل لچکدار ہیں، لیکن یہ قیمت کے بغیر نہیں آتی ہے۔ break، لوپ کے رویے کو ڈرامائی طور پر تبدیل کرتا ہے، جو ہمیں نہ صرف یہ سمجھنے پر مجبور کرتا ہے کہ کوڈ کیا حاصل کرنے کی کوشش کر رہا ہے، continueبلکہ returnیہ بھی سمجھنے کے لیے کہ لوپ کیسے کام کرتا ہے۔ اب ہم اس پر ایک نظر ڈالیں گے کہ ہم لوپس کو مزید جامع اور پڑھنے کے قابل کوڈ میں کیسے تبدیل کر سکتے ہیں۔

کوڈنگ شروع ہونے دو!

ہم مضامین کے ساتھ کام کریں گے۔ ایک مضمون میں ایک عنوان، مصنف اور کئی ٹیگ ہوتے ہیں۔

private class Article {

    private final String title;
    private final String author;
    private final List<String> tags;

    private Article(String title, String author, List<String> tags) {
        this.title = title;
        this.author = author;
        this.tags = tags;
    }

    public String getTitle() {
        return title;
    }

    public String getAuthor() {
        return author;
    }

    public List<String> getTags() {
        return tags;
    }
}

ہر مثال میں لوپس کا استعمال کرتے ہوئے ایک روایتی حل اور Java 8 کی نئی خصوصیات کا استعمال کرتے ہوئے ایک حل شامل ہوگا۔ پہلی مثال میں، ہم مجموعہ میں پہلا مضمون "جاوا" کے ٹیگ کے ساتھ تلاش کرنا چاہتے ہیں۔ آئیے لوپ کا استعمال کرتے ہوئے حل پر ایک نظر ڈالیں۔

public Article getFirstJavaArticle() {

    for (Article article : articles) {
        if (article.getTags().contains("Java")) {
            return article;
        }
    }
    return null;
}

اب اسٹریم API سے آپریشنز کا استعمال کرتے ہوئے مسئلہ کو حل کریں۔

public Optional<Article> getFirstJavaArticle() {
    return articles.stream()
        .filter(article -> article.getTags().contains("Java"))
        .findFirst();
    }

بہت اچھا، ہے نا؟ filterہم سب سے پہلے "جاوا" ٹیگ والے تمام مضامین کو تلاش کرنے کے لیے آپریشن کا استعمال کرتے ہیں ، پھر ہم findFirst()پہلا واقعہ حاصل کرنے کے لیے استعمال کرتے ہیں۔ چونکہ اسٹریمز سست ہیں اور فلٹر ایک سلسلہ واپس کرتا ہے، یہ نقطہ نظر صرف عناصر پر کارروائی کرے گا جب تک کہ اسے پہلا میچ نہ مل جائے۔ اب آئیے پہلے کے بجائے تمام مضامین کو "جاوا" ٹیگ کرتے ہیں۔ سب سے پہلے لوپس کا استعمال کرتے ہوئے حل.

public List<Article> getAllJavaArticles() {

    List<Article> result = new ArrayList<>();

    for (Article article : articles) {
        if (article.getTags().contains("Java")) {
            result.add(article);
        }
    }
    return result;
}

اسٹریم آپریشنز کا استعمال کرتے ہوئے حل۔

public List<Article> getAllJavaArticles() {
    return articles.stream()
        .filter(article -> article.getTags().contains("Java"))
        .collect(Collectors.toList());
    }

اس مثال میں، ہم نے collectمجموعہ کا اعلان کرنے اور مماثل اندراجات کو واضح طور پر شامل کرنے کے بجائے، نتیجے میں آنے والے سلسلے کو مختصر کرنے کے لیے ایک آپریشن کا استعمال کیا۔ اب تک بہت اچھا۔ ایسی مثالوں کا وقت جو Stream API کو واقعی چمکدار بنا دے گی۔ آئیے مصنف کے ذریعہ تمام مضامین کو گروپ کریں۔ ہمیشہ کی طرح، ہم اسے لوپس کے ذریعے حل کرکے شروع کرتے ہیں:

public Map<String, List<Article>> groupByAuthor() {

    Map<String, List<Article>> result = new HashMap<>();

    for (Article article : articles) {
        if (result.containsKey(article.getAuthor())) {
            result.get(article.getAuthor()).add(article);
        } else {
            ArrayList<Article> articles = new ArrayList<>();
            articles.add(article);
            result.put(article.getAuthor(), articles);
        }
    }
    return result;
}

کیا ہم اسٹریم آپریشنز کا استعمال کرتے ہوئے اس مسئلے کا صاف ستھرا حل تلاش کر سکتے ہیں؟

public Map<String, List<Article>> groupByAuthor() {
    return articles.stream()
        .collect(Collectors.groupingBy(Article::getAuthor));
}

حیرت انگیز! آپریشن groupingByاور طریقہ کا حوالہ استعمال کرنے سے getAuthor()، ہمیں صاف اور پڑھنے کے قابل کوڈ ملتا ہے۔ اب مجموعہ میں استعمال ہونے والے باقی ٹیگ تلاش کرتے ہیں۔ آئیے ایک لوپ مثال کے ساتھ شروع کریں:

public Set<String> getDistinctTags() {

    Set<String> result = new HashSet<>();

    for (Article article : articles) {
        result.addAll(article.getTags());
    }
    return result;
}

ٹھیک ہے، آئیے اس پر ایک نظر ڈالیں کہ ہم سٹریم آپریشنز کا استعمال کرتے ہوئے اسے کیسے حل کر سکتے ہیں:

public Set<String> getDistinctTags() {
    return articles.stream()
        .flatMap(article -> article.getTags().stream())
        .collect(Collectors.toSet());
}

ٹھنڈا! flatmapٹیگز کی فہرست کو ایک نتیجہ کے سلسلے میں ہموار کرنے میں ہماری مدد کرتا ہے، جسے ہم پھر collectواپسی سیٹ بنانے کے لیے استعمال کرتے ہیں۔

نہ ختم ہونے والے امکانات

یہ 4 مثالیں تھیں کہ کس طرح لوپس کو مزید پڑھنے کے قابل کوڈ سے تبدیل کیا جا سکتا ہے۔ Stream API کو ضرور دیکھیں، کیونکہ اس مضمون نے صرف سطح کو کھرچ دیا ہے۔ جاوا کے نئے فنکشنل انداز میں مہارت حاصل کرنا OOP ڈویلپرز کے لیے ایک چیلنج ہو گا، لیکن یہ ایک چیلنج ہے جسے اچھی طرح سے قبول کیا جانا چاہیے۔ میں یہاں تک کہ آگے بڑھ کر کہوں گا کہ آپ کو خالص فنکشنل پروگرامنگ لینگویج سیکھنی چاہیے۔ اس طرح آپ اس کی فراہم کردہ صلاحیتوں اور طاقت کو پوری طرح سمجھ سکتے ہیں۔ میرے خیال میں اس سے آپ کو ایک اور سطح پر فنکشنل پروگرامنگ کو سمجھنے میں مدد ملے گی۔ لہذا اچھے پرانے OOP کے ساتھ فنکشنل پروگرامنگ سیکھیں، اور ان دونوں کا استعمال اس سے بھی بڑا کوڈ لکھنے کے لیے کریں! دو مضامین کے تراجم کا ایک مفت مرکب - آپ کو جاوا 8 میں فنکشنل پروگرامنگ اور جاوا 8 میں لوپس سے دور کیوں جانا چاہئے