Java核心类

String

引用类型，默认值null，不可变性->本质

本质：private final char[] ，没有修改char[]的方法 -> 字符串操作不改变原字符串内容，而是返回新字符串

String s= "abc"
//等同于
String s1=new String(new char[] {'a','b','c'})

字符编码

ASCII 编码：数字、英文字母、常用符号
GB2312：汉字（两个字节表示）
Unicode编码：统一世界主要语言的编码 -> java中的char
- UTF-8 ：节约资源，英文使用ASCII,中文使用GB2312

char转换为byte编码

byte[] b1=s.getBytes("UTF-8")  //转换为UTF-8编码
byte[] b2=s.getBytes("GBK")  //转化为GBK编码

byte转换为String

String s1=new String(b1,StandardCharsets.UTF_8);
String s2=new String(b2,"GBK")

StringBuilder

与String不同：可变对象（循环中新增字符不会像String那样创建新的临时对象）

StringBuilder sb = new StringBuilder(1024);
for(int i=0;i<100;i++){
    sb.append(',');
    sb.append(i);
    //链式操作写法 -> 拼接操作数据库语句
    sb.append(',')
      .append(i)
}

reverse() 方法 : 反转字符串

String original=123456;

String res=new StringBuilder(original).reverse().toString()
//654321

tips：使用 + 拼接字符串时不需要手动转换为StringBuilder对象，java编译器会自动编码

包装类型

相比于基本类型，引用类型可以赋值为null

-> 将基本类型包装为引用类型 -> 包装类(wrapper class)

本质：final class

//int包装类Interger
Interger n=null;
Interger n1=Interger.valueOf(20);
Interger n2=Interger.valueOf("33");

System.out.printIn(n2.intValue()); //33

//自动装箱、自动拆箱 -> 编译阶段
int i=100; //自动使用Interger.valueOf(100)
int n=i; //自动使用Interger.intValue()
	//拆箱时有可能发生NullPointerException

为什么使用valueof静态工厂方法而不是new操作符？

new总是创建新的实例，valueof能够返回缓存的实例节省内存

其余包装类：java.lang.Boolean / Byte /Short / Long / Float / Double / Character

枚举类enum

类似ts中的enum ， java中的enum一般用来枚举常量，如：

enum Color { RED, YELLOW,BLUE,PINK}

//本质：
public final class Color extends Enum { // 继承自Enum，标记为final class
    // 每个实例均为全局唯一:
    public static final Color RED = new Color();
    public static final Color GREEN = new Color();
    public static final Color BLUE = new Color();
    // private构造方法，确保外部无法调用new操作符:
    private Color() {}
}

优点：利于检查类型，可以使用==比较两个实例（每个实例都是引用类型的唯一实例）

特点：

enum继承于java.lang.Enum，无法被继承
只能通过enum定义实例，不能通过new创建

方法：

name()返回常量名 String red=Color.RED.name() //"RED"
ordinal() 常量的顺序 -> 不建议使用，建议在enum中自己定义字段读取设置变量
可以在enum中添加字段(建议定为final)和方法
常用于switch语句中

工具类

Math （常见的就不列举了
- Math.abs(-15) 求绝对值
- Math.pow(2,3) 次方计算 ->2的3次方
- Marh.round(double->long,float->int)将浮点数四舍五入为整数
- Math.random()生成随机数 0<=x<1
- 常量：Math.PI3.1415926…… Math.E2.71828……

Random : 生成随机数

Random r = new Random();
Random r2= new Random(3333);//指定序列生成随机数唯一

r.nextInt() //在int范围生成一个随机数
r.nextInt(8) //[0,8)生成随机数    
r.nextFloat //在[0,1)生成一个float

SecureRandom : 生成安全的随机数

SecureRandom sr = new SecureRandom();
sr.nextInt(23);

正则表达式

java中的正则表达式\特殊字符需要转义 -> 多一个\

eg. a&c -> a\&c

匹配任意字符 (跟在字母后面\d+)
- 任意一个字符 .
- 任意字符*
- 至少一个字符+
- 0个或1个 ?
- 匹配n~m个 {n~m}
任意一个数字 \d -> 非数字 \D
任意一个字母、数字、下划线 \w -> 取反\W
任意一个空格 \s tab字符 \t
任意字母[a-z]
一个单词开头或者结尾\b eg. \bhappy\b匹配happy

在java中使用

java.util.regex包提供Pattern \ Matcher class来帮助我们高效编写正则表达式，步骤如下：

//1.将正则表达式转化为pattern对象
Pattern p =Pattern.compile("\w?")
//2.创建Matcher对象
Matcher m=p.matcher("要匹配的字符串")    
/*3.使用方法
    find():查找与其匹配的子序列
    matches():整个字符串满足true /false
    lookingAt():从开始部分满足 true /false    
*/

假设封装一个findMatch方法：

private static List<Match> findMatch(String text, String regex) {
        Pattern regexPattern = Pattern.compile(regex);
        Matcher matcher = regexPattern.matcher(text);
        List<Match> matcheList = new ArrayList<>();
        while(matcher.find()) {
                matcheList.add(new Match(matcher.group(), matcher.start(),matcher.end() ));
        }
        return matcheList;
    }

集合

定义：一个Object内部持有若干其他Object，并对外提供访问接口 eg.List \ Set \ Map

List

有序列表：ArrayList（更像数组） \ LinkedList （更像链表）

tips:

允许使用泛型、添加重复元素、null
内部通过equals()方法判断两个元素是否相等问题：新加入的实例查询不到-> 影响contain() \ indexof()方法 -> 解决：覆写equals方法

方法

创建List

List <String> list = new ArrayList<>();
List <Interger> l= List.of(1,2,3) //这种方法不接受传入null

操作元素

add remove get size()

hasNext()：是否有下一个元素 next()返回下一个元素

contains(o) indexof(o)
遍历List -> for each遍历（内置iterable迭代器，效率最高
```
for(String s : list){
    System.out.printIn(s);
}
```

List和Array转换

List -> Array :type[] arrname=list.toArray(new type[list.size()])

List <Interger> list=List.of(1,2,3);
Interger[] arr= list.toArray(new Interger[3]);//不知道具体长度时指定为new Interger[0]也可以

//函数式写法
Interger[] arr = list.toArray(Integer[]::new);

Array -> List : List.of()

String[] arr={"lili","huh"};
List<String> list=List.of(arr);

Map

本质：key-value映射表

tips:

put()具有覆盖性，以最后一次put为准
Hashmap中内容相同的两个key不一定是同一个对象 -> 放入key要正确覆写equals() hashCode()方法 （常用key String已经覆写过了） (EnumMap可以不用)
TreeMap可以实现有序map ，key必须有comparable接口或要给它定义排序算法

方法

创建map

Person p1=new Person("lili",23);
Person p2=new Person("wang",29);
Map<String,Person> pmap=new HashMap<>();

pmap.put("lili",p1);
pmap.put("wang",p2);

操作元素 (js是set/get)

存入put(key,value) 取出 get(key,value)

contain(key)

遍历map

//1.遍历Key -> 从KeySet()得到key的Set集合（无重复元素的key
for(String key : pmap.keySet()){
    Person v = pamp.get(key);
    System.out.printIn(key+":"+value)
}// lili:23  wang:29

//2.遍历Key、Value -> enterySet()
for(Map.Enter<String,Person> entey : pmap.enterySet()){
    String key=entry.getKey();
    Person v=entry.getValue();
     System.out.printIn(key+":"+value)
}// lili:23  wang:29

map遍历是没有顺序的，这点区分List

Collections

提供工具方法来帮助我们更加方便地使用集合类，区分Collection，末尾有s噢！

创建集合

创建的集合不可变，无法对其添加或删除元素

空集合

List<T> emptyList()

Map<K,V> emptyMap()
    
Set<T> emptySet()   
    
//等价于：
List<String> list1 = List.of();
List<String> list2 = Collections.emptyList();

单元素集合

List<T> singletonList(T o)
Map<K,V> singletonMap(K key,V value)
Set<T> singleton(T o)

不可变集合

List<T> unmodifiableList(List< ? extends T> list)
Map<K, V> unmodifiableMap(Map<? extends K, ? extends V> m)
Set<T> unmodifiableSet(Set<? extends T> set)    
eg: List<String> list=List.of("gt","jy","op";)
    List<String> unlist=Collections.unmodifiableList(list)
    list=null;//保证不可变

可以对原集合修改->最好赋值为null，以防止其他意外操作改变

操作元素

排序sort() 洗牌shuffle 反转reverse()

List<Interger> intList = List.of(2,5,1,9);
Collections.sort(list)  //排序
Collections.shuffle(list)  //洗牌 
    
List<Object> list =Array.asList(array);
Collections.reverse(list); //数组reverse

gtb-4 java核心类

Java核心类

String

相关方法

比较字符串内容

去除首尾空白字符

替换子串

操作字符串

类型转换