关于java:熬了2个通宵终于把java基础类知识总结全了看完可以进大厂了

25次阅读

共计 10874 个字符，预计需要花费 28 分钟才能阅读完成。

该文章是分享对于 Java 中根底广泛常识类的总结之 SE 方面的常识，是我在学习过程中的笔记以及前期整顿好的总结，实用性很高，心愿对大家有帮忙。

接下来开始进行分享：

目录

  1. 字符串相干的类

       1.1 String

   1.2 String 的罕用办法

   1.3 StringBuffer 与 StringBuilder

  2. 日期工夫

       2.1 JDK8 之前的日期工夫

   2.2JDK 中的日期和工夫

   2.3 Instant（刹时）2.4 DateTimeFormatter

3. 比拟

  1. System, Math, BigInteger 和 BigDecimal

       4.1 System

   4.2Math

   4.3BigInteger 与 Bigdecimal

   4.4 集体总结的其余类
  2. 字符串相干的类
    1.1 String
    String 是一个 final 类，代表不可变的字符序列。不可被继承。

String 对象的字符内容是存储在一个字节数组 byte[]中。JDK1.8 中存储的是 char[]留神区别。

String 实现了 Serializable 接口，反对序列化

实现了 Comparable 接口，示意能够比拟大小

通过字面量的形式（区别于 new）给一个 String 赋值，此时的字符串值在字符串常量池中（和办法区在同一个中央）

当 String 进行连贯操作、从新赋值、replace()等操作时，会从新指定内存区域赋值，不应用原有的 value 进行赋值

String str = “hello”; // 字面量赋值

String s1 = new String();// 实质上为，this.value = new byte[0]

String s2 = new String(String str); // 放一个 String 类型的参数

String s3 = new String(byte[] a);

String s3 = new String(byte[] a,int off,int length);// 构造方法，放 char[]也是能够的

思考如下代码：

String s1 = “javaEE”; String

s2 = “javaEE”; String

s3 = new String(“javaEE”); String

s4 = new String(“javaEE”);

这里，s1==s2 为 true，s1==s3, s1==s4, s3==s4 均为 false

起因如下：

实际上，通过构造方法来结构 String 会指向 value，而 value 再去指向字符串常量。即 String s3 = new String(“javaEE”); 在内存中创立了两个对象：一个是堆中的 value 构造，一个是常量池中的字符串数据。

intern()返回字符串对象的标准示意。这里会返回一个字符串常量。内存空间在常量池中。

​另外，有一个对于形参实参方面的须要留神：

public class StringTest {

String str = new String("hello");

char[]ch = {'t','e','s','t'};

public void change(String str,char ch[]){

    str = "hello,world";

    ch[0]='b';

}

public static void main(String[] args) {StringTest st = new StringTest();

    st.change(st.str, st.ch);

    System.out.println(st.str);

    System.out.println(st.ch);

}

}

这里的后果为：”hello” /n “best”

相似于 C 语言中，依据指针进行替换两个指针中的内容，值传递过程中，理论参数的值传入形参，造成正本，办法完结后形参隐没，理论参数值并没有扭转。

另外还有一点须要留神：

String str = null; // 这个指针指向 null，并没有实例化

System.out.println(str);// 输入”null“

System.out.println(str.length());// 异样

1.2 String 的罕用办法
将 String 的罕用办法总结如下（未总结的请本人查阅）：

同时还须要留神的一些办法如下，重要水平顺次升高，但仍需把握：

留神：上表下部的 4 个 int 办法如果未找到，返回的均为 -1

再举例一些办法（一些可能不太罕用的）：

String regex 个别都用正则表达式示意

String 转换为根本数据类型或包装类
String 转换为根本数据类型或包装类

调用包装类的静态方法：对应的类型，如要转 int，调用 Integer.parseInt(str)

根本数据类型、包装类转为 String

调用 String 重载的 valueOf(xxx)

另外

int num = 100;

String str = num+””; // 存在变量才会返回堆中，如果常量相加则会返回常量池

这样也能够转换为 String，然而须要留神，该类型是在堆中生成了 value 数组，和 new String 的形式相似。

String 与 char[], byte[]的互相转换

String–>char[]：调用 String.toCharArray 即返回了一个 char[]

char[]或 byte[] –> String：间接调用结构器

String–>byte[]：调用 String.getBytes 即返回了一个 byte[]，应用默认的字符集（例如 ”gbk、utf-8″ 等）进行转换。

getBytes(Charset charset) 应用给定的 charset 将该 String 编码为字节序列，将后果存储到新的字节数组中。不同的编码方式返回的可能不同。

String 与 char[], byte[]的互相转换
String

–>char[]：调用 String.toCharArray 即返回了一个 char[]

char[]或 byte[] –> String：间接调用结构器

String–>byte[]：调用 String.getBytes 即返回了一个 byte[]

，应用默认的字符集（例如 ”gbk、utf-8″ 等）进行转换。

getBytes(Charset charset)应用给定的 charset 将该 String 编码为字节序列，将后果存储到新的字节数组中。不同的编码方式返回的可能不同。

1.3 StringBuffer 与 StringBuilder
String 与 StringBuffer, StringBuilder 之间的异同？

String：不可变的字符序列，留神了解不可变性

StringBuffer：可变的字符序列，线程平安，效率较低（都是同步办法）

StringBuilder：jdk5.0 新增，可变的字符序列，线程不平安，效率高

final byte[] value //String 中的

byte[] value //StringBuffer 和 StringBuilder 中的

StringBuffer
String str = new String();// new char[0]

String str1 = new String(“abc”);//new char[] {‘a’,’b’,’c’};

StringBuffer sb = new StringBuffer();//new char[16] 初始容量为 16

sb.append(‘a’);// value[0]=’a’; 顺次进行

StringBuffer sb1 = new StringBuffer(“abc”);//new char[“abc”.length()+16]

System.out.println(sb.length()); //return 的是 count, 每 append 操作 count+=len，这里为 1，并不是 value.length

接下来看 StringBuffer 的扩容机制

简述：个别状况下，若容量不够的时候，裁减为原来容量的 2 倍 +2，同时将原有数组的元素复制到新数组中 JDK15 中，源码曾经扭转，为：

private int newCapacity(int minCapacity) {

int oldLength = value.length;

int newLength = minCapacity << coder;

int growth = newLength - oldLength;

int length = ArraysSupport.newLength(oldLength, growth, oldLength + (2 << coder));

if (length == Integer.MAX_VALUE) {throw new OutOfMemoryError("Required length exceeds implementation limit");

}

return length >> coder;

}

ArraysSupport.newLength 这里就是比拟 growth 和 oldLength + (2 << coder)谁大，大者加上 oldLength（这样就成了 2 倍 +2）。这里 coder 原始值为 0，我只看了 append 相干源码，coder 值并没有变，其余源码没有看，留神可能产生扭转。

JDK1.8 中是间接进行移位操作 + 2 的，现版本已更新。

StringBuffer 罕用办法

StringBuilder 的 API 与之雷同，只是线程不平安，没有保障同步。

  1. 日期工夫
    2.1 JDK8 之前的日期工夫
    java.lang.System 中的 static long currentTimeMillis() 返回以后工夫与 1970 年 1 月 1 日 00：00：00 之间的时间差（以毫秒为单位）。实用于计算时间差。（工夫戳）

计算世界工夫的次要规范有：UTC, GMT, CST

java.util.Date

java.sql 中也有一个 Date 类，是 java.util.Date 的子类

示意特定的工夫，准确到毫秒

两个结构器的应用：

结构器一：创立一个以后工夫的 Date 对象

Date date = new Date();

System.out.println(date);//sout 自带.toString，输入：Mon Apr 26 01:16:00 CST 2021

System.out.println(date.getTime());// 返回以后 date 对象对应的工夫戳

//Date 中的无参结构源码

public Date() {

    this(System.currentTimeMillis());

}

结构器二：创立了一个指定工夫的 Date 对象

Date date1 = new Date(1619371381884L); // 轻易找了个工夫戳

System.out.println(date1);

结构器的其余办法均已过期，不倡议应用。

java.sql.Date 对应的是数据库中的日期工夫类，个别在数据库交互时应用

java.sql.Date date2 = new java.sql.Date(1619371381884L); //2021-04-26System.out.println(date2);

该类没有无参结构。输入模式不同。

两种 Date 互转：

Date date3 = (Date)date2; // 子类转父类

System.out.println(date3);

java.sql.Date date4 = new java.sql.Date(new Date().getTime()); // 父类转子类，不能强制类型转换

java.text.SimpleDateFormat
容许进行格式化：日期 –> 文本，解析：文本 –> 日期

格式化：

解析：

Date parse(String text, ParsePosition pos) 从字符串中解析文本以产生一个 Date。

pattern 举例如下图：

demo1 默认模式：

SimpleDateFormat sdf = new SimpleDateFormat();

Date date = new Date();

String format = sdf.format(date);

System.out.println(date); //Mon Apr 26 02:38:11 CST 2021

System.out.println(format); //2021/4/26 上午 2:38

// 解析过程

String str = “2021/4/16 上午 12:38”; // 格局有要求

Date date1 = sdf.parse(str);

System.out.println(date1); //Fri Apr 16 00:38:00 CST 2021

应用指定模式：

SimpleDateFormat sdf1 = new SimpleDateFormat(“yyyy,MM,dd HH:mm:ss aaa”);

String str2 = sdf1.format(date);

System.out.println(str2); //2021,04,26 02:47:22 上午

// 解析的话也须要按这种模式进行，失常模式通常为”yyyy-MM-dd hh:mm:ss“

String str3 =”2021,04,26 02:47:22 上午 ”;

Date date2 = sdf1.parse(str3);

System.out.println(date2); //Mon Apr 26 02:47:22 CST 2021

Calendar
Calendar 是一个抽象类，次要用于实现日期字段之间的互相操作。

Calendar 提供了一品种办法 getInstance，用于获取此类型的个别有用的对象。Calendar 的 getInstance 办法返回一个 Calendar 对象，其日历字段已应用以后日期和工夫进行初始化：

Calendar rightNow = Calendar.getInstance(); 调用了它的子类 GregorianCalendar 的结构器

Calendar calendar = Calendar.getInstance();

System.out.println(calendar.getClass());//class java.util.GregorianCalendar

Calendar 对象能够产生实现特定语言和日历格调的日期工夫格式化所需的所有日历字段值（例如日语 – 公历，日语 – 繁体）。Calendar 定义某些日历字段返回的值的范畴及其含意。例如，日历零碎第一个月的值为 MONTH == JANUARY 为所有日历。其余值由具体的子类定义，如 ERA。无关详细信息，请参阅各个实体文档和子类文档。

罕用办法：

void set(int field, int value) 将给定的日历字段设置为给定的值。

void add(int field, int amount) 依据日历的规定，将指定的工夫量增加或减去给定的日历字段。

final Date getTime() 返回一个 Date 示意此物体 Calendar 的工夫值

void setTime(Date date) 应用给定的 Date 设置此日历的工夫

demo 如下：

Calendar calendar = Calendar.getInstance();

//get

int i = calendar.get(Calendar.DAY_OF_MONTH);

System.out.println(i);// 获取这个月的第几天，本实例为 26，以后工夫 4 /26

System.out.println(calendar.get(Calendar.DAY_OF_YEAR));// 相似上一个

//set

calendar.set(Calendar.DAY_OF_MONTH,12);

int j = calendar.get(Calendar.DAY_OF_MONTH); //12，扭转了

System.out.println(j);

//add

calendar.add(Calendar.DAY_OF_MONTH,3);

j = calendar.get(Calendar.DAY_OF_MONTH); //15，还是扭转，减少 3 天

System.out.println(j);

//getTime

Date date = calendar.getTime(); //Thu Apr 15 03:10:28 CST 2021，返回工夫戳

System.out.println(date);

//setTime：Date –> Calendar

calendar.setTime(date);// 间接操作以后对象

int days = calendar.get(Calendar.DAY_OF_MONTH); //15

System.out.println(days);

获取月份时，一月是 0；获取星期几时，周日是 1

2.2 JDK8 中的日期工夫
因为之前的类具备 4 个问题：

可变性：例如 Calendar 的 set，它们都是可变的

偏移性：Date 中的年份都是从 1900 开始，月份从 0 开始，如果调用有参结构，会产生偏移。

格式化：格式化只对 Date 有用，对于 Calendar 则不行

线程不平安

java8 中的 java.time API 曾经纠正了过来的缺点。

工夫日期的相干 packge：

LocalDate, LocalTime, LocalDateTime 是其中比拟重要的几个类，他们的实例均为不可变实例，应用 ISO-8601 日历零碎。

ISO-8601 日历零碎是国际标准话组织制订的古代公民的日期和工夫的表示法（公历）

相干办法：

下面四个档次其实就是结构、get、set、加减操作。和 Calendar 相似。

localDate 是一个 final 类，有构造方法，相似 String, Math，举例以后工夫生成：

LocalDate localDate = LocalDate.now(); //2021-04-27

LocalTime localTime = LocalTime.now(); //19:24:37.171676500

LocalDateTime localDateTime = LocalDateTime.now(); //2021-04-27T19:24:37.171676500

举例设置指定工夫：

LocalDateTime localDateTime1 = LocalDateTime.of(2020,10,6,13,12,13);//2020-10-06T13:12:13

举例相干 get 操作：

System.out.println(localDateTime.getMonth()); //APRIL

System.out.println(localDateTime.getMonthValue()); //4

这里的月份是从 1 开始的。

.with 操作（设置相干属性）：

LocalDate localDate1 = localDate.withDayOfMonth(22); //2021-04-22

System.out.println(localDate); //2021-04-27

System.out.println(localDate1);

locatDate 实例自身并没有发生变化（不可变性）。

加减操作：

LocalDate localDate2 = localDate.plusDays(4); //localDate 为 4 -27

System.out.println(localDate2);//2021-05-01

// 减的话行将 Plus 换位 minus

2.3 Instant（刹时）
工夫线上的一个刹时点，可能用来记录应用程序中的事件工夫戳。

同样是起始于 1970 年 1 月 1 日 00：00：00 的一个工夫戳（纳秒级）。

相干办法：

工夫规范次要有：UTC, GMT, CST，UTC 工夫与伦敦本地工夫雷同，与北京相差 8 个小时（早了 8 个小时）

Instant instant = Instant.now();

System.out.println(instant); //2021-04-27T11:45:00.321544Z，理论工夫 19：45，相差 8 个小时

偏移利用：

OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));

System.out.println(offsetDateTime); //2021-04-27T19:48:17.448368100+08:00

返回工夫戳（毫秒数）：

System.out.println(instant.toEpochMilli());//1619524168468

设置特定工夫，和 Date 相似：

Instant instant1 = Instant.ofEpochMilli(1619524168468L); //2021-04-27T11:49:28.468Z，这里的工夫就是毫秒级的了

System.out.println(instant1);

2.4 DateTimeFormatter

三种预约义的规范格局：

DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;

// 格式化：日期 –> 字符串

LocalDateTime localDateTime = LocalDateTime.now();

String str = dateTimeFormatter.format(localDateTime); // 将以后工夫格式化

System.out.println(str); //2021-04-27T19:59:19.0153049

// 解析：字符串 –> 日期

TemporalAccessor temporalAccessor = dateTimeFormatter.parse(“2021-04-27T19:59:19.0153049”);

System.out.println(temporalAccessor);//{},ISO resolved to 2021-04-27T19:59:19.015304900

本地化相干的格局：

DateTimeFormatter format = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);

//SHORT 2021/4/27 下午 8:09, MEDIUM 2021 年 4 月 27 日 下午 8:10:02,

// 在 java15 中 LONG 会异样，1.8 不会，DateTime 中没有 FULL,Date 中有

String str1 = format.format(localDateTime);

System.out.println(str1);

自定义格局（相似于 SimpleDateFormat）：

DateTimeFormatter format = DateTimeFormatter.ofPattern(“yyyy-MM-dd hh:mm:ss”);

String str1 = format.format(localDateTime); //2021-04-27 08:21:52

System.out.println(str1);

TemporalAccessor temporalAccessor1 = format.parse(str1);

System.out.println(temporalAccessor1);

//{MicroOfSecond=0, HourOfAmPm=8, MilliOfSecond=0, NanoOfSecond=0, MinuteOfHour=21, SecondOfMinute=52},ISO resolved to 2021-04-27

解析同下面即可，留神解析时须要一个 TemporalAccessor 转承。

其余的一些 API（不再具体赘述）：

以上三种 Date 之间的转换：

  1. 比拟器
    这里牵扯到对象的比拟

实现 Comparable 接口（天然排序），重写 compareTo()办法，重写的规定是：以后对象 this 大于形参对象 obj，返回正整数；this 小于，返回负整数；this 等于，返回 0；

应用 Comparator 接口（定制排序）

实用于该类型没有实现 Comparable 接口，且不不便批改代码；或者实现了 Comparable 接口然而排序规定不适宜以后操作

比照：

Comparable 接口的形式能够保障类的对象在任何地位都能够实现比拟

Comparator 接口属于临时性的比拟

对于利用在之前的博客中已有实现，可参考

（Set, Map, Collections 工具类）JAVA 汇合框架二

  1. System, Math, BigInteger 和 BigDecimal

4.1 System

java.lang.System

成员变量：in, out ,err 三个，别离代表规范输出流（键盘输入），规范输入流（显示器），规范谬误输入流（显示器）

static long currentTimeMillis() 返回以后工夫（以毫秒为单位）。表白格局同工夫戳。

static void exit(int status) 终止以后运行的 Java 虚拟机。status 为 0 时代表失常退出，非零则为异样退出。

static void gc() 运行垃圾回收器。申请零碎进行垃圾回收。

static String getProperty(String key) 获取指定键批示的零碎属性。对于罕用的 key：

4.2 Math

以上为 Math 罕用办法总结。可见开发文档。

4.3 BigInteger 与 BigDecimal
BigInteger
构造方法：

BigInteger 提供所有 java 的根本整数操作符的对应物，并提供 java.lang.Math 的所有相干办法，另外，还提供一下运算：模算术，GCD 计算，质数测试，素数生成，位操作等。

![上传中 …]()

BigDecimal

Float 和 Double 的精度不能满足用户需要时，能够应用 BigDecimal

构造方法：

BigDecimal(double val) 将 double 转换为 BigDecimal，这是 double 的二进制浮点值的准确十进制示意。

BigDecimal(String val) 将 BigDecimal 的字符串示意 BigDecimal 转换为 BigDecimal。

还有很多，只举例了两种罕用的。

加减乘除操作相似于 BigInteger，阐明一下 devide：

scale 即保留多少位小数，上下文设置用的不多不再赘述。

几种舍入模式：

其中，有些翻译不够精确，解释一下：

ROUND_UP，即向上舍。0.1203456789, 当精度为 3 的时候，依照 ROUND_UP 模式，后果是 0.121

ROUND_DOWN 即向下舍。

而 ROUND_HALF_EVEN，像邻近的偶数方向舍。

这几个能够参考对应英文进行了解。

4.4 集体总结的其余类

其实常常用到的还有 Ramdom，生存中常常用到随机数。

例如取一个随机整数。

Random r1 = new Random();

int i = r1.nextInt(100); // 取 0 到 100 的随机整数，无 100

其余办法都是与之类似的，具体可参考开发文档。

以上就是明天 Java 中根底广泛常识类的总结之 SE 方面的常识的分享，感激大家观看，也欢送大家交换探讨，该文章若有不正确的中央，心愿大家多多包涵。

若对大家有帮忙，给个赞哦~，你们的

正文完
java
发表至： java
2021-04-29
 0
Spring-Boot-2-实战mock测试你的web应用
关于java:算法
关于java:Java中的三大特性-超详细篇
关于java:面试官JDKJREJVM-三者什么关系