جافا "يساوي" و "==" أوجه تشابه
أولاً ، دعنا نتحدث بإيجاز عن "متساو" و "=="
== العملية تقارن ما إذا كانت قيم المتغيرين مساوية لنوع البيانات الأساسية.
للحصول على المتغيرات المرجعية ، فهذا يعني ما إذا كانت العناوين المخزنة في الكومة هي نفسها ،
هل المحتوى في المكدس هو نفسه؟
ما إذا كان المتغيران الممثلان من خلال عملية متساوية هي إشارات إلى نفس الكائن ،
أي ما إذا كان المحتوى الموجود في الكومة هو نفسه.
باختصار ، == يقارن عناوين كائنين ، في حين أن متساوي يقارن محتويات كائنين.
اسمحوا لي أن أقدم باختصار فئة السلسلة
يسمى فئة السلسلة أيضًا تسلسل الأحرف غير القابل للتغيير
تستخدم String قيمة char النهائية الخاصة [] لتحقيق تخزين السلاسل. وهذا يعني ، بعد إنشاء كائن السلسلة ، لا يمكن تعديل محتوى السلسلة المخزنة في هذا الكائن. تحتوي فئة السلسلة على طريقة إنشاء خاصة ، والتي تتمثل في استخدام "عروض الأسعار المزدوجة لإنشائها. على سبيل المثال ، تقوم سلسلة جديدة ("123") في الواقع بإنشاء كائنين سلسلة ، يتم إنشاء أحدهما بواسطة "123" من خلال "عروض الأسعار المزدوجة ، والآخر يتم إنشاؤه بواسطة جديد. ومع ذلك ، فإن الفترات التي تنشئها مختلفة ، واحدة هي فترة التجميع والآخر هو فترة التشغيل. تقوم Java بتحميل تشغيل + مشغل لنوع السلسلة ، ويمكنك استخدامها مباشرة + لتسلسل سلسلتين. يمكن استدعاء طريقة المتدرب () لفئة السلسلة أثناء وقت التشغيل إضافة كائنات إلى تجمع السلسلة.
التفريق بين طريقتين لإنشاء كائنات سلسلة "" و New ()
السلسلة هي بيانات تغليف خاصة. يمكن استخدامه:
String str1 = سلسلة جديدة ("123") ؛ String str2 = "123" ؛إنشاء شكلين
الأول هو استخدام New () لإنشاء كائن جديد ، سيتم تخزينه في الكومة. يتم إنشاء كائن جديد في كل مرة يطلق عليها. (إنه في الواقع اثنان ، كما ذكر أعلاه ، ولكن بعد وجود "123" في المجمع الثابت ، لن يتم إنشاء "123" الجديد في التجمع الثابت)
النوع الثاني هو أولاً إنشاء STR متغير إلى كائن فئة السلسلة في المكدس ، ثم استخدم مرجعًا رمزيًا لمعرفة ما إذا كان هناك "ABC" في تجمع السلسلة الثابت. إذا لم يكن الأمر كذلك ، فقم بتخزين "ABC" في المسبح الثابت للسلسلة واترك Str يشير إلى "ABC". إذا كان هناك بالفعل "ABC" ، فدع Str يشير مباشرة إلى "ABC".
يجب أن نولي اهتماما في هذا الوقت
من ناحية ، فإن طريقة الكتابة الأولى مفيدة وتوفر مساحة الذاكرة. في الوقت نفسه ، يمكن أن يحسن سرعة تشغيل البرنامج إلى حد ما ، لأن JVM ستقرر تلقائيًا ما إذا كان من الضروري إنشاء كائن جديد بناءً على الموقف الفعلي للبيانات في المكدس. بالنسبة إلى رمز السلسلة String = سلسلة جديدة ("123") ؛ ، يتم إنشاء كائنات جديدة في الكومة بغض النظر عما إذا كانت قيم السلسلة متساوية أم لا ، سواء كان ذلك ضروريًا لإنشاء كائنات جديدة ، وبالتالي زيادة العبء على البرنامج. من ناحية أخرى ، عندما نحدد فئة باستخدام تنسيق مثل String STR = "123" ؛ ، نأخذ دائمًا أمراً مفروغاً منه أننا ننشئ كائنًا من فئة السلسلة.
قد لا يكون الكائن قد تم إنشاؤه! وربما فقط أشير إلى كائن تم إنشاؤه سابقًا. فقط من خلال الطريقة الجديدة () يمكننا التأكد من إنشاء كائن جديد في كل مرة.
يرجى الاطلاع على المثال التالي
حزمة TestString. الفئة العامة TestString {public static void main (string [] args) {string a = "123" ؛ السلسلة B = "123" ؛ system.out.println (a == b) ؛ system.out.println (A.equals (b)) ؛ System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- And محتوى الكائنات المرجعية في الكومة هو نفسه ، لذلك A. System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- But c is نفس كومة d ، لذلك c.equals (d) هو صحيح */ string e = "a1" ؛ سلسلة f = "a" +1 ؛ system.out.println (e == f) ؛ system.out.println (E.equals (f)) ؛ System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ * نعم ، يحمل Java بعض المشغل ، لكن لا يمكنك استخدام المحمل الذي يحدده C ++ "H" ؛ System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
شكرا لك على القراءة ، آمل أن تساعدك. شكرا لك على دعمك لهذا الموقع!