خلاص شدن از شر حلقه ها در جاوا 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;
    }
}

هر مثال حاوی یک راه حل سنتی با استفاده از حلقه ها و یک راه حل با استفاده از ویژگی های جدید جاوا 8 است. در مثال اول، می خواهیم اولین مقاله مجموعه را با برچسب "جاوا" پیدا کنیم. بیایید نگاهی به یک راه حل با استفاده از یک حلقه بیندازیم.

public Article getFirstJavaArticle() {

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

حالا بیایید با استفاده از عملیات Stream 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 و Swerving Away from Loops در جاوا 8 بپذیرید