المشكلات المقارنة في Java هي أساسية للغاية وسهلة الخلط. اليوم سألخص وتنظيم ملخص أكثر تفصيلاً وترتيبًا لبعض النقاط المعرضة للخطأ ، على أمل أن يكون ذلك مفيدًا لدراسة الجميع ومقابلته.
1. الفرق بين == و equals ()
بادئ ذي بدء ، نحن بحاجة إلى معرفة الفرق بين == و equals (). تتم مقارنة علامة == دائمًا مع قيمة العنوان. بالنسبة لأنواع البيانات الأساسية ، فإن المقارنة == هي في الواقع ما إذا كانت القيم المتغيرة متساوية ، بينما بالنسبة لأنواع البيانات المرجعية ، تتم مقارنة قيمة العنوان. ما تحتاج إلى إيلاء اهتمام خاص له هنا هو نوع السلسلة ، وهو من السهل أخذه كأمر مسلم به == ومن السهل ارتكاب أخطاء. طريقة equals () هي طريقة في فئة الكائن. نحن نعلم أن جميع الفئات في Java سترث فئة الكائن بشكل افتراضي ، وبالتالي فإن كائنات الفئة سيكون لها طريقة متساوية (). يتم عرض طريقة متساوية () في فئة الكائن في الشكل أدناه:
كما يتضح من الكود المصدري ، تستخدم الطبقة الأساسية للطريقة المتساوية () في فئة الكائن أيضًا == ، لذلك فهي في الواقع قيمة العنوان. لذلك إذا أردنا استخدام طريقة متساوية () لإجراء مقارنات أخرى ، فنحن بحاجة إلى تجاوز طريقة متساوية ().
2. أنواع البيانات الأساسية وأنواع التغليف
نعلم جميعًا أن البايت ، القصيرة ، int ، طويلة ، منطقية ، شار ، مزدوج ، وتعويم من أنواع البيانات الأساسية ، والمتغيرات التي يعلنون يتم تخزينها في ذاكرة المكدس. توجد المتغيرات المحددة بواسطة أنواع التغليف المقابلة (بايت ، قصيرة ، عدد صحيح ، طويل ، منطقية ، شخصية ، مزدوجة) في ذاكرة الكومة. بالنسبة لأنواع البيانات الأساسية ، تكون المقارنة بسيطة نسبيًا ، أي استخدام == لتحديد ما إذا كانت متساوية ، واستخدامها <،> ، <= ،> = لمقارنة الأحجام. ولكن بالنسبة لأنواع التغليف ، فهي مختلفة بعض الشيء.
أولاً ، لتحديد ما إذا كانت متساوية ، راجع نتيجة تنفيذ الكود التالي:
Package DailyTest ؛ استيراد org.junit.test ؛/*** ملخص مقارن في Java* Author yrr*/الفئة العامة javacomparetest {/*** integer type الحكم متساوٍ*/test public void test01 () {int n3 = 48 ؛ System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- N8) ؛ System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.Out.Println (N1.Indvalue () N6) NullPointException}/*** الحكم الطويل نوع متساوٍ*/test public void test02 () {// لاحظ هنا أنه عند استخدام تعريف طويل ، لا يكون L أو L مطلوبًا ، ولكن عند استخدام طويل ، سيتم الإبلاغ عن خطأ // أضفه في البناء للإشارة إلى الفرق الطويل N3 = 48L ؛ System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- N1) // true system.println ( System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- System.out.println (n4 n5) ؛ // عند استخدام طريقة long.intvalue () ، تحتاج إلى الانتباه للتحقق مما إذا كان من الفارغ منع NullPointException}}لنتائج التنفيذ أعلاه ، يتم التفسير التالي:
أولاً ، للطريقة الجديدة ، نعلن عن عدد صحيح أو كائن طويل. نظرًا لأن الكائن الجديد يفتح مساحة من المساحة في الكومة ، حتى لو كانت قيم الاثنين متماثلة ، بالنسبة لـ == ، تتم مقارنة قيمة العنوان ، لذلك سيتم إرجاع خطأ. بالنسبة لفئات الغلاف لأنواع البيانات الأساسية ، تمت إعادة كتابة طريقة متساوية () ، وسيتم مقارنة الحجم العددي ، بحيث يمكن استخدام طريقة متساوية () للحكم بناءً على الحجم العددي. فيما يتعلق بمشكلة مقارنة متغيرات عدد صحيح مع متغيرات Int ، سنجد أن قيمة المقارنة تعتمد أيضًا على الحجم العددي. هذا لأنه عند المقارنة ، يكون نوع عدد صحيح غير مصنوع تلقائيًا وتحويله إلى نوع int. ينطبق شرح النقاط الثلاث الأولى على جميع أنواع التغليف. بالنسبة لطريقة المهمة المباشرة ، يتم الحكم على متغيري عدد صحيح بقيمة 48 من خلال علامة == ، ولكن عندما تكون القيمة 128 ، تكون خاطئة. هذا لأنه في الأسفل ، بالنسبة إلى عدد صحيح N1 = 48 ؛ ، فإن طريقة المهمة المباشرة تستدعي فعليًا طريقة integer.value (). يمكننا إلقاء نظرة موجزة على الكود المصدري لطريقة integer.value () ، كما هو موضح في الشكل أدناه:
يمكننا أن نرى أن هناك حكم إذا هنا. عندما يكون الإدخال I ضمن نطاق [-128 ، 127] ، يتم إرجاعه مباشرة من مجموعة integercache. لذلك ، بالنسبة للقيم في هذا النطاق ، يتم إرجاع قيم العنوان المقابلة لهذا الصفيف ، لذلك سيتم إرجاع علامة == لعلامة الحكم True. ما ليس ضمن هذا النطاق هو الكائن الجديد ، لذلك سيتم إرجاع خطأ. هذا الاستنتاج صحيح بالنسبة للبايت ، وقصير ، عدد صحيح ، وأنواع طويلة (إذا كنت مهتمًا ، يمكنك التحقق من الكود المصدري لطريقة القيمة المقابلة ()) ، لأن نطاق نوع البايت هو [-128 ، 127] ، لذلك لنوع البايت ، باستخدام == لا يختلف عن المساواة ().
لمقارنة الحجم ، لا توجد مشكلة في استخدام> ، <، <= ،> = ، وسيتم إلغاء التلقائي تلقائيًا. لكننا نوصي عادة باستخدام طريقتين التاليتين لمقارنة الأحجام:
استدعاء طريقة xxxvalue () لتحويلها إلى نوع البيانات الأساسي للمقارنة. في فئة Wrapper ، تتم إعادة كتابة طريقة المقارنة (). من خلال النظر إلى رمز المصدر للمقارنة () ، يمكنك أن ترى أنه في الواقع ، يتم تحويل الاستخدام الأساسي أيضًا إلى نوع البيانات الأساسي المقابل عن طريق إلغاء التزام تلقائيًا ثم مقارنته.
2. مقارنة كائنات جافا
مع المقدمة أعلاه ، من الأسهل مقارنة الكائنات. المبادئ هي نفسها.
1. مقارنة أنواع السلسلة
تجدر الإشارة إلى أنه لا يمكن استخدام نوع السلسلة مباشرة> ، <= ،> = ، و <، وسيقوم بالإبلاغ عن استثناء التجميع.
حزمة DailyTest ؛ استيراد org.junit.test ؛/*** ملخص مقارن في java* author yrr*/class public javacomparetest {test public void test03 () {String s1 = new string ("123") ؛ السلسلة S2 = سلسلة جديدة ("123") ؛ System.out.println (S1 == S2) ؛ // false system.out.println (s1.equals (s2)) ؛ السلسلة S3 = "234" ؛ السلسلة S4 = "234" ؛ System.out.println (S3 == S4) ؛ // true system.out.println (S3.equals (S4)) ؛ // true //system.out.println(S1 <= s3) ؛ . //حقيقي }}2. مقارنة كائنات الفصل
خاتمة كائنات الفئة هي نفسها ، ولكن مقارنة بأنواع البيانات الأساسية وأنواع السلسلة ، فهو أكثر تعقيدًا قليلاً.
وفقًا لقاعدة معينة ، لتحديد ما إذا كان الكائنان متساويان ، يجب إعادة كتابة طريقة متساوية () في الفصل المحكم. رمز المثال هو كما يلي:
Package DailyTest ؛ import org.junit.test ؛/*** ملخص مقارن في Java* author yrr*/class public javacomparetest {test public void test04 () الشخص p2 = شخص جديد ("yrr" ، 18) ؛ system.out.println (p1 == p2) ؛ // false system.out.println (p2.equals (p1)) ؛ // true}} class person {private string name ؛ عصر عدد صحيح خاص ؛ public person () {} الشخص العام (اسم السلسلة ، عصر الصدفة) {this.name = name ؛ this.age = العمر ؛ } السلسلة العامة getName () {return name ؛ } integer getAge () {return Age ؛ } Override public boolean يساوي (كائن obj) {person person = (person) obj ؛ return name.equals (person.getName ()) && Age.equals (person.getage ()) ؛ }}وإذا كنت ترغب في مقارنة أحجام كائنين (هذا هو أيضًا سؤال مشترك للمقابلة) ، فهناك طريقتان:
تنفذ الفئة المماثلة الواجهة المماثلة ، وتتجاوز طريقة المقارنة () لتحديد الفئة التي تنفذ واجهة المقارنة أو استخدام الفئة الداخلية لتجاوز طريقة المقارنة (): يتم تعريف السابق على الفئة المماثلة ، بينما يتم تعريف الأخير خارج الفئة القابلة للمقارنة. من خلال هذا الاختلاف ، فإن مزايا وعيوب الاثنين واضحة أيضًا. الأول بسيط ، ولكنه يتطلب تعديل الفئة المقارنة ، في حين أن الأخير لا يحتاج إلى تعديل الكود الأصلي ، وهو أكثر مرونة.
الطريقة الأولى ، رمز العينة كما يلي:
Package DailyTest ؛ import org.junit.test ؛/*** ملخص مقارن في Java* author yrr*/class public class javacomparetest {test public void test5 () {person p1 = new شخص ("yrr" ، 18) ؛ الشخص p2 = شخص جديد ("WX" ، 19) ؛ System.out.println (p1.compareto (p2) <0) ؛ }} فئة الشخص ينفذ قابلة للمقارنة <profer> {اسم السلسلة الخاصة ؛ عصر عدد صحيح خاص ؛ public person () {} الشخص العام (اسم السلسلة ، عصر الصدفة) {this.name = name ؛ this.age = العمر ؛ } integer getAge () {return Age ؛ } Override public int compareto (person o) {return this.getage () - o.getage () ؛ }}الطريقة الثانية ، رمز العينة كما يلي:
Package Packator ؛ Import java.util.arrays ؛ import java.util.comparator ؛ public class mycomparator {public static void main (string [] args) {user [] user = new user [] {new user ("u1001" ، 25) ، user new ("u1002" ، 20) ، user user ("u1003 ، 21)} ؛ Arrays.sort (المستخدمين ، المقارن الجديد <Sether> () {Override public int (user o1 ، user o2) {return o1.getage () - o2.getage () ؛}}) ؛ لـ (int i = 0 ؛ i <user.length ؛ i ++) {user user = useral [i] ؛ System.out.println (user.getId () + "" + user.getage ()) ؛ }}} فئة مستخدم {private string id ؛ عصر INT الخاص ؛ المستخدم العام (معرف السلسلة ، int age) {this.id = id ؛ this.age = العمر ؛ } public int getage () {return Age ؛ } public void setage (int age) {this.age = age ؛ } السلسلة العامة getId () {return id ؛ } public void setId (string id) {this.id = id ؛ }}ما سبق هو المحتوى ذي الصلة لأسئلة مقارنة Java التي أخبرتك بها هذه المرة. إذا كانت لديك أسئلة أخرى ، فيمكنك مناقشتها في منطقة التعليق أدناه. شكرا لك على دعمك.