常用类

Posted 2022-01-18 Spring-_-Bear

第13章 常用类

460. 八大Wrapper类

• 除 Boolean 和 Character 外，其余包装类均继承父类 Number

461. 装箱和拆箱

• jdk 5 以前是手动装箱和拆箱，自动装箱底层调用的是对应包装类的 valueOf() 方法

// 手动装箱
Integer integer = Integer.valueOf(i);
// 手动拆箱
int ii = integer.intValue();

462. 包装类测试

Object object = true ? new Integer(1) : new Double(2.0);
// 三元运算符需要看作一个整体，故输出 1.0；if - else 分支结构则输出 1
System.out.println(object);

463. 包装类方法

/* 包装类转 String */
Integer i = 100;
// 方式 1
String str = i + "";
// 方式 2
String str = i.toString();
// 方式 3
String str = String.valueOf(i);

/* String 转包装类 */
String str = "123";
// 方式 1
Integer i = Integer.parseInt(str);
// 方式 2 
Integer i = new Integer(str);

464. Integer创建机制

Integer i = new Integer(1);
Integer ii = new Integer(1);
// false
System.out.println(i == ii);

Integer j = 1;
Integer jj = 1;
// true
System.out.println(j == jj);

Integer k = 128;
Integer kk = 128;
// false
System.out.println(k == kk);

• 自动装箱机制，在 [-128,127] 范围内直接返回，否则 new Integer(i)

public static Integer valueOf(int i) 
   if (i >= IntegerCache.low && i <= IntegerCache.high)
       return IntegerCache.cache[i + (-IntegerCache.low)];
   return new Integer(i);

465. Integer面试题

• 只要有基本数据类型与包装类型进行比较时，判断的是值是否相等

Integer i = 127;
int ii = 127;
// true
System.out.println(i == ii);

Integer j = 128;
int jj = 128;
// true
System.out.println(j == jj);

466. String结构剖析

• 字符串的字符使用 Unicode 字符编码，一个字符占两个字节（不区分字母还是汉字）
• UTF - 8 编码一个字母占 1 个字节，一个汉字占 3 个字节

467. String创建剖析

// 方式 1
String s1 = "lcx";
// 方式 2
String s2 = new String("lcx");

• 方式 1：先从常量池查找是否有 “lcx” 数据空间，如果有，直接将 s1 指向 “lcx”；没有则新建后指向，s1 最终指向的是常量池的空间地址
• 方式 2：先在堆中创建空间，维护了 String 的字段 value[] 属性，value 指向常量池的 “lcx” 空间；如果常量池没有 “lcx”，则新建；如果有，则通过 value 指向；s2 最终指向的是堆中的空间地址即 value 的地址

468. String测试题1

String a = "lcx";
String b = new String("lcx");
// true：a 指向常量池中 "lcx" 的地址，b.intern() 返回常量池中 "lcx" 的地址
System.out.println(a == b.intern());
// false：b 返回 String 类的字段 value[] 的地址
System.out.println(b == b.intern());

469. String测试题2

String s1 = new String("abc");
String s2 = new String("abc");
// false：s1，s2 -> 不同的 value[]
System.out.println(s1 == s2);
// true：引用到常量池的同一个地址
System.out.println(s1.intern()==s2.intern());

470. String对象特性1

// 只创建了一个字符串常量 "hello123"
String a = "hello" + "123";

// b -> 常量池的 "hello"
String b = "hello";
// c -> 常量池的 "123"
String c = "123";
// d -> 堆中 value，value 指向常量池中的 "hello123"
// 调用 StringBuilder 的 append 方法连接两次，然后再 new String()
String d = b + c;

• 常量相加看池，变量相加看堆

471. String对象特性2

// str 指定堆中的 value，value 指向常量池中的 "lcx"
String str = new String("lcx");
// 字符数组对象存放于堆中
final char[] ch = 'j','a','v','a';
public void change(String str, char[] ch) 
   str = "java";
   ch[0] = 'h';

public static void main(String[] args) 
   Test test = new Test();
   test.change(test.str, test.ch);
   // output result: lcx and hava
   System.out.print(test.str + " and ");
   System.out.println(test.ch);

• 内存布局图

472. String常用方法1

473. String常用方法2

• 调用字符串的 replace() 方法若忽略返回值，则原字符串并未发生变化
• 调用 compartTo() 方法时，若其中一个字符串是另一个字符串的子串，则返回长度之差

474. String常用方法3

475. StringBuffer结构剖析

• StringBuffer 也是一个 final 类，但其字段 value[] 不是 final 类型的；StringBuffer 线程安全
• String 保存的是字符串常量，value 引用到常量池；而 StringBuffer 保存的是字符串变量，数据存放在堆中

476. StringBuffer转换

• StringBuffer value[] 无参构造器默认初始化容量为 16；若构造器传入的是字符串，则初始化容量为字符串长度加上 16

477. StringBuffer方法

String str = null;

StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append(str);
// output:null
System.out.println(stringBuffer);

// NullPointerException
StringBuffer stringBuffer1 = new StringBuffer(str);
System.out.println(stringBuffer1);

478. StringBuffer练习

479. StringBuilder结构剖析

• StringBuilder 线程不安全，与 StringBuffer 使用方法基本一致

480. StringBuilder应用

481. Math方法

482. Arrays排序源码解读

Integer[] arrays = new Integer[]1, 31, 523, 452, 13, 64, 23, 75;
Arrays.sort(arrays, new Comparator<Integer>() 
   @Override
   public int compare(Integer o1, Integer o2) 
       return o1 - o2;
   
);
System.out.println(Arrays.toString(arrays));

483. Arrays模拟排序

import java.util.Arrays;
import java.util.Comparator;

/**
* @author Spring-_-Bear
* @version 2021-12-07 20:06
*/
public class Test 
   public static void main(String[] args) 
       Integer[] arrays = new Integer[]1, 31, 523, 452, 13, 64, 23, 75;
       Test test = new Test();
       // 面向接口编程 + 动态绑定（多态）
       test.bubble(arrays, new Comparator<Integer>() 
           @Override
           public int compare(Integer o1, Integer o2) 
               return o1 - o2;
           
       );
       System.out.println(Arrays.toString(arrays));
   

   public void bubble(Integer[] arrays, Comparator<Integer> comparator) 
       int len = arrays.length;
       for (int i = 0; i < len - 1; i++) 
           for (int j = 0; j < len - 1 - i; j++) 
               if (comparator.compare(arrays[j], arrays[j + 1]) > 0) 
                   int temp = arrays[j];
                   arrays[j] = arrays[j + 1];
                   arrays[j + 1] = temp;
               
           
       
   

484. Arrays其他方法

• 使用 Arrays.binarySearch() 方法对有序数组进行二分查找时，若不存在该元素，则返回该元素应在数组中位置下标的负值
• Arrays.asList() 可以将数组转换为 List 类型的集合，运行类型为 Arrays$ArrayList，即 Arrays 类中的静态内部类 ArrayList

485. Arrays课堂练习

486. System方法

487. 大数处理方案

BigDecimal bigDecimal = new BigDecimal("242131.24321335243234123");
// 为避免结果为无限循环小数，可对结果指定精度以解决 ArithmeticException
BigDecimal res = bigDecimal.divide(new BigDecimal(1.1), BigDecimal.ROUND_CEILING);
System.out.println(res);

488. Date介绍

489. Date应用案例

490. Calendar介绍

• Calendar 构造器私有，可通过 getInstance() 方法获取到一个实例

491. Calendar应用实例

492. 第三代日期使用

• JDK 1.0 中出现的 java.util.Date 类，大多数方法在 jdk 1.1 引入的 Calendar 类中已被弃用，但Calendar 也存在着以下一些问题

   1. 可变性：像日期和时间这样的类应该是不可变的
   2. 偏移性：年份从 1900 开始，月份从 0 开始
   3. 格式化：不能对 Calendar 进行格式化
   4. 线程不安全，不能处理闰秒（每隔两天，多出 1s）

• JDK 8 引入的第三代日期类：LocalDate(日期)、LocalTime(时间)、LocalDateTime(日期时间)

493. 第三代日期方法

LocalDateTime now = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy:MM:dd HH:mm:ss");
System.out.println(formatter.format(now));

494. String翻转

495. 注册处理题

496. 字符串统计

497. String内存布局测试题

498. 常用类阶段梳理