diff --git a/docs/java/basis/images/编译型语言和解释型语言.drawio b/docs/java/basis/images/编译型语言和解释型语言.drawio index cd273d4f..3866134e 100644 --- a/docs/java/basis/images/编译型语言和解释型语言.drawio +++ b/docs/java/basis/images/编译型语言和解释型语言.drawio @@ -1 +1 @@ -5VpXd+NIrv41epw9zOGxmDPFIInSG5MoUhSzGPTrb1GWu9vd7tm5d7Zn5p61fcwqVAbwASiQG5y/zXIXNhezTtJygyHJvMGFDYahKELBx0pZ3igsS78Rsi5PXp2+Erz8kb6IyIt6z5O0/9BxqOtyyJuPxLiuqjQePtDCrqunj93Odflx1SbM0h8IXhyWP1IPeTJc3qgMRn+lK2meXd5XRin2reUWvnd+naS/hEk9fUPCxQ3Od3U9vJVuM5+WK/Pe+fI2TvpJ65eNdWk1/JEBisU5veUiey5JrIeJc3p0+g19iacflvcTpwlkwKtad8OlzuoqLMWvVK6r71WSrtMisPa1j1HXDSSikFikw7C8pBnehxqSLsOtfLW+rbku9NOzvEh9fe/iV6+CG5S7Ry7lKWJal/aWZE/9hr10IuyydPi9gxJfWA51Na1v6dAtcGCXluGQjx83Er6UJvvS7ytfYeHF2s/Z/Hu7HMPy/lppg1El3C/XN2H1gf9Ue181gjvX1fBb/+QggB1Qppm/NsJS9no+Z4neCf8qwjF8p8KtRt/3hLS3Jd/J30n/q2xXQU2XfEi9JnyKYIII/yjHc16WfF3W3XMsfj6nVByvhxq6+pp+05LQbISsytJf0yG+fFCDT6Q+pt2Qzt+QfpTbq5V6getlXTDyVZ++YhVlX7TLNzh9H/dnJP25nn0i6e9YDA1Bsxbz29P2cOtpc2hxjDBKy23d50NeV7A9qoehvsEO5drAhfE1e0rnA8fXn2/mAGWerWOHFYlc2DdvNvGcz6tMueeS4J2KvFNgOQmHEGraWxWTmirbYHy+52x3QnQ5qwH8sbzdRdxlsKSuVR7+HuFTELY3xVgpILA8F1FB1xMx5cAedaK5orRLJXqonHPPFbvTXDFX+oKgel7bjjX5kpvYmtg4iF/kSu7L3s6XpCOmg9lR7ibgeFtX5+Li1LiSKXcgunsgaox5khhSZBafZbbWEkGV51j8XiTwuYQBPMADlsjhBks0uy0pOrnjEX4GJ2un0obQouVYmI7eV8CVAb8Fy0U6pmdr4ATAd9zClf757GagmMzaPSjVI3KcCbRTnJ12OI4cgcoIuri/kAwRh+BA2DSgYyEq0qVQ7qsGLWdQMmDMDjHapdNppD1OyYQYykzqWMtIEkki1d7WJiCXlubkk0YDm5ATDw3MJbvmcLLJtjnjHIitcwQBWFahHGbFqIgAeLAy5DgZA8hAe9Fb6uS10qRiwMRNg0LuoJssmuRb/CzuHMgJcJou7AKHcRchQ2OOux/rIUBFUcjs9IpauTIZDOguWFEaxm5euGBSafLkhR4hRHdl3xRX2jCnie+7gbHpoA4gB7jg8mgLzdguGe9PQXpt60s5CSO4UPu2f3gC0QE+5ovdI7iKd3AlbKpZ8gdbgwujdBelzY6Fwzc5g6Ajp11GnJg9c9kCHSrUnri6R4NkTaSzCsAXkzCftV0ILSF3jixd2D1APfEMvuxloNywR1qg5qSaoDMZdJ//MBtzbfkz6AjzDA4xOGdaz1tz5eqQj1d8UipQEaCzGmpuI1UHt3y1ARhHb4FEogrNMayu9w9SL5k9BkbCOkrp3cYn484Jk1Hda+hEJVPi7+w9xh8zlIDK7PtDxi/c20RFSpP7adHmcTRsK0bvu0cDW1CHRIMDM5TjnvGrpSJnMw+uB48AWyAyinHNxEYr45rh3MlG/GW8xjHcMieyBnV1a84UrYAUGNykmBHbBQml78OevOzpJ5tEsToR0eTXQFIfi6cA/mEsSVwtwm1VQ8fU4H+w7YGcSXrOiZkYB0UWJ9iiWBohn+7XMRkdgV62K6gcH7mtLEGPVhRXZ/CYlp1J7+EgIOBGehdq0MJ2K0wrQl7EIajI8RG4pZypVFLf/HMM4yIpwadgwQFB4ErANO7YWLLCiFvBzE2aBtDBSXOjXF149q29IA98ZrLHEkU0IRUQSoJbAxFi0kglJBsj2rDrnDpSvtnRlVYT5B5uAP657GRaYXBvRYaJmVvU2aofneDcUxmrrcLed9egdzqnQ8KZCx6GERxM9C4GPiI0Ui092CCWx2H20CJIbIjWwpntPdI5WzTyXJcD5zu+QL8qnbWGfZhbEOwcQqm4h1Y3ZyVbZQzw9STk9kbcFv6GyrI5qH3myEVdxisTtTptmMoCNSFsw/ESO7x/Ki89weB6ZPQId264MHcVb48wQDiPAZ/xpRxQunhIaV1Dr/ag+ewN43ZzN55E1eb2q0Cpu71XvDBUYcWnXa9tNYI/+DtYxVT9JLRCa97y++wTPQxOxwd/RWyFJTnshIEG35sYJRPB9fYc5VFP/VQ4hdB7lrAUc11BXvVZaseAxucgcxwx6tSzi5Ksc4u8tq4yfn7MeOGkxCWCXoRL+RZFRTp+kKTiZ3ONBWZerJovb3XooFmQ4oy/k0Uqu2YtWZu2jC5H08FE3pbZO7TRZ1sray0Ui5Mko0CfR1+7qYaczsrlFPODOG5Rb0+wIPCm3RGtr1gMujcl4B7D+r/p99P9kZ3y2X/U4hohS8EyYUSHdZ4fMiUeyOFDtq9utHVkRGpSt0FwjCcmOwjyiyNFlhoQdIVHzDETB+lYNH5KN3VpNaQC58/qlS0hfgwPVFZNms0PSuOtq1jmYkoxcpHvOXnZsn27duzP3I6bJWk3mBXZ1snCsNa+QLggy5lpsCjMSZGJPHYRnvo9HTH76cTLCAMXqtw+6FMb0IjTaisQr6uy7w/jzYbPdW3qmJ/2i1D5bcMD94DS3oB36OIu+yw6yLCTIW2FwNdSpBsPbZVxLaXseG6VRpyn3DbgZwGn2LhyISV8Y+JaAmctRjqKhxpldcfqsjNUFfQF7s/2YA2iXYkhh8necNsnhreFqmle0UpCzxUhenV7uJXNPDA9phqhPq7mduc4ykiYKz8oV5A16XQnWiZXayS/MZdTK0I7wUH8cEns3glpe8ayBsNOPTW0tnG/HhwHoJYQ7pbL3rjS7TGn0wMUR8RskfwEsZLrhqCJuBuIlruTVrUVfBj7S1nfc+cVfPBWgnuGegRM72m3vTGC/LLr9g/BGI7A90myv4uwvzFpt1BeGcGfaFQWhWhOar64lvWMygVWJjl3dplxzngeJGhX89vcnXCrTcZBQ/qcpbbHporDXEcS625X1XFPWBRAR1t/6GuEkI6eUa4mk/PzTst9F7kRSa8Y9EABek+fXMgp18kpZhvaR+Zi5jdxq7ILwM4oegp851G63hoHZItUxo7jHITOYliMb+XqYFBjZnhWWeY+uCxWhISHcEDgTrWHY+aQqTZShVvjOHtulGecUhqPs8bCuqsBOjmK3iXxFhfqnbQ/eyxa+yPvXE/DAe7WuWcHJojmg1kzCt3YWb8eBtpFKwMExWTV3sjPtH66836QPET/NKiHUkJWee7whVUP/TWvoIXilBCAVnvkRY2cwjW6AefwDEYqqUC/BlC12gOMZ+83VPVMv1sDOf3Wxqf7qjgyO5KFY4RsuYIjO41YtKrtauSVc+jI5PWWHkxoayW12Kf4TsyBvAxjImdGgKa6za6xXWYhQS8fbQzkEzmQuNDtsSOT694B+hi1pgMEwcEl4yJOJ04ZfeQN4YZ3yXYyGxqfYIPBwXJNmnzNBXfLnqgpZtArGjAiKslO4QUqG9C+0rVZpI3wsqCKo48sg58T3ADeEMYf7bAdtjBWsiFF4jBfpbpKvHLWzpzSOSXmm0txmHptowmnYbw2x7PPTDIkcq5gpncxnhm+ta760M5jwZQIbzp5DfYd2sRArxbTswp/8oc1JI5wqpeS24VA7Ghlm6fNGLC46xb4t5veao0hdND4b4FbS3xDhPwq48dZRaVosJrYWSWCa3VINVcMT+2L60uYv6pgUfOXMYl1ozLpqz92p7bkT2BHpPb+GPPWNlTIiilpzTn5/lIJRY3heYLFx8bmwsGJ1ZI7yRkvSFrjUzJF8NVJW6hHlsccyzxMmxp6b5EBuB7iraAvdhUdBGFFdnwJqBbtdeA6Nn5J2rFgddrb1YRq51npDN6iAJzgjCKZ/P5cCCoaVz6LeLwuOHHRSTaxiwlVU+GqdG4SpSjyF0LsYqEhhFadpjEvCjs9WFWbwLjPY73QEQkVBlR1s9+JhnKUg52fcRIJudksA8PCu5ExJslZFdqy6A2t0xgutlq9nSMlzLsx24Vid8rONBo5u065r9EcO9fm7QRvLhLCBg/Hr+N+VA4maKtWyeXyWA2ulgmNver3LQls9xaLk3RdrBsJ7RoXuobCU96NtOuu50+abOb+CYcu7+ppTUxeVYBHVENZC2XKqlVfCuGy7FNH2KlQWlkG1NUG5ZSp6L5rLs1u8u7bKloRGi8CKLWQ0SM5oPvrkAdmNll8oO/wBMaTrDTpQRXpfLzwwLj5cbSrHW3whvuE7BY8W26OyVlcqW8Hh5APWgmDZqfzwtUJMNcYykBWSOT4CPplAjUUoxtY1GmrV+YlE4Ujh2dZb9+vOVhWv8HP64VXUqtLGe/RB4BWwu3C5abDS4+oA7IJHHg9SLt29f86ajnq7kJ7d1AjIDnvAyapQ3BshEOZcm7Nw+iGawciOiJg9uShRUDhSDi7jxbMrYX8ap32NSdn3Ui0QdkXjiKp1NI5vMQF5/kw0gHDSZ1vXKXTDvoKrn9efr3d3nZ1kj+q6no7f89v/JDM+CTl8dP8BkahHxIcNPJJggNjfkxwfCH+5zMczN+RMkznfAjW4f8iX7XjNy3C/Jr5WVlelf9bmvHTQ+N/MM1I/UVZxt/b5J/OMr7xDnm2TS+dWlufyvdDClJkNoDewCsPjNwYesOAjUhuWHHDvDVJGyA8C8yGQTYiteHAhoUFYsNxz1FwLLJh0H9ugvJPARin/3EZSvb/T8r/5xj7Iyl/8u8EI/VTMEZ/It//OdjYFV2fJv1/knquz+dtmEEAPF+arSD4d0j6CLsf8BMxJEEinyCOidM3xP2HcUW8SfcLrgj0E1whn+AKRX8ZsOj/Qsf49l7tH4/G923++jdwq0Pj+A1Lvbwfi/4biP4xt/fLkEvFTBqdf0RuEqbM+VcgF0X+ccjF8L8Duat+vRpR8j+MSvKPovJvBSX514GS2rD8Gnp+wSIsMNIKUIhXGH8x1De+FVLAhiF+N0j9S9+sp2hCpvRn8GUpGg+pXwBTDP8YuFKfwfQvDVzfP6T5Vl1WCb1dLN7ESX5G+SFm+l40kEvDR/5/5HNVV+l3QnmRwtf79hhyNe0+eRF/y5PkaS4+E/hHE/K0B69N/dw+/Lmo6bvbCIl/lk74RKjYLxPqJ5/GfBUhtQH8BqBrAVahFD91rgBeNvlnZ0gh/3uli1L/NOnin3wOs+KSXOW6ihnKkn4hlYMF6UkBWjiG8vrh3xdD3v0hZ0BBZ/A0yD9cm+BSwuoBxKdewfXfl3pbZvUK+Gor/pm685MPgN4X/0aTqFf9Gw/BPX+fcw7h69Oi3/BfkevAEPaD/uHMJ/rHfBbZ/e/1b/2Q5sunk8+2bz5AxcX/AQ== \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/java/basis/images/编译型语言和解释型语言.png b/docs/java/basis/images/编译型语言和解释型语言.png index af483a76..9191e57e 100644 Binary files a/docs/java/basis/images/编译型语言和解释型语言.png and b/docs/java/basis/images/编译型语言和解释型语言.png differ diff --git a/docs/java/basis/java基础知识总结.md b/docs/java/basis/java基础知识总结.md index ae3f3540..65726405 100644 --- a/docs/java/basis/java基础知识总结.md +++ b/docs/java/basis/java基础知识总结.md @@ -122,9 +122,7 @@ JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有 1. **形式** : 字符常量是单引号引起的一个字符，字符串常量是双引号引起的 0 个或若干个字符 2. **含义** : 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置) -3. **占内存大小** ： 字符常量只占 2 个字节; 字符串常量占若干个字节 (**注意： char 在 Java 中占两个字节**), - - > 字符封装类 `Character` 有一个成员常量 `Character.SIZE` 值为 16,单位是`bits`,该值除以 8(`1byte=8bits`)后就可以得到 2 个字节 +3. **占内存大小** ： 字符常量只占 2 个字节; 字符串常量占若干个字节 (**注意： `char` 在 Java 中占两个字节**), > java 编程思想第四版：2.2.2 节 > ![](https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/18-9-15/86735519.jpg) @@ -186,23 +184,25 @@ Java 中的注释有三种： 在写代码的过程中，常见的一种情况是需要某个整数类型变量增加 1 或减少 1，Java 提供了一种特殊的运算符，用于这种表达式，叫做自增运算符（++)和自减运算符（--）。 -++和--运算符可以放在变量之前，也可以放在变量之后，当运算符放在变量之前时(前缀)，先自增/减，再赋值；当运算符放在变量之后时(后缀)，先赋值，再自增/减。例如，当 `b = ++a` 时，先自增（自己增加 1），再赋值（赋值给 b）；当 `b = a++` 时，先赋值(赋值给 b)，再自增（自己增加 1）。也就是，++a 输出的是 a+1 的值，a++输出的是 a 值。用一句口诀就是：“符号在前就先加/减，符号在后就后加/减”。 +++ 和 -- 运算符可以放在变量之前，也可以放在变量之后，当运算符放在变量之前时(前缀)，先自增/减，再赋值；当运算符放在变量之后时(后缀)，先赋值，再自增/减。例如，当 `b = ++a` 时，先自增（自己增加 1），再赋值（赋值给 b）；当 `b = a++` 时，先赋值(赋值给 b)，再自增（自己增加 1）。也就是，++a 输出的是 a+1 的值，a++输出的是 a 值。用一句口诀就是：“符号在前就先加/减，符号在后就后加/减”。 -### continue、break、和 return 的区别是什么？ +### continue、break 和 return 的区别是什么？ 在循环结构中，当循环条件不满足或者循环次数达到要求时，循环会正常结束。但是，有时候可能需要在循环的过程中，当发生了某种条件之后 ，提前终止循环，这就需要用到下面几个关键词： -1. continue ：指跳出当前的这一次循环，继续下一次循环。 -2. break ：指跳出整个循环体，继续执行循环下面的语句。 +1. `continue` ：指跳出当前的这一次循环，继续下一次循环。 +2. `break` ：指跳出整个循环体，继续执行循环下面的语句。 -return 用于跳出所在方法，结束该方法的运行。return 一般有两种用法： +`return` 用于跳出所在方法，结束该方法的运行。return 一般有两种用法： 1. `return;` ：直接使用 return 结束方法执行，用于没有返回值函数的方法 2. `return value;` ：return 一个特定值，用于有返回值函数的方法 -### Java 泛型了解么？什么是类型擦除？介绍一下常用的通配符？ +### 泛型 -Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。 +#### Java 泛型了解么？什么是类型擦除？介绍一下常用的通配符？ + +**Java 泛型（generics）** 是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。 Java 的泛型是伪泛型，这是因为 Java 在运行期间，所有的泛型信息都会被擦掉，这也就是通常所说类型擦除 。 @@ -214,13 +214,13 @@ list.add(12); list.add("a"); Class clazz = list.getClass(); Method add = clazz.getDeclaredMethod("add", Object.class); -//但是通过反射添加，是可以的 +//但是通过反射添加是可以的 +//这就说明在运行期间所有的泛型信息都会被擦掉 add.invoke(list, "kl"); - System.out.println(list); ``` -泛型一般有三种使用方式:泛型类、泛型接口、泛型方法。 +泛型一般有三种使用方式: 泛型类、泛型接口、泛型方法。 **1.泛型类**： @@ -228,13 +228,10 @@ System.out.println(list); //此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型 //在实例化泛型类时，必须指定T的具体类型 public class Generic { - private T key; - public Generic(T key) { this.key = key; } - public T getKey() { return key; } @@ -298,16 +295,28 @@ printArray(intArray); printArray(stringArray); ``` +#### 常用的通配符有哪些？ + **常用的通配符为： T，E，K，V，？** -- ？ 表示不确定的 java 类型 -- T (type) 表示具体的一个 java 类型 -- K V (key value) 分别代表 java 键值中的 Key Value +- ？ 表示不确定的 Java 类型 +- T (type) 表示具体的一个 Java 类型 +- K V (key value) 分别代表 Java 键值中的 Key Value - E (element) 代表 Element -### ==和 equals 的区别 +#### 你的项目中哪里用到了泛型？ -对于基本数据类型来说，==比较的是值。对于引用数据类型来说，==比较的是对象的内存地址。 +- 可用于定义通用返回结果 `CommonResult` 通过参数 `T` 可根据具体的返回类型动态指定结果的数据类型 +- 定义 `Excel` 处理类 `ExcelUtil` 用于动态指定 `Excel` 导出的数据类型 +- 用于构建集合工具类。参考 `Collections` 中的 `sort`, `binarySearch` 方法 +- ...... + +### == 和 equals() 的区别 + +**`==`** 对于基本类型和引用类型的作用效果是不同的： + +- 对于基本数据类型来说，`==` 比较的是值。 +- 对于引用数据类型来说，`==` 比较的是对象的内存地址。 > 因为 Java 只有值传递，所以，对于 == 来说，不管是比较基本数据类型，还是引用数据类型的变量，其本质比较的都是值，只是引用类型变量存的值是对象的地址。 @@ -326,32 +335,22 @@ public boolean equals(Object obj) { - **类没有覆盖 `equals()`方法** ：通过`equals()`比较该类的两个对象时，等价于通过“==”比较这两个对象，使用的默认是 `Object`类`equals()`方法。 - **类覆盖了 `equals()`方法** ：一般我们都覆盖 `equals()`方法来比较两个对象中的属性是否相等；若它们的属性相等，则返回 true(即，认为这两个对象相等)。 -**举个例子：** +举个例子（这里只是为了举例。实际上，你按照下面这种写法的话，像 IDEA 这种比较智能的 IDE 都会提示你将 `==` 换成 `equals()` ）： ```java -public class test1 { - public static void main(String[] args) { - String a = new String("ab"); // a 为一个引用 - String b = new String("ab"); // b为另一个引用,对象的内容一样 - String aa = "ab"; // 放在常量池中 - String bb = "ab"; // 从常量池中查找 - if (aa == bb) // true - System.out.println("aa==bb"); - if (a == b) // false，非同一对象 - System.out.println("a==b"); - if (a.equals(b)) // true - System.out.println("aEQb"); - if (42 == 42.0) { // true - System.out.println("true"); - } - } -} +String a = new String("ab"); // a 为一个引用 +String b = new String("ab"); // b为另一个引用,对象的内容一样 +String aa = "ab"; // 放在常量池中 +String bb = "ab"; // 从常量池中查找 +System.out.println(aa == bb);// true +System.out.println(a == b);// false +System.out.println(a.equals(b));// true +System.out.println(42 == 42.0);// true ``` -**说明：** +`String` 中的 `equals` 方法是被重写过的，因为 `Object` 的 `equals` 方法是比较的对象的内存地址，而 `String` 的 `equals` 方法比较的是对象的值。 -- `String` 中的 `equals` 方法是被重写过的，因为 `Object` 的 `equals` 方法是比较的对象的内存地址，而 `String` 的 `equals` 方法比较的是对象的值。 -- 当创建 `String` 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 `String` 对象。 +当创建 `String` 类型的对象时，虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 `String` 对象。 `String`类`equals()`方法： @@ -379,13 +378,13 @@ public boolean equals(Object anObject) { } ``` -### hashCode()与 equals() +### hashCode() 与 equals() -面试官可能会问你：“你重写过 `hashcode` 和 `equals`么，为什么重写 `equals` 时必须重写 `hashCode` 方法？” +面试官可能会问你：“你重写过 `hashcode()` 和 `equals()`么?为什么重写 `equals()` 时必须重写 `hashCode()` 方法？” -**1)hashCode()介绍:** +#### hashCode() 介绍 -`hashCode()` 的作用是获取哈希码，也称为散列码；它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。`hashCode()`定义在 JDK 的 `Object` 类中，这就意味着 Java 中的任何类都包含有 `hashCode()` 函数。另外需要注意的是： `Object` 的 hashcode 方法是本地方法，也就是用 c 语言或 c++ 实现的，该方法通常用来将对象的 内存地址 转换为整数之后返回。 +`hashCode()` 的作用是获取哈希码（`int` 整数），也称为散列码。这个哈希码的作用是确定该对象在哈希表中的索引位置。`hashCode()`定义在 JDK 的 `Object` 类中，这就意味着 Java 中的任何类都包含有 `hashCode()` 函数。另外需要注意的是： `Object` 的 `hashCode()` 方法是本地方法，也就是用 C 语言或 C++ 实现的，该方法通常用来将对象的内存地址转换为整数之后返回。 ```java public native int hashCode(); @@ -393,25 +392,25 @@ public native int hashCode(); 散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象） -**2)为什么要有 hashCode？** +#### 为什么要有 hashCode？ -我们以“`HashSet` 如何检查重复”为例子来说明为什么要有 hashCode？ +我们以“`HashSet` 如何检查重复”为例子来说明为什么要有 `hashCode`？ -当你把对象加入 `HashSet` 时，`HashSet` 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的 hashcode，`HashSet` 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象，这时会调用 `equals()` 方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，`HashSet` 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。（摘自我的 Java 启蒙书《Head First Java》第二版）。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。 +下面这段内容摘自我的 Java 启蒙书《Head First Java》: -**3)为什么重写 `equals` 时必须重写 `hashCode` 方法？** +> 当你把对象加入 `HashSet` 时，`HashSet` 会先计算对象的 `hashcode` 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hashcode 值作比较，如果没有相符的 `hashcode`，`HashSet` 会假设对象没有重复出现。但是如果发现有相同 `hashcode` 值的对象，这时会调用 `equals()` 方法来检查 `hashcode` 相等的对象是否真的相同。如果两者相同，`HashSet` 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。。这样我们就大大减少了 `equals` 的次数，相应就大大提高了执行速度。 -如果两个对象相等，则 hashcode 一定也是相同的。两个对象相等,对两个对象分别调用 equals 方法都返回 true。但是，两个对象有相同的 hashcode 值，它们也不一定是相等的 。**因此，equals 方法被覆盖过，则 `hashCode` 方法也必须被覆盖。** +#### 为什么重写 equals() 时必须重写 hashCode() 方法？ -> `hashCode()`的默认行为是对堆上的对象产生独特值。如果没有重写 `hashCode()`，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据） +`hashCode()`的默认行为是对堆上的对象产生独特值。如果没有重写 `hashCode()`，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据） -**4)为什么两个对象有相同的 hashcode 值，它们也不一定是相等的？** +简单来说就是：如果 `equals` 方法判断两个对象是相等的，那这两个对象的 `hashCode` 值也要相等。 -在这里解释一位小伙伴的问题。以下内容摘自《Head Fisrt Java》。 +**为什么两个对象有相同的 hashcode 值，它们也不一定是相等的？** 因为 `hashCode()` 所使用的哈希算法也许刚好会让多个对象传回相同的哈希值。越糟糕的哈希算法越容易碰撞，但这也与数据值域分布的特性有关（所谓碰撞也就是指的是不同的对象得到相同的 `hashCode` )。 -我们刚刚也提到了 `HashSet`,如果 `HashSet` 在对比的时候，同样的 hashcode 有多个对象，它会使用 `equals()` 来判断是否真的相同。也就是说 `hashcode` 只是用来缩小查找成本。 +我们刚刚也提到了 `HashSet`,如果 `HashSet` 在对比的时候，同样的 `hashcode` 有多个对象，它会使用 `equals()` 来判断是否真的相同。也就是说 `hashcode` 只是用来缩小查找成本。 更多关于 `hashcode()` 和 `equals()` 的内容可以查看：[Java hashCode() 和 equals()的若干问题解答](https://www.cnblogs.com/skywang12345/p/3324958.html) @@ -897,14 +896,14 @@ Java 程序设计语言对对象采用的不是引用调用，实际上，对象 暖心的 Guide 哥最后再来个图表总结一下！ -| 区别点 | 重载方法 | 重写方法 | -| :--------- | :------- | :----------------------------------------------------------- | -| 发生范围 | 同一个类 | 子类 | -| 参数列表 | 必须修改 | 一定不能修改 | -| 返回类型 | 可修改 | 子类方法返回值类型应比父类方法返回值类型更小或相等 | +| 区别点 | 重载方法 | 重写方法 | +| :--------- | :------- | :--------------------------------------------------------------- | +| 发生范围 | 同一个类 | 子类 | +| 参数列表 | 必须修改 | 一定不能修改 | +| 返回类型 | 可修改 | 子类方法返回值类型应比父类方法返回值类型更小或相等 | | 异常 | 可修改 | 子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等； | -| 访问修饰符 | 可修改 | 一定不能做更严格的限制（可以降低限制） | -| 发生阶段 | 编译期 | 运行期 | +| 访问修饰符 | 可修改 | 一定不能做更严格的限制（可以降低限制） | +| 发生阶段 | 编译期 | 运行期 | **方法的重写要遵循“两同两小一大”**（以下内容摘录自《疯狂 Java 讲义》,[issue#892](https://github.com/Snailclimb/JavaGuide/issues/892) ）： @@ -1384,4 +1383,4 @@ Java IO 流共涉及 40 多个类，这些类看上去很杂乱，但实际上 - https://stackoverflow.com/questions/1906445/what-is-the-difference-between-jdk-and-jre - https://www.educba.com/oracle-vs-openjdk/ -- https://stackoverflow.com/questions/22358071/differences-between-oracle-jdk-and-openjdk 基础概念与常识 +- https://stackoverflow.com/questions/22358071/differences-between-oracle-jdk-and-openjdk