jdk源码阅读第一天

最新推荐文章于 2022-10-17 11:45:53 发布
最新推荐文章于 2022-10-17 11:45:53 发布
阅读量608 收藏 1
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qxf1374268/article/details/79325242
版权

jdk源码项目架构

String类

  • String类位于java.lang.String包下面。
package java.lang;

import java.io.ObjectStreamField;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Formatter;
import java.util.Locale;
import java.util.Objects;
import java.util.StringJoiner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
  • String类的开始引入的类
public final class String
    //继承了三个父类接口：Serializable,Comparable,CharSequence
    implements java.io.Serializable, Comparable<String>, CharSequence {

    private final char value[];


    private int hash; // Default to 0


    private static final long serialVersionUID = -6849794470754667710L;
  • String类的类修饰词是final，意味着String类不能被继承，所以我们只能调用String类
  • String类的上层接口有三个，分别是Serializable，Comparable，CharSequence
  • 首先，是Serializable接口，我去看了下源码，发现只是定义了一个接口：
package java.io;

public interface Serializable {
}
  • 而且，这个Serializable接口在我想修改的时候提示我：file is read only，说明java中定义的接口都是只读的，不允许修改
  • 我们知道，Serializable在java中是属于java.io.Serializable的，类通过实现Serializable接口以启用其序列化功能，未实现此接口的类将无法使其任何状态序列化和反序列化，可序列化类的所有子类型本身都是可序列化的，序列化接口没有方法或者字段，仅用于标识可序列化的语义。
  • 然后我们来看Comparable
package java.lang;
import java.util.*;

public interface Comparable<T> {
  public int compareTo(T o);
}
  • 此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo 方法被称为它的自然比较方法。
  • 当我想点击compareTo方法时，发现好多类都重写了这个方法
  • 然后，我们接下来看CharSequence接口
package java.lang;

import java.util.NoSuchElementException;
import java.util.PrimitiveIterator;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.IntConsumer;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;


public interface CharSequence {
    int length();
    char charAt(int index);
    CharSequence subSequence(int start, int end);
    public String toString();
    public default IntStream chars() {
        class CharIterator implements PrimitiveIterator.OfInt {
            int cur = 0;

            public boolean hasNext() {
                return cur < length();
            }

            public int nextInt() {
                if (hasNext()) {
                    return charAt(cur++);
                } else {
                    throw new NoSuchElementException();
                }
            }

            @Override
            public void forEachRemaining(IntConsumer block) {
                for (; cur < length(); cur++) {
                    block.accept(charAt(cur));
                }
            }
        }

        return StreamSupport.intStream(() ->
                Spliterators.spliterator(
                        new CharIterator(),
                        length(),
                        Spliterator.ORDERED),
                Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
                false);
    }
    public default IntStream codePoints() {
        class CodePointIterator implements PrimitiveIterator.OfInt {
            int cur = 0;

            @Override
            public void forEachRemaining(IntConsumer block) {
                final int length = length();
                int i = cur;
                try {
                    while (i < length) {
                        char c1 = charAt(i++);
                        if (!Character.isHighSurrogate(c1) || i >= length) {
                            block.accept(c1);
                        } else {
                            char c2 = charAt(i);
                            if (Character.isLowSurrogate(c2)) {
                                i++;
                                block.accept(Character.toCodePoint(c1, c2));
                            } else {
                                block.accept(c1);
                            }
                        }
                    }
                } finally {
                    cur = i;
                }
            }

            public boolean hasNext() {
                return cur < length();
            }

            public int nextInt() {
                final int length = length();

                if (cur >= length) {
                    throw new NoSuchElementException();
                }
                char c1 = charAt(cur++);
                if (Character.isHighSurrogate(c1) && cur < length) {
                    char c2 = charAt(cur);
                    if (Character.isLowSurrogate(c2)) {
                        cur++;
                        return Character.toCodePoint(c1, c2);
                    }
                }
                return c1;
            }
        }

        return StreamSupport.intStream(() ->
                Spliterators.spliteratorUnknownSize(
                        new CodePointIterator(),
                        Spliterator.ORDERED),
                Spliterator.ORDERED,
                false);
    }
}
  • CharSequence 是 char 值的一个可读序列。此接口对许多不同种类的 char 序列提供统一的只读访问。char 值表示 Basic Multilingual Plane (BMP) 或代理项中的一个字符。有关详细信息，请参阅 Unicode 字符表示形式。
  • 这个类我是看不太懂，需要以后加以补充
  • 还有一个serialVersionUID，这个变量我百度了一下，发现是这么解释的：

    serialVersionUID适用于Java的序列化机制。简单来说，Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是InvalidCastException。

  • 所以说，当一个类需要序列化和反序列化的时候，是不是就需要添加这个serialVersionUID了？有待我以后的补充

    测试类1
        String hello = new String("你好，hello");
    System.out.println(hello.charAt(1));
    hello.compareTo("你");
    hello.compareToIgnoreCase("你好，hello");

  • charAt方法时String类中的一个方法，它的作用是拿取String字符串的下标值，源码如下：

//最开始定义的是一个char数组，应该是将String放到char数组里面
private final char value[];
//定义一个整型变量hash，是String的hashCode，默认是0
private int hash;

//这个是String的无参构造方法
public String() {
    this.value = "".value;
  }

//这个是String的有参构造方法，获取传入的String字符串，然后将传入值的值给value数组，将传入值的hashCode给当前的hash值
public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
  }

public char charAt(int index) {
        //如果我们取的下标值小于0或者大于char数组的长度，就报字符串下标越界异常
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        //否则的话，返回下标的值
        return value[index];
    }

  • compareTo方法也是String类中的一个方法，是按字典顺比较两个字符串，那是什么字典顺序呢？先来看看Unicode字符串表示形式

    char 数据类型（和 Character 对象封装的值）基于原始的 Unicode 规范，将字符定义为固定宽度的 16 位实体。 char 值表示 Basic Multilingual Plane (BMP) 代码点，其中包括代理项代码点，或 UTF-16 编码的代码单元。int 值表示所有 Unicode 代码点，包括增补代码点。

  • 反正以上的我是没看太懂

  • 也就是说一个char类型对应一个整数。这个整数的大小就是字典顺序
  • 下面是compareTo的源码：
    //最开始定义的是一个char数组，应该是将String放到char数组里面
    private final char value[];

    public int compareTo(String anotherString) {
        //首先，定义一个整型变量len1,用于存储value数组的长度
        int len1 = value.length;
        //再定义一个整型变量len2,用于存储传入的值的长度
        int len2 = anotherString.value.length;
        //取两个值中的最小值
        int lim = Math.min(len1, len2);
        //将value值给v1数组
        char v1[] = value;
        //将传入的值给v2数组
        char v2[] = anotherString.value;

        //定义一个中间值k
        int k = 0;
        //当k小于最小的长度时，
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
           }
        // 如果短串相等，那么直接返回
        // 如：len1 = abc,len2 = ab
        // 由于短串全部相等，那么这里长度相剪：3-2 = 1， 1串大于二串
        // 如果：len1 = ab,len2 = abc, 2-3=-1, 1串小于二串
        // 如果正好相等，那么返回0；
        return len1 - len2;
    }
public int compareToIgnoreCase(String str) {
        return CASE_INSENSITIVE_ORDER.compare(this, str);
  }
  public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
    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();
            int n2 = s2.length();
            int min = Math.min(n1, n2);
            // 和compareTo一样的套路，对比最小串长度
            for (int i = 0; i < min; i++) {
                char c1 = s1.charAt(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) { // 还不相等，直接返回了。 对Unicode不熟悉，本人不知道在什么情况下会出现这种情况
                            // No overflow because of numeric promotion
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }
    }

读不下去了，先挖个坑放在这儿。。。

101之歌
关注
专栏目录
jdk源码阅读需要多长时间，看完直接跪服
m0_56662269的博客
06-22 529
流程描述 我们从bind函数开始： 1、首先创建了两个NioEventLoopGroup，这是初始化了两个线程组，这两个线程组根据命名可以知道一个是bossGroup，是服务器用来接收客户端的请求的，另一个是workGroup是用来处理NioServerSocketChannel的网络读写的。这两个线程组实际承担的是一个Reactor的角色。 2、第二步就是初始化一个ServerBootstrap，这是Netty用于启动NIO服务端的辅助启动类，目的是降低服务器开发的复杂度。ServerBootstrap的
JDK源码阅读第一天——java.lang.Appendable
a_man_floats的博客
01-22 1881
今天开始对jdk源码进行一次阅读，不知道自己能不能坚持到把所有常用的类，接口的源码看一遍。希望自己能够坚持下去。 jdk版本是1.8的，结合了jdk1.8的API进行阅读，先从常用的包 java.lang开始阅读。在java.lang包中一共有9个接口、37个类，等等。只看接口与类其他的不涉及到不看。 接口 接口 Appendable 概述 所有已知实现的子类 从以下版本开始 源代码
JDK源码阅读顺序
huangchunxia_1的博客
06-17 1633
转载自：https://blog.csdn.net/qq_21033663/article/details/79571506很多java开发的小伙伴都会阅读jdk源码，然而确不知道应该从哪读起。以下为小编整理的通常所需阅读的源码范围。 标题为包名，后面序号为优先级1-4，优先级递减 1、java.lang1) Object 1 2) String 1 3) AbstractStringBuilde...
如何阅读jdk源码？
weixin_34223655的博客
04-07 303
2019独角兽企业重金招聘Python工程师标准>>> ...
JDK源码-LinkedList源码
bangzun0726的博客
01-21 98
1，LinkedList： -1，实现了List接口，允许null元素。LinkedList还为链表开头和结尾提供了操作，所以使用LinekedList可以用作堆栈、列队或双端队列。 -2，LinkedList实现Deque接口，提供了基于队列的先进先出序列的实现。 -3，所有的操作都是按照双重链表来实现的。 -4，操作为非线程...
从0开始学Java第一天-Java学习资料-源码基础-Java源码-总结
最新发布
01-06
第一天了解Java语言发展史，Java是一门具有面向对象思想，并且支持跨平台，并且支持泛型的高级编程语言。1.学习并掌握如何从0搭建Java环境（JDK的下载，安装，卸载）；2.学会HelloWorld案例编写，知道如何解释该程序...
2022最新JDK源码深度解析小册，Github开源三天全站热榜第二
Q54665642ljf的博客
10-17 206
前几日闲来无事逛微信公众号时有幸看到了一位博主分享自己阅读开源框架源码的心得，看了之后也引发了我的一些深度思考。我们为什么要看源码？我们该怎么样去看源码？其中前者那位博主描述的我觉得很全了（如下图所示），就不做过多的赘述了，我这篇主要跟大家说说怎么去看源码。
druid1.2.8源码阅读：第一天
hefrankeleyn的博客
05-11 321
druid1.2.8源码阅读：第一天 文章目录druid1.2.8源码阅读：第一天一、背景二、在本地启动MySQL，并简单测试JDBC2.1 在本地启动MySQL2.2 JDK11 之后没有jre文件夹，手动生成jre文件夹2.3 简单测试JDBC三、druid1.2.8 的源码结构 一、背景 2022年5月7日，看到秦老师在群里发消息说要组织源码活动。我之前没有源码阅读的经历，为了让自己也具备源码阅读的经验，积极的参与的这次活动。 二、在本地启动MySQL，并简单测试JDBC 2.1 在本地启动M
刘意老师的Java基础教学源码（第一天到第八天）
06-06
这些文件名为"day01"到"day08"的压缩包内容，是刘意老师针对Java基础教学的源码，覆盖了从第一天到第八天的学习进度。这通常意味着它们包含了一系列逐步进阶的编程示例，旨在帮助初学者理解和掌握Java编程语言的基本...
jdk源码 jdk源码
02-01
jdk源码, jdk源码 jdk源码， jdk源码， jdk源码， jdk源码 jdk源码 jdk源码 jdk源码
JDK源码（sun包）
12-04
JDK源码（sun包）,版本jdk1.5，可用于关联查看源码。
jdk中文源码
11-18
jdk_1.6源码中文版。。
jdk源码（完整版）
04-19
jdk源码（完整版）。最新最全的jdk源码，网上基本上都是阉割版的
openjdk jdk源码
08-14
openjdk jdk源码，在研究JAVA本地方法源码时，这个是必须的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值