جاوا میں کلیکشن سے تقسیم کا حساب لگائیں۔

نمبروں کے مجموعے (یا ایسی اشیاء جن کے فیلڈز کا آپ معائنہ کرنا چاہتے ہیں) کو ان نمبروں کی تقسیم میں تبدیل کرنا ایک عام شماریاتی تکنیک ہے، اور رپورٹنگ اور ڈیٹا پر مبنی ایپلی کیشنز میں مختلف سیاق و سباق میں استعمال کی جاتی ہے۔

ایک مجموعہ دیا:

1, 1, 2, 1, 2, 3, 1, 4, 5, 1, 3

آپ ان کی تقسیم کو بطور شمار (ہر عنصر کی تعدد) کا معائنہ کر سکتے ہیں، اور نتائج کو نقشے میں محفوظ کر سکتے ہیں:

{
"1": 5,
"2": 2,
"3": 2,
"4": 1,
"5": 1
}

یا ، آپ کر سکتے ہیں۔ معمول اقدار کی کل تعداد پر مبنی اقدار - اس طرح ان کا اظہار فیصد میں:

{
"1": 0.45,
"2": 0.18,
"3": 0.18,
"4": 0.09,
"5": 0.09
}

یا یہاں تک کہ ان فیصد کو a میں ظاہر کریں۔ 0..100 a کے بجائے فارمیٹ 0..1 فارمیٹ.

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

جاوا میں فنکشنل پروگرامنگ سپورٹ کے اضافے کے ساتھ - تقسیم کا حساب لگانا پہلے سے کہیں زیادہ آسان ہے۔ ہم نمبروں کے مجموعے اور کے مجموعہ کے ساتھ کام کریں گے۔ Books:

public class Book {

    private String id;
    private String name;
    private String author;
    private long pageNumber;
    private long publishedYear;

   
}

جاوا میں کلیکشن کی تقسیم کا حساب لگائیں۔

آئیے پہلے اس پر ایک نظر ڈالیں کہ آپ قدیم اقسام کے لیے تقسیم کا حساب کیسے لگا سکتے ہیں۔ اشیاء کے ساتھ کام کرنا آپ کو حساب میں مزید لچک فراہم کرنے کے لیے اپنی ڈومین کلاسز سے حسب ضرورت طریقوں کو کال کرنے کی اجازت دیتا ہے۔

پہلے سے طے شدہ طور پر، ہم فی صد کو ڈبل کے طور پر پیش کریں گے۔ 0.00 کرنے کے لئے 100.00.

قدیم اقسام

آئیے عدد کی فہرست بنائیں اور ان کی تقسیم پرنٹ کریں:

List integerList = List.of(1, 1, 2, 1, 2, 3, 1, 4, 5, 1, 3);
System.out.println(calculateIntegerDistribution(integerList));

تقسیم کا حساب اس کے ساتھ کیا جاتا ہے:

public static Map calculateIntegerDistribution(List list) {
    return list.stream()
            .collect(Collectors.groupingBy(Integer::intValue,
                    Collectors.collectingAndThen(Collectors.counting(),
                            count -> (Double.parseDouble(String.format("%.2f", count * 100.00 / list.size()))))));
}

یہ طریقہ ایک فہرست کو قبول کرتا ہے اور اسے جاری کرتا ہے۔ سلسلہ بندی کے دوران، قدریں ہیں۔ کی طرف سے گروپ ان کی عددی قدر - اور ان کی قدریں ہیں۔ counted,en کا استعمال کرتے ہوئے Collectors.counting()، ایک میں جمع ہونے سے پہلے Map جہاں چابیاں ان پٹ اقدار کی نمائندگی کرتی ہیں اور ڈبلز تقسیم میں ان کے فیصد کی نمائندگی کرتی ہیں۔

یہاں اہم طریقے ہیں۔ collect() جو قبول کرتا ہے دو جمع کرنے والے. کلیدی جمع کرنے والا کلیدی اقدار (ان پٹ عناصر) کے ذریعہ صرف گروپ بندی کرکے جمع کرتا ہے۔ ویلیو کلیکٹر کے ذریعے جمع کرتا ہے۔ collectingAndThen() طریقہ، جو ہمیں اجازت دیتا ہے اقدار شمار کریں اور پھر انہیں کسی اور فارمیٹ میں فارمیٹ کریں، جیسے count * 100.00 / list.size() جو ہمیں شمار شدہ عناصر کو فیصد میں ظاہر کرنے دیتا ہے:

{1=45.45, 2=18.18, 3=18.18, 4=9.09, 5=9.09}

قدر یا کلید کے لحاظ سے تقسیم کو ترتیب دیں۔

تقسیم تخلیق کرتے وقت - آپ عام طور پر اقدار کو ترتیب دینا چاہیں گے۔ زیادہ کثرت سے، یہ ہو جائے گا کلید. جاوا HashMaps داخل کرنے کے آرڈر کو محفوظ رکھنے کی ضمانت نہ دیں۔، لہذا ہمیں ایک استعمال کرنا پڑے گا۔ LinkedHashMap جو کرتا ہے. مزید برآں، نقشے کو دوبارہ اسٹریم کرنا اور اسے دوبارہ جمع کرنا سب سے آسان ہے کیونکہ یہ بہت چھوٹا سائز اور بہت زیادہ قابل انتظام ہے۔

پچھلا آپریشن ایک سے زیادہ ہزار ریکارڈز کو تیزی سے چھوٹے نقشوں میں سمیٹ سکتا ہے، اس بات پر منحصر ہے کہ آپ جن کلیدوں کے ساتھ کام کر رہے ہیں، اس لیے دوبارہ سلسلہ بندی مہنگا نہیں ہے:

public static Map calculateIntegerDistribution(List list) {
    return list.stream()
            .collect(Collectors.groupingBy(Integer::intValue,
                    Collectors.collectingAndThen(Collectors.counting(),
                            count -> (Double.parseDouble(String.format("%.2f", count.doubleValue() / list.size()))))))
            
            
            .entrySet()
            .stream()
            .sorted(Map.Entry.comparingByKey())
            .collect(Collectors.toMap(e -> Integer.parseInt(e.getKey().toString()),
                    Map.Entry::getValue,
                    (a, b) -> {
                        throw new AssertionError();
                    },
                    LinkedHashMap::new));
}

آبجیکٹ

یہ اشیاء کے لیے کیسے کیا جا سکتا ہے؟ ایک ہی منطق لاگو ہوتی ہے! شناختی فنکشن کے بجائے (Integer::intValue)، ہم اس کے بجائے مطلوبہ فیلڈ استعمال کریں گے – جیسے ہماری کتابوں کے لیے شائع شدہ سال۔ آئیے چند کتابیں بنائیں، انہیں ایک فہرست میں محفوظ کریں اور پھر اشاعت کے سالوں کی تقسیم کا حساب لگائیں:

Book book1 = new Book("001", "Our Mathematical Universe", "Max Tegmark", 432, 2014);
Book book2 = new Book("002", "Life 3.0", "Max Tegmark", 280, 2017);
Book book3 = new Book("003", "Sapiens", "Yuval Noah Harari", 443, 2011);
Book book4 = new Book("004", "Steve Jobs", "Water Isaacson", 656, 2011);

List books = Arrays.asList(book1, book2, book3, book4);

آئیے کی تقسیم کا حساب لگائیں۔ publishedYear فیلڈ:

public static Map calculateDistribution(List books) {
    return books.stream()
            .collect(Collectors.groupingBy(Book::getPublishedYear,
                    Collectors.collectingAndThen(Collectors.counting(),
                            count -> (Double.parseDouble(String.format("%.2f", count * 100.00 / books.size()))))))
            
            .entrySet()
            .stream()
            .sorted(Map.Entry.comparingByKey())
            .collect(Collectors.toMap(e -> Integer.parseInt(e.getKey().toString()),
                    Map.Entry::getValue,
                    (a, b) -> {
                        throw new AssertionError();
                    },
                    LinkedHashMap::new));
}

ایڈجسٹ کریں "%.2f" فلوٹنگ پوائنٹ کی درستگی کا تعین کرنے کے لیے۔ اس کے نتیجے میں:

{2011=50.0, 2014=25.0, 2017=25.0}

دی گئی کتابوں میں سے 50% (2/4) 2011 میں شائع ہوئی تھیں، 25% (1/4) 2014 میں اور 25% (1/4) 2017 میں شائع ہوئی تھیں۔ میں رینج 0..1?

جاوا میں جمع کرنے کی نارملائزڈ (فیصد) تقسیم کا حساب لگائیں۔

a سے فیصد کو معمول پر لانے کے لیے 0.0...100.0 حد تک a 0..1 رینج - ہم اسے آسانی سے ڈھال لیں گے۔ collectingAndThen() کو کال کریں نوٹ گنتی کو ضرب دیں۔ 100.0 مجموعہ کے سائز سے تقسیم کرنے سے پہلے۔

اس سے پہلے ، Long کی طرف سے واپس شمار Collectors.counting() واضح طور پر ڈبل میں تبدیل کیا گیا تھا (دوہری قدر کے ساتھ ضرب) - لہذا اس بار، ہم واضح طور پر حاصل کرنا چاہیں گے doubleValue() کی count:

    public static Map calculateDistributionNormalized(List books) {
        return books.stream()
            .collect(Collectors.groupingBy(Book::getPublishedYear,
                    Collectors.collectingAndThen(Collectors.counting(),
                            count -> (Double.parseDouble(String.format("%.4f", count.doubleValue() / books.size()))))))
            
            .entrySet()
            .stream()
            .sorted(comparing(e -> e.getKey()))
            .collect(Collectors.toMap(e -> Integer.parseInt(e.getKey().toString()),
                    Map.Entry::getValue,
                    (a, b) -> {
                        throw new AssertionError();
                    },
                    LinkedHashMap::new));
}

ایڈجسٹ کریں "%.4f" فلوٹنگ پوائنٹ کی درستگی کا تعین کرنے کے لیے۔ اس کے نتیجے میں:

{2011=0.5, 2014=0.25, 2017=0.25}

مجموعہ کے عنصر کی گنتی (تعدد) کا حساب لگائیں۔

آخر میں - ہم مجموعہ میں عنصر کی گنتی (تمام عناصر کی تعدد) حاصل کر سکتے ہیں محض شمار کو مجموعہ کے سائز سے تقسیم نہ کر کے! یہ مکمل طور پر غیر معمولی شمار ہے:

   public static Map calculateDistributionCount(List books) {
        return books
            .stream()
            .collect(Collectors.groupingBy(Book::getPublishedYear,
                    Collectors.collectingAndThen(Collectors.counting(),
                            count -> (Integer.parseInt(String.format("%s", count.intValue()))))))
            
            .entrySet()
            .stream()
            .sorted(Map.Entry.comparingByKey())
            .collect(Collectors.toMap(e -> Integer.parseInt(e.getKey().toString()),
                    Map.Entry::getValue,
                    (a, b) -> {
                        throw new AssertionError();
                    },
                    LinkedHashMap::new));
}

اس کے نتائج:

{2011=2, 2014=1, 2017=1}

درحقیقت، 2011 کی دو کتابیں ہیں، اور 2014 اور 2017 میں سے ایک۔

نتیجہ

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

اس مختصر مسودے میں، ہم نے اس پر ایک نظر ڈالی ہے کہ آپ کس طرح ایک مجموعہ میں تمام عناصر کی تعدد کی گنتی کا حساب لگا سکتے ہیں، اور ساتھ ہی تقسیم کے نقشوں کا حساب کیسے لگا سکتے ہیں جن کے درمیان فیصد کو معمول بنایا گیا ہے۔ 0 اور 1 طور پر 0 اور 100 جاوا میں