JavaSE Day12 数组API StringAPI StringBUffer 包装类 正则
JavaSE Day12 数组API StringAPI StringBUffer 包装类 正则
目录
Arrays类
int[] arr = {2,34,12,363,1,65};
// 把数组转换成字符串
System.out.println(Arrays.toString(arr));
// 排序，升序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
// 查找,二分查找（前提：升序排序）
// 查找的元素存在，返回位置索引；不存在，返回 -(插入点+1)
System.out.println(Arrays.binarySearch(arr,34));
System.out.println(Arrays.binarySearch(arr,89));
// 比较相等 两个数组(元素的个数，类型)
int[] arr1 = {11,22,33,44,55,66,77};
int[] arr2 = {11,22};
System.out.println(Arrays.equals(arr1,arr2));
数组的复制
int[] arr3;
arr3 = Arrays.copyOf(arr1,arr1.length);// 源数组，新数组的长度；
System.out.println(Arrays.toString(arr3));
System.out.println(Arrays.toString(arr1));
数组的复制2
创建2个数组，通过for循环来一一赋值
创建2个数组，通过System.arraycopy(源数组，源数组开始位置，目的数组，目的数组开始位置，复制长度)
使用clone(）方法
使用浅拷贝，直接替换变量名；
String类
表示字符串，字符序列。
不可变的类
一旦字符串对象确定了，此字符串对象的字符序列就不能更改了
因为是不可变对象，每一次的常量值赋值或对象赋值时，都会创建对象，效率低；
常量值会在常量池中创建新对象
对象赋值会在堆内存中创建对象
创建字符串
String s1 = "hello";
直接使用赋值运算符的，是存储在方法区的常量池中的维护的；如果池中存在，则不创建直接赋值；如果没有，则创建一个再赋值；
加了final的变量，存储在方法区的常量池中维护的；
String s2 = new String("hello")；
一看到new就是在堆内存中分配空间
使用new创建，则在堆中创建对象；然后去常量池中查找是否存在，如果常量池中存在相同的字符串，则将该常量池的地址保存在创建的堆内存空间中；否则在堆内存中创建一份；而不会在常量池中创建,因为在Java中根本就不存在两个完全一模一样的字符串对象
参考资料：https://www.cnblogs.com/xiaoxi/p/6036701.html
字符串方法
String s2 = new String();
// 空串，没有字符序列，null空对象
// 方法 判断字符串相等（堆内存地址）
System.out.println(s3 == s5);
// equals 比较的是字符序列是否相等；（区分大小写）
System.out.println(s1.equals(s3));
// 不区分大小写，比较字符序列
System.out.println(s1.equalsIgnoreCase(s3));
// 追加
String str = "hello";
// System.out.println(str.concat("tom"));
str.concat("tom");
str = str.concat("tom");
// 字符串是不可变类，直接打印str，没有任何变化还是hello
System.out.println(str);
// 长度
System.out.println(str1.length());
// 大小写转换
System.out.println(str1.toUpperCase());
System.out.println(str1.toLowerCase());
// 查找参数字符串在当前字符串中 第一次出现的位置索引，不包含返回-1；
System.out.println(str2.indexOf("he"));
// 查找参数字符串在当前字符串中 第一次出现的位置索引，
System.out.println(str2.lastIndexOf("he"));
// char 取出参数索引位置的一个字符
System.out.println(str2.charAt(10));
// 取子串
// 从起始位置参数 取到字符串的末尾；
System.out.println(str3.substring(str3.indexOf("a")));
// [起始位置,终止位置） 从起始位置 到终止位置的前一位；
System.out.println(str3.substring(5,8));
// 去除字符串的前后空格
String str4 = " h e l l o ";
System.out.println(str4.trim());
// 使用第二个参数字符串替换第一个参数字符串；全部替换；
System.out.println(str5.replace("hello","你好"));
// 去除所有空格
System.out.println(str4.replace(" ",""));
// 是否以指定参数的字符串为 结尾，是true；
System.out.println(str6.endsWith("java"));
// 是否以指定参数的字符串为 开头，是true；
System.out.println(str6.startsWith("Demo"));
// 比较字符串大小
String str7 = "abc";
// 比较的对象 在参数对象之前，结果是负数；
System.out.println(str7.compareTo("Adc"));
// 两个字符串一样 返回0；
System.out.println(str7.compareTo("abc"));
// 比较的对象 在参数对象之后，结果是正数；
System.out.println("xyz".compareTo("abc"));
// 把字符串转换成字符数组char[]
String str8 = " aga sdgsag ";
char[] crs = str8.toCharArray();
System.out.println(Arrays.toString(crs));
// 把当前字符串 用参数字符串分割 为一个字符串数组，String[]
String str9 = "aa bb cc dd ee";
String[] strs = str9.split(" ");
// 参数字符串在当前 字符串中是否存在，存在就是true，不包含就是false；
System.out.println(str9.contains("cc"));
可变的类
StringBuffer
StringBuffer sf = new StringBuffer();
// 查看StringBuffer的长度
System.out.println(sf.capacity());
// 默认是16，如果大小不够，则成倍的扩容；
// 缩小容量 为 实际存储字符的大小
sf.trimToSize();
StringBuffer sf1 = new StringBuffer(100);
// 可以指定容量
// 添加数据
sf1.append("hello");
// 向参数索引位置插入一个字符串；
sf1.insert(5,"tom");
// 修改某个索引位置的字符
sf1.setCharAt(3,'y');
// 删除 索引位置的字符
sf1.deleteCharAt(5);
// 删除 [起始位置，终止位置)
sf1.delete(5,8);
//反转
sr.reverse();
// 转换为字符串；
String str = sr.toString();
StringBuilder
StringBuilder s1 = new StringBuilder();
方法和StringBuffer差不多
区别
- String
- 表示一个字符串，不可变类
- 字符串的字符序列 频繁更改，效率低；
- StringBuffer && StringBuilder
- 可变字符串类
- 字符序列频繁更改 ，可以使用
- StringBuffer
- 线程安全的
- 都是用synchronized 关键字进行修饰，因此是线程安全的
- 数据准确，但是速度慢；
- StringBuilder
- 线程非安全
- 数据不准确，但是速度快
时间
System.currentTimeMillis();
从1970-1-1-0:0:0计算到现在的毫秒数
native 关键字 表示是由底层的C语言来实现的；
正则表达式
语法
// 1. 定义正则表达式 Pattern.compile(regString)
Pattern ptn = Pattern.compile("\\d{6}");
// 2. 表达式模式 Matcher matcher = ptn.matcher("需要匹配的数据")
Matcher mr = ptn.matcher("343434");
// 3. 验证 matcher.matches()；
System.out.println(mr.matches());
简易语法
boolean flag = Pattern.matches("\\d{6}","343434");
// 参数1：regString
// 参数2：需要匹配的数据
匹配模式
总共三种匹配模式
贪婪模式
勉强模式
侵占模式
参考文档
正则表达式匹配模式
拆箱装箱
包装类
装箱
把基本数据类型 包装成对象。
基本数据类型 --> 引用类型；
自动装箱
Integer i1 = 23;
默认调用Integer.valueOf()
拆箱
把对象中的值，取出来
引用类型 --- 》 基本类型
自动拆箱
int n = i;
默认调用 i.intValue()；
包装类是不可变类
进制转换
System.out.println(Integer.toBinaryString(5));// 10-》2
System.out.println(Integer.toOctalString(12));// 10-》8
System.out.println(Integer.toHexString(15));// 10-》16
System.out.println(Integer.valueOf("101",2));// 2-》10
System.out.println(Integer.valueOf("14",8));// 8-》10
System.out.println(Integer.valueOf("f",16));// 16-》10
字符串 和 数值 转换
基本类型转换为字符串的方法有三种方法：
- 使用包装类中的toString()方法
- 使用String类的valueOf()方法
- 加入空字符(最常用)
// 数字 转换为 字符串
int x = 22;
String str = x+"";// "22"
str = Integer.toString(x);
str = String.valueOf(x);
字符串转换为基本类型
包装类转换为基本类型有两种方法：
- 使用包装类中的parseXXX()方法
- 使用包装类中的valueOf()方法
// 字符串转换为数字
String str1 = "123";
int y = new Integer(str1);
y = Integer.parseInt(str1);
y = Integer.valueOf(str1);
Character包装类的方法
Character.isUpperCase(c)
判断字符是否是大写字母
Character.isLowerCase(c)
判断字符是否是小写字母
Character.isDigit(c)
数字
Character.isSpaceChar(c)
空格
除了float和double以外，其余的都有缓冲：1个字节的空间；
Boolen --->都缓冲
Character ---> 0-127
Byte，Short,Integer,Long ----> -128~127
有缓存的数据，引用的是同一块内存地址
NumberFormatException 非数字异常
浙公网安备 33010602011771号