Skip to main content

4 posts tagged with "总结"

View All Tags

1. java基本数据类型和他们的封装类​

八种基本数据类型，int ,double ,long ,float, short,byte,character,boolean

对应的封装类型是：Integer ,Double ,Long ,Float, Short,Byte,Character,Boolean

1.1 补充​

1.1.1 Java 5 (2004) - 重大变革​

  • 自动装箱/拆箱 ：基本类型与包装类自动转换
// Java 5之前
Integer i = new Integer(10); 
int j = i.intValue();

// Java 5之后
Integer i = 10;    // 自动装箱
int j = i;         // 自动拆箱
  • 值缓存 ：引入包装类的缓存机制（Integer缓存-128~127）

1.1.2 Java 8 (2014) - 函数式与工具增强​

  • 无符号运算 ：为Integer、Long添加无符号操作方法
int unsigned = Integer.parseUnsignedInt("4294967295");
long result = Integer.toUnsignedLong(-1);
  • 函数式接口 ：虽然不直接针对基本类型，但影响了它们的用法
  • Stream API ：需要频繁使用包装类进行装箱操作

1.1.3 Java 9 (2017) - 废弃构造方法​

  • 废弃包装类的构造方法 ：
// Java 9之前
Integer i = new Integer(10);

// Java 9之后推荐使用
Integer i = Integer.valueOf(10);  // 使用缓存
Integer i = 10;                   // 自动装箱

1.1.4 Java 10+ - 局部变量类型推断​

  • var关键字 ：但有限制
var i = 10;        // 推断为int
var integer = 10;  // 推断为Integer（自动装箱）

1.1.5 Java 17/21 - 稳定与性能优化​

  • 模式匹配 ：instanceof模式匹配简化类型检查
  • 性能优化 ：持续优化自动装箱和缓存机制
  • Valhalla项目预备 ：为值类型做准备，可能改变基本类型的未来
总结2 min read

==与equals的主要区别是：

  • ==常用于比较原生类型，而equals()方法用于检查对象的相等性。
  • 如果==和equals()用于比较对象，当两个引用地址相同，==返回true。而equals()可以返回true或者false主要取决于重写实现。

最常见的一个例子，字符串的比较，不同情况==和equals()返回不同的结果。

equals()方法最重要的一点是，能够根据业务要求去重写，按照自定义规则去判断两个对象是否相等。

重写equals()方法的时候，要注意一下hashCode是否会因为对象的属性改变而改变，否则在使用散列集合储存该对象的时候会碰到坑！！理解equals()方法的存在是很重要的。

1.1.1 字符串字面量比较​

String s1 = "hello";
String s2 = "hello";
String s3 = "he" + "llo";

System.out.println(s1 == s2);      // true - 指向字符串常量池的同一个对象
System.out.println(s1 == s3);      // true - 编译期优化，同样指向常量池
System.out.println(s1.equals(s2)); // true - 内容相同
System.out.println(s1.equals(s3)); // true - 内容相同

1.1.2 new String() 创建对象​

String s1 = "hello";
String s2 = new String("hello");
String s3 = new String("hello");

System.out.println(s1 == s2);      // false - s1在常量池，s2在堆内存
System.out.println(s2 == s3);      // false - 两个不同的堆内存对象
System.out.println(s1.equals(s2)); // true - 内容相同
System.out.println(s2.equals(s3)); // true - 内容相同

1.1.3 运行时拼接的字符串​

String s1 = "hello";
String s2 = "he";
String s3 = s2 + "llo";  // 运行时拼接

System.out.println(s1 == s3);      // false - s3在堆内存中
System.out.println(s1.equals(s3)); // true - 内容相同

1.1.4 intern() 方法的影响​

String s1 = "hello";
String s2 = new String("hello");
String s3 = s2.intern();  // 将s2放入常量池

System.out.println(s1 == s2);      // false
System.out.println(s1 == s3);      // true - intern()后指向同一个常量池对象
System.out.println(s1.equals(s2)); // true

1.1.5 更复杂的例子​

String s1 = "java";
String s2 = "ja";
String s3 = "va";
String s4 = s2 + s3;           // 运行时拼接
String s5 = "ja" + "va";       // 编译期优化
final String s6 = "ja";
String s7 = s6 + "va";         // 编译期优化（s6是final）

System.out.println(s1 == s4);  // false
System.out.println(s1 == s5);  // true
System.out.println(s1 == s7);  // true
System.out.println(s1.equals(s4)); // true

1.1.6 空字符串和null的比较​

String s1 = "";
String s2 = new String("");
String s3 = null;

System.out.println(s1 == s2);      // false
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
// System.out.println(s3.equals(s1)); // NullPointerException!

1.2 详细说明

1.2.1 使用==比较有两种情况​

比较基础数据类型(Java中基础数据类型包括八中：short,int,long,float,double,char,byte,boolen)：

这种情况下，==比较的是他们的值是否相等。

引用间的比较：

在这种情况下，==比较的是他们在内存中的地址，也就是说，除非引用指向的是同一个new出来的对象，此时他们使用 ==去比较得到true，否则，得到false。

1.2.2 使用equals进行比较​

equals追根溯源，是Object类中的一个方法，在该类中，equals的实现也仅仅只是比较两个对象的内存地址是否相等，但在一些子类中，如：String、Integer 等，该方法将被重写。

1.2.3 以 String类为例子说明 eqauls与 ==的区别：​

在开始这个例子之前，同学们需要知道JVM处理String的一些特性。

Java的虚拟机在内存中开辟出一块单独的区域，用来存储字符串对象，这块内存区域被称为字符串缓冲池。

当使用 String a = "abc"这样的语句进行定义一个引用的时候，首先会在字符串缓冲池中查找是否已经相同的对象，如果存在，那么就直接将这个对象的引用返回给a，如果不存在，则需要新建一个值为"abc"的对象，再将新的引用返回a。

String a = new String("abc");这样的语句明确告诉JVM想要产生一个新的String对象，并且值为"abc"，于是就 在堆内存中的某一个小角落开辟了一个新的String对象 。

即使多次调用 new String("abc");

  • ==在比较引用的情况下，会去比较两个引用的内存地址是否相等。
    String str1 = "abc"; // true
    String str2 = "abc";
  
    System.out.println(str1 == str2);      // true 因为在str2赋值之前，str1的赋值操作就已经在内存中创建了一个值为"abc"的对象了，然后str2将会与str1指向相同的地址。
    System.out.println(str1.equals(str2)); // true
  
    String str2 = new String("abc");
    System.out.println(str1 == str2);       // false
    System.out.println(str1.equals(str2));  // true

以上代码将会输出

false true第一个true： **第二个true：**因为 String已经重写了 equals方法：为了方便大家阅读我贴出来，并且在注释用进行分析： public boolean equals(Object anObject) {

//如果比较的对象与自身内存地址相等的话 //就说明他两指向的是同一个对象 //所以此时equals的返回值跟==的结果是一样的。 if (this == anObject) { return true; } //当比较的对象与自身的内存地址不相等，并且 //比较的对象是String类型的时候 //将会执行这个分支 if (anObject instanceof String) { String anotherString = (String)anObject; int n = value.length; if (n == anotherString.value.length) { char v1[] = value; char v2[] = anotherString.value; int i = 0; //在这里循环遍历两个String中的char while (n-- != 0) { //只要有一个不相等，那么就会返回false if (v1[i] != v2[i]) return false; i++; } return true; } } return false; } 进行以上分析之后，就不难理解第一段代码中的实例程序输出了。

总结5 min read

1. java 基础​

1.1 java 语言基础​

1.1.1 基础语法与面向对象​

1.1.1.1 重载与重写的区别​
1.1.1.2 == 和 equals​
1.1.1.3 String, StringBuilder,StringBuffer​
1.1.1.4 Java 中的异常​

1.1.2 集合类​

1.1.2.1 java 的数据结构​
1.1.2.2 java 的集合类​
1.1.2.3 HashMap 的原理​

1.1.3 Lambda 表达式​

1.1.4 反射以及泛型​

1.1.4.1 反射​
1.1.4.2 泛型​

1.1.5 网络编程​

1.1.5.1 BIO, NIO, AIO​

1.1.6 IO 流​

1.1.6.1 IO 流​

1.1.7 数据结构与算法​

1.1.7.1 排序算法​
1.1.7.2 字符串类​
1.1.7.3 搜索​

1.2 并行相关​

1.2.1 原理​

1.2.1.1 ThreadLocal 的原理​

1.2.1.2 解释悲观锁与乐观锁​

1.2.1.3 synchronized 原理​

1.2.1.4 synchronized 锁升级​

1.2.1.5 对比 synchronized 和 volatile​

1.2.1.6 对比 synchronized 和 lock​

1.2.2 线程池​

1.2.2.1 线程池的核心参数​

  • 七个参数
    • 核心线程数
    • 最大线程数
    • 存活时间
    • 存活时间单位
    • 工作队列
    • 线程工厂
    • 拒绝策略
      • AbortPolicy
      • CallerRunsPolicy
      • DiscardOldestPolicy
      • DiscardPolicy

3. JVM 虚拟机​

3.1 堆内存结构​

3.2 垃圾回收算法​

2. spring 生态​

spring​

IoC 和 DI​

Spring bean​

Spring 中的容器是线程安全的吗​
作用域​
bean 生命周期​
bean 的循环依赖问题​

AOP​

AoP 底层实现​
JDK 动态代理与 CgLib 动态代理​
Spring 事务​
事务失效​
事务的传播行为​

Spring MVC​

核心组件​
  • DispatchServlet
  • HandlerMapping
  • HandlerAdapter
  • Handler
  • ViewResolver
请求执行流程是什么样​
拦截器​
Interceptor 与 Filter​
如何处理异常​
常用注解​

spring boot​

理解​

starter​

配置的优先级​

自动配置的原理​

如何自定义 starter​

MyBatis 以及 MyBatis-Plus​

spring cloud​

Nacos​

Nacos 服务注册流程​
Nacos 分级存储模型​
Nacos 与 Eureka 的区别​

OpenFeign​

OpenFeign 的服务调用流程​

Ribbon，Spring LoadBalancer 负载均衡​

限流​

Hystrix 和 Sentinel​
如何利用 Sentinel 配置限流​
滑动窗口算法​

Gateway 相关，路由断言，过滤器​

网关作用​
实现原理​
路由断言类型​
过滤器实现方式​

3. 数据库​

sql 基本语法​

mysql 中 char 和 varchar 的区别​

什么是事务以及事务的四大特性​

并发事务会引发哪些问题，如何解决，越高越好吗​

mysql 索引​

Mysql 数据库索引的数据结构，B+tree 索引结构的特点​

聚簇索引（聚集索引），二级索引（非聚簇索引，辅助索引）​

回表查询​

为什么 MySQL 索引结构是 B+tree​

索引优化​

索引创建的原则​

索引失效的场景​

最左前缀法则​

SQL 新能分析以及优化​

如何定位慢 SQL​

  • SkyWalking

如何知道 SQL 语句的执行性能，以及索引是否生效​

4. 中间件​

redis​

基础​

redis 常见数据类型​

集群​

redis 主从集群与分片集群的区别​

持久化​

持久化策略​

内存淘汰策略​

redis 数据删除​

redis 是单线程吗​

为什么单线程快​

redis 红锁​

MQ​

为什么要使用 MQ​

MQ 应用场景​

MQ 如何保障发送消息可靠​

MQ 如何保障消费消息可靠​

MQ 死信队列（延迟队列）​

如何防止消息重复消费​

如何解决消息解压问题​

RabbitMQ 的消息模式​

elasticsearch​

正向索引​

倒排索引​

ES 索引文档的过程​

ES 搜索步骤​

ES 相对 mysql 的特点是什么​

ES 集群情况​

ES 采用什么数据结构​

5. CICD​

docker​

基础​

docker 与虚拟机的区别​
常用命令​
数据卷​
默认网络模式​
docker compose​

K8S​

常用组件​

tomcat​

Nginx​

什么是正向代理​

什么是反向代理​

CDN​

Nginx 负载均衡​

Nginx 限流​

基础知识​

git​

git 本地仓库，远程仓库​

git 工作原理​

处理冲突​

分支如何管理，创建分支有什么规则​

Maven​

maven 用来做什么​

maven 规约​

maven 的生命周期​

密码学​

加密算法​

有哪些加密算法​
对称加密，非对称加密以及哈希摘要​
签名算法​
项目中密码如何存储​
DES, AES, SM4​
RSA, ECDSA, SM2​

web​

HTTP 协议​

Session 会话跟踪的原理​

分布式​

理论​

CAP 定理​

BASE 理论​

二阶段提交​

SEATA 模式​

柔性事务，刚性事务​

分布式锁​

什么是分布式锁​

分布式锁的实现方案​

如何选择分布式锁的方案​

redisson 分布式锁如何应用​

如何实现分布式锁的可重入​

如何提升分布式锁的性能​

总结4 min read