java学习笔记
Hashmap
HashMap集合：
1、HashMap集合底层是哈希表/散列表的数据结构。 2、哈希表是一个怎样的数据结构呢？ 哈希表是一个数组和单向链表的结合体。 数组：在查询方面效率很高，随机增删方面效率很低。 单向链表：在随机增删方面效率较高，在查询方面效率很低。 哈希表将以上的两种数据结构融合在一起，充分发挥它们各自的优点。 3、HashMap集合底层的源代码：
public class HashMap{
// HashMap底层实际上就是一个数组。（一维数组）
Node<K,V>[ ] table;
// 静态的内部类HashMap.Node
static class Node<K,V> {
final int hash; // 哈希值（哈希值是key的hashCode()方法的执行结果。hash值通过哈希函数/算法，可以转换存储成数组的下标。）
final K key; // 存储到Map集合中的那个key
V value; // 存储到Map集合中的那个value
Node<K,V> next; // 下一个节点的内存地址。
}
}
哈希表/散列表：一维数组，这个数组中每一个元素是一个单向链表。（数组和链表的结合体。） 4、最主要掌握的是： map.put(k,v) v = map.get(k) 以上这两个方法的实现原理，是必须掌握的。
原理图：非常重要！！！
5、HashMap集合的key部分特点： 无序，不可重复。 为什么无序？ 因为不一定挂到哪个单向链表上。 不可重复是怎么保证的？ equals方法来保证HashMap集合的key不可重复。 如果key重复了，value会覆盖。
放在HashMap集合key部分的元素其实就是放到HashSet集合中了。 所以HashSet集合中的元素也需要同时重写hashCode()+equals()方法。
6、哈希表HashMap使用不当时无法发挥性能！ 假设将所有的hashCode()方法返回值固定为某个值，那么会导致底层哈希表变成了 纯单向链表。这种情况我们成为：散列分布不均匀。 什么是散列分布均匀？ 假设有100个元素，10个单向链表，那么每个单向链表上有10个节点，这是最好的， 是散列分布均匀的。 假设将所有的hashCode()方法返回值都设定为不一样的值，可以吗，有什么问题？ 不行，因为这样的话导致底层哈希表就成为一维数组了，没有链表的概念了。也是散列分布不均匀。 散列分布均匀需要你重写hashCode()方法时有一定的技巧。 7、重点：放在HashMap集合key部分的元素，以及放在HashSet集合中的元素，需要同时重写hashCode和equals方法。 8、HashMap集合的默认初始化容量是16，默认加载因子是0.75 这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候，数组开始扩容。
重点，记住：HashMap集合初始化容量必须是2的倍数，这也是官方推荐的， 这是因为达到散列均匀，为了提高HashMap集合的存取效率，所必须的。
重写hashCode()和equals()方法
在源码中已经在HashMap中重写了上述两种方法
程序测试：
// 测试HashMap集合key部分的元素特点
// Integer是key，它的hashCode和equals都重写了。
Map<Integer,String> map = new HashMap<>();
map.put(1111, "zhangsan");
map.put(6666, "lisi");
map.put(7777, "wangwu");
map.put(2222, "zhaoliu");
map.put(2222, "king"); //key重复的时候value会自动覆盖。
System.out.println(map.size()); // 4
// 遍历Map集合
Set<Map.Entry<Integer,String>> set = map.entrySet();
for(Map.Entry<Integer,String> entry : set){
// 验证结果：HashMap集合key部分元素：无序不可重复。
System.out.println(entry.getKey() + "=" + entry.getValue());
}
对于自己定义的类中：
重写equals方法：
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return Objects.equals(name, student.name);
}
重写hashCode()方法：（IDEA）
@Override
public int hashCode() {
return Objects.hash(name);
}
测试：
Student s1 = new Student("zhangsan");
Student s2 = new Student("zhangsan");
// 重写equals方法之前是false
//System.out.println(s1.equals(s2)); // false
// 重写equals方法之后是true
System.out.println(s1.equals(s2)); //true （s1和s2表示相等）
System.out.println("s1的hashCode=" + s1.hashCode()); //284720968 (重写hashCode之后-1432604525)
System.out.println("s2的hashCode=" + s2.hashCode()); //122883338 (重写hashCode之后-1432604525)
// s1.equals(s2)结果已经是true了，表示s1和s2是一样的，相同的，那么往HashSet集合中放的话，
// 按说只能放进去1个。（HashSet集合特点：无序不可重复）
Set<Student> students = new HashSet<>();
students.add(s1);
students.add(s2);
System.out.println(students.size()); // 没有重写是2，重写后是1
总结
1、向Map集合中存，以及从Map集合中取，都是先调用key的hashCode方法，然后再调用equals方法！ equals方法有可能调用，也有可能不调用。 拿put(k,v)举例，什么时候equals不会调用？ k.hashCode()方法返回哈希值， 哈希值经过哈希算法转换成数组下标。 数组下标位置上如果是null，equals不需要执行。 拿get(k)举例，什么时候equals不会调用？ k.hashCode()方法返回哈希值， 哈希值经过哈希算法转换成数组下标。 数组下标位置上如果是null，equals不需要执行。
2、注意：如果一个类的equals方法重写了，那么hashCode()方法必须重写。 并且equals方法返回如果是true，hashCode()方法返回的值必须一样。 equals方法返回true表示两个对象相同，在同一个单向链表上比较。 那么对于同一个单向链表上的节点来说，他们的哈希值都是相同的。 所以hashCode()方法的返回值也应该相同。
3、hashCode()方法和equals()方法不用研究了，直接使用IDEA工具生成，但是这两个方法需要同时生成。
4、终极结论： 放在HashMap集合key部分的，以及放在HashSet集合中的元素，需要同时重写hashCode方法和equals方法。
5、对于哈希表数据结构来说： 如果o1和o2的hash值相同，一定是放到同一个单向链表上。 当然如果o1和o2的hash值不同，但由于哈希算法执行结束之后转换的数组下标可能相同，此时会发生“哈希碰撞”。
HashMap和HashTable的区别 HashMap集合key部分允许null吗？ 允许 但是要注意：HashMap集合的key null值只能有一个。 有可能面试的时候遇到这样的问题。
Map map = new HashMap();
// HashMap集合允许key为null
map.put(null, null);
System.out.println(map.size()); // 1
// key重复的话value是覆盖！
map.put(null, 100);
System.out.println(map.size()); //1
// 通过key获取value
System.out.println(map.get(null)); // 100
Hashtable的key可以为null吗？ Hashtable的key和value都是不能为null的。 HashMap集合的key和value都是可以为null的。
Hashtable方法都带有synchronized：线程安全的。 线程安全有其它的方案，这个Hashtable对线程的处理 导致效率较低，使用较少了。
Hashtable和HashMap一样，底层都是哈希表数据结构。 Hashtable的初始化容量是11，默认加载因子是：0.75f Hashtable的扩容是：原容量 * 2 + 1
源码：
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
Properties集合
目前只需要掌握Properties属性类对象的相关方法即可。 Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型。 Properties被称为属性类对象。 Properties是线程安全的。
// 创建一个Properties对象
Properties pro = new Properties();
// 需要掌握Properties的两个方法，一个存，一个取。
pro.setProperty("url", "jdbc:mysql://xxxx/xxxxx");
pro.setProperty("driver","com.mysql.jdbc.Driver");
pro.setProperty("username", "root");
pro.setProperty("password", "123");
// 通过key获取value
String url = pro.getProperty("url");
String driver = pro.getProperty("driver");
String username = pro.getProperty("username");
String password = pro.getProperty("password");
System.out.println(url);
System.out.println(driver);
System.out.println(username);
System.out.println(password);
getOrDeafault()
hashmap.getOrDefault(Object key, V defaultValue)
// key 的映射存在于 HashMap 中，返回key映射的value
// Not Found - 如果 HashMap 中没有该 key，则返回默认值
copyOfRange()
Java中copyOfRange()函数深度理解 平常我们说copyOfRange(original,int from,int to)该方法是从original数组的下标from开始赋值，到下标to结束，不包括下标为to的元素。实际上看完代码应该这样理解copyOfRange(original,int from,int to)该方法返回一个长度为to-from的数组，其中from~min(original.length,to)之间的元素（不包括min(original.length,to)）是从数组original复制的元素，剩下的值为0。
演示代码1：
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 0, 5);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
运行结果：
Arrays.copyOfRange(n, 0, 5);意思是返回一个长度为to-from即5-0=5的数组，从n数组下标0开始复制，由于n数组只有一个元素，故复制一个就没有可以复制的，剩下的4个元素默认为0。
演示代码2：
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1,2,3,4,5};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 0, 3);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
运行结果：
Arrays.copyOfRange(n, 0, 3);的意思是返回一个长的为3-0=3的数组，从n数组0开始复制，由于数组n的长度大于3，因此直接从n数组0下标开始复制3个元素返回即可。
演示代码3：
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 1, 3);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
运行结果：
n数组没有可以复制的，所以m数组全为0。
演示代码4：
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 1, 1);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
该运行没有任何输出，因为它返回的是一个长度为1-1=0的数组。
演示代码5：
长度为0的数组是存在的，只是输出啥也没有。
package niuke;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{};
int[] m=new int[0];
for(int i=0;i<n.length;i++) {
System.out.print(n[i]+" ");
}
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
演示代码6：
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 1, 0);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
运行结果： 会抛出异常，因为不存在长度为0-1=-1的数组。
演示代码7：
package niuke;
import java.util.Arrays;
public class Solution {
public static void main(String[] args) {
int[] n=new int[]{1};//Java中数组初始化
int[] m=Arrays.copyOfRange(n, 2, 3);
for(int i=0;i<m.length;i++) {
System.out.print(m[i]+" ");
}
}
}
运行结果：
抛出数组越界异常。根据copyOfRange(original,int from,int to)该方法返回一个长度为to-from的数组，其中from~min(original.length-to,to)之间的元素（不包括min(original.length-to,to)）是从数组original复制的元素，剩下的值为0。此时min(original.length-to,to)=min(1-2,3)=min(-1,3)=-1，下标为-1是非法的。
Java构造器 继承问题（子类是否必须实现父类的有参构造函数）
首先，答案是否定的，但是 如果你在父类中写了一个有参构造函数，但是没有声明无参构造函数，就有问题。
（这里补充一下，我们都知道，当我们不写有参构造函数的时候，系统会自动生成一个无参构造函数，而且每个类的创建都依赖构造函数，子类的构造函数依赖父类的构造函数，这牵扯到一个隐式传递super和this的问题 不多赘述）
因为你在父类中只有有参构造函数，没有无参构造函数，但是子类如果不写构造函数，系统默认创建一个无参构造函数，子类这个无参的构造函数就会去调用父类的无参构造函数，时候就出错了。
结论：
- 父类 仅仅声明了有参构造函数，没有自己声明无参构造函数，则子类必须重写 父类构造函数
- 父类 有无参构造函数，则子类不必重写父类构造函数。