Oort.

0%

Java相关知识

发表于 更新于 分类于
本文字数： 9.5k 阅读时长 ≈ 9 分钟

1、基本数据类型与包装类型

1、整数类型

数据类型 内存空间 取值范围
byte 8位(1个字节) -128~127
short 16位(2个字节) -32768~32767
int 32位(4个字节) -2147483648~2147483647
long 64位(8个字节) -9223372036854775808~9223372036854775807

2、浮点类型

数据类型 内存空间 取值范围
float 32位(4个字节) 1.4E-45~3.4028235-E38
double 64位(8个字节) 4.9E-324~1.7976931348623157E-308

3、字符类型

数据类型 内存空间 取值范围
char 16位(2个字节) 0~65535

4、布尔类型

数据类型 内存空间 取值范围
boolean 8位(1个字节)或32位(4个字节) true,false

当声明一个 boolean 变量时占用4个字节，当声明一个 boolean 数组时占用1个字节。

5、包装类型

基本类型对应的包装类型

基本类型 包装器类
boolean Boolean
byte Byte
char Character
short Short
int Integer
long Long
float Float
double Double

装箱与拆箱

装箱：基本数据类型转换成包装数据类型
如：int 转换成 Integer

拆箱：包装数据类型转换成基本数据类型
如：Integer 转换成 int

2、数组操作

1、遍历

1、通过索引遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void ergodic(int arr[]) {
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }
}
public static void ergodic(int arr[][]) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            System.out.print(arr[i][j] + " ");
        }
        System.out.println("");
    }
}

2、使用 foreach 遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void ergodic(int arr[]) {
    for (int x : arr) {
        System.out.println(x);
    }
}
public static void ergodic(int arr[][]) {
    for (int a[] : arr) {
        for (int x : a) {
            System.out.print(x + " ");
        }
        System.out.println("");
    }
}

2、填充

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/* 
 * Arrays.fill(Object[] a, Object value);
 * a:要进行元素填充的数组
 * value:填充值
 */

/*
 * Arrays.fill(Object[] a, int fromIndex, int toIndex, Object value);
 * a:要进行元素填充的数组
 * fromIndex:填充起始位置
 * toIndex:填充结束位置
 * value:填充值 
 */

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int arr[] = new int[10];
        Arrays.fill(arr, 1); // 全部填充为1
        Arrays.fill(arr, 0, 10, 5); // 填充[0,10)，填充值为5
    }
}

3、排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
 * Arrays.sort(Object a[])
 * a:要排序的数组
 */

/*
 * Arrays.sort(Object a[], int fromIndex, int toIndex)
 * a:要排序的数组
 * fromIndex:排序的起始位置
 * toIndex:排序的结束位置
 */
import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int arr[] = { 5, 0, 4, 7, 0, 0, 3, 8, 3, 8 };
        Arrays.sort(arr); // 数组排序
        Arrays.sort(arr, 0, 10); // 数组[0,10)排序
    }
}

4、复制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
 * Object b[] = Arrays.copyOf(Object a[], int newLength)
 * a:要复制的数组
 * newLength:要复制后数组长度，如果<a.length，复制前[0,newLength)；如果>a.length，后面补初始值(整数补0；char补null；)
 */

/*
 * Object b[] = Arrays.copyOfRange(Object a[], int fromIndex, int toIndex)
 * a:要复制的数组
 * from:复制开始位置
 * to:复制结束位置
 */

import java.util.Arrays;
public class Main {
	public static void main(String[] args) {
		int arr[] = { 5, 0, 4, 7, 0, 0, 3, 8, 3, 8 };
		int arr2[] = Arrays.copyOf(arr,arr.length); //复制arr数组
		int arr3[] = Arrays.copyOfRange(arr, 0, 10); //复制arr[0,10)
	}
}

3、字符串操作

1、查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
 * int idx = str.indexOf(String substr)
 * substr:要搜索的子串
 * idx:返回子串在str中第一次出现的位置，如果没有返回-1
 */

/*
 * int idx = str.lastIndexOf(String substr)
 * substr:要搜索的子串
 * idx:返回子串在str中最后一次出现的位置，如果没有返回-1
 */

/*
 * char ch = str.charAt(int index)
 * index:下标
 * ch:str中下标为index的字符
 */

public static void main(String[] args) {
    String str = "Hello World!";
    int firIdx = str.indexOf("o");
    int lastIdx = str.lastIndexOf("o");
    char ch = str.charAt(3);
}

2、替换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/*
 * String newStr = str.replace(char oldChar, char newChar) 
 * oldChar:被替换的字符
 * newChar:替换的字符
 * newStr:替换所有匹配位置后的字符串
 */

/*
 * String newStr = str.replace(CharSequence target, CharSequence replacement) 
 * target:被替换的字符串
 * replacement:替换的字符串
 * newStr:替换所有匹配位置后的字符串
 */

/*
 * String newStr = str.replaceAll(String regex, String replacement)
 * regex:正则表达式，或字符串
 * replacement:用于替换的字符串
 * newString:替换所有匹配位置后的字符串
 */

/*
 * String newStr = str.replaceFirst(String regex, String replacement)
 * regex:正则表达式，或字符串
 * replacement:用于替换的字符串
 * newString:只替换第一个匹配位置后的字符串
 */

public static void main(String[] args) {
    String str = "Hello World!";
    str = str.replace('!', '.');
    str = str.replace("World", "Java");
    str = str.replaceAll("[A-Z]", "*");
    str = str.replaceAll("o", "*");
    str = str.replaceFirst("[A-Z]", "#");
    str = str.replaceFirst("l", "#");
}

3、比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/*
 * boolean bool = str.equals(String str1)
 * str1:要比较的字符串
 * bool:比较结果，相等为true，不相等为flase
 */

/*
 * boolean bool = str.equalsIgnoreCase(String str1)
 * str1:要比较的字符串
 * bool:忽略字母大小写的比较结果，相等为true，不相等为flase
 */

/*
 * boolean bool = str.startWith(String prefix)
 * prefix:指作为前缀的字符
 * bool:比较结果，如果prefix是str的前缀则为true，否则为flase
 */

/*
 * boolean bool = str.startWith(String prefix, int offset)
 * prefix:指作为前缀的字符
 * offset:从str的offset位置开始
 * bool:比较结果，如果prefix是str从offset开始的前缀则为true，否则为flase
 */

/*
 * boolean bool = str.endWith(String suffix)
 * suffix:指作为后缀的字符
 * bool:比较结果，如果suffix是str的后缀则为true，否则为flase
 */

/*
 * String newStr = str.toLowerCase();
 * newStr:大写字母全部替换为小写字母后的字符串
 */

/*
 * String newStr = str.toUpperCase();
 * newStr:小写字母全部替换为大写字母后的字符串
 */

public static void main(String[] args) {
    String str = "Hello World!";
    boolean bool1 = str.equals("Hello");
    boolean bool2 = str.equalsIgnoreCase("hello world!");
    boolean bool3 = str.startsWith("Hello");
    boolean bool4 = str.startsWith("ello",1);
    boolean bool5 = str.endsWith("World!");
    str = str.toLowerCase();
    str = str.toUpperCase();
}

4、分割

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*
 * String[] subStrs = str.split(String sign)
 * sign:分隔符，可以使用正则表达式
 * subStrs:str分割后的字符串数组 
 */

/*
 * String[] subStrs = str.split(String sign, int limit)
 * sign:分隔符，可以使用正则表达式
 * limit:限制的分割份数
 * subStrs:str分割后的字符串数组 
 */

public static void main(String[] args) {
    String str = "Hello World!";
    String strs[] = str.split(" ");
    String strs1[] = str.split(" ", 1);
}

5、格式化

常规转换符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*
 * String.format(String format,  Object... args)
 * format:格式化格式
 * args:要被格式化的数据
 */

public static void main(String[] args) {
    System.out.println(String.format("%b、%B", 1==1,1==1));
    System.out.println(String.format("%h、%H", "Hello","Hello"));
    System.out.println(String.format("%s、%S", "Hello","Hello"));
    System.out.println(String.format("%c、%C", 'a','a'));
    System.out.println(String.format("%d", 16));
    System.out.println(String.format("%o", 16));
    System.out.println(String.format("%x、%X", 16,16));
    System.out.println(String.format("%e %E", 16.0,16.0));
    System.out.println(String.format("%a %A", 16.0,16.0));
    System.out.println(String.format("%% %s","Hello"));
}
转换符 说明 示例
%b、%B 结果被格式化为布尔类型 true、TRUE
%h、%H 结果被格式化为散列码 42628b2、42628B2
%s、%S 结果被格式化为字符串类型 Hello、HELLO
%c、%C 结果被格式化为字符类型 a、A
%d 结果被格式化为十进制整数 16
%o 结果被格式化为八进制整数 20
%x、%X 结果被格式化为十六进制整数 10、10
%e 结果被格式化为用计算机科学计数法表示的十进制数 1.600000e+01 1.600000E+01
%a 结果被格式化为带有效位数和指数的十六进制浮点值 0x1.0p4 0X1.0P4
%% 结果为字面值 % % Hello
时间和日期格式转换符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*
 * String.format(String format,  Object... args)
 * format:格式化格式
 * args:要被格式化的数据
 */
import java.util.Date;
public class Main {
    public static void main(String[] args) {
        Date data = new Date();
        System.out.println(String.format("%tH", data));
        System.out.println(String.format("%tI", data));
        System.out.println(String.format("%tk", data));
        System.out.println(String.format("%tl", data));
        System.out.println(String.format("%tM", data));
        System.out.println(String.format("%tS", data));
        System.out.println(String.format("%tL", data));
        System.out.println(String.format("%tN", data));
        System.out.println(String.format("%tp", data));
        System.out.println(String.format("%tz", data));
        System.out.println(String.format("%tZ", data));
        System.out.println(String.format("%ts", data));
        System.out.println(String.format("%tQ", data));
        System.out.println(String.format("%tF", data));
        System.out.println(String.format("%tD", data));
        System.out.println(String.format("%tc", data));
        System.out.println(String.format("%tr", data));
        System.out.println(String.format("%tT", data));
        System.out.println(String.format("%tR", data));
    }
}
转换符 说明 示例
%tH 2位数字的24时制的小时（00~23） 23
%tI 2位数字的12时制的小时（01~12） 05
%tk 2位数字的24时制的小时（0~23） 9
%tl 2位数字的12时制的小时（1~12） 6
%tM 2位数字的分钟（00~59） 44
%tS 2位数字的秒数（00~60） 52
%tL 3位数字的毫秒数（000~999） 558
%tN 9为数字的微秒数（000000000~999999999） 558000000
%tp 制定语言环境上下午标记 下午
%tz 相对于GMT RFC 82 格式的数字时区偏移量 +0800
%tZ 时区缩写形式的字符串 CST
%ts 1970-01-01 00:00:00 到现在经过的秒数 1595951092
%tQ 1970-01-01 00:00:00 到现在经过的毫秒数 1595951092558
%tF “年-月-日”格式（4位年份） 2020-07-28
%tD “月/日/年”格式（2位年份） 07/28/20
%tc 全部日期和时间信息 周二 7月 28 23:44:52 CST 2020
%tr “时:分:秒 PM(AM)”格式（12时制） 11:44:52 下午
%tT “时:分:秒”格式（24时制） 23:44:52
%tR “时:分”格式（24时制） 23:44

6、StringBuilder

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/*
 * builder.append(Object obj)
 * obj:追加在builder末尾的值
 */

/*
 * builder.insert(int offset, Object obj)
 * offset:插入位置
 * obj:要插入的值
 */

/* builder.delete(int start, int end)
 * start:开始位置（包含）
 * end:结束位置（不包含）
 */

/* builder.deleteCharAt(int index)
 * index:要删除字符的位置
 */

public static void main(String[] args) {
    StringBuilder builder = new StringBuilder("Test");
    //在末尾添加
    builder.append("string");
    builder.append((int)10);
    builder.append((Boolean)true);
    //...
    System.out.println(builder);
    
    //插入
    builder.insert(2, "123");
    builder.insert(2, (int)999);
    builder.insert(2, (CharSequence)"***");
    //...
    System.out.println(builder);
    
    //删除
    builder.delete(2, 3);
    builder.deleteCharAt(0);
    System.out.println(builder);
    
    //转换
    String str = builder.toString();
    builder = new StringBuilder(str);
}

7、扩展：正则表达式

1
2
3
4
5
6
7
8
9
10
/*
 * boolean bool = str.matches(String regex)
 * regex:正则表达式
 * bool:判断str是否符合正则表达式，符合则为true
 */
public static void main(String[] args) {
    String str = "Hello";
    boolean bool  = str.matches("[A-Z][a-z]{4}");
    System.out.println(bool);
}

正则表达式中的元字符

元字符 正则表达式中的写法 含义
. . 代表任意一个字符
\d \\d 代表0~9的任何一个数字
\D \\D 代表任何一个非数字字符
\s \\s 代表空字符，如\t、\n
\S \\S 代表非空字符
\w \\w 代表可用作标识符的字符，但不包括$
\W \\W 代表不可用于标识符的字符
\p{Lower} \\p{Lower} 代表小写字母{a~z}
\p{Upper} \\p{Upper} 代表大写字母{A~Z}
\p{ASCII} \\p{ASCII} 代表 ASCII 字符
\p{Alpha} \\p{Alpha} 代表字母字符
\p{Digit} \\p{Digit} 代表十进制数字{0~9}
\p{Alnum} \\p{Alnum} 代表数字或字母字符
\p{Punct} \\p{Punct} 代表标点符号 ```!@#$%^&*()-=_+[]\{}\ ;:’”,<.>/?`~```
\p{Graph} \\p{Graph} 代表可见字符[\p{Alnum}\p{Punct}]
\p{Print} \\p{Print} 代表可打印字符[\p{Graph}\x20]
\p{Blank} \\p{Blank} 代表空格或制表符\t
\p{Cntrl} \\p{Cntrl} 代表控制字符[\x00-\x1F\x7F]

正则表达式中的限定符

限定修饰符 意义 示例
? 0次或1次 A?
* 0次或多次 A*
+ 0次或多次 A+
{n} 正好出现n次 A{2}
{n,} 至少出现n次 A{3,}
{n,m} 出现 n~m 次 A{2,6}

方括号中元字符含义

字符 含义
[abc] 表示a、b或者c
[^abc] 表示除a、b、c以外的字符
[a-zA-Z] a~z或A~Z的任何字符
[a-d[m-p]] a~d或m~p的任何字符
[a-z&&[def]] 表示d、e或者f
[a-z&&[^bc]] 除b、c以外a~z的所有字符
[a-z&&[^m-p]] 除m~p以外a~z的所有字符