java成神之路-基础篇
文章目录
- java成神之路-基础篇
- @[toc]
- 01面向对象
- **→ 什么是面向对象**
- → 平台无关性
- → 值传递
- 1、什么是[值传递](https://so.csdn.net/so/search?q=值传递&spm=1001.2101.3001.7020)，什么是引用传递？
- 2.值传递和[引用传递](https://so.csdn.net/so/search?q=引用传递&spm=1001.2101.3001.7020)的区别是什么？
- 3.为什么说 Java 中只有值传递
- **3.1纠正一下大家以前的那些错误看法**
- **3.2 严格求值**
- **3.3 java 的求值策略**
- → 封装、继承、多态
- 封装
- 继承
- 多态
- 接口
- 02Java 基础知识
-
- 03 阅读源代码
- String源码精读
- 1、String的定义
- 2、字段属性
- 3、构造函数
- 4、长度和是否为空函数
- 5、charAt、codePointAt类型函数
- 6、getChar、getBytes类型函数
- 7、equal类函数(是否相等)
- 8、regionMatchs()方法
- 9、compareTo类函数和CaseInsensitiveComparator静态内部类
- 10、startWith、endWith类函数
- 11、hashCode()函数
- 12、indexOf、lastIndexOf类函数
- 13、substring()函数
- 14、concat()函数
- 15、replace、replaceAll类函数
- 16、matches()和contains()函数;
- 17、split()函数
- 18、join()函数
- 19、trim()函数
- 20、toString()函数
- 21、toCharArray()函数
- 22、toLowerCase()、toUpperCase()函数
- 23、String 为什么是不可变的
- 总结
- 04 Java 并发编程
- **→ 并发与并行**
- **→ 什么是线程，与进程的区别**
- → 线程池
- → 线程安全
- → 锁
- → 死锁
- → synchronized
- → volatile
- **→ sleep 和 wait**
- **→ wait 和 notify**
- **→ notify 和 notifyAll**
- **→ ThreadLocal**
- **→ 写一个死锁的程序**
- **→ 写代码来解决生产者消费者问题**
- **→ 并方包**
文章目录
- java成神之路-基础篇
- @[toc]
- 01面向对象
- **→ 什么是面向对象**
- → 平台无关性
- → 值传递
- 1、什么是[值传递](https://so.csdn.net/so/search?q=值传递&spm=1001.2101.3001.7020)，什么是引用传递？
- 2.值传递和[引用传递](https://so.csdn.net/so/search?q=引用传递&spm=1001.2101.3001.7020)的区别是什么？
- 3.为什么说 Java 中只有值传递
- **3.1纠正一下大家以前的那些错误看法**
- **3.2 严格求值**
- **3.3 java 的求值策略**
- → 封装、继承、多态
- 封装
- 继承
- 多态
- 接口
- 02Java 基础知识
- 03 阅读源代码
- String源码精读
- 1、String的定义
- 2、字段属性
- 3、构造函数
- 4、长度和是否为空函数
- 5、charAt、codePointAt类型函数
- 6、getChar、getBytes类型函数
- 7、equal类函数(是否相等)
- 8、regionMatchs()方法
- 9、compareTo类函数和CaseInsensitiveComparator静态内部类
- 10、startWith、endWith类函数
- 11、hashCode()函数
- 12、indexOf、lastIndexOf类函数
- 13、substring()函数
- 14、concat()函数
- 15、replace、replaceAll类函数
- 16、matches()和contains()函数;
- 17、split()函数
- 18、join()函数
- 19、trim()函数
- 20、toString()函数
- 21、toCharArray()函数
- 22、toLowerCase()、toUpperCase()函数
- 23、String 为什么是不可变的
- 总结
- 04 Java 并发编程
- **→ 并发与并行**
- **→ 什么是线程，与进程的区别**
- → 线程池
- → 线程安全
- → 锁
- → 死锁
- → synchronized
- → volatile
- **→ sleep 和 wait**
- **→ wait 和 notify**
- **→ notify 和 notifyAll**
- **→ ThreadLocal**
- **→ 写一个死锁的程序**
- **→ 写代码来解决生产者消费者问题**
- **→ 并方包**
最近关注了个 主播，Hollis 阿里巴巴的一位专家，该博主总结了一份java成神之路的知识图谱，基于图谱打算出 几期总结文档也有助于自己巩固与学习。于是有了这篇文章。
图谱有着么几个阶段，附件我放到资源里
基础篇大概长这样
01面向对象
→ 什么是面向对象
- 1、面向对象、面向过程
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
- 2、面向对象的三大基本特征和五大基本原则
三大特性是：封装,继承,多态
所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。 简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。
所谓继承是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
所谓多态就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。
五大基本原则
单一职责原则SRP(Single Responsibility Principle)
是指一个类的功能要单一，不能包罗万象。如同一个人一样，分配的工作不能太多，否则一天到晚虽然忙忙碌碌的，但效率却高不起来。
开放封闭原则OCP(Open－Close Principle)
一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。比如：一个网络模块，原来只服务端功能，而现在要加入客户端功能，
那么应当在不用修改服务端功能代码的前提下，就能够增加客户端功能的实现代码，这要求在设计之初，就应当将服务端和客户端分开，公共部分抽象出来。
替换原则(the Liskov Substitution Principle LSP)
子类应当可以替换父类并出现在父类能够出现的任何地方。比如：公司搞年度晚会，所有员工可以参加抽奖，那么不管是老员工还是新员工，
也不管是总部员工还是外派员工，都应当可以参加抽奖，否则这公司就不和谐了。
依赖原则(the Dependency Inversion Principle DIP) 具体依赖抽象，上层依赖下层。假设B是较A低的模块，但B需要使用到A的功能，
这个时候，B不应当直接使用A中的具体类： 而应当由B定义一抽象接口，并由A来实现这个抽象接口，B只使用这个抽象接口：这样就达到
了依赖倒置的目的，B也解除了对A的依赖，反过来是A依赖于B定义的抽象接口。通过上层模块难以避免依赖下层模块，假如B也直接依赖A的实现，那么就可能造成循环依赖。一个常见的问题就是编译A模块时需要直接包含到B模块的cpp文件，而编译B时同样要直接包含到A的cpp文件。
接口分离原则(the Interface Segregation Principle ISP)
模块间要通过抽象接口隔离开，而不是通过具体的类强耦合起来
→ 平台无关性
Java 如何实现的平台无关
JVM 还支持哪些语言（Kotlin、Groovy、JRuby、Jython、Scala）
→ 值传递
值传递、引用传递
1、什么是值传递，什么是引用传递？
- 值传递（pass by value）是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
- 引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
2.值传递和引用传递的区别是什么？
3.为什么说 Java 中只有值传递
3.1纠正一下大家以前的那些错误看法
错误理解一：值传递和引用传递，区分的条件是传递的内容，如果是个值，就是值传递。如果是个引用，就是引用传递
错误理解二：Java是引用传递。
错误理解三：传递的参数如果是普通类型，那就是值传递，如果是对象，那就是引用传递。
3.2 严格求值
在“严格求值”中，函数调用过程中，给函数的实际参数总是在应用这个函数之前求值。多数现存编程语言对函数都使用严格求值。所以，我们本文只关注严格求值。
在严格求值中有几个关键的求值策略是我们比较关心的，那就是传值调用（Call by value）、传引用调用（Call by reference）以及传共享对象调用（Call by sharing）
1.传值调用（值传递）：在传值调用中，实际参数先被求值，然后其值通过复制，在传递给被调函数的形式参数。因为形式参数拿到的只是一个"局部拷贝"，所以如果在被调函数中改变了形式参数的值，并不会改变实际参数的值。
2.传引用调用（引用传递）在传引用调用中，传递给函数的是它的实际参数的隐式引用而不是实参的拷贝。因为传递的是引用，所以，如果在被调函数中改变了形式参数的值，改变对于调用者来说是可见的。
3.传共享对象调用（共享对象传递）传共享对象调用中，先获取到实际参数的地址，然后将其复制，并把该地址的拷贝传递给被调函数的形式参数。因为参数的地址都指向同一个对象，所以我们也称之为"传共享对象"，所以，如果在被调函数中改变了形式参数的值，调用者是可以看到这种变化的。
不知道大家有没有发现，其实传共享对象调用和传值调用的过程几乎是一样的，都是进行"求值"、“拷贝”、“传递”。你品，你细品。
但是，传共享对象调用和内传引用调用的结果又是一样的，都是在被调函数中如果改变参数的内容，那么这种改变也会对调用者有影响。你再品，你再细品。
那么，共享对象传递和值传递以及引用传递之间到底有很么关系呢？
对于这个问题，我们应该关注过程，而不是结果，因为传共享对象调用的过程和传值调用的过程是一样的，而且都有一步关键的操作，那就是"复制"，所以，通常我们认为传共享对象调用是传值调用的特例
我们先把传共享对象调用放在一边，我们再来回顾下传值调用和传引用调用的主要区别：
传值调用是指在调用函数时将实际参数复制一份传递到函数中，传引用调用是指在调用函数时将实际参数的引用直接传递到函数中。
3.3 java 的求值策略
前面我们介绍过了传值调用、传引用调用以及传值调用的特例传共享对象调用，那么，Java中是采用的哪种求值策略呢？
很多人说Java中的基本数据类型是值传递的，这个基本没有什么可以讨论的，普遍都是这样认为的。
但是，有很多人却误认为Java中的对象传递是引用传递。之所以会有这个误区，主要是因为Java中的变量和对象之间是有引用关系的。Java语言中是通过对象的引用来操纵对象的。所以，很多人会认为对象的传递是引用的传递。
而且很多人还可以举出以下的代码示例：
输出结果：
print in pass , user is User{name=‘hollis’, gender=‘Male’}
print in main , user is User{name=‘hollischuang’, gender=‘Male’}：
可以看到，对象类型在被传递到pass方法后，在方法内改变了其内容，最终调用方main方法中的对象也变了。
所以，很多人说，这和引用传递的现象是一样的，就是在方法内改变参数的值，会影响到调用方。
但是，其实这是走进了一个误区。
**其实Java中使用的求值策略就是传共享对象调用，也就是说，Java会将对象的地址的拷贝传递给被调函数的形式参数。**只不过"传共享对象调用"这个词并不常用，所以Java社区的人通常说"Java是传值调用"，这么说也没错，因为传共享对象调用其实是传值调用的一个特例。
值传递和共享对象传递的现象冲突吗？
看到这里很多人可能会有一个疑问，既然共享对象传递是值传递的一个特例，那么为什么他们的现象是完全不同的呢？
难道值传递过程中，如果在被调方法中改变了值，也有可能会对调用者有影响吗？那到底什么时候会影响什么时候不会影响呢？
其实是不冲突的，之所以会有这种疑惑，是因为大家对于到底是什么是"改变值"有误解。
我们先回到上面的例子中来，看一下调用过程中实际上发生了什么？
以上 说明值传递和引用传递 总结引用于一篇写的比较好的文章：
值传递与引用传递
→ 封装、继承、多态
什么是多态、方法重写与重载
Java 的继承与实现
构造函数与默认构造函数
类变量、成员变量和局部变量
成员变量和方法作用域
封装
所谓的封装就是把类的属性和方法使用private修饰，不允许类的调用者直接访问，我们定义如下一个类，可以看到所有的成员变量和成员方法都使用private修饰了，我们现在来使用一下这个类。
当我们使用的时候编译器给出了下面这样的报错。
告诉我们说是private访问控制，那么这是什么意思呢？我们来看看另外一张图，那么这张图代表这什么呢？在看这张图之前，我们先来看看四者都提到的包，那么包又是什么呢，包可以简单理解为一个文件夹，把类放到放到包里面，也就相当于是专门的文件夹里面，这不是我们说的重点，知道就行，类都知道吧，不知道的先去看看博主这篇博客类和对象再回来继续往下。
ps：稍微记一下这张图中的内容。
有了上面的基础我们现在再来看private，他的使用范围只有 同一个包中的同一个类中使用（这个范围也就是他的权限），我们就记住只能在我们定义的那个类中使用就好了，别问为什么，因为这就是语法，记住就好了，记准确了是当前类中，不能外部引用，否则就会出现上面那样的报错。既然不能直接从外部引用，那么类的调用者总得有个办法使用吧，不然实现这个类干嘛，这个时候就是我们在设计类的时候要提供的公开的方法了，那么上述的代码应该写成如下形式。
ps：这里重写了toString方法才会是下面的输出形式。
上面就是调用了，那么有的读者可能就会问了，那你的eat方法还是private的呀，我还是不能调用啊，这里我解释一下，这是因为我是为了演示private的作用而在eat方法前面加的private，运行时我将它注释掉了，至于实际上像eat这样需要被类的调用者直接使用的方法，肯定是不能使用private修饰的，至于用什么访问权限修饰这就是类的设计者根据日后业务的需要而决定了。
封装的第一个作用就是为了不直接被外部使用，提高代码的安全性，第二个作用就是降低类的使用者的学习成本，不需要知道类的实现，只需要学会调用就好了，封装差不多就介绍完了，接下来聊聊继承。
继承
所谓继承本质就是实现代码的复用，防止重复的代码多次书写，当一个类继承一个类的时候，该类中就会拥有另外一个类中的所有代码，举个例子看下面代码
可以看到继承的语法形式是class 子类名 extends 父类名，继承类就是子类，也叫派生类，被继承的类称为父类，基类或者超类（名字一般不做区分，均可使用），语法形式很简单，我们来聊聊其中的细节，首先Java是单继承的， 一个子类只能有一个父类，但是一个子类可以当作另外一个类的父类，即可以B继承A，然后C继承B，代码如下，那么B会拥有A中的代码，C会拥有A、B的代码。
下面讲的普通类继承知识都是基于父类是公开的并单独位于一个.java文件的。
我们定义一个这样的Animal类当作父类：
当访问使用private修饰的属性时就会报错，这个就是上面封装的知识了，只能在定义的类中使用。
当去掉private不加任何修饰符时为包访问权限（对应上面的default范围，至于default关键字的使用在接口当中会提到），当前包底下的类才能使用Animal中的属性。
当使用protected修饰时，是可以在子类中调用的，那么下面为什么会报错呢，那是因为调用的方式不对，这里我们需要改变访问方式并使用到super关键字。
改为如下调用，在子类中调用，并使用super关键字，而不是通过实例化对像调用，上面那张图除了提到包还提到了类，小伙伴们注意到了吗？不记得的小伙伴们就往上翻再看看那张图吧。
至于public没啥好说的，哪都能用。
上面呢介绍了继承普通类的知识，现在我们来看看不太正常的类，抽象类，抽象类是指被abstract修饰，包含抽象方法的类，如下就是一个抽象类，首先是类名前面添加了abstract关键字，其次是其中包含了一个抽象方法，什么是抽象方法，就是没有被具体实现的方法，如下图的work方法，没有方法体，并被abstract修饰，不加的话会报错，被abstract修饰的类中可以没有抽象方法，这是语法允许的（jdk1.8测出来的），但是建议同步使用，要么既有abstract修饰类又有abstract方法，要么都没有，不然使用了abstract修饰类又不加abstract方法这不是闹吗，除非你不想这个类直接被实例化，注意一点，abstract修饰的类不能直接被实例化，需要被继承之后通过子类调用父类的构造方法，对从父类继承过来的字段进行初始化，注意这些继承过来的字段和方法都到了子类中了，但是子类能不能使用和如何使用就和给的权限（使用了什么访问修饰符限定）相关了，并没有实例化产生一个父类对象，有些地方说会实例化一个父类对象这是不对的，说一个极端的说法，父类为抽象类你能实例化吗？
当一个普通类继承一个抽象类的时候需要重写抽象类的所有抽象方法，如果不想重写的话就需要声明为抽象类，看下面代码
继承主要是为了代码的复用，减少代码的重复书写和为多态打一个基础，接下来我们聊聊多态
多态
多态是一种思想，是同一份代码，不同的传参（子类）调用会产生不同的效果，绝对不是写死的代码
多态是建立在继承机制上的一种机制，想要了解多态就必须知道向上转型，那么什么是向上转型呢，所谓的向上转型就是使用父类对象的引用，引用子类对象看下面代码
Teacher是People的一个子类，使用People引用引用一个Teacher对象，向上转型是自动发生的，不需要进行强制类型转换，发生向上转型一般有三种情况
1.像上面代码一样，让父类引用直接引用子类对象时。
2.子类作为函数调用时的实参，使用父类形参接收时。
3.子类作为父类返回值函数的返回值时。
总的说就是父类引用引用了子类对象
红色的框表示第二种，橘黄色的框表示第三种
ps：不难理解吧QAQ
与向上转型对应的还有向下转型，就是将父类对象赋值给子类引用，一般很少用的，就简单的提一下吧，因为他发生条件比较严格，首先是不能直接强制类型转换，看下面代码（已经将People类变成了类）
其次是需要父类引用引用子类的对象（发生过向上转型），最后需要强制转换为对应的子类对象，像下面这样
ps：这东西用起来挺奇怪的，不太建议使用
到这里相信你应该知道什么叫做向上转型了，但是这还不足以接触多态，我们需要先来聊聊另外一个知识点，动态绑定，所谓动态绑定也叫运行时绑定，我们先来看看代码
首先可以看到三个输出，第一个输出睡觉，第三个输出教书没问题吧，问题就出在第二个上面，我明明调用的是people的work方法，为什么输出的不是睡觉，而是教书呢？这就是发生了动态绑定，所谓动态绑定就是使用父类引用引用子类对象然后（向上转型）去调用父类和子类相同的方法（返回值（构成父子类关系也可以，也就是协变类型），方法名，形参列表完全相同）换句话说也就是说在子类中重写了父类的方法，这样的重写需要注意一些点，那就是子类重写的方法的访问权限必须不小于父类的方法的权限也就是说父类为public子类就必须为public因为public是最大的权限，权限对应上图的 √ 的个数√越多权限越大，静态方法不能重写，被final修饰的方法（密封方法）不能重写。
ps：与动态绑定对应的还有静态绑定，这里就不多说了…
好了，知道了向上转型和动态绑定就可以了解多态了，看代码
是不是觉得很神奇，明明是指向了同一份代码却打印了不同的结果，这就是多态，我不管你怎么实现的方法，只要你有这个方法我就能帮你调用，并且这里如果是子类对象会发生向上转型，进而发生动态绑定，形成多态，上面是通过继承来实现的多态，接下来我们再来讲一个东西实现多态，接口
接口
那么接口是什么呢，接口也可以想象成一个类，但是它既然单独出现，肯定说明它和类有有所不同，首先接口由interface关键字定义，并且其中的所有方法都默认为public abstract的，所有字段都默认为public static final的，下面几种定义方式并无区别，
然后类似与继承，接口可以通过implements被实现，实现也很简单，和继承抽象类一样重写所有的抽象方法即可，同样接口不能被直接实例化。
有了上面的了解，我们来用接口实现多态，看下面代码，也和类实现多态没什么很大区别，也类似与发生了向上转型和动态绑定，实现接口和继承类的一个很大区别就是一个类只能继承一个类，但是一个类可以实现多个接口
其中接口也可以扩展接口，看下面代码
从jdk1.8开始接口中可以包含默认方法了需要使用default关键字修饰，和类的成员方法一样，看下面代码，到这里接口就差不多聊完了，小结一下
一些建议和小结
1.建议字段的访问权限能给小绝不给大，能使用private修饰的字段一定要用private，提高安全性。
2.继承的层次不要太深，建议最多继承三层，使用final修饰可以让类无法被继承。
3.抽象类的出现就是为了继承之后重写发生动态绑定。
4.能使用接口就不要使用抽象类，因为类只能单继承，但是接口可以“多继承”，更加的灵活。
5.多态的核心都是让调用者不必关注对象的具体类型. 这是降低用户使用成本的一种重要方式。
6.抽象类和接口的核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 接口中只能包含静态常量，子类必须重写所有的抽象方法。
7.接口中的方法和字段定义都只写必要部分，尽量简洁像博主上面一样
封装、多态、继承
02Java 基础知识
→ 基本数据类型
8 种基本数据类型：整型、浮点型、布尔型、字符型
整型中 byte、short、int、long 的取值范围
什么是浮点型？什么是单精度和双精度？为什么不能用浮点型表示金额？
剖析金额不能用浮点数表示的原因
→ 自动拆装箱
什么是包装类型、什么是基本类型、什么是自动拆装箱
Integer 的缓存机制
→ String
字符串的不可变性
JDK 6 和 JDK 7 中 substring 的原理及区别、
replaceFirst、replaceAll、replace 区别、
String 对“+”的重载、字符串拼接的几种方式和区别
String.valueOf 和 Integer.toString 的区别、
switch 对 String 的支持
字符串池、常量池（运行时常量池、Class 常量池）、intern
由浅入深完全讲解String
→ 熟悉 Java 中各种关键字
transient、instanceof、final、static、volatile、synchronized、const 原理及用法
→ 集合类
常用集合类的使用、ArrayList 和 LinkedList 和 Vector 的区别 、SynchronizedList 和 Vector 的区别、HashMap、HashTable、ConcurrentHashMap 区别、
Set 和 List 区别？Set 如何保证元素不重复？
Java 8 中 stream 相关用法、apache 集合处理工具类的使用、不同版本的 JDK 中 HashMap 的实现的区别以及原因
Collection 和 Collections 区别
Arrays.asList 获得的 List 使用时需要注意什么
Enumeration 和 Iterator 区别
fail-fast 和 fail-safe
CopyOnWriteArrayList、ConcurrentSkipListMap
java容器相关
→ 枚举
枚举的用法、枚举的实现、枚举与单例、Enum 类
Java 枚举如何比较
switch 对枚举的支持
枚举的序列化如何实现
枚举的线程安全性问题
1.什么是枚举
Java中的枚举是一种类型，顾名思义：就是一个一个列举出来。所以它一般都是表示一个有限的集合类型，它是一种类型，在维基百科中给出的定义是：
在数学和计算机科学理论中，一个集的枚举是列出某些有穷序列集的所有成员的程序，或者是一种特定类型对象的计数。这两种类型经常（但不总是）重叠.。枚举是一个被命名的整型常数的集合，枚举在日常生活中很常见，例如表示星期的SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY就是一个枚举。
public enum Season {
SPRING(1), SUMMER(2), AUTUMN(3), WINTER(4);
private int code;
private Season(int code){
this.code = code;
}
public int getCode(){
return code;
}
}
public class UseSeason {
/**
* 将英文的季节转换成中文季节
* @param season
* @return
*/
public String getChineseSeason(Season season){
StringBuffer result = new StringBuffer();
switch(season){
case SPRING :
result.append("[中文：春天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
case AUTUMN :
result.append("[中文：秋天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
case SUMMER :
result.append("[中文：夏天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
case WINTER :
result.append("[中文：冬天，枚举常量:" + season.name() + "，数据:" + season.getCode() + "]");
break;
default :
result.append("地球没有的季节 " + season.name());
break;
}
return result.toString();
}
public void doSomething(){
for(Season s : Season.values()){
System.out.println(getChineseSeason(s));//这是正常的场景
}
//System.out.println(getChineseSeason(5));
//此处已经是编译不通过了，这就保证了类型安全
}
public static void main(String[] arg){
UseSeason useSeason = new UseSeason();
useSeason.doSomething();
}
}
2.Java 枚举如何比较
可以通过三种方式比较两个枚举常量：
使用Enum类的compareTo()方法
使用Enum类的equals()方法
使用==运算符
enum Level {
LOW, MEDIUM, HIGH, URGENT;
}
public class Main {
public static void main(String[] args) {
Level s1 = Level.LOW;
Level s2 = Level.URGENT;
// s1.compareTo(s2) returns s1.ordinal() - s2.ordinal()
int diff = s1.compareTo(s2);
System.out.println(diff);
}
}
enum Level {
LOW, MEDIUM, HIGH, URGENT;
}
public class Main {
public static void main(String[] args) {
Level s1 = Level.LOW;
Level s2 = Level.URGENT;
System.out.println(s1.equals(s1));
System.out.println(s1==s1);
}
}
3.switch 对枚举的支持
package mark.demo;
import java.util.Random;
public class EnumDemo {
public static void main(String[] args) {
int len = Color.values().length;
Color color = Color.getColor(len);
switch (color) {
case RED:
System.out.println("select " + "RED");
break;
case GREEN:
System.out.println("select " + "GREEN");
break;
case BLUE:
System.out.println("select " + "BLUE");
break;
case YELLOW:
System.out.println("select " + "YELLOW");
break;
default:
System.out.println("select " + "unknow!!");
break;
}
}
public enum Color {
RED("red color", 0),
GREEN("green color", 1),
BLUE("blue color", 2),
YELLOW("yellow color", 3);
Color(String name, int id) {
_name = name;
_id = id;
}
private String _name;
private int _id;
public String getName() {
return _name;
}
public int getId() {
return _id;
}
public static Color getColor(int max) {
Random random = new Random(System.currentTimeMillis());
int num = random.nextInt(max);
switch (num) {
case 0:
return Color.RED;
case 1:
return Color.GREEN;
case 2:
return Color.BLUE;
case 3:
return Color.YELLOW;
default:
return Color.BLUE;
}
}
}
}
→ IO
字符流、字节流、输入流、输出流、
同步、异步、阻塞、非阻塞、Linux 5 种 IO 模型
BIO、NIO 和 AIO 的区别、三种 IO 的用法与原理、netty
懒得自己写摘抄两个写的比较详细的文档：
写的很细致的io流文案
这个写的比较基础，主要是有几本的输入输出的小代码可以看下
BIO、NIO 和 AIO 的区别
→ 反射
反射与工厂模式、反射有什么用
Class 类、java.lang.reflect.*
一篇讲反射
→ 代理
静态代理、动态代理
动态代理和反射的关系
动态代理的几种实现方式
AOP
Java|面试被问Java的动态代理机制，能说说吗
→ 序列化
什么是序列化与反序列化、为什么序列化、序列化底层原理、序列化与单例模式、protobuf、为什么说序列化并不安全
简述序列化
序列化与单例模式
→ 注解
元注解、自定义注解、Java 中常用注解使用、注解与反射的结合
java注解
Spring 常用注解 ，详见spring梳理。
→ JMS
什么是 Java 消息服务、JMS 消息传送模型
→ JMX
java.lang.management.、 javax.management.
→ 泛型
泛型与继承、类型擦除、泛型中 KTVE? object 等的含义、泛型各种用法
限定通配符和非限定通配符、上下界限定符 extends 和 super
List 和原始类型 List 之间的区别?
List<?> 和 List 之间的区别是什么?
List、List<?>、List这三者都可以容纳所有的对象，但使用的顺序应该是首选List,次之List<?>,最后选择List,原因如下：
(1) List是确定的某一个类型
List表示的是List集合中的元素都为T类型，具体类型在运行期决定；List<?>表示 的是任意类型，与List类似，而List则表示List集合中的所有元素为Object类 型，因为Object是所有类的父类，所以LiSt也可以容纳所有的类类型，从这一字面 意义上分析，List更符合习惯：编码者知道它是某一个类型，只是在运行期才确定而已。
(2) List可以进行读写操作
List可以进行诸如add、remove等操作，因为它的类型是固定的T类型，在编码期 不需要进行任何的转型操作。
List<?>是只读类型的，不能进行增加、修改操作，因为编译器不知道List中容纳的是 什么类型的元素，也就无毕校验类型是否安全了，而且List<?>读取出的元素都是Object类 型的，需要主动转型，所以它经常用于泛型方法的返回值。注意，List<?>虽然无法增加、修 改元素，但是却可以删除元素，比如执行remove、clear等方法，那是因为它的删除动作与泛型类型无关
List也可以读写操作，但是它执行写入操作时需要向上转型（Upcast),在读 取数据后需要向下转型（Downcast),而此时已经失去了泛型存在的意义了。
(3) Dao应该比Dao<?>、Dao更先采用，Desc则比Desc<?>、Desc 更优先采用。
→ 单元测试
junit、mock、mockito、内存数据库（h2）
→ 正则表达式
java.lang.util.regex.*
→ 常用的 Java 工具库
commons.lang、commons.*…、 guava-libraries、 netty
→ API & SPI
API、API 和 SPI 的关系和区别
如何定义 SPI、SPI 的实现原理
→ 异常
异常类型、正确处理异常、自定义异常
Error 和 Exception
异常链、try-with-resources
finally 和 return 的执行顺序
→ 时间处理
时区、冬令时和夏令时、时间戳、Java 中时间 API
格林威治时间、CET,UTC,GMT,CST 几种常见时间的含义和关系
SimpleDateFormat 的线程安全性问题
Java 8 中的时间处理
如何在东八区的计算机上获取美国时间
→ 编码方式
Unicode、有了 Unicode 为啥还需要 UTF-8
GBK、GB2312、GB18030 之间的区别
UTF8、UTF16、UTF32 区别
URL 编解码、Big Endian 和 Little Endian
如何解决乱码问题
→ 语法糖
Java 中语法糖原理、解语法糖
语法糖：switch 支持 String 与枚举、泛型、自动装箱与拆箱、方法变长参数、枚举、内部类、条件编译、 断言、数值字面量、for-each、try-with-resource、Lambda 表达式
03 阅读源代码
String、Integer、Long、Enum、
BigDecimal、ThreadLocal、ClassLoader & URLClassLoader、
ArrayList & LinkedList、
HashMap & LinkedHashMap & TreeMap & CouncurrentHashMap、HashSet & LinkedHashSet & TreeSet
Arrays方法
String源码精读
String类的一个最大特性是不可修改性，而导致其不可修改的原因是在String内部定义了一个常量数组，因此每次对字符串的操作实际上都会另外分配分配一个新的常量数组空间;
1、String的定义
public final class String implements java.io.Serializable, Comparable, CharSequence
从上，我们可以看出几个重点：
String是一个final类，既不能被继承的类；
String类实现了java.io.Serializable接口，可以实现序列化；
String类实现了Comparable，可以用于比较大小(按顺序比较单个字符的ASCII码)；
String类实现了 CharSequence 接口，表示是一个有序字符的序列，因为String的本质是一个char类型数组。
2、字段属性
//用来存字符串,字符串的本质，是一个final的char型数组
private final char value[];
//缓存字符串的哈希
private int hash; // Default to 0
//实现序列化的标识
private static final long serialVersionUID = -6849794470754667710L;
这里需要注意的重点是：
private final char value[]这是String字符串的本质，是一个字符集合，而且是final的，是不可变的
3、构造函数
/** 01
* 这是一个经常会使用的String的无参构造函数.
* 默认将""空字符串的value赋值给实例对象的value，也是空字符
* 相当于深拷贝了空字符串""
*/
public String() {
this.value = "".value;
}
/** 02
* 这是一个有参构造函数，参数为一个String对象
* 将形参的value和hash赋值给实例对象作为初始化
* 相当于深拷贝了一个形参String对象
*/
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
/** 03
* 这是一个有参构造函数，参数为一个char字符数组
* 虽然我不知道为什么要Arrays.copyOf去拷贝，而不直接this.value = value;
* 意义就是通过字符数组去构建一个新的String对象
*/
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}
/** 04
* 这是一个有参构造函数，参数为char字符数组,offset(起始位置，偏移量),count(个数)
* 作用就是在char数组的基础上，从offset位置开始计数count个，构成一个新的String的字符串
* 意义就类似于截取count个长度的字符集合构成一个新的String对象
*/
public String(char value[], int offset, int count) {
if (offset < 0) { //如果起始位置小于0，抛异常
throw new StringIndexOutOfBoundsException(offset);
}
if (count <= 0) {
if (count < 0) { //如果个数小于0，抛异常
throw new StringIndexOutOfBoundsException(count);
}
if (offset <= value.length) { //在count = 0的前提下，如果offset<=len，则返回""
this.value = "".value;
return;
}
}
// Note: offset or count might be near -1>>>1.
//如果起始位置>字符数组长度 - 个数,则无法截取到count个字符，抛异常
if (offset > value.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}
//重点，从offset开始，截取到offset+count位置(不包括offset+count位置)
this.value = Arrays.copyOfRange(value, offset, offset+count);
}
/** 05
* 这是一个有参构造函数，参数为int字符数组,offset(起始位置，偏移量),count(个数)
* 作用跟04构造函数差不多，但是传入的不是char字符数组，而是int数组。
* 而int数组的元素则是字符对应的ASCII整数值
* 例子：new String(new int[]{97,98,99},0,3); output: abc
*/
public String(int[] codePoints, int offset, int count) {
if (offset < 0) {
throw new StringIndexOutOfBoundsException(offset);
}
if (count <= 0) {
if (count < 0) {
throw new StringIndexOutOfBoundsException(count);
}
if (offset <= codePoints.length) {
this.value = "".value;
return;
}
}
// Note: offset or count might be near -1>>>1.
if (offset > codePoints.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}
//以上都是为了处理offset和count的正确性，如果有错，则抛异常
final int end = offset + count;
// Pass 1: Compute precise size of char[]
int n = count;
for (int i = offset; i < end; i++) {
int c = codePoints[i];
if (Character.isBmpCodePoint(c))
continue;
else if (Character.isValidCodePoint(c))
n++;
else throw new IllegalArgumentException(Integer.toString(c));
}
//上面关于BMP什么的，我暂时也没看懂，猜想关于验证int数据的正确性，通过上面的测试就进入下面的算法
// Pass 2: Allocate and fill in char[]
final char[] v = new char[n];
for (int i = offset, j = 0; i < end; i++, j++) { //从offset开始，到offset + count
int c = codePoints[i];
if (Character.isBmpCodePoint(c))
v[j] = (char)c; //将Int类型显式缩窄转换为char类型
else
Character.toSurrogates(c, v, j++);
}
this.value = v; //最后将得到的v赋值给String对象的value，完成初始化
}
/****这里把被标记为过时的构造函数去掉了***/
/** 06
* 这是一个有参构造函数，参数为byte数组,offset(起始位置，偏移量),长度，和字符编码格式
* 就是传入一个byte数组，从offset开始截取length个长度，其字符编码格式为charsetName，如UTF-8
* 例子：new String(bytes, 2, 3, "UTF-8");
*/
public String(byte bytes[], int offset, int length, String charsetName)
throws UnsupportedEncodingException {
if (charsetName == null)
throw new NullPointerException("charsetName");
checkBounds(bytes, offset, length);
this.value = StringCoding.decode(charsetName, bytes, offset, length);
}
/** 07
* 类似06
*/
public String(byte bytes[], int offset, int length, Charset charset) {
if (charset == null)
throw new NullPointerException("charset");
checkBounds(bytes, offset, length);
this.value = StringCoding.decode(charset, bytes, offset, length);
}
/** 08
* 这是一个有参构造函数，参数为byte数组和字符集编码
* 用charsetName的方式构建byte数组成一个String对象
*/
public String(byte bytes[], String charsetName)
throws UnsupportedEncodingException {
this(bytes, 0, bytes.length, charsetName);
}
/** 09
* 类似08
*/
public String(byte bytes[], Charset charset) {
this(bytes, 0, bytes.length, charset);
}
/** 10
* 这是一个有参构造函数，参数为byte数组,offset(起始位置，偏移量),length(个数)
* 通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
*
*/
public String(byte bytes[], int offset, int length) {
checkBounds(bytes, offset, length);
this.value = StringCoding.decode(bytes, offset, length);
}
/** 11
* 这是一个有参构造函数，参数为byte数组
* 通过使用平台默认字符集编码解码传入的byte数组，构造成一个String对象，不需要截取
*
*/
public String(byte bytes[]) {
this(bytes, 0, bytes.length);
}
/** 12
* 有参构造函数，参数为StringBuffer类型
* 就是将StringBuffer构建成一个新的String,比较特别的就是这个方法有synchronized锁
* 同一时间只允许一个线程对这个buffer构建成String对象
*/
public String(StringBuffer buffer) {
synchronized(buffer) {
this.value = Arrays.copyOf(buffer.getValue(), buffer.length()); //使用拷贝的方式
}
}
/** 13
* 有参构造函数，参数为StringBuilder
* 同12差不多，只不过是StringBuilder的版本，差别就是没有实现线程安全
*/
public String(StringBuilder builder) {
this.value = Arrays.copyOf(builder.getValue(), builder.length());
}
/** 14
* 这个构造函数比较特殊，有用的参数只有char数组value,是一个不对外公开的构造函数，没有访问修饰符
* 加入这个share的只是为了区分于String(char[] value)方法，用于重载，功能类似于03，我也在03表示过疑惑。
* 为什么提供这个方法呢，因为性能好，不需要拷贝。为什么不对外提供呢？因为对外提供会打破value为不变数组的限制。
* 如果对外提供这个方法让String与外部的value产生关联，如果修改外不的value，会影响String的value。所以不能
* 对外提供
*/
String(char[] value, boolean share) {
// assert share : "unshared not supported";
this.value = value;
}
展示了总共14种构造方法：
- 可以构造空字符串对象,既"";
- 可以根据String,StringBuilder,StringBuffer构造字符串对象;
- 可以根据char数组，其子数组构造字符串对象;
- 可以根据int数组，其子数组构造字符串对象;
- 可以根据某个字符集编码对byte数组，其子数组解码并构造字符串对象;
4、长度和是否为空函数
public int length() { //所以String的长度就是一个value的长度
return value.length;
}
public boolean isEmpty() { //当char数组的长度为0，则代表String为"",空字符串
return value.length == 0;
}
5、charAt、codePointAt类型函数
/**
* 返回String对象的char数组index位置的元素
*/
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) { //index不允许小于0，不允许大于等于String的长度
throw new StringIndexOutOfBoundsException(index);
}
return value[index]; //返回
}
/**
* 返回String对象的char数组index位置的元素的ASSIC码(int类型)
*/
public int codePointAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return Character.codePointAtImpl(value, index, value.length);
}
/**
* 返回index位置元素的前一个元素的ASSIC码(int型)
*/
public int codePointBefore(int index) {
int i = index - 1; //获得index前一个元素的索引位置
if ((i < 0) || (i >= value.length)) { //所以，index不能等于0，因为i = 0 - 1 = -1
throw new StringIndexOutOfBoundsException(index);
}
return Character.codePointBeforeImpl(value, index, 0);
}
/**
* 方法返回的是代码点个数，是实际上的字符个数,功能类似于length()
* 对于正常的String来说，length方法和codePointCount没有区别，都是返回字符个数。
* 但当String是Unicode类型时则有区别了。
* 例如：String str = “/uD835/uDD6B” (即使 'Z' ), length() = 2 ,codePointCount() = 1
*/
public int codePointCount(int beginIndex, int endIndex) {
if (beginIndex < 0 || endIndex > value.length || beginIndex > endIndex) {
throw new IndexOutOfBoundsException();
}
return Character.codePointCountImpl(value, beginIndex, endIndex - beginIndex);
}
/**
* 也是相对Unicode字符集而言的，从index索引位置算起，偏移codePointOffset个位置，返回偏移后的位置是多少
* 例如，index = 2 ,codePointOffset = 3 ，maybe返回 5
*/
public int offsetByCodePoints(int index, int codePointOffset) {
if (index < 0 || index > value.length) {
throw new IndexOutOfBoundsException();
}
return Character.offsetByCodePointsImpl(value, 0, value.length,
index, codePointOffset);
}
6、getChar、getBytes类型函数
/**
* 这是一个不对外的方法，是给String内部调用的，因为它是没有访问修饰符的，只允许同一包下的类访问
* 参数：dst[]是目标数组，dstBegin是目标数组的偏移量，既要复制过去的起始位置(从目标数组的什么位置覆盖)
* 作用就是将String的字符数组value整个复制到dst字符数组中，在dst数组的dstBegin位置开始拷贝
*
*/
void getChars(char dst[], int dstBegin) {
System.arraycopy(value, 0, dst, dstBegin, value.length);
}
/**
* 得到char字符数组，原理是getChars() 方法将一个字符串的字符复制到目标字符数组中。
* 参数：srcBegin是原始字符串的起始位置，srcEnd是原始字符串要复制的字符末尾的后一个位置(既复制区域不包括srcEnd)
* dst[]是目标字符数组，dstBegin是目标字符的复制偏移量，复制的字符从目标字符数组的dstBegin位置开始覆盖。
*/
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
if (srcBegin < 0) { //如果srcBegin小于，抛异常
throw new StringIndexOutOfBoundsException(srcBegin);
}
* if (srcEnd > value.length) { //如果srcEnd大于字符串的长度，抛异常
throw new StringIndexOutOfBoundsException(srcEnd);
}
if (srcBegin > srcEnd) { //如果原始字符串其实位置大于末尾位置，抛异常
throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
}
System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}
/****去除被标记过时的方法****/
/**
* 获得charsetName编码格式的bytes数组
*/
public byte[] getBytes(String charsetName)
throws UnsupportedEncodingException {
if (charsetName == null) throw new NullPointerException();
return StringCoding.encode(charsetName, value, 0, value.length);
}
/**
* 与上个方法类似，但charsetName和charset的区别，我还没搞定，搞懂来再更新
*/
public byte[] getBytes(Charset charset) {
if (charset == null) throw new NullPointerException();
return StringCoding.encode(charset, value, 0, value.length);
}
/**
* 使用平台默认的编码格式获得bytes数组
*/
public byte[] getBytes() {
return StringCoding.encode(value, 0, value.length);
}
7、equal类函数(是否相等)
/**
* String的equals方法，重写了Object的equals方法（区分大小写）
* 比较的是两个字符串的值是否相等
* 参数是一个Object对象，而不是一个String对象。这是因为重写的是Object的equals方法，所以是Object
* 如果是String自己独有的方法，则可以传入String对象，不用多此一举
*
* 实例：str1.equals(str2)
*/
public boolean equals(Object anObject) {
if (this == anObject) { //首先判断形参str2是否跟当前对象str1是同一个对象，既比较地址是否相等
return true; //如果地址相等，那么自然值也相等，毕竟是同一个字符串对象
}
if (anObject instanceof String) { //判断str2对象是否是一个String类型，过滤掉非String类型的比较
String anotherString = (String)anObject; //如果是String类型，转换为String类型
int n = value.length; //获得当前对象str1的长度
if (n == anotherString.value.length) { //比较str1的长度和str2的长度是否相等
//如是进入核心算法
char v1[] = value; //v1为当前对象str1的值，v2为参数对象str2的值
char v2[] = anotherString.value;
int i = 0; //就类似于for的int i =0的作用，因为这里使用while
while (n-- != 0) { //每次循环长度-1,直到长度消耗完，循环结束
if (v1[i] != v2[i]) //同索引位置的字符元素逐一比较
return false; //只要有一个不相等，则返回false
i++;
}
return true; //如比较期间没有问题，则说明相等，返回true
}
}
return false;
}
8、regionMatchs()方法
/**
* 这是一个类似于equals的方法，比较的是字符串的片段，也即是部分区域的比较
* toffset是当前字符串的比较起始位置(偏移量),other是要比较的String对象参数，ooffset是要参数String的比较片段起始位置，len是两个字符串要比较的片段的长度大小
*/
public boolean regionMatches(int toffset, String other, int ooffset,
int len) {
char ta[] = value; //当前对象的值
int to = toffset; //当前对象的比较片段的起始位置，既偏移量
char pa[] = other.value; //参数，既比较字符串的值
int po = ooffset; //比较字符串的起始位置
// Note: toffset, ooffset, or len might be near -1>>>1.
if ((ooffset < 0) || (toffset < 0) //起始位置不小于0或起始位置不大于字符串长度 - 片段长度，大于就截取不到这么长的片段了
|| (toffset > (long)value.length - len)
|| (ooffset > (long)other.value.length - len)) {
return false; //惊讶脸，居然不是抛异常，而是返回false
}
while (len-- > 0) { //使用while循环，当然也可以使for循环
if (ta[to++] != pa[po++]) { //片段区域的字符元素逐个比较
return false;
}
}
return true;
}
/**
* 这个跟上面的方法一样，只不过多了一个参数，既ignoreCase,既是否为区分大小写。
* 是equalsIgnoreCase()方法的片段比较版本，实际上equalsIgnoreCase()也是调用regionMatches函数
*/
public boolean regionMatches(boolean ignoreCase, int toffset,
String other, int ooffset, int len) {
char ta[] = value;
int to = toffset;
char pa[] = other.value;
int po = ooffset;
// Note: toffset, ooffset, or len might be near -1>>>1.
if ((ooffset < 0) || (toffset < 0)
|| (toffset > (long)value.length - len)
|| (ooffset > (long)other.value.length - len)) {
return false;
}
//上面的解释同上
while (len-- > 0) {
char c1 = ta[to++];
char c2 = pa[po++];
if (c1 == c2) {
continue;
}
if (ignoreCase) { //当ignoreCase为true时，既忽视大小写时
// If characters don't match but case may be ignored,
// try converting both characters to uppercase.
// If the results match, then the comparison scan should
// continue.
char u1 = Character.toUpperCase(c1); //片段中每个字符转换为大写
char u2 = Character.toUpperCase(c2);
if (u1 == u2) { //大写比较一次，如果相等则不执行下面的语句，进入下一个循环
continue;
}
// Unfortunately, conversion to uppercase does not work properly
// for the Georgian alphabet, which has strange rules about case
// conversion. So we need to make one last check before
// exiting.
if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
//每个字符换行成小写比较一次
continue;
}
}
return false;
}
return true;
}
- 片段比较时针对String对象的;所以如果你要跟StringBuffer和StringBuilder比较，那么记得toString;
- 如果你要进行两个字符串之间的片段比较的话，就可以使用regionMatches，如果是完整的比较那么就equals;
9、compareTo类函数和CaseInsensitiveComparator静态内部类
/**
* 这是一个比较字符串中字符大小的函数，因为String实现了Comparable<String>接口，所以重写了compareTo方法
* Comparable是排序接口。若一个类实现了Comparable接口，就意味着该类支持排序。
* 实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。
*
* 参数是需要比较的另一个String对象
* 返回的int类型，正数为大，负数为小，是基于字符的ASSIC码比较的
*
*/
public int compareTo(String anotherString) {
int len1 = value.length; //当前对象的长度
int len2 = anotherString.value.length; //比较对象的长度
int lim = Math.min(len1, len2); //获得最小长度
char v1[] = value; //获得当前对象的值
char v2[] = anotherString.value; //获得比较对象的值
int k = 0; //相当于for的int k = 0,就是为while循环的数组服务的
while (k < lim) { //当当前索引小于两个字符串中较短字符串的长度时，循环继续
char c1 = v1[k]; //获得当前对象的字符
char c2 = v2[k]; //获得比较对象的字符
if (c1 != c2) { //从前向后遍历，只要其实一个不相等，返回字符ASSIC的差值,int类型
return c1 - c2;
}
k++;
}
return len1 - len2; //如果两个字符串同样位置的索引都相等，返回长度差值，完全相等则为0
}
/**
* 这时一个类似compareTo功能的方法，但是不是comparable接口的方法，是String本身的方法
* 使用途径，我目前只知道可以用来不区分大小写的比较大小，但是不知道如何让它被工具类Collections和Arrays运用
*
*/
public int compareToIgnoreCase(String str) {
return CASE_INSENSITIVE_ORDER.compare(this, str);
}
/**
* 这是一个饿汉单例模式，是String类型的一个不区分大小写的比较器
* 提供给Collections和Arrays的sort方法使用
* 例如：Arrays.sort(strs,String.CASE_INSENSITIVE_ORDER);
* 效果就是会将strs字符串数组中的字符串对象进行忽视大小写的排序
*
*/
public static final Comparator<String> CASE_INSENSITIVE_ORDER
= new CaseInsensitiveComparator();
/**
* 这一个私有的静态内部类，只允许String类本身调用
* 实现了序列化接口和比较器接口，comparable接口和comparator是有区别的
* 重写了compare方法，该静态内部类实际就是一个String类的比较器
*
*/
private static class CaseInsensitiveComparator
implements Comparator<String>, java.io.Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 8575799808933029326L;
public int compare(String s1, String s2) {
int n1 = s1.length(); //s1字符串的长度
int n2 = s2.length(); //s2字符串的长度
int min = Math.min(n1, n2); //获得最小长度
for (int i = 0; i < min; i++) {
char c1 = s1.charAt(i); //逐一获得字符串i位置的字符
char c2 = s2.charAt(i);
if (c1 != c2) { //部分大小写比较一次
c1 = Character.toUpperCase(c1); //转换大写比较一次
c2 = Character.toUpperCase(c2);
if (c1 != c2) {
c1 = Character.toLowerCase(c1); //转换小写比较一次
c2 = Character.toLowerCase(c2);
if (c1 != c2) { //返回字符差值
// No overflow because of numeric promotion
return c1 - c2;
}
}
}
}
return n1 - n2; //如果字符相等，但是长度不等，则返回长度差值，短的教小，所以小-大为负数
}
/** Replaces the de-serialized object. */
private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
}
10、startWith、endWith类函数
/**
* 作用就是当前对象[toffset,toffset + prefix.value.lenght]区间的字符串片段等于prefix
* 也可以说当前对象的toffset位置开始是否以prefix作为前缀
* prefix是需要判断的前缀字符串，toffset是当前对象的判断起始位置
*/
public boolean startsWith(String prefix, int toffset) {
char ta[] = value; //获得当前对象的值
int to = toffset; //获得需要判断的起始位置，偏移量
char pa[] = prefix.value; //获得前缀字符串的值
int po = 0;
int pc = prefix.value.length;
// Note: toffset might be near -1>>>1.
if ((toffset < 0) || (toffset > value.length - pc)) { //偏移量不能小于0且能截取pc个长度
return false; //不能则返回false
}
while (--pc >= 0) { //循环pc次，既prefix的长度
if (ta[to++] != pa[po++]) { //每次比较当前对象的字符串的字符是否跟prefix一样
return false; //一样则pc--,to++,po++,有一个不同则返回false
}
}
return true; //没有不一样则返回true，当前对象是以prefix在toffset位置做为开头
}
/**
* 判断当前字符串对象是否以字符串prefix起头
* 是返回true,否返回fasle
*/
public boolean startsWith(String prefix) {
return startsWith(prefix, 0);
}
/**
* 判断当前字符串对象是否以字符串prefix结尾
* 是返回true,否返回fasle
*/
public boolean endsWith(String suffix) {
//suffix是需要判断是否为尾部的字符串。
//value.length - suffix.value.length是suffix在当前对象的起始位置
return startsWith(suffix, value.length - suffix.value.length);
}
11、hashCode()函数
/**
* 这是String字符串重写了Object类的hashCode方法。
* 给由哈希表来实现的数据结构来使用，比如String对象要放入HashMap中。
* 如果没有重写HashCode，或HaseCode质量很差则会导致严重的后果，既不靠谱的后果
*
*/
public int hashCode() {
int h = hash; //hash是属性字段，是成员变量，所以默认为0
if (h == 0 && value.length > 0) { //如果hash为0，且字符串对象长度大于0，不为""
char val[] = value; //获得当前对象的值
//重点，String的哈希函数
for (int i = 0; i < value.length; i++) { //遍历len次
h = 31 * h + val[i]; //每次都是31 * 每次循环获得的h +第i个字符的ASSIC码
}
hash = h;
}
return h; //由此可见""空字符对象的哈希值为0
}
12、indexOf、lastIndexOf类函数
/**
* 返回cn对应的字符在字符串中第一次出现的位置，从字符串的索引0位置开始遍历
*
*/
public int indexOf(int ch) {
return indexOf(ch, 0);
}
/**
* index方法就是返回ch字符第一次在字符串中出现的位置
* 既从fromIndex位置开始查找，从头向尾遍历，ch整数对应的字符在字符串中第一次出现的位置
* -1代表字符串没有这个字符，整数代表字符第一次出现在字符串的位置
*/
public int indexOf(int ch, int fromIndex) {
final int max = value.length; //获得字符串对象的长度
if (fromIndex < 0) { //如果偏移量小于0，则代表偏移量为0，校正偏移量
fromIndex = 0;
} else if (fromIndex >= max) { //如果偏移量大于最大长度，则返回-1，代表没有字符串没有ch对应的字符
// Note: fromIndex might be near -1>>>1.
return -1;
}
if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) { //emmm,这个判断，不懂
// handle most cases here (ch is a BMP code point or a
// negative value (invalid code point))
final char[] value = this.value; //获得字符串值
for (int i = fromIndex; i < max; i++) { //从fromIndex位置开始向后遍历
if (value[i] == ch) { //只有字符串中的某个位置的元素等于ch
return i; //返回对应的位置，函数结束，既第一次出现的位置
}
}
return -1; //如果没有出现，则返回-1
} else {
return indexOfSupplementary(ch, fromIndex); //emmm,紧紧接着没看懂的地方
}
}
private int indexOfSupplementary(int ch, int fromIndex) {
if (Character.isValidCodePoint(ch)) {
final char[] value = this.value;
final char hi = Character.highSurrogate(ch);
final char lo = Character.lowSurrogate(ch);
final int max = value.length - 1;
for (int i = fromIndex; i < max; i++) {
if (value[i] == hi && value[i + 1] == lo) {
return i;
}
}
}
return -1;
}
/**
* 从尾部向头部遍历，返回cn第一次出现的位置，value.length - 1就是起点
* 为了理解，我们可以认为是返回cn对应的字符在字符串中最后出现的位置
*
* ch是字符对应的整数
*/
public int lastIndexOf(int ch) {
return lastIndexOf(ch, value.length - 1);
}
/**
* 从尾部向头部遍历，从fromIndex开始作为起点，返回ch对应字符第一次在字符串出现的位置
* 既从头向尾遍历，返回cn对应字符在字符串中最后出现的一次位置，fromIndex为结束点
*
*/
public int lastIndexOf(int ch, int fromIndex) {
if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) { //之后不解释了,emmmmmmm
// handle most cases here (ch is a BMP code point or a
// negative value (invalid code point))
final char[] value = this.value;
//取最小值，作用就是校正，如果fromIndex传大了，就当时len - 1
int i = Math.min(fromIndex, value.length - 1);
for (; i >= 0; i--) { //算法中是从后向前遍历，直到i<0,退出循环
if (value[i] == ch) { //只有有相等，返回对应的索引位置
return i;
}
}
return -1; //没有找到则返回-1
} else {
return lastIndexOfSupplementary(ch, fromIndex);
}
}
private int lastIndexOfSupplementary(int ch, int fromIndex) {
if (Character.isValidCodePoint(ch)) {
final char[] value = this.value;
char hi = Character.highSurrogate(ch);
char lo = Character.lowSurrogate(ch);
int i = Math.min(fromIndex, value.length - 2);
for (; i >= 0; i--) {
if (value[i] == hi && value[i + 1] == lo) {
return i;
}
}
}
return -1;
}
/**
* 返回第一次出现的字符串的位置
*
*/
public int indexOf(String str) {
return indexOf(str, 0);
}
/**
*
* 从fromIndex开始遍历，返回第一次出现str字符串的位置
*
*/
public int indexOf(String str, int fromIndex) {
return indexOf(value, 0, value.length,
str.value, 0, str.value.length, fromIndex);
}
/**
* 这是一个不对外公开的静态函数
* source就是原始字符串，sourceOffset就是原始字符串的偏移量，起始位置。
* sourceCount就是原始字符串的长度，target就是要查找的字符串。
* fromIndex就是从原始字符串的第fromIndex开始遍历
*
*/
static int indexOf(char[] source, int sourceOffset, int sourceCount,
String target, int fromIndex) {
return indexOf(source, sourceOffset, sourceCount,
target.value, 0, target.value.length,
fromIndex);
}
/**
* 同是一个不对外公开的静态函数
* 比上更为强大。
* 多了一个targetOffset和targetCount，既代表别查找的字符串也可以被切割
*/
static int indexOf(char[] source, int sourceOffset, int sourceCount,
char[] target, int targetOffset, int targetCount,
int fromIndex) {
if (fromIndex >= sourceCount) { //如果查找的起点大于当前对象的大小
//如果目标字符串的长度为0，则代表目标字符串为""，""在任何字符串都会出现
//配合fromIndex >= sourceCount,所以校正第一次出现在最尾部，仅仅是校正作用
return (targetCount == 0 ? sourceCount : -1);
}
if (fromIndex < 0) { //也是校正，如果起始点小于0，则返回0
fromIndex = 0;
}
if (targetCount == 0) { //如果目标字符串长度为0，代表为""，则第一次出现在遍历起始点fromIndex
return fromIndex;
}
char first = target[targetOffset]; //目标字符串的第一个字符
int max = sourceOffset + (sourceCount - targetCount); //最大遍历次数
for (int i = sourceOffset + fromIndex; i <= max; i++) {
/* Look for first character. */
if (source[i] != first) {
while (++i <= max && source[i] != first);
}
/* Found first character, now look at the rest of v2 */
if (i <= max) {
int j = i + 1;
int end = j + targetCount - 1;
for (int k = targetOffset + 1; j < end && source[j]
== target[k]; j++, k++);
if (j == end) {
/* Found whole string. */
return i - sourceOffset;
}
}
}
return -1;
}
/**
* 查找字符串Str最后一次出现的位置
*/
public int lastIndexOf(String str) {
return lastIndexOf(str, value.length);
}
public int lastIndexOf(String str, int fromIndex) {
return lastIndexOf(value, 0, value.length,
str.value, 0, str.value.length, fromIndex);
}
static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
String target, int fromIndex) {
return lastIndexOf(source, sourceOffset, sourceCount,
target.value, 0, target.value.length,
fromIndex);
}
static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
char[] target, int targetOffset, int targetCount,
int fromIndex) {
/*
* Check arguments; return immediately where possible. For
* consistency, don't check for null str.
*/
int rightIndex = sourceCount - targetCount;
if (fromIndex < 0) {
return -1;
}
if (fromIndex > rightIndex) {
fromIndex = rightIndex;
}
/* Empty string always matches. */
if (targetCount == 0) {
return fromIndex;
}
int strLastIndex = targetOffset + targetCount - 1;
char strLastChar = target[strLastIndex];
int min = sourceOffset + targetCount - 1;
int i = min + fromIndex;
startSearchForLastChar:
while (true) {
while (i >= min && source[i] != strLastChar) {
i--;
}
if (i < min) {
return -1;
}
int j = i - 1;
int start = j - (targetCount - 1);
int k = strLastIndex - 1;
while (j > start) {
if (source[j--] != target[k--]) {
i--;
continue startSearchForLastChar;
}
}
return start - sourceOffset + 1;
}
}
只对外提供了int整形，String字符串两种参数的重载方法;
13、substring()函数
/**
* 截取当前字符串对象的片段，组成一个新的字符串对象
* beginIndex为截取的初始位置，默认截到len - 1位置
*/
public String substring(int beginIndex) {
if (beginIndex < 0) { //小于0抛异常
throw new StringIndexOutOfBoundsException(beginIndex);
}
int subLen = value.length - beginIndex; //新字符串的长度
if (subLen < 0) { //小于0抛异常
throw new StringIndexOutOfBoundsException(subLen);
}
//如果beginIndex是0，则不用截取，返回自己(非新对象)，否则截取0到subLen位置，不包括(subLen)
return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}
/**
* 截取一个区间范围
* [beginIndex,endIndex)，不包括endIndex
*/
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}
public CharSequence subSequence(int beginIndex, int endIndex) {
return this.substring(beginIndex, endIndex);
}
- substring函数是一个不完全闭包的区间，是[beginIndex,end)，不包括end位置;
- subString的原理是通过String的构造函数实现的;
14、concat()函数
/**
* String的拼接函数
* 例如:String str = "abc"; str.concat("def") output: "abcdef"
*
*/
public String concat(String str) {
int otherLen = str.length();//获得参数字符串的长度
if (otherLen == 0) { //如果长度为0，则代表不需要拼接，因为str为""
return this;
}
/****重点****/
int len = value.length; //获得当前对象的长度
//将数组扩容，将value数组拷贝到buf数组中，长度为len + str.lenght
char buf[] = Arrays.copyOf(value, len + otherLen);
str.getChars(buf, len); //然后将str字符串从buf字符数组的len位置开始覆盖，得到一个完整的buf字符数组
return new String(buf, true);//构建新的String对象，调用私有的String构造方法
}
15、replace、replaceAll类函数
public String replace(char oldChar, char newChar) {
if (oldChar != newChar) { //如果旧字符不等于新字符的情况下
int len = value.length; //获得字符串长度
int i = -1; //flag
char[] val = value; /* avoid getfield opcode */
while (++i < len) { //循环len次
if (val[i] == oldChar) { //找到第一个旧字符，打断循环
break;
}
}
if (i < len) { //如果第一个旧字符的位置小于len
char buf[] = new char[len]; 新new一个字符数组，len个长度
for (int j = 0; j < i; j++) {
buf[j] = val[j]; 把旧字符的前面的字符都复制到新字符数组上
}
while (i < len) { //从i位置开始遍历
char c = val[i];
buf[i] = (c == oldChar) ? newChar : c; //发生旧字符就替换，不想关的则直接复制
i++;
}
return new String(buf, true); //通过新字符数组buf重构一个新String对象
}
}
return this; //如果old = new ，直接返回自己
}
//替换第一个旧字符
String replaceFirst(String regex, String replacement) {
return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
}
//当不是正规表达式时，与replace效果一样，都是全体换。如果字符串的正则表达式，则规矩表达式全体替换
public String replaceAll(String regex, String replacement) {
return Pattern.compile(regex).matcher(this).replaceAll(replacement);
}
//可以用旧字符串去替换新字符串
public String replace(CharSequence target, CharSequence replacement) {
return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
}
从replace的算法中，我们可以发现，它不是从头开始遍历替换的，而是首先找到第一个要替换的字符，从要替换的字符开始遍历，发现一个替换一个;
16、matches()和contains()函数;
/**
* matches() 方法用于检测字符串是否匹配给定的正则表达式。
* regex -- 匹配字符串的正则表达式。
* 如：String Str = new String("www.snailmann.com");
* System.out.println(Str.matches("(.*)snailmann(.*)")); output:true
* System.out.println(Str.matches("www(.*)")); output:true
*/
public boolean matches(String regex) {
return Pattern.matches(regex, this); //实际使用的是Pattern.matches()方法
}
//是否含有CharSequence这个子类元素，通常用于StrngBuffer,StringBuilder
public boolean contains(CharSequence s) {
return indexOf(s.toString()) > -1;
}
17、split()函数
public String[] split(String regex, int limit) {
/* fastpath if the regex is a
(1)one-char String and this character is not one of the
RegEx's meta characters ".$|()[{^?*+\\", or
(2)two-char String and the first char is the backslash and
the second is not the ascii digit or ascii letter.
*/
char ch = 0;
if (((regex.value.length == 1 &&
".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
(regex.length() == 2 &&
regex.charAt(0) == '\\' &&
(((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
((ch-'a')|('z'-ch)) < 0 &&
((ch-'A')|('Z'-ch)) < 0)) &&
(ch < Character.MIN_HIGH_SURROGATE ||
ch > Character.MAX_LOW_SURROGATE))
{
int off = 0;
int next = 0;
boolean limited = limit > 0;
ArrayList<String> list = new ArrayList<>();
while ((next = indexOf(ch, off)) != -1) {
if (!limited || list.size() < limit - 1) {
list.add(substring(off, next));
off = next + 1;
} else { // last one
//assert (list.size() == limit - 1);
list.add(substring(off, value.length));
off = value.length;
break;
}
}
// If no match was found, return this
if (off == 0)
return new String[]{this};
// Add remaining segment
if (!limited || list.size() < limit)
list.add(substring(off, value.length));
// Construct result
int resultSize = list.size();
if (limit == 0) {
while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
resultSize--;
}
}
String[] result = new String[resultSize];
return list.subList(0, resultSize).toArray(result);
}
return Pattern.compile(regex).split(this, limit);
}
public String[] split(String regex) {
return split(regex, 0);
}
18、join()函数
/**
* join方法是JDK1.8加入的新函数，静态方法
* 这个方法就是跟split有些对立的函数,不过join是静态方法
* delimiter就是分割符，后面就是要追加的可变参数，比如str1,str2,str3
*
* 例子：String.join(",",new String("a"),new String("b"),new String("c"))
* output: "a,b,c"
*/
public static String join(CharSequence delimiter, CharSequence... elements) {
Objects.requireNonNull(delimiter); //就是检测是否为Null,是null,抛异常
Objects.requireNonNull(elements); //不是就返回自己，即nothing happen
// Number of elements not likely worth Arrays.stream overhead.
StringJoiner joiner = new StringJoiner(delimiter); //嗯，有兴趣自己看StringJoiner类源码啦
for (CharSequence cs: elements) {
joiner.add(cs); //既用分割符delimiter将所有可变参数的字符串分割，合并成一个字符串
}
return joiner.toString();
}
- Java 1.8加入的新功能，有点跟split对立的意思，是个静态方法;
- 有两个重载方法，一个是直接传字符串数组，另个是传集合。传集合的方式是一个好功能，很方遍将集合的字符串元素拼接成一个字符串;
19、trim()函数
/**
* 去除字符串首尾部分的空值，如,' ' or " ",非""
* 原理是通过substring去实现的，首尾各一个指针
* 头指针发现空值就++，尾指针发现空值就--
* ' '的Int值为32，其实不仅仅是去空的作用，应该是整数值小于等于32的去除掉
*/
public String trim() {
int len = value.length; //代表尾指针，实际是尾指针+1的大小
int st = 0; //代表头指针
char[] val = value; /* avoid getfield opcode */
//st<len,且字符的整数值小于32则代表有空值，st++
while ((st < len) && (val[st] <= ' ')) {
st++;
}
//len - 1才是真正的尾指针，如果尾部元素的整数值<=32,则代表有空值，len--
while ((st < len) && (val[len - 1] <= ' ')) {
len--;
}
//截取st到len的字符串(不包括len位置)
return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}
20、toString()函数
//就是返回自己
public String toString() {
return this;
}
21、toCharArray()函数
/**
* 就是将String转换为字符数组并返回
*/
public char[] toCharArray() {
// Cannot use Arrays.copyOf because of class initialization order issues
char result[] = new char[value.length]; //定义一个要返回的空数组，长度为字符串长度
System.arraycopy(value, 0, result, 0, value.length); //拷贝
return result; //返回
}
22、toLowerCase()、toUpperCase()函数
//en,好长,下次再更新吧，先用着吧
public String toLowerCase(Locale locale) {
if (locale == null) {
throw new NullPointerException();
}
int firstUpper;
final int len = value.length;
/* Now check if there are any characters that need to be changed. */
scan: {
for (firstUpper = 0 ; firstUpper < len; ) {
char c = value[firstUpper];
if ((c >= Character.MIN_HIGH_SURROGATE)
&& (c <= Character.MAX_HIGH_SURROGATE)) {
int supplChar = codePointAt(firstUpper);
if (supplChar != Character.toLowerCase(supplChar)) {
break scan;
}
firstUpper += Character.charCount(supplChar);
} else {
if (c != Character.toLowerCase(c)) {
break scan;
}
firstUpper++;
}
}
return this;
}
char[] result = new char[len];
int resultOffset = 0; /* result may grow, so i+resultOffset
* is the write location in result */
/* Just copy the first few lowerCase characters. */
System.arraycopy(value, 0, result, 0, firstUpper);
String lang = locale.getLanguage();
boolean localeDependent =
(lang == "tr" || lang == "az" || lang == "lt");
char[] lowerCharArray;
int lowerChar;
int srcChar;
int srcCount;
for (int i = firstUpper; i < len; i += srcCount) {
srcChar = (int)value[i];
if ((char)srcChar >= Character.MIN_HIGH_SURROGATE
&& (char)srcChar <= Character.MAX_HIGH_SURROGATE) {
srcChar = codePointAt(i);
srcCount = Character.charCount(srcChar);
} else {
srcCount = 1;
}
if (localeDependent ||
srcChar == '\u03A3' || // GREEK CAPITAL LETTER SIGMA
srcChar == '\u0130') { // LATIN CAPITAL LETTER I WITH DOT ABOVE
lowerChar = ConditionalSpecialCasing.toLowerCaseEx(this, i, locale);
} else {
lowerChar = Character.toLowerCase(srcChar);
}
if ((lowerChar == Character.ERROR)
|| (lowerChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {
if (lowerChar == Character.ERROR) {
lowerCharArray =
ConditionalSpecialCasing.toLowerCaseCharArray(this, i, locale);
} else if (srcCount == 2) {
resultOffset += Character.toChars(lowerChar, result, i + resultOffset) - srcCount;
continue;
} else {
lowerCharArray = Character.toChars(lowerChar);
}
/* Grow result if needed */
int mapLen = lowerCharArray.length;
if (mapLen > srcCount) {
char[] result2 = new char[result.length + mapLen - srcCount];
System.arraycopy(result, 0, result2, 0, i + resultOffset);
result = result2;
}
for (int x = 0; x < mapLen; ++x) {
result[i + resultOffset + x] = lowerCharArray[x];
}
resultOffset += (mapLen - srcCount);
} else {
result[i + resultOffset] = (char)lowerChar;
}
}
return new String(result, 0, len + resultOffset);
}
public String toLowerCase() {
return toLowerCase(Locale.getDefault());
}
public String toUpperCase(Locale locale) {
if (locale == null) {
throw new NullPointerException();
}
int firstLower;
final int len = value.length;
/* Now check if there are any characters that need to be changed. */
scan: {
for (firstLower = 0 ; firstLower < len; ) {
int c = (int)value[firstLower];
int srcCount;
if ((c >= Character.MIN_HIGH_SURROGATE)
&& (c <= Character.MAX_HIGH_SURROGATE)) {
c = codePointAt(firstLower);
srcCount = Character.charCount(c);
} else {
srcCount = 1;
}
int upperCaseChar = Character.toUpperCaseEx(c);
if ((upperCaseChar == Character.ERROR)
|| (c != upperCaseChar)) {
break scan;
}
firstLower += srcCount;
}
return this;
}
/* result may grow, so i+resultOffset is the write location in result */
int resultOffset = 0;
char[] result = new char[len]; /* may grow */
/* Just copy the first few upperCase characters. */
System.arraycopy(value, 0, result, 0, firstLower);
String lang = locale.getLanguage();
boolean localeDependent =
(lang == "tr" || lang == "az" || lang == "lt");
char[] upperCharArray;
int upperChar;
int srcChar;
int srcCount;
for (int i = firstLower; i < len; i += srcCount) {
srcChar = (int)value[i];
if ((char)srcChar >= Character.MIN_HIGH_SURROGATE &&
(char)srcChar <= Character.MAX_HIGH_SURROGATE) {
srcChar = codePointAt(i);
srcCount = Character.charCount(srcChar);
} else {
srcCount = 1;
}
if (localeDependent) {
upperChar = ConditionalSpecialCasing.toUpperCaseEx(this, i, locale);
} else {
upperChar = Character.toUpperCaseEx(srcChar);
}
if ((upperChar == Character.ERROR)
|| (upperChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {
if (upperChar == Character.ERROR) {
if (localeDependent) {
upperCharArray =
ConditionalSpecialCasing.toUpperCaseCharArray(this, i, locale);
} else {
upperCharArray = Character.toUpperCaseCharArray(srcChar);
}
} else if (srcCount == 2) {
resultOffset += Character.toChars(upperChar, result, i + resultOffset) - srcCount;
continue;
} else {
upperCharArray = Character.toChars(upperChar);
}
/* Grow result if needed */
int mapLen = upperCharArray.length;
if (mapLen > srcCount) {
char[] result2 = new char[result.length + mapLen - srcCount];
System.arraycopy(result, 0, result2, 0, i + resultOffset);
result = result2;
}
for (int x = 0; x < mapLen; ++x) {
result[i + resultOffset + x] = upperCharArray[x];
}
resultOffset += (mapLen - srcCount);
} else {
result[i + resultOffset] = (char)upperChar;
}
}
return new String(result, 0, len + resultOffset);
}
public String toUpperCase() {
return toUpperCase(Locale.getDefault());
}
23、String 为什么是不可变的
- String 不可变是因为在 JDK 中 String 类被声明为一个 final 类，且类内部的 value 字节数组也是 final 的，只有当字符串是不可变时字符串池才有可能实现，字符串池的实现可以在运行时节约很多 heap 空间，因为不同的字符串变量都指向池中的同一个字符串;
- 如果字符串是可变的则会引起很严重的安全问题，譬如数据库的用户名密码都是以字符串的形式传入来获得数据库的连接，或者在 socket 编程中主机名和端口都是以字符串的形式传入，因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子改变字符串指向的对象的值造成安全漏洞;
- 因为字符串是不可变的，所以是多线程安全的，同一个字符串实例可以被多个线程共享，这样便不用因为线程安全问题而使用同步，字符串自己便是线程安全的;
- 因为字符串是不可变的所以在它创建的时候 hashcode 就被缓存了，不变性也保证了 hash 码的唯一性，不需要重新计算，这就使得字符串很适合作为 Map 的键，字符串的处理速度要快过其它的键对象，这就是 HashMap 中的键往往都使用字符串的原因;
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tZR2OxM6-1669736788892)(https://s3.51cto.com/oss/202109/12/c10e82bfc985726fde78d69add19fa77.jpg)]
总结
StringBuffer、StringBuilder和String一样，也用来代表字符串。String类是不可变类，任何对String的改变都 会引发新的String对象的生成;StringBuilder则是可变类，任何对它所指代的字符串的改变都不会产生新的对象，而StringBuilder则是线程安全版的StringBuilder;
04 Java 并发编程
→ 并发与并行
什么是并发、什么是并行
并发与并行的区别
→ 什么是线程，与进程的区别
线程的实现、线程的状态、优先级、线程调度、创建线程的多种方式、守护线程
线程与进程的区别
→ 线程池
自己设计线程池、submit() 和 execute()、线程池原理
为什么不允许使用 Executors 创建线程池
→ 线程安全
死锁、死锁如何排查、线程安全和内存模型的关系
→ 锁
CAS、乐观锁与悲观锁、数据库相关锁机制、分布式锁、偏向锁、轻量级锁、重量级锁、monitor、
锁优化、锁消除、锁粗化、自旋锁、可重入锁、阻塞锁、死锁
→ 死锁
什么是死锁
死锁如何解决
→ synchronized
synchronized 是如何实现的？
synchronized 和 lock 之间关系、不使用 synchronized 如何实现一个线程安全的单例
synchronized 和原子性、可见性和有序性之间的关系
→ volatile
happens-before、内存屏障、编译器指令重排和 CPU 指令重
volatile 的实现原理
volatile 和原子性、可见性和有序性之间的关系
有了 symchronized 为什么还需要 volatile
→ sleep 和 wait
→ wait 和 notify
→ notify 和 notifyAll
→ ThreadLocal
→ 写一个死锁的程序
→ 写代码来解决生产者消费者问题
→ 并方包
Thread、Runnable、Callable、ReentrantLock、ReentrantReadWriteLock、Atomic*、Semaphore、CountDownLatch、ConcurrentHashMap、Executors
（String类之后的代码以后总结）
![[世界杯]根据赔率计算各种组合可能性与赔率](https://img-blog.csdnimg.cn/7f2a3967841e4c8f80462733d5178590.png)
