我的Java基础学习第八天

tech2024-12-02 10

CoreJava_day08

记得要复习前面的： CoreJava_day06

CoreJava_day07

文章目录

CoreJava_day08一、访问控制1.1 修饰符1.2 案例二、内部类2.1 成员内部类2.2 静态内部类2.3 局部内部类2.4 匿名内部类2.5 总结：三、包装类3.1 案例3.2 自动装箱/拆箱3.2.1 练习四、Object中常用方法4.1 toString方法4.2 getClass方法 4.3 equals方法 4.3.1 ==和equals的区别 4.4 hashCode方法五、关于String对象5.1 概述5.2 案例

一、访问控制

1.1 修饰符

类中的属性和方法，可以使用下面四种修饰符进行访问控制：

public > protected > default > private

public ：公共的，在所有的地方都可以访问protected：受保护的，当前类中，子类中，同一个包中其他类可以访问default ：默认的，当前类中，同一个包中的子类中可以访问注意：default默认的，指的是空修饰符，并不是default这个关键字例如，String name; 在类中，这种情况就是默认的修饰符private：私有的，当前类可以访问修饰符类中同包非子类同包子类不同包子类同包子类public✔✔✔✔✔protected✔✔✔✔✘default✔✔✔✘✘private✔✘✘✘✘

1.2 案例

package com.lz.day04; public class Test { public String pu = "public"; protected String pro = "protected"; String de = "default"; private String pri = "private"; public void test() { System.out.println(pu); System.out.println(pro); System.out.println(de); System.out.println(pri); } } class SamePackage { //在同包的非子类中访问 public void test() { Test test = new Test(); System.out.println(test.pu); System.out.println(test.pro); System.out.println(test.de); //编译报错，无法访问 // System.out.println(test.pri); } } class SamePackageSub extends Test { //在同包的子类中访问 public void test() { //继承后，可直接访问 System.out.println(pu); System.out.println(pro); System.out.println(de); //编译报错，无法访问 // System.out.println(pri); } }

同一个类中，全部可以访问同包非子类中，四个修饰符除了private，都可以访问。同包子类中，四个修饰符除了private，都可以访问。

在另一个包中，创建类进行访问测试：

package com.lz.zm.six; import com.lz.day04.Test; public class OtherTest { //在不同包的非子类中访问 public void test() { //需要创建对象，然后访问 Test test = new Test(); System.out.println(test.pu); // 编译报错 // System.out.println(test.pro); // System.out.println(test.de); // System.out.println(test.pri); } } class otherSub extends Test { //在不同包的子类中访问 public void test(){ // 继承后可以直接访问 System.out.println(pro); System.out.println(pu); // 编译报错 // System.out.println(pri); // System.out.println(de); } }

在不同包非子类中，只有public可以访问在不同包子类中，只有public和protected可以访问

思考，正常情况下，编写一个类，都可以使用哪些权限控制修饰符？

正常编写的类，可以使用两种权限控制修饰符：例如：

public class A {} class B extends A {}

但是，内部类可以使用四种限权控制修饰符：

public class Test { private class A {} class B {} protected class C {} public class D {} }

在Test类的内部，嵌套了四个内部类：A B C D，分别使用了private、default、protected、public进行了修饰

二、内部类

在类中在定义一个类，称为内部类

非内部类：

public class Test { } class A { }

内部类：

public class Test { // 外部类 public class A { // 内部类 } }

内部类一共分为四种形式：

成员内部类静态内部类局部内部类匿名内部类

2.1 成员内部类

在类中可以定义成员变量，成员方法，这样我们也可以定义成员内部类

// 外部类 public class MemberOuterClass { // 外部类属性 private String name; private static int age; // 外部类方法 public void run() { } public static void go() { } /* * 成员内部类，声明开始 */ public class MemberInnerClass { // 内部类属性 private String name; private int age; // private static int age; // 内部类方法 public void run() { } /* * public static void go() { * * } */ }// 声明结束 }

注意，在内部类中，不能写静态成员变量和静态方法注意，当前这个代码，编译成功后，会生成俩个class文件，一个对应外部类，一个对应内部类

编译生成的2个class文件的名字分别为： MemberOuterClass.class MemberOuterClass$MemberInnerClass.class

成员内部类和外部类的相互访问

成员内部类访问外部类的属性和方法 // 外部类 public class MemberOuterClass { // 外部类属性 private String name; private static int age; // 外部类方法 public void run() { } public static void go() { } /* * 成员内部类，声明开始 */ public class MemberInnerClass { // 内部类属性 private String name; private int age; // private static int age; // 内部类方法 public void run(String name) { System.out.println(name); System.out.println(this.name); // 访问外部类非静态属性 System.out.println(MemberOuterClass.this.name); // 访问外部类静态属性 System.out.println(MemberOuterClass.age); // 外部类静态方法 MemberOuterClass.go(); // 外部类非静态方法 MemberOuterClass.this.run(); } /* * public static void go() { * * } */ }// 声明结束 } 外部类访问成员内部类的属性和方法 // 外部类 public class MemberOuterClass { // 外部类属性 private String name; private static int age; // 外部类方法 public void run() { //需要创建内部类对象，然后才可以访问 MemberInnerClass t = new MemberInnerClass(); // 访问内部类成员变量 System.out.println(t.age); System.out.println(t.name); t.run("李白"); } public static void go() { } /* * 成员内部类，声明开始 */ public class MemberInnerClass { // 内部类属性 private String name; private int age; // private static int age; // 内部类方法 public void run(String name) { System.out.println(name); System.out.println(this.name); // 访问外部类非静态属性 System.out.println(MemberOuterClass.this.name); // 访问外部类静态属性 System.out.println(MemberOuterClass.age); // 外部类静态方法 MemberOuterClass.go(); // 外部类非静态方法 MemberOuterClass.this.run(); } /* * public static void go() { * * } */ }// 声明结束 }

其他类中使用这个内部类

import com.lyy.zm.six.MemberOuterClass.MemberInnerClass; public class OutAndInnerClassTest { public static void main(String[] args) { MemberOuterClass m = new MemberOuterClass(); MemberInnerClass i = m.new MemberInnerClass(); i.run("小黑"); } }

在其他类中，使用这个非private修饰的成员内部类的时候，需要注意以下几点：

这个内部类需要import导入，并且是外部类.内部类的形式导入在创建对象的时候，需要先创建出外部类对象，然后使用外部类对象再创建内部类对象形式为：外部类对象.new 内部类对象成员内部类私有的话，其他类无法创建内部类对象，但是在外部类可以创建内部类内部类访问外部类静态成员：直接通过外部类.成员

思考，类的内部除了嵌套另一个类之外，是否还可以嵌套接口？

可以，不仅类中可以嵌套接口，接口内部也可以嵌套其他接口比如，参考java.util.Map接口中的内部接口Entry

思考，什么情况下会使用内部类？

在对事物进行抽象的时候，若一个事物内部还包含其他事物，就可以考虑使用内部类这种结构。

2.2 静态内部类

public class OutClass { // 静态内部类 public static class staticInerClass { // 静态属性 private static int age; // 静态方法 public static void go() { } } }

静态内部类可以有静态属性和静态方法生成的class文件： OutClass.class OutClass$staticInerClass.class

静态内部类和外部类的相互访问

静态内部类访问外部类的属性和方法 public class OutClass { private String mame; private static int age; public void run() { } public static void go() { } // 静态内部类 public static class staticInerClass { private String name; // 静态属性 private static int age; public void run(String name) { System.out.println(name); System.out.println(this.name); System.out.println(age); //静态内部类中，无法访问外部类的非静态属性和方法 // System.out.println(OutClass.this.mame); // OutClass.this.run(); //静态内部类中，访问外部类的非静态属性和方法 OutClass outClass = new OutClass(); System.out.println(outClass.mame); outClass.run(); //访问外部类的静态属性和方法 System.out.println(OutClass.age); OutClass.go(); } // 静态方法 public static void go() { } } }

注意，在静态内部类中访问不了静态属性和方法，可以创建外部类对象，然后去访问

外部类访问静态内部类的属性和方法 public class OutClass { private String mame; private static int age; public void run() { // 外部类访问静态内部类中的静态属性和静态方法 System.out.println(staticInerClass.age); staticInerClass.go(); // 外部类访问静态内部类中的非静态属性和方法 //需要创建内部类对象，然后才可以访问 staticInerClass c = new staticInerClass(); System.out.println(c.name); c.run("tom"); } public static void go() { } // 静态内部类 public static class staticInerClass { private String name; // 静态属性 private static int age; public void run(String name) { System.out.println(name); System.out.println(this.name); System.out.println(age); //静态内部类中，无法访问外部类的非静态属性和方法 // System.out.println(OutClass.this.mame); // OutClass.this.run(); //静态内部类中，访问外部类的非静态属性和方法 OutClass outClass = new OutClass(); System.out.println(outClass.mame); outClass.run(); //访问外部类的静态属性和方法 System.out.println(OutClass.age); OutClass.go(); } // 静态方法 public static void go() { } } }

外部类访问内部类的非静态属性和方法：创建对象

其他类中使用这个内部类：如果这个静态内部类不是private修饰的，那么在其他类中就可以访问到这个内部类

import com.lz.zm.six.OutClass.staticInerClass; public class OutAndInnerClassTest { public static void main(String[] args) { staticInerClass sInerClass = new staticInerClass(); sInerClass.run("李白"); } }

在其他类中，使用这个非private修饰的静态内部类的时候，需要注意以下几点：

这个内部类需要import导入，并且是外部类.内部类的形式导入在创建对象的时候，直接使用这个静态内部类的名字即可new 静态内部类对象();，不再需要依赖外部类对象 ==表示要比较这个两个对象的内存地址是否相等

2.3 局部内部类

局部内部类，是另一种形式的内部，声明在外部类的方法中，相当于方法中的局部变量的位置，它的作用范围只是在当前方法中。

局部内部类是最不常用的一种内部类

public class LocalOuterClass { public void run(String name) { // 局部内部类 class LocalInnerClass { } } }

局部内部类和外部类的相互访问：

局部内部类访问外部类属性和方法

public class LocalOuterClass { // 外部类的属性 private String name; private static int age; // 外部类方法 public void run() { } public static void go() { } public void run(String name) { // 局部内部类 class LocalInnerClass { // 局部内部类的属性 private String name; // 无法定义静态属性和静态方法 // private static int age; /* * public static void go() { * * } */ public void run(String name) { // 当前方法里面的参数name System.out.println(name); // 访问内部类自己的属性 System.out.println(this.name); // 外部类的静态属性 System.out.println(LocalOuterClass.age); // 外部类的非静态属性 System.out.println(LocalOuterClass.this.name); // 外部类静态方法 LocalOuterClass.go(); // 外部类非静态方法 LocalOuterClass.this.run(); } } } }

局部内部类不能有静态属性和静态方法可以直接外部类名.属性或者方法调用，静态的话加个this

外部类访问局部内部类的属性和方法

局部内部类，只能在当前声明的方法中进行使用。在局部内部类的下面去创建对象

局部内部类中，访问当前方法中的变量，这个变量必须是final修饰的

public void sayHello(final String name) { final int num = 1; // 局部内部类 class A { public void test() { System.out.println(name); System.out.println(num); } } }

final修饰的变量，只能赋值一次在JDK1.8中，一个局部变量在局部内部类中进行方法了，那么这个局部变量自动变为final修饰

2.4 匿名内部类

匿名内部类是一种没有名字的内部类，是一种内部类的简化写法

在普通的代码中，使用一个接口的步骤如下：

声明一个类，去实现这个接口实现这个接口中的抽象方法(重写)在其他代码中，创建这个类的对象调用类中实现(重写)红藕的方法

这个过程就是把接口的抽象方法重写了，最后再调用重写的方法那么，匿名内部类，就是把这个过程简化了，可以更加方便的实现(重写)后的方法格式：

父类或者接口类型变量名 = new 父类或者接口() { // 方法重写 public void method { // 执行语句 } }； // 调用实现(重写)后的方法变量名.method();

new 创建对象 new Person()：创建Person类型对象

匿名内部类的两种形式：

利用一个父类，进行声明并创建匿名内部类对象，这个匿名内部类默认就是这个父类的子类型利用一个接口，进行声明并创建匿名内部类对象，这个匿名内部类默认就是这个接口的实现类

匿名内部类由于没有类名：

匿名内部类必须依托于一个父类型(抽象类)或者一个接口匿名内部类在声明的同时，就必须创建出对象，否则后面就没法创建了匿名内部类中无法定义构造器

利用父类型来声明并创建匿名内部类对象

public abstract class Animal { public abstract void run(); } class Test { public static void main(String[] args) { /** * 创建一个没有名字的类，继承Anaimal抽象类，同时重写抽象类方法 * 并且创建这个类的对象 */ Animal animal = new Animal() { @Override public void run() { System.out.println("这是匿名内部类中的默认实现"); } }; animal.run(); } }

注意，利用父类型来声明这个匿名内部类，那么这个匿名内部类默认就是这个父类型的子类

利用接口来声明并创建匿名内部类对象

public interface Action { void run(); } class Test1 { public static void main(String[] args) { Action a = new Action() { @Override public void run() { System.out.println("匿名内部类中的默认实现"); } }; a.run(); } }

案例：

import java.util.Arrays; public interface Algorithm { void sort(int[] arr); } class Test2 { // 使用指定算法，对数组arr进行排序 public void sort(int[] arr,Algorithm algorithm) { algorithm.sort(arr); } public static void main(String[] args) { Test2 t = new Test2(); int[] arr = {3,4,1,23,2,9}; Algorithm algorithm = new Algorithm() { @Override public void sort(int[] arr) { //使用当前需要的排序算法 //例如，这里简单的使用Arrays工具类中的排序方法 Arrays.sort(arr); } }; t.sort(arr, algorithm); System.out.println(Arrays.toString(arr)); } }

运行结果： [1, 2, 3, 4, 9, 23]

内部类的选择：

假设现在已经确定了要使用内部类，那么一般情况下，该如何选择？

考虑这个内部类，如果需要反复的进行多次使用（必须有名字）在这个内部类中，如果需要定义静态的属性和方法，选择使用静态内部类在这个内部类中，如果需要访问外部类的非静态属性和方法，选择使用成员内部类考虑这个内部类，如果只需要使用一次（可以没有名字）选择使用匿名内部类局部内部类，几乎不会使用

2.5 总结：

成员内部类，局部内部类不能有静态属性和静态方法，访问外部类非静态方法记得加this，成员内部类和成员变量类似，局部内部类和局部变量类似。成员内部类和局部内部类访问外部类都是在自己的方法里面访问，外部类访问内部类：记得创建内部类对象。成员内部类：其他类访问，先创建外部类对象，后导包，再外部类对象.new 内部类对象；局部内部类中，访问当前方法中的变量，这个变量必须是final修饰的，只能赋值一次静态内部类可以写静态属性和静态方法，访问静态属性和方法和上面两个相同，但是访问非静态属性和方法西药先创建外部类对象，然后再访问，外部类访问静态内部类非静态属性和方法，先创建外部类对象，再调用。当它非private修饰时，创建内部类对象，就可以使用了。匿名内部类需要实例化对象(抽象父类型或者接口)，然后重写父类型(抽象类)或者接口的方法。匿名内部类没有名字。

三、包装类

基本类型包装类型booleanjava.lang.Booleanbytejava.lang.Byteshortjava.lang.Shortintjava.lang.Integerlongjava.lang.Longfloatjava.lang.Floatdoublejava.lang.Doublecharjava.lang.Character

3.1 案例

/** * 将基本数据类型转换对应的引用类型 ====> 装箱 * 将包装类类型转成对应的基本数据类型 ====> 拆箱 * 发现很麻烦，然后在jdk1.5之后，引入了自动装箱自动拆箱（见3.2） * @author ASUS * */ public class PzClass { public static void main(String[] args) { int a = 1; //编译报错，因为i不是对象 // i.toString(); // int -----> integer Integer a1 = Integer.valueOf(a); // 装箱 System.out.println(a1.toString()); int i = a1.intValue(); // 拆箱 } }

3.2 自动装箱/拆箱

// 自动装箱 Integer a2 = 1; // 自动拆箱 int a3 = a2;

3.2.1 练习

public class Ex { public void show1(int number) { System.out.println(number); } public void show2(Integer number) { System.out.println(number); } public void show3(long number) { System.out.println(number); } public void show4(Long number) { System.out.println(number); } public static void main(String[] args) { Ex ex = new Ex(); ex.show1(1); // 自动装箱 ex.show2(1); // 自动转换32位转64位 ex.show3(1); // 编译报错 // ex.show4(1); // 1 ---> Integer 和Long无关 ex.show4(1l); // 1l(long) ---> Long /** * IntegerCache int缓存区 * 从源码得知-128~127的Integer对象都提前创建好了 * 并且防止cath数组里面 */ // i1,i2是对象，是地址，从cath数组里面取出来，是同一个对象 // 所以地址值一样 Integer i1 = Integer.valueOf(127); Integer i2 = Integer.valueOf(127); System.out.println(i1==i2); // true /* * 128 不在下面的范围所以重新new了一个对象 * if(x>= -128 && x <= 127) {...} * else{ return new Integer();} * 所以地址值不同 */ Integer i3 = Integer.valueOf(128); Integer i4 = Integer.valueOf(128); System.out.println(i3==i4); // false /* * new 创建新对象所以地址不同 */ Integer in1 = new Integer(127); Integer in2 = new Integer(127); System.out.println(in1==in2); // false } } System.out.println(Integer.MAX_VALUE); // 2147483647 System.out.println(Integer.MIN_VALUE); // -2147483648 // 将字符串转int类型 String a = "1"; // 第一种方法 int b = Integer.valueOf(a); sout(b++)// 结果1 // 第二种方法 int a1 = Integer.parseInt(a); sout(++a1); // 2 // 字符串转进制 String a = "8"; // 转进制得先转成Integer inr a1 = 10; int i = Integer.parseInt(a,8); // 转八进制 sout(i); //运行报错--> 类型转换失败 String s = Integer.toBinaryString(a1); // 十转二进制 sout(s); // 1011 String s1 = Integer.toOctalString(a1); // 十进制转八进制 sout(s1); // 12 String s2 = Integer.toHexString(a1); // 转十六进制 sout(s2); // a

四、Object中常用方法

Object是祖宗类，超父类

搜源码：ctrl+shift+t

4.1 toString方法

该方法可以返回一个对象默认的字符串形式：

public class Object{ public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); } }

toHexString：转十六进制

package com.lz.zm.serven; public class Student { @Override public String toString() { return "哈哈"; } } package com.lz.zm.serven; public class StudentTest { public static void main(String[] args) { Student student = new Student(); //com.lz.zm.serven.Student@6d06d69c System.out.println(student.toString()); // 手动调用toString // 如果不想要这样写，可以重新toString方法 // 重写后输出:哈哈 System.out.println(student); // 默认调用toString(推荐使用) } }

4.2 getClass方法

该方法是非常重要的一种方法，它可以返回一个引用在运行时所指向的对象，具体类型是什么该方法是native修饰的本地方法，不是java语言实现的。

public class Object{ public final native Class<?> getClass(); }

native ：本地方法，其他语言写的(不是Java) final ：不能重写

package com.lz.zm.serven; public class StudentTest { public static void main(String[] args) { Student student = new Student(); // class com.lz.zm.serven.Student System.out.println(student.getClass()); } } package com.lz.zm.serven; public class StudentTest { public static void show(Object obj) { System.out.println(obj.getClass()); } public static void main(String[] args) { Student student = new Student(); show(student); // class com.lz.zm.serven.Student show(new Object()); //class java.lang.Object } }

package corejave_day01.Object; public class Person { } package corejave_day01.Object; public class ObjectTest { public static void main(String[] args) { Person person = new Person(); // 得到class 全限类名 class corejave_day01.Object.Person System.out.println(person.getClass()); // 得到全限类名 corejave_day01.Object.Person System.out.println(person.getClass().getName()); // 得到类名 Person System.out.println(person.getClass().getSimpleName()); } }

4.3 equals方法

进行比较的，只有引用类型才存在equals方法，在jdk提供的绝大多数都重写equals方法，所以当进行判断调用的最好是equalsequals比较的都是内容== 比较的是地址在以后开发过程中字符串等其他引用类型判断是否相等，最好是用equals而不是==，如果是基本数据类型只能是==，想要使用equals就得装箱重写equals最好一起重写hascode （重写后比较内容），这样在进行对象的比较时，先进性判断两个对象的hashcode是否相同，如果同，那么再去判断equals，如果hashcode不同，这两个对象一定是不等的，这样做是为了提供效率。finalize ===> finalize()是Object中的方法，当垃圾回收器将要回收对象所占内存之前被调用，即当一个对象被虚拟机宣告死亡时会先调用它finalize()方法，让此对象处理它生前的最后事情（这个对象可以趁这个时机挣脱死亡的命运） public class Object{ public boolean equals(Object obj) { return (this == obj); } }

不是本地方法

Person p1 = new Person(); Person p2 = new Person(); /** * == 如果用来判断引用类型那就是比较地址 */ // false System.out.println(p1.equals(p2)); Person p1 = new Person(1,"李四"); Person p2 = new Person(1,"李四"); // false System.out.println(p1.equals(p2)); /** * 如果id，name都一样，就认为是同一个人 * 此时equals不满足条件了，需要重写 */

对equals方法重写，一般需要注意以下几点(约定)：

自反性：对任意引用obj，obj.equals(obj)的返回值一定为true.对称性：对于任何引用o1、o2，当且仅当o1.equals(o2)返回值为true时，o2.equals(o1)的返回值一定为true;传递性：如果o1.equals(o2)为true, o2.equals(o3)为true,则o1.equals(o3)也一定为true一致性：如果参与比较的对象没任何改变，则对象比较的结果也不应该有任何改变非空性：任何非空的引用obj，obj.equals(null)的返回值一定为false Person p1 = new Person(1,"李四"); Person p2 = new Person(1,"李四"); System.out.println(p1.equals(p1)); //自反性 true

重写equals：

package corejave_day01.Object; public class Person { private int id; private String name; public Person(int id, String name) { this.id = id; this.name = name; } public Person() {} public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "id=" + id + ", name=" + name ; } /** * 如果equals(null) 一定返回false :非空性 * 自反性： */ @Override public boolean equals(Object obj) { // 非空性 if (obj == null) { return false; } // 自反性 (当前对象 == 传进来的对象) 两者地址一样 if (this == obj) { return true; } // 两者类型不一样 if (!(obj instanceof Person)) { return false; } // obj转成Student Person p1 = (Person)obj; // 内容一样返回true if (this.id == p1.id) { return true; } // 如果全都不满足 return false; } }

运行结果：true

Person p1 = new Person(1,"李四"); Person p2 = new Person(1,"李四"); // true System.out.println(p1.equals(p2)); -------------------------------------------------------- Person p1 = new Person(1,"李四"); Person p2 = new Person(1,"李四"); Person p3 = new Person(1,"张三"); // true 因为之定义了id相同 System.out.println(p1.equals(p3));

判断两个对象是否相等

== 比较的是对象的地址equals 按照自己的规则去判断两个对象 String a = new String("1"); String b = new String("1"); System.out.println(a); // 1 String重写了toString方法 System.out.println(b); // 1 System.out.println(a == b); // false System.out.println(a.equals(b)); // true String重写了equals方法

修改下面的代码：

// 内容一样返回true if (this.id == p1.id && this.name.equals(p1.name)) { return true; } Person p1 = new Person(1,"李四"); Person p2 = new Person(1,"李四"); Person p3 = new Person(1,"张三"); System.out.println(p2.equals(p3)); // 修改前：true 修改后：false

4.3.1 ==和equals的区别

两者都可以用来比较对象== 还可以用来比较基本数据类型equals 不可用用来比较基本数据类型 (equals是Object类型的，使用它得继承Object，但是基本类型不存在继承关系，除非装箱)== 比较的是对象的地址equals 比较的是对象的内容，如果equals没有重写，比较的还是地址 Integer i1 = new Integer(123); Integer i2 = new Integer(123); System.out.println(i1==i2); // false System.out.println(i1.equals(i2)); // true

4.4 hashCode方法

Hash，一般翻译做“散列”，也可以音译为“哈希”，就是把任意长度的数据输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。 . 一个任意长度的输入转为一个固定长度的输出，是一种压缩映射，也就是说，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。

返回一个对象的内存地址（int类型数)，可以通过任意数据然后经过哈希算法得到一个hash值两个对象如果相同那么其hashcode相同，但是如果不同，那么两个对象一定不同；如果相同，那么这两个对象不一定统一对象 public class Object{ public native int hashCode(); }

本地方法

System.out.println(p1.hashCode()); // 1829164700 // 可以转成十六进制 System.out.println(Integer.toHexString(p1.hashCode())); // 6d06d69c

对于俩个对象的hashCode值：

相等的两个对象，hashCode值一定相等hashCode值相同，两个个对象有可能相等，也可能不同等hashCode值不同，两个对象一定不同

思考，hashCode在代码中有什么用？

现在有100个对象，突然又来了一个对象obj，那么怎么判断这个obj对象和之前的100个对象是否有相等的呢？

除了使用obj对象的equals方法和之前的100个对象比较100次之外，是否还有更好的方式？

使用hashCode()

Integer integer = new Integer(1); Integer i4 = Integer.valueOf(1); Integer i3 = 1; String s = "1"; System.out.println(integer.hashCode()); // 1 System.out.println(i3.hashCode()); // 1 System.out.println(i4.hashCode()); // 1 System.out.println(s.hashCode()); // 49 System.out.println(integer == i3); // false 不是同一个对象 System.out.println(i3==i4); // true

五、关于String对象

字符串String，是程序中使用最多的一种数据，JVM在内存中专门设置了一块区域（字符串常量池），来提高字字符串对象的使用效率。 JDK1.7字符串常量池存在堆区中

5.1 概述

创建字符串对象，和其他普通对象一样，会占用计算机的资源（时间和空间），作为最常用的数据类型，大量频繁的创建字符串对象，会极大程度地影响程序的性能。

JVM为了提高性能和减少内存开销，在实例化字符串常量的时候进行了一些优化

为字符串开辟一个字符串常量池，类似于缓存区创建字符串常量时，首先会检查字符串常量池中是否存在该字符串，如果存在该字符串，则返回该实例的引用，如果不存在，则实例化创建该字符串，并放入池中

5.2 案例

public class StringTest { public static void main(String[] args) { /** * 创建String对象 */ // 1. String a = "11"; // 2. String b = new String(); System.out.println(a==b); // false } }

1.第一种情况： 2.第二种情况：

String a = "11"; String b = new String("11"); System.out.println(a==b); // false System.out.println(a.equals(b)); // true 比较内容

String a = "hello"; String b = "world"; String c = "hello" + "world"; String d = a+b; System.out.println(c); System.out.println(d); System.out.println(c == d); // false

运行结果： helloworld helloworld false

最新回复(0)