Java常用类
@## 包装类Wrapper
[^注意]: 只要有基本数据类型，判断的就是值是否相同
针对八种数据类型相应引用类型
| 基本数据类型 | 包装类 |
| :----------: | :-----------------: |
| boolean | Boolean |
| char | Character |
| byte |Byte(父类Number) |
| short |Short(父类Number)|
| int | Integer(父类Number) |
| long |Long(父类Number) |
| float |Float(父类Number)|
| double | Double(父类Number)|
### 包装类和基本数据的转换
- jdk5之前是手动装箱和拆箱
- 装箱：基本类型->包装类型，反之拆箱
- jkd5之后自动装箱和拆箱
- 自动装箱底层调用的是valueOf方法
#### 代码
```java
package com.xiaolin.wrapper;
/**
* @AuThor 林小鹿
* @version 1.0
*/
public class Integer01 {
@SuppressWarnings({"all"})
public static void main(String[] args) {
// jdk5前是手动装箱和拆箱
// 手动装箱 int->Integer
int n1 = 100;
Integer integer = new Integer(n1);
// 或者
Integer integer1 = Integer.valueOf(n1);
// 手动拆箱 Integer->int
int i = integer.intValue();
// jdk5后，就可以自动装箱和拆箱
// int->Integer
int n2 = 200;
Integer integer2 = n2;// 底层使用的是 Integer.valueOf(n2)
// 自动拆箱 Integer->int
int n3 = integer2;// 底层使用的是 valueOf()方法
}
}
```
---
## String类
> 内含有不可变序列final value[]数组
1. String 对象用于保存字符串，即是一组字符序列
2. 字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节
3. String类中有很多构造器构成了重载
4. String类 实现了接口 Serializable [可以窜行化：可以在网络传输]
5. String类 实现了接口 Comparable
6. String 是final 类，不能被其他的类继承
7. String 有属性 private final char value[]; 用于存放字符串内容
8. value 是一个final类型，不可修改（地址不可修改）**（注意）**
### 两种创建String对象区别
①：直接复制String s = "linxiaolu"
②：调用构造器 String s2 = new String("linxiaolu")
1. 方法一：先从常量池查看是否有“linxiaolu” 数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址
2. 方法二：先在堆中创建空间，里面维护了value属性，指向常量池的linxiaolu空间，如果常量池没有“linxiaolu”，重新创建，如果有，直接通过value执行。最终指向的是堆中的空间地址
**重要规则：**
- String c1 = "a" + "b";常量相加，看的是池
- String c1 = a + b;变量相加，是在堆中
[^注]: 看源码学习
### String类的常见方法
- equals：区分大小写，判断内容是否相等
- equalsIgnoreCase：忽略大小写的判断内容是否相等
- length：获取字符的个数，字符串的长度
- indexOf：获取字符在字符串中第1次出现的索引，索引从0开始如果找不到，返回-1
- lastIndexOf：获取字符在字符串中最后1次出现的索引，索引从0开始，如找不到，返回-1
- substring：截取指定范围的子串
- trim：去前后空格
- charAt：获取某索引处的字符，注意不能使用String这种方式获取下标下的元素
- toUpperCase：字符串转大写
- toLowerCase：字符串转小写
- concat：拼接字符串
- concat（）方法首先获取拼接字符串的长度，判断这个字符串长度是否为0（判断这个用来拼接的字符串是不是空串），如果是就返回原来的字符串（等于没有拼接）；否则就获取源字符串的长度，创建一个新的char[]字符数组，这个字符数组的长度是拼接字符串的长度与源字符串的长度之和，通过Arrays类的copyOf方法复制源数组，然后通过getChars方法将拼接字符串拼接到源字符串中，然后将新串返回。
- replace：替换字符串中的字符
- split：分割字符串，对于某些分割的字符，则需要转义符
- compareTo：比较两个字符串的大写
- toCharArray：转换成字符数组
- format：格式化字符串，%s 字符串；%c 字符；%d 整型；%.2f 浮点型
### String的增强类StringBuffer类
- 代表可变字符序列，可以对字符串内容进行增删
- 很多方法与String相同，但StringBuffer是可变长度
- 是一个容器
### StringBufferVS String
- String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低// private final char value[];
- StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer都更新实际上可以更新内容，不用每次更新地址，效率较高 (不用每次都创建新对象) // char[] value;
### StringBuffer与String相互转换
```java
package com.xiaolin.stringbuffer;
/**
* @author 林小鹿
* @version 1.0
*/
public class StringBuffer02 {
public static void main(String[] args) {
// String-->StringBuffer
String str = "hello sw";
// 方法① 使用构造器
StringBuffer stringBuffer = new StringBuffer(str);
// 方法② 使用append方法
StringBuffer stringBuffer1 = new StringBuffer();
stringBuffer1 = stringBuffer1.append(str);
// StringBuffer-->String
StringBuffer stringBuffer2 = new StringBuffer("xialu");
// 方式① 使用toString方法
String s = stringBuffer2.toString();
// 方式② 使用构造器
String s1 = new String(stringBuffer2);
}
}
```
### StringBuffer常用方法
1. 增 append
2. 删 delete(start,end)
3. 改 replace(start,end,string)// 将start---end 间的内容替换掉，不包含end
4. 查 indexOf// 查找子窜在字符串第1此出现的索引，如果找不到返回-1
5. 插 insert
6. 获取长度 length
### StringBuilder类
- 一个可变的字符序列，此类提供一个与StringBuffer 兼容的 API ，但不保证同步（StringBuilder 存在线程安全问题）。该类被设计用作StringBuffer 的一个简易替换，**用在字符串缓冲区被单个线程使用的时候**。通常情况，单线程建议优先采用该类，它比StringBuffer要快
### 结论
1. 如果字符串存在大量的修改操作，一般使用StringBuffer 或StringBuilder
2. 如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder
3. 如果字符串卒中大量的修改操作，并在多线程的情况，使用StringBuffer
4. 如果我们字符串很少修改，被多个对象引用，使用String，比如配置信息等
## Math类
- 执行基本数学运算的方法
- 在a~b之间取随机数
- (int)(a + Math.random() * (b - a + 1))
## Arrays类
- Arrays.toString(arr)
- sort排序
- binarySearch 通过二分搜索法进行查找，要求必须排好序
- int index = Arrays.binarySearch(arr, 3);
#### sort定制排序
通过传入一个接口 Comparator 实现定制排序
```java
Integer[] arr = {1, -2, 10, 8};
// 定制排序
// 传入参数，（1）排序数组arr；（2）实现了Comparator接口的匿名内部类，要求实现compare方法
Arrays.sort(arr, new Comparator(){
@Override
public int compare(Object o1, Object o2) {
Integer o11 = (Integer) o1;
Integer o22 = (Integer) o2;
return o22 -o11;
}
});
```
### 练习题代码--接口编程+动态绑定+定制化排序
```java
package com.xiaolin;
import java.util.Arrays;
import java.util.Comparator;
/**
* @author 林小鹿
* @version 1.0
* 练习题--接口编程+动态绑定+定制化排序
*/
public class Array01 {
public static void main(String[] args) {
Book[] books = new Book;
books = new Book("红楼梦", 100);
books = new Book("誓死", 90);
books = new Book("文艺青年", 5);
books = new Book("JAVA从入门到入土", 300);
// 按price从大到小
// Arrays.sort(books, new Comparator() {
// @Override
// public int compare(Object o1, Object o2) {
// Book book1 = (Book) o1;
// Book book2 = (Book) o2;
// double priceVal =book2.getPrice() - book1.getPrice();
// // 进行了一个转换
// if (priceVal > 0) {
// return 1;
// }else if (priceVal < 0) {
// return -1;
// }else {
// return 0;
// }
// }
// });
// 按照书名长度从大到小排序
Arrays.sort(books, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
Book book1 = (Book) o1;
Book book2 = (Book) o2;
return book2.getName().length() - book1.getName().length();
}
});
System.out.println(Arrays.toString(books));
// 定制化排序测试---动态绑定+定制化排序
Integer[] arr = {56, -1, 34, -7, 16};
Book.bubble(arr, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
Integer o11 = (Integer) o1;
Integer o22 = (Integer) o2;
return o22 - o11;
}
});
System.out.println(Arrays.toString(arr));
}
}
class Book {
private String name;
private double price;
public Book(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
// 定制化冒泡排序
public static void bubble(Integer[] arr, Comparator c) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
// 数组排序由c.compare(arr, arr)返回的值决定
if (c.compare(arr, arr) > 0) {
temp = arr;
arr = arr;
arr = temp;
}
}
}
}
}
```
## System类
- exit：退出当前程序
- arraycopy：复制数组元素，比较适合底层调用
- currentTimeMillens：返回当前时间距离1970-1-1 的毫秒数
- gc：运行垃圾回收机制
## BigInteger和BigDecimal类
> 底层把数据当作字符串进行处理，可接收一个字符串
- BigInteger适合保存比较大的整形
- BigDecimal适合保存精度更高的浮点型（小数）
#### 常见方法
- add()：加
- subtract()：减
- multiply()：乘
- divide()：除 （BigDecimal在除法时可能会抛出无限不循环小数的错误，可以通过 RoundingMode.CEILING参数 保留分子的小数点位数）
## 第一代日期类 Data类
### 代码
```java
package com.xiaolu.data;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* @author 林小鹿
* @version 1.0
*/
public class Date01 {
public static void main(String[] args) throws ParseException {
Date d1 = new Date(); // 获取当前系统时间
System.out.println("当前日期=" + d1);
// 通过指定毫秒数得到时间
Date d2 = new Date(9234567);
System.out.println("d2="+d2);
// 创建 SimpleDateFormat 对象，可以对日期格式化，格式是规定的，不可乱写
SimpleDateFormat sdf = new SimpleDateFormat("yyy年MM月dd日 hh:mm:ss E");
String format = sdf.format(d1);// format：将日期转换成指定格式的字符串
System.out.println("当前日期="+format);
// 可以把一个格式化的String 转成对应的 Date
// 在把String转换成Date时，使用的 sdf 格式需要和你给的String的格式保持一致，否则会抛出转换异常
String s = "1996年01月01日 10:20:30 星期一";
Date parse = sdf.parse(s); // 存在转化异常，通过Alt+enter 抛出异常
System.out.println("parse="+parse);
}
}
```
## 第二代日期类 Calendar(日历)类
### 代码
```java
package com.xiaolu.data;
import java.util.Calendar;
/**
* @author 林小鹿
* @version 1.0
*/
public class Calendar_ {
public static void main(String[] args) {
// 1、Calendar是一个抽象类，并且构造器是private
// 2、可以通过 getInstance() 来获取
// 3、Calendar没有提供对应的格式化的类，需要自己组合输出
// 4、如果需要输出24小时制，只需要吧Calendar.HOUR 改成 Calendar.HOUR_OF_DAY
Calendar c = Calendar.getInstance();
System.out.println("c=" + c);
// 获取日历对象的某个日历字段
System.out.println("年：" + c.get(Calendar.YEAR));
// 这里的 + 1 是因为Calendar 返回月的时候，是按照 0 开始编号
System.out.println("月：" + c.get(Calendar.MONTH) + 1);
System.out.println("日：" + c.get(Calendar.DAY_OF_MONTH));
System.out.println("小时：" + c.get(Calendar.HOUR));
System.out.println("分钟：" + c.get(Calendar.MINUTE));
System.out.println("秒：" + c.get(Calendar.SECOND));
}
}
```
## 第三代日期类
> 前面两代日期类存在不足
**Calendar存在的问题**
1. 可变性：像日期和时间类应该是不可变的
2. 偏移性：Date中的年份是从1900开始的，而月份都是从0开始
3. 格式化：格式化只对Date有用
4. 它们也不是线程安全，不能处理闰年秒等问题（每隔2天，多出1s）
### 三代日期类(JDK8加入)
- LocalDate(日期/年月日)
- LocalTIME(时间/时分秒)
- LocalDateTime(日期时间)
### 格式化日期类 DateTimeFormatter类
```java
// 使用DateTimeFormatter 对象来进行格式化
// 创建 DateTimeFormatter对象
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分钟ss秒");
String format = dateTimeFormatter.format(ldt);
System.out.println("格式化的日期=" + format);
```
### 代码
```java
package com.xiaolu.data;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
/**
* @author 林小鹿
* @version 1.0
*/
public class LocalDate_ {
public static void main(String[] args) {
// 第三代日期
// 使用now() 返回表示当前日期时间的 对象
LocalDateTime ldt = LocalDateTime.now();// LocalDate.now(); // LocalTime.now()
System.out.println(ldt);
// 使用DateTimeFormatter 对象来进行格式化
// 创建 DateTimeFormatter对象
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分钟ss秒");
String format = dateTimeFormatter.format(ldt);
System.out.println("格式化的日期=" + format);
System.out.println("年="+ldt.getYear());
System.out.println("月="+ldt.getMonth());
System.out.println("月="+ldt.getMonthValue());
System.out.println("日="+ldt.getDayOfMonth());
System.out.println("时="+ldt.getHour());
System.out.println("分="+ldt.getMinute());
System.out.println("秒="+ldt.getSecond());
}
}
```
### Instant时间戳
>类似于Date，提供了一系列和Date类转换的方式
- Instant ===> Date
- Date date = Date.from(instant);
- Date===>Instant
- Instant now = Instant.now();
### 代码
```java
// 通过 静态方法 now() 获取表示当前时间戳的对象
Instant now = Instant.now();
System.out.println(now);
// 通过 from 可以把 Instant转成 Date
Date date = Date.from(now);
// 通过 date的toInstant() 可以把date 转成Instant对象
Instant instant = date.toInstant();
```
### 其他对象方法
```java
// 提供 plus 和 minus方法可以对当前时间进行加或者减
// 890天后
LocalDateTime localDateTime = ldt.plusDays(890);
System.out.println("890天后=" + dateTimeFormatter.format(localDateTime));
// 在345分钟前是什么时候
LocalDateTime localDateTime1 = ldt.minusMinutes(345);
System.out.println("345分钟前=" + dateTimeFormatter.format(localDateTime1));
``` 总结的不错，先收藏
java也太麻烦了， 写的不错，支持 写的挺好的 没事可以看看，期待后面的内容和更新:Dweeqw
页:
[1]