ميزات Java 8 مع أمثلة

جافا 8 تم إصدارها في 18 مارس 2014. إنه منذ وقت طويل ولكن لا يزال هناك العديد من المشاريع تعمل على جافا 8. هذا لأنها كانت إصدارًا رئيسيًا مع العديد من الميزات الجديدة. دعونا نلقي نظرة على جميع الميزات المثيرة والرئيسية لجافا 8 مع أمثلة على الشفرة.

نظرة سريعة على ميزات جافا 8

بعض الميزات الهامة في جافا 8 هي؛

1. طريقة forEach() في واجهة Iterable
2. الطرق الافتراضية والثابتة في الواجهات
3. الواجهات الوظيفية وتعبيرات Lambda
4. واجهة تيار جافا لعمليات البيانات الضخمة على المجموعات
5. واجهة زمن جافا
6. تحسينات في واجهة المجموعات
7. تحسينات في واجهة التوازي
8. تحسينات في مدخلات ومخرجات جافا

دعونا نلقي نظرة سريعة على هذه الميزات في جافا 8. سأقدم بعض مقاطع الشفرة لفهم أفضل للميزات بطريقة بسيطة.

1. طريقة forEach() في واجهة Iterable

عندما نحتاج إلى عبور مجموعة، نحتاج إلى إنشاء محدد يهدف بأكمله إلى التكرار، ثم لدينا منطق الأعمال في حلقة لكل من العناصر في المجموعة. قد نحصل على ConcurrentModificationException إذا لم يتم استخدام المحدد بشكل صحيح.

Java 8 قد قدمت طريقة forEach في واجهة java.lang.Iterable حتى نركز أثناء كتابة الشيفرة على منطق الأعمال. تأخذ طريقة forEach كائن java.util.function.Consumer كمعامل، لذا فهي تساعد في وضع منطق الأعمال لدينا في موقع منفصل يمكننا إعادة استخدامه. دعونا نرى استخدام forEach بمثال بسيط.

package com.journaldev.java8.foreach;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;
import java.lang.Integer;

public class Java8ForEachExample {

	public static void main(String[] args) {
		
		//إنشاء مجموعة عينة
		List<Integer> myList = new ArrayList<Integer>();
		for(int i=0; i<10; i++) myList.add(i);
		
		//العبور باستخدام المحدد
		Iterator<Integer> it = myList.iterator();
		while(it.hasNext()){
			Integer i = it.next();
			System.out.println("Iterator Value::"+i);
		}
		
		//العبور من خلال طريقة forEach من Iterable باستخدام فئة مجهولة
		myList.forEach(new Consumer<Integer>() {

			public void accept(Integer t) {
				System.out.println("forEach anonymous class Value::"+t);
			}

		});
		
		//العبور باستخدام تنفيذ واجهة Consumer
		MyConsumer action = new MyConsumer();
		myList.forEach(action);
		
	}

}

//تنفيذ Consumer يمكن إعادة استخدامه
class MyConsumer implements Consumer<Integer>{

	public void accept(Integer t) {
		System.out.println("Consumer impl Value::"+t);
	}
}

عدد الأسطر قد يزيد ولكن طريقة forEach تساعد في وضع منطق التكرار ومنطق الأعمال في مكان منفصل مما يؤدي إلى فصل أكبر للمخاوف وشيفرة نظيفة.

2. الأساليب الافتراضية والثابتة في الواجهات

إذا قرأت تفاصيل طريقة forEach بعناية، ستلاحظ أنها معرفة في واجهة Iterable ولكننا نعلم أن الواجهات لا يمكن أن تحتوي على جسم للطريقة. ابتداءً من Java 8، تم تعزيز الواجهات لتحتوي على طريقة بتنفيذ. يمكننا استخدام الكلمات الرئيسية default و static لإنشاء واجهات مع تنفيذ الطريقة. تنفيذ طريقة forEach في واجهة Iterable هو:

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

نعلم أن جافا لا توفر التوريث المتعدد في الفئات لأنه يؤدي إلى مشكلة الماسة. فكيف سيتم التعامل مع الواجهات الآن حيث أصبحت الواجهات مشابهة للفئات الكلاسيكية؟

الحل هو أن المترجم سيُلقي استثناءً في هذscenario ال وسيتعين علينا توفير منطق التنفيذ في الفئة التي تنفذ الواجهات.

package com.journaldev.java8.defaultmethod;

@FunctionalInterface
public interface Interface1 {

	void method1(String str);
	
	default void log(String str){
		System.out.println("I1 logging::"+str);
	}
	
	static void print(String str){
		System.out.println("Printing "+str);
	}
	
	// محاولة الكتابة فوق طريقة Object تؤدي إلى خطأ في وقت الترجمة كما
	// "لا يمكن للطريقة الافتراضية استبدال طريقة من java.lang.Object"
	
//	default String toString(){
//		return "i1";
//	}
	
}

package com.journaldev.java8.defaultmethod;

@FunctionalInterface
public interface Interface2 {

	void method2();
	
	default void log(String str){
		System.out.println("I2 logging::"+str);
	}

}

يرجى ملاحظة أن كلا الواجهتين لديهما طريقة مشتركة تسمى log() مع منطق التنفيذ.

package com.journaldev.java8.defaultmethod;

public class MyClass implements Interface1, Interface2 {

	@Override
	public void method2() {
	}

	@Override
	public void method1(String str) {
	}

	// MyClass لن تترجم بدون تنفيذ log() الخاص بها
	@Override
	public void log(String str){
		System.out.println("MyClass logging::"+str);
		Interface1.print("abc");
	}
	
}

كما يمكنك أن ترى أن Interface1 تحتوي على تنفيذ للطريقة الثابتة التي يُستخدم في تنفيذ طريقة MyClass.log(). يستخدم Java 8 default و static methods بشكل كبير في API الخاصة بالمجموعات وتُضاف الطرق الافتراضية لكي يبقى الكود الخاص بنا متوافقًا مع الإصدارات السابقة.

إذا كان لدى أي فئة في التسلسل طريقة بنفس التوقيع، فإن الطرق الافتراضية تصبح غير مهمة. Object هو الفئة الأساسية، لذا إذا كانت لدينا طرق افتراضية equals()، hashCode() في الواجهة، فسيصبح ذلك غير مهم. هذا هو السبب في عدم السماح بواجهات ذات طرق افتراضية لكائن Object من أجل وضوح أفضل.

للحصول على تفاصيل كاملة حول تغييرات الواجهة في Java 8، يرجى قراءة تغييرات واجهة Java 8.

3. الواجهات الوظيفية وتعبيرات لامبدا

إذا لاحظت الشيفرة الواجهة أعلاه، ستلاحظ تعليق @FunctionalInterface . الواجهات الوظيفية هي مفهوم جديد تم تقديمه في جافا 8. تصبح الواجهة التي تحتوي بالضبط على طريقة واحدة مجردة واجهة وظيفية. لا نحتاج إلى استخدام تعليق @FunctionalInterface لتحديد واجهة كواجهة وظيفية. تعليق

@FunctionalInterface هو وسيلة لتجنب إضافة عرضية عن طريق الخطأ للأساليب المجردة في الواجهات الوظيفية. يمكنك التفكير فيه على أنه تعليق @Override ومن الممارسات الجيدة استخدامه. واجهة java.lang.Runnable مع طريقة مجردة واحدة run() هي مثال رائع على واجهة وظيفية.

أحد الفوائد الرئيسية للواجهة الوظيفية هو إمكانية استخدام تعابير اللامبدا لتثبيتها. يمكننا تثبيت واجهة بـفئة مجهولة ولكن الشيفرة تبدو ضخمة.

Runnable r = new Runnable(){
			@Override
			public void run() {
				System.out.println("My Runnable");
			}};

نظرًا لأن الواجهات الوظيفية تحتوي فقط على طريقة واحدة، يمكن لتعابير اللامبدا توفير تنفيذ الطريقة بسهولة. نحتاج فقط إلى توفير معاملات الطريقة ومنطق العمل. على سبيل المثال، يمكننا كتابة التنفيذ أعلاه باستخدام تعبير لامبدا كالتالي:

Runnable r1 = () -> {
			System.out.println("My Runnable");
		};

إذا كان لديك عبارة واحدة في تنفيذ الطريقة، فليس من الضروري أن نستخدم القوسين المجعدين أيضًا. على سبيل المثال، يمكن تثبيت فئة الواجهة 1 بواسطة تعبير لامبدا على النحو التالي:

Interface1 i1 = (s) -> System.out.println(s);
		
i1.method1("abc");

إذن، تعبر تعبيرات اللامبدا عن وسيلة لإنشاء فئات مجهولة المعرف للواجهات الوظيفية بسهولة. ليست هناك فوائد في وقت التشغيل من استخدام تعبيرات اللامبدا، لذا سأستخدمها بحذر لأنني لا أمانع كتابة بضعة أسطر إضافية من الكود.

A new package java.util.function has been added with bunch of functional interfaces to provide target types for lambda expressions and method references. Lambda expressions are a huge topic, I will write a separate article on that in the future.

يمكنك قراءة البرنامج التعليمي الكامل في شرح تعبيرات اللامبدا في جافا 8.

4. واجهة برمجة تطبيقات الجافا لعمليات البيانات الجماعية على المجموعات

A new java.util.stream has been added in Java 8 to perform filter/map/reduce like operations with the collection. Stream API will allow sequential as well as parallel execution. This is one of the best features for me because I work a lot with Collections and usually with Big Data, we need to filter out them based on some conditions.

تمت إضافة واجهة Collection بالأساليب الافتراضية stream() و parallelStream() للحصول على التيار للتنفيذ التسلسلي والتوازي. دعنا نرى استخدامهم مع مثال بسيط.

package com.journaldev.java8.stream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamExample {

	public static void main(String[] args) {
		
		List<Integer> myList = new ArrayList<>();
		for(int i=0; i<100; i++) myList.add(i);
		
		// التيار التسلسلي
		Stream<Integer> sequentialStream = myList.stream();
		
		// التيار التوازي
		Stream<Integer> parallelStream = myList.parallelStream();
		
		// استخدام اللامبدا مع واجهة برمجة التيار، مثال على التصفية
		Stream<Integer> highNums = parallelStream.filter(p -> p > 90);
		// استخدام اللامبدا في forEach
		highNums.forEach(p -> System.out.println("High Nums parallel="+p));
		
		Stream<Integer> highNumsSeq = sequentialStream.filter(p -> p > 90);
		highNumsSeq.forEach(p -> System.out.println("High Nums sequential="+p));

	}

}

إذا قمت بتشغيل الكود المثال أعلاه، ستحصل على مخرجات مثل هذه:

High Nums parallel=91
High Nums parallel=96
High Nums parallel=93
High Nums parallel=98
High Nums parallel=94
High Nums parallel=95
High Nums parallel=97
High Nums parallel=92
High Nums parallel=99
High Nums sequential=91
High Nums sequential=92
High Nums sequential=93
High Nums sequential=94
High Nums sequential=95
High Nums sequential=96
High Nums sequential=97
High Nums sequential=98
High Nums sequential=99

لاحظ أن قيم معالجة التوازي ليست مرتبة، لذا ستكون المعالجة التوازية مفيدة جدًا أثناء العمل مع مجموعات ضخمة.

لا يمكن تغطية كل شيء عن واجهة برمجة التطبيقات للتيار في هذه المقالة، يمكنك قراءة كل شيء عن واجهة برمجة التطبيقات للتيار في Java 8 Stream API Example Tutorial.

5. واجهة برمجة الوقت في جافا

كان من الصعب دائمًا العمل مع التاريخ والوقت والمناطق الزمنية في جافا. لم يكن هناك نهج قياسي أو واجهة برمجة تطبيقات في جافا للتاريخ والوقت في جافا. أحد الإضافات الجيدة في جافا 8 هو حزمة java.time التي ستبسط عملية العمل مع الوقت في جافا.

بمجرد النظر إلى حزم واجهة برمجة التطبيقات الزمنية في جافا، يمكنني أن أشعر أنها ستكون سهلة جدًا في الاستخدام. تحتوي على بعض الحزم الفرعية مثل java.time.format التي توفر فئات لطباعة وتحليل التواريخ والأوقات و java.time.zone توفر دعمًا للمناطق الزمنية وقواعدها.

واجهة الوقت الجديدة تفضل استخدام التعدادات enum على الثوابت الصحيحة للشهور وأيام الأسبوع. إحدى الفئات المفيدة هي DateTimeFormatter لتحويل كائنات DateTime إلى سلاسل نصية. للحصول على درس شامل، توجه إلى Java Date Time API Example Tutorial.

6. تحسينات في واجهة برمجة المجموعات

لقد رأينا بالفعل أساليب forEach() و Stream API للمجموعات. بعض الأساليب الجديدة التي تمت إضافتها في واجهة برمجة تطبيقات المجموعات هي:

• Iterator الأسلوب الافتراضي forEachRemaining(Consumer action) لأداء الإجراء المعطى لكل عنصر متبقي حتى يتم معالجة جميع العناصر أو يثير الإجراء استثناءً.
• Collection الأسلوب الافتراضي removeIf(Predicate filter) لإزالة جميع العناصر في هذه المجموعة التي تستوفي الشرط المعطى.
• Collection الأسلوب spliterator() الذي يُرجع مثيل Spliterator يمكن استخدامه لعبور العناصر بتتابع أو موازاة.
• أساليب replaceAll(), compute(), merge() للخريطة.
• تحسين الأداء لفئة HashMap مع اصطدامات المفاتيح

تحسينات واجهة برمجة التوازن

بعض تحسينات واجهة برمجة التوازن الهامة هي:

• ConcurrentHashMap أساليب compute()، forEach()، forEachEntry()، forEachKey()، forEachValue()، merge()، reduce() و search().
• CompletableFuture الذي يمكن أن يتم إكماله بشكل صريح (عن طريق تعيين قيمته وحالته).
• Executors الأسلوب newWorkStealingPool() لإنشاء مجموعة خيوط تنفيذ تقوم بسرقة العمل باستخدام جميع المعالجات المتاحة كمستوى توازن متوازن لها.

تحسينات Java IO

بعض التحسينات في الإدخال/الإخراج المعروفة لدي هي:

• Files.list(Path dir) تعيد Stream مملوءة بشكل كسول، حيث تكون العناصر فيها هي الإدخالات في الدليل.
• Files.lines(Path path) التي تقرأ جميع الأسطر من ملف ك Stream.
• Files.find() تعيد Stream مملوءة بشكل كسول مع مسار بحث عن الملفات في شجرة ملفات تنطلق من ملف بدء محدد.
• BufferedReader.lines() التي تعيد Stream، حيث تكون العناصر فيها هي الأسطر التي تم قراءتها من BufferedReader هذا.

تحسينات Java 8 Core API المتنوعة

بعض التحسينات المتنوعة في واجهة البرمجة الأساسية لـ Java 8 التي قد تكون مفيدة هي:

1. طريقة ثابتة ThreadLocal بالإضافة إلى طريقة withInitial(Supplier supplier) لإنشاء الحالات بسهولة.
2. تم توسيع واجهة Comparator بالعديد من الطرق الافتراضية والثابتة للترتيب الطبيعي، الترتيب العكسي، إلخ.
3. الطرق min()، max() و sum() في فئات Integer، Long و Double القابلة للتغليف.
4. الطرق logicalAnd()، logicalOr() و logicalXor() في فئة Boolean.
5. الطريقة stream() في فئة ZipFile للحصول على تيار مرتب على إدخالات ملف ZIP. تظهر الإدخالات في التيار بالترتيب الذي تظهر به في الدليل المركزي لملف ZIP.
6. عدة طرق مساعدة في فئة Math.
7. أُضيفت الأمر jjs لاستدعاء محرك Nashorn.
8. أُضيف الأمر jdeps لتحليل ملفات الفئات
9. تم إزالة جسر JDBC-ODBC.
10. تمت إزالة مساحة الذاكرة PermGen

هذا كل شيء بالنسبة لميزات Java 8 مع أمثلة على البرامج. إذا كنت قد نسيت بعض الميزات الهامة في Java 8، يرجى إعلامي من خلال التعليقات.