从零开始的知识巩固（【2021】1.java基础篇）_class people {private string name;private int age;-优快云博客

本文链接：https://blog.youkuaiyun.com/evelynnJava/article/details/116063246

本文深入浅出地介绍了Java中的核心概念和技术，包括面向对象的基本特征、JDK/JRE/JVM的区别、==与equals的差异、内部类访问局部变量的限制、String与StringBuffer等字符串类的对比、重载与重写的区别、接口与抽象类的特点、hashCode与equals的使用规范、List与Set的差异、ArrayList与LinkedList的选择、HashMap与HashTable的区别及其底层实现、ConcurrentHashMap的工作原理以及CopyOnWriteArrayList的底层机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言

本专栏系列文章仅用于个人学习总结,从零开始逐步到常见服务框架。觉得基础的大佬可以提前离开。欢迎各位大佬评论指教，如有不当之处请及时联系调整 ~

本专栏工作之余抽空更新…

下一篇文章地址：2.java基础进阶篇

java基础

1.什么是面向对象?

面向对象是更注重事情有哪些参与者（对象）、及各自需要做什么。(面向过程更注重事情的每一个步骤及顺序) 其四大特征如下：

封装： 封装的意义，在于明确标识出允许外部使用的所有成员函数和数据项（内部细节对外部调用透明，外部调用无需修改或者关心内部实现）
继承： 继承基类（父类）的方法，并做出自己的改变和/或扩展（子类共性的方法或者属性直接使用父类的，而不需要自己再定义，只需扩展自己个性化的）
多态： 基于对象所属类的不同，外部对同一个方法的调用，实际执行的逻辑不同。（继承和接口可以实现多态）
抽象： 抽取关键相关特性（属性和方法）构成对象，用程序的方法逻辑和数据结构属性模拟现实的世界对象。（所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。）

2.JDK JRE JVM

JDK： Java Develpment Kit java 开发工具（程序员所需的各开发工具，包含 JRE JVM等）
JRE： Java Runtime Environment java运行时环境（运行java程序）
JVM： java Virtual Machine java 虚拟机（编译，解释.class文件，操作系统才能够执行）

3.==和equals比较

== : 对比的是栈中的值，基本数据类型是变量值，引用类型是堆中内存对象的地址

equals： Object中默认也是采用==比较（通常开发者要自己重写，改为比较属性内容）

初学者可能没注意到这点，平时使用String比的也是内容，根本没有去重写它呀。实际上String类中，已经帮我们重写了equals方法。

下面我们来看一个例子：

/**
 * @author wook
 * @date 2021/4/23 21:35
 */
public class WookTest {
    private Integer id;
    private String name;
    public WookTest(Integer id,String name){
        this.id = id;
        this.name = name;
    }
    public static void main(String[] args) {
        WookTest wook = new WookTest(1, "wook");
        WookTest wook2 = new WookTest(1, "wook");
        System.out.println(wook.equals(wook2)); 
    }
}

根据开头的概念，所有类都继承Object，而Object的equals采用==比较内存地址，所以此处结果为：false 。那如果想让结果返回：true 呢？

   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       WookTest wookTest = (WookTest) o;
       return Objects.equals(id, wookTest.id) &&
               Objects.equals(name, wookTest.name);
    }

只需要在WookTest中重写equals即可（快捷键 ctrl + insert，选择equals…）。

细心的同学肯定发现了，equals和hashCode一般是成对出现的，equals搞明白了，那hashCode是干什么的呢？别着急，后面的文章会讲到。(着急请翻到第8点=。=）

4.为什么局部内部类和匿名内部类只能访问局部final变量？

首先回顾下 final修饰基本类型数据和引用类型数据的情况:

如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；
如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。但是引用的值是可变的。

  public static void main() {
        final int[] iArr = {1, 2, 3, 4};
        iArr[2] = -3;//合法
        iArr = null;//非法，对iArr不能重新赋值(不能重新指向）
        final Person p = new Person(25);
        p.setAge(24);//合法
        p = null;//非法
    }

回到正题为什么局部内部类和匿名内部类只能访问局部final变量？

/**
 * @author wook
 * @date 2021/4/23 22:35
 */
public class Test {
    //局部final变量a,b
    //jdk8在此处做了优化(语法糖),可不写final,但实际上也是有的，参数a,b在内部类中不能修改
    public void test(final int b) {
        final int a = 10;
        //匿名内部类
        new Thread() {
            public void run() {
                System.out.println(a);
                System.out.println(b);
            }
        }.start();
    }
}

class OutClass {
    private int age = 12;
    public void outPrint(final int x) {
        //局部内部类
        class InClass {
            public void InPrint() {
                System.out.println(x);
                System.out.println(age);
            }
        }
        new InClass().InPrint();
    }
}

ps:程序编译后的文件共有4个（内部类生成的class为原类名+$1…2…3）

Test.class 、 Test$1.class
- ps: 再有匿名内部类则为 Test$2.class)
OutClass.class 、 OutClass$1InClass.class
- ps: 再有局部内部类则为 OutClass$1其他内部类名

首先需要知道的一点: 内部类和外部类是处于同一个级别的，内部类不会因为定义在方法中就会随着方法的执行完毕就被销毁（例如开了线程跑匿名内部类）。

这里就会产生问题：

当外部类的方法结束时，局部变量（a）就会被销毁了，但是内部类对象可能还存在(只有没有人再引用它时，才会死亡)。这里就出现了一个矛盾：内部类对象访问了一个不存在的变量。为了解决这个问题，就将局部变量复制了一份作为内部类的成员变量，这样当局部变量死亡后，内部类仍可以访问它，实际访问的是局部变量的"copy"。这样就好像延长了局部变量的生命周期。
将局部变量复制为内部类的成员变量时，必须保证这两个变量是一样的，也就是如果我们在内部类中修改了成员变量，方法中的局部变量也得跟着改变，怎么解决问题呢？
- 就将局部变量设置为final，对它初始化后，我就不让你再去修改这个变量，就保证了内部类的成员变量和方法的局部变量的一致性。这实际上也是一种妥协。使得局部变量与内部类内建立的拷贝保持一致。

答：因为内部类复制了一份作为内部类的成员变量，为保证复制的与原先的值一致，只能妥协，使用final修饰，不让别人修改。

5.String、StringBuffer、StringBuilder

String是final修饰的，不可变，每次操作都会产生新的String对象
StringBuffer和StringBuilder都是在原对象上操作
- StringBuffer是线程安全的(方法都是synchronized修饰的)
- StringBuilder线程不安全的

性能： StringBuilder > StringBuffer > String

场景： 经常需要改变字符串内容时使用后面两个优先使用StringBuilder，多线程使用共享变量时使用StringBuffer。

6.重载和重写的区别

重载： 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。
重写： 发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为private则子类就不能重写该方法。

public int add(int a,String b)
//编译报错（非重载）
public String add(int a,String b)

7.接口和抽象类的区别

抽象类可以存在普通成员函数，而接口中只能存在public abstract 方法。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。
抽象类只能继承一个，接口可以实现多个。

详细说明：（赶时间知道上面三点即可）
接口的设计目的，是对类的行为进行约束（更准确的说是一种“有”约束，因为接口不能规定类不可以有什么行为），也就是提供一种机制，可以强制要求不同的类具有相同的行为。它只约束了行为的有无，但不对如何实现行为进行限制。

抽象类的设计目的，是代码复用。当不同的类具有某些相同的行为(记为行为集合A)，且其中一部分行为的实现方式一致时（A的真子集，记为B），可以让这些类都派生于一个抽象类。在这个抽象类中实现了B，避免让所有的子类来实现B，这就达到了代码复用的目的。而A减B的部分，留给各个子类自己实现。正是因为A-B在这里没有实现，所以抽象类不允许实例化出来（否则当调用到A-B时，无法执行）。

真子集就是一个集合中的元素全部是另一个集合中的元素。

解释一下抽象类的话：

①A类和B类都有action()方法，但实现不同
②A类和B类都有fun()方法，且实现相同
③可将A类和B类的fun()方法提取到抽象类C，A和B去继承C
④而action则作为C类的抽象方法，由A和B去重写

使用场景： 当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。

抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度。（Java 8 接口default method不讨论）

总结：
抽象类是对类本质的抽象，表达的是 is a 的关系，比如：宝马是一辆车。抽象类包含并实现子类的通用特性，将子类存在差异化的特性进行抽象，交由子类去实现。
而接口是对行为的抽象，表达的是 like a 的关系。比如：鸟像飞行器一样可以飞，但其本质上 is a Bird 。接口的核心是定义行为，即实现类可以做什么，至于实现类主体是谁、是如何实现的，接口并不关心。

8.hashCode与equals

hashCode介绍：
hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个int整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在JDK的Object.java中，Java中的任何类都包含有hashCode() 函数。

散列表存储的是键值对(key-value)，它的特点是：能根据“键(索引）”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

hashCode方法的主要作用是为了配合基于散列的集合一起正常运行，这样的散列集合包括HashSet、HashMap以及HashTable。

以“HashSet如何检查重复”为例子来说明为什么要有hashCode：
对象加入HashSet时，HashSet会先计算对象的hashcode值来判断对象加入的位置，看该位置是否有值，如果没有、HashSet会认为对象没有重复出现。但是如果发现有值（hash冲突了），这时会调用equals（）方法来检查两个对象是否真的相同。如果两者相同，HashSet就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样就大大减少了equals的次数（equals性能较差），相应就大大提高了执行速度。

从这里也可看出，如果没有hashcode,每次我们插入一个数据，都需要拿这个数据去遍历，判断是否已经存在，而使用hashcode则直接定位到要存储的位置！

我们应保证如下的规范（重写hascode和equal）

如果两个对象相等，则hashcode一定也是相同的
两个对象相等,对两个对象分别调用equals方法都返回true
两个对象有相同的hashcode值，它们也不一定是相等的（例hash冲突，此时需要调equal比较）
equals方法被覆盖过，则hashCode方法也必须被覆盖
hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据（内容））

理论明白了，下面通过代码来说明：
ps：代码参照海子大佬 https://www.cnblogs.com/dolphin0520/p/3681042.html

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
 
class People{
    private String name;
    private int age;
 
    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  
 
    public void setAge(int age){
        this.age = age;
    }
 
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;
    }
}
 
public class Main {
 
    public static void main(String[] args) {
 
        People p1 = new People("Jack", 12);
        System.out.println(p1.hashCode());
 
        HashMap<People, Integer> hashMap = new HashMap<People, Integer>();
        hashMap.put(p1, 1);
 
        System.out.println(hashMap.get(new People("Jack", 12)));
    }
}

这里我只重写了equals方法，也就说如果两个People对象，如果它的姓名和年龄相等，则认为是同一个人。

这段代码本来的意愿是想这段代码输出结果为“1”，但是事实上它输出的是“null”。为什么呢？原因就在于重写equals方法的同时忘记重写hashCode方法。

虽然通过重写equals方法使得逻辑上姓名和年龄相同的两个对象被判定为相等的对象（跟String类类似），但是要知道默认情况下，hashCode方法是将对象的存储地址进行映射。那么上述代码的输出结果为“null”就不足为奇了。原因很简单，p1指向的对象和System.out.println(hashMap.get(new People(“Jack”, 12)));这句中的new People(“Jack”, 12)生成的是两个对象，它们的存储地址肯定不同。下面是HashMap的get方法的具体实现：

所以在hashmap进行get操作时，因为得到的hashcdoe值不同（注意，上述代码也许在某些情况下会得到相同的hashcode值，不过这种概率比较小，因为虽然两个对象的存储地址不同也有可能得到相同的hashcode值），所以导致在get方法中for循环不会执行，直接返回null。

因此如果想上述代码输出结果为“1”，很简单，只需要重写hashCode方法，让equals方法和hashCode方法始终在逻辑上保持一致性。

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
 
class People{
    private String name;
    private int age;
 
    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  
 
    public void setAge(int age){
        this.age = age;
    }
 
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()*37+age;
    }
 
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;
    }
}
 
public class Main {
 
    public static void main(String[] args) {
 
        People p1 = new People("Jack", 12);
        System.out.println(p1.hashCode());
 
        HashMap<People, Integer> hashMap = new HashMap<People, Integer>();
        hashMap.put(p1, 1);
 
        System.out.println(hashMap.get(new People("Jack", 12)));
    }
}

这样一来的话，输出结果就为“1”了。

“设计hashCode()时最重要的因素就是：无论何时，对同一个对象调用hashCode()都应该产生同样的值。如果在讲一个对象用put()添加进HashMap时产生一个hashCdoe值，而用get()取出时却产生了另一个hashCode值，那么就无法获取该对象了。所以如果你的hashCode方法依赖于对象中易变的数据，用户就要当心了，因为此数据发生变化时，hashCode()方法就会生成一个不同的散列码”。

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
 
class People{
    private String name;
    private int age;
 
    public People(String name,int age) {
        this.name = name;
        this.age = age;
    }  
 
    public void setAge(int age){
        this.age = age;
    }
 
    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode()*37+age;
    }
 
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.name.equals(((People)obj).name) && this.age== ((People)obj).age;
    }
}
 
public class Main {
 
    public static void main(String[] args) {
 
        People p1 = new People("Jack", 12);
        System.out.println(p1.hashCode());
 
        HashMap<People, Integer> hashMap = new HashMap<People, Integer>();
        hashMap.put(p1, 1);
 
        p1.setAge(13);
 
        System.out.println(hashMap.get(p1));
    }
}

这段代码输出的结果为“null”，想必其中的原因大家应该都清楚了。

因此，在设计hashCode方法和equals方法的时候，如果对象中的数据易变，则最好在equals方法和hashCode方法中不要依赖于该字段。

9.List 和 Set的区别

List： 有序，按对象进入的顺序保存对象，可重复，允许多个Null元素对象，可以使用Iterator取出所有元素，在逐一遍历，还可以使用get(int index)随机访问获取指定下标的元素
Set： 无序，不可重复，最多允许有一个Null元素对象，取元素时只能用Iterator接口取得所有元素，在逐一遍历各个元素 （没有get方法）

10.ArrayList和LinkedList区别

ArrayList： 基于动态数组，连续内存存储，适合下标访问（随机访问）

扩容机制：
- 因其基于数组，而数组长度固定。超出长度存数据时会新建更大的数组，然后将老数组的数据拷贝到新数组。
插入机制：
- 性能差：如果从前，中间插入元素会涉及元素移动，例 [1,3,4…]，要在3前面插入元素2，此时会将4的值赋值到后面的索引位，3的值赋值到4的索引位，插入的元素2赋值到3的索引位，从而实现插入。
- 性能好：使用尾插法(不会导致元素移动）并指定初始容量可以极大提升性能、甚至超过linkedList

LinkedList： 基于链表，可以存储在分散的内存中，适合做数据插入及删除操作（实际上如果链表长度过长，插入效率也低，因为插入时是需要遍历的集合才能找到要插入的位置），不适合查询

缺点1：极其不建议使用for循环，因为每次for循环体内通过get(i)取元素，链表并不知道某元素的索引，实际上都需要对list集合重新进行遍历，性能消耗极大。（建议使用迭代器iterator）
缺点2：不要试图使用indexOf等返回元素索引，并利用其进行遍历，使用indexlOf对list进行了遍历，当结果为空时会遍历整个列表。
缺点3：每插入任意元素，都需要new一个node节点，而arrayList放什么就存什么。

上面列举了那么多缺点，个人建议使用哪个就不用我说了吧？

11.HashMap和HashTable有什么区别？其底层实现是什么？

区别：
①HashMap方法没有synchronized修饰，线程非安全；HashTable 线程安全；
②HashMap允许key和value为null，而HashTable不允许

底层实现： 数组+链表实现（JDK 1.7）

jdk8开始链表高度到8、数组长度超过64，链表转变为红黑树，元素以内部类Node节点存在。

计算key的hash值，二次hash然后位与数组长度-1(hash & length -1 )，得到数组下标（有点类似取模，例如 3%16,3永远在16范围内）
如果没有产生hash冲突(下标位置没有元素)，则直接创建Node存入数组
如果产生hash冲突，先进行equal比较，相同则取代该元素，不同，则判断链表高度插入链表，链表高度达到8，并且数组长度到64则转变为红黑树，长度低于6则将红黑树转回链表
key为null，存在下标0的位置

扩容： 当HashMap元素>= 扩容阈值，会扩容为原来的两倍。（重新new个数组，将老数组移进去）
例：初始容量16，负载因子固定为0.75； 16 * 0.75 = 12 ,元素过12个就会扩容。

二次Hash -> hash(key.hashCode())： 防止高位都是0，只有低位在参与位与运算的情况。如下代码结果都为15。。疯狂hash冲突

System.out.println(Integer.parseInt("0001111", 2) & Integer.parseInt("0001111", 2));
System.out.println(Integer.parseInt("0011111", 2) & Integer.parseInt("0001111", 2));
System.out.println(Integer.parseInt("0111111", 2) & Integer.parseInt("0001111", 2));
System.out.println(Integer.parseInt("1111111", 2) & Integer.parseInt("0001111", 2));

以hash 为 xxx，数组长度为 4举例。
既然能用 xxx % 4 取模运算得到下标，为什么还要搞那么复杂？

因为 %是十进制运算，最终还是要转为二进制的，性能不如直接用 &进行二进制运算。
另一个原因就是能降低冲突概率，下面解释了

那为什么一定要 2 的幂次方？
其实可以反推，因为公式为 hash & (length -1），如果 lenght是 2的幂次方，例 xxx & (4-1) ,要注意的是， (4-1)这一部分，二进制的末尾一定都为1 ，这样有什么好处呢？这时候就得明白 &的意义，同位都为1则为 1，那么不管 hash是什么值，只要 hash & xxx1 , 结果的二进制末尾， 0 或 1都有可能。

如果 hash & xxx0 ，那么二进制末尾一定为0，这就是&运算

所以 hash & 0011 二进制的末尾一定可以是 0 或 1 ，而这样的意义是能保证，0~3的任意一个位置都能插入，即较为均匀的分散开来，散列性！

12.ConcurrentHashMap原理，jdk7和jdk8版本的区别

jdk7：
数据结构： ReentrantLock+Segment+HashEntry，一个Segment中包含一个HashEntry数组，每个HashEntry又是一个链表结构（有点hashMap那味了）

ReentrantLock是李二狗写的可重入锁，在jdk1.8之前，synchronized远不如它。
Segment 存储结构如下 (get方法无需加锁，volatile保证)
transient volatile HashEntry<K,V>[] table;

元素查询： 二次hash，第一次Hash定位到Segment，第二次Hash定位到元素所在的链表的头部。

锁： Segment分段锁 Segment继承ReentrantLock，锁定操作的Segment，其他的Segment不受影响，segment个数相当于可同时并发的数量，可通过构造函数指定；数组扩容不会影响其他的segment。
get方法无需加锁，volatile保证

jdk8：
数据结构： synchronized+CAS+Node+（链表）红黑树，Node的val和next都用volatile修饰，保证可见性。（查找，替换，赋值操作都使用CAS，性能比syn高，但CAS线程竞争激烈的时候会自旋浪费cpu，所以扩容，hash冲突等会使用syn锁）

锁：锁链表的head节点，不影响其他元素的读写，锁粒度更细，效率更高，扩容时，阻塞所有的读写操作、并发扩容

两个版本读操作无锁，Node的val和next使用volatile修饰，读写线程对该变量互相可见；数组用volatile修饰，保证扩容时被读线程感知，但不保证原子性。

1.7重要成员

static final class HashEntry<K,V> {
        final int hash;
        final K key;
        volatile V value;
        volatile HashEntry<K,V> next;

1.8重要成员

static class Node<K,V> implements Map.Entry<K,V> {
       final int hash;
       final K key;
       volatile V val;
       volatile Node<K,V> next;

13. CopyOnWriteArrayList的底层原理是怎样的

⾸先CopyOnWriteArrayList内部也是⽤过数组来实现的，在向CopyOnWriteArrayList添加元素时，会复制⼀个新的数组，写操作在新数组上进⾏，读操作在原数组上进⾏
并且，写操作会加锁，防⽌出现并发写⼊丢失数据的问题
写操作结束之后会把原数组指向新数组
CopyOnWriteArrayList允许在写操作时来读取数据，⼤⼤提⾼了读的性能，因此适合读多写少的应⽤场景，但是CopyOnWriteArrayList会⽐较占内存，同时可能读到的数据不是实时最新的数据，所以不适合实时性要求很⾼的场景