Day17 常用API
1 谁的方法(哪个类)
2 什么方法(静态还是成员)
3 功能是什么(能做什么)
4 需要传入什么参数
5 返回什么数据
6 方法名
- String
1.1 概述
- java.lang.String是字符串类
- 他的底层就是一个字符数组，所以他的很多特性就是数组的特性
-
1 字符串一旦创建，这个字符串对象不能更改 -
2 字符串需要使用""双引号表示 -
3 为了提高字符串访问效率，提出了一个缓存机制，字符串常量池
1.2 基本使用
//尽管没有new，但是s1依然代表String的对象，因为字符串常量池
String s1 = “abc”; //abc是个对象 不可被更改
//s1没有使用final修饰，所以s1的值可以更改，只不过是让s1指向了bcd字符串这个对象，而abc对象没有更改
s1 = “bcd”;//只不过现在s1指向bcd，可以重新指向其他对象
//第二部分
String s2 = "Hello";
String s3 = "Hello";
String s4 = "Hello";
System.out.println(s2 == s3);
//第三种
String s5 = new String("abc");
String s6 = new String("abc");
String s7 = "abc";
//s5和s6都是new的方式，所以分别指向各自的堆内存
System.out.println(s5 == s6);
System.out.println(s5 == s7);
//但是String类中覆写了equals方法，比较的是值，不是内存地址
//所以我们比较字符串是否相等的时候，应该用equals
System.out.println(s5.equals(s6));
1.3 不要频繁拼接
- 因为String一旦创建，字符串对象不可更改，所以尽量不要
- 使用String进行大量的字符串拼接操作
String[] arr = { “a”, “b”, “c”, “d” };
String temp = “”;
for (int i = 0; i < arr.length; i++) {
//ab浪费
//abc浪费
//abcd
temp += arr[i];
}
System.out.println(temp);
1.4 构造方法
//1 字面量
String s1 = “abc”;
//2
String s2 = new String(“xxx”);
//3 字节数组
byte[] bytes = { 97, 98, 99, 100, 101, 102 };
String s3 = new String(bytes);
//abcdef
System.out.println(s3);
//4 截取字节数组一部分
//下标为3开始(包含)，取两个
String s4 = new String(bytes, 3, 2);
//100 101 d e
System.out.println(s4);
//5 字符数组
char[] chars = { ‘a’, ‘b’, ‘c’, ‘d’, ‘e’ };
String s5 = new String(chars);
//abcde
System.out.println(s5);
//6 截取字符数组一部分
String s6 = new String(chars, 2, 2);
//cd
System.out.println(s6);
1.5 常用方法
int length()：返回字符串的长度： return value.length
char charAt(int index)： 返回某索引处的字符return value[index]
boolean isEmpty()：判断是否是空字符串：return value.length == 0
String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写
String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写
String trim()：返回字符串的副本，忽略前导空白和尾部空白
boolean equals(Object obj)：比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
int compareTo(String anotherString)：比较两个字符串的大小
String substring(int beginIndex)： 返回一个新的字符串， 它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字 符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的
子字符串是否以指定前缀开始
boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列 时，返回 true
int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出 现处的索引，从指定的索引开始
int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后 一次出现处的索引，从指定的索引开始反向搜索
注：indexOf和lastIndexOf方法如果未找到都是返回-1
String replace(char oldChar, char newChar)：返回一个新的字符串，它是
通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)： 使 用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String replaceAll(String regex, String replacement) ： 使 用 给 定 的
replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement) ： 使用给定的
replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此 字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中
String s1 = "qwert!";
// 1 char charAt(int index) : 获取字符串中某个位置上的字符
System.out.println(s1.charAt(2));
// 2 boolean startsWith(String prefix) : 是否以指定字符串开始
System.out.println("Hello.java".startsWith("He"));
// 是否以指定字符串结尾
System.out.println("Hello.java".endsWith(".java"));
// false 注意空格
System.out.println("Hello.java".endsWith(".java "));
// 3 boolean equals(Object obj) : 比较两个字符串是否相等
System.out.println("abc".equals("Abc"));
// true 不区分大小写比较
System.out.println("abc".equalsIgnoreCase("Abc"));
System.out.println("------------");
// 4 byte[] getBytes() : 把字符串转换为字节数组
byte[] bytes = "abc".getBytes();
for (byte b : bytes) {
System.out.println(b);
}
// 5 char[] toCharArray() : 把字符串转换为字符数组
char[] chars = "abc".toCharArray();
for (char c : chars) {
System.out.println(c);
}
// 字节数组转换字符串 : new String(bytes,起始值,个数);
// 字符串转字节数组 : getBytes();
// 字符数组转字符串 : new String(chars,起始值,个数);
// 字符串转字符数组 : toCharArray();
// 6 int indexOf(String str) : 获取字符串中,指定字符串的起始索引,找不到就返回-1
System.out.println("abcdebcfg".indexOf("bc"));
// 7 int lastIndeOf(String str) : 获取字符串中,指定字符串最后一次出现的索引,找不到返回-1
System.out.println("abcdebcfg".lastIndexOf("bc"));
// 8 int length() : 返回字符串的长度
System.out.println("abc".length());
// 9 String replaceAll(String regex, String replacement) : 把指定字符串,用某个字符串替换
// replace : 这个方法 和 replaceAll 几乎一样,只是 replaceAll 支持正则表达式,而 replace 不支持正则表达式
// 1111111 因为.在正则表达式中 可以匹配任意字符,所以把所有字符都替换为1
System.out.println("abc.dae".replaceAll(".", "1"));
// abc1dae .就是. , 不识别正则表达式
System.out.println("abc.dae".replace(".", "1"));
System.out.println("====");
// 10 String[] split(String regex) : 分割字符串,需要指定分隔符,返回字符串数组,支持正则表达式
String myTime = "2021,07,13";
// 以逗号分割,返回字符串数组
String[] time = myTime.split(",");
for (String string : time) {
System.out.println(string);
}
// 11 String substring(int beginIndex) : 获取该字符串中,以某个下标为起始的子字符串(包含)
// defg
System.out.println("abcdefg".substring(3));
// 12 String substring(int beginIndex, int endIndex) : 获取该字符串中,以某个下标为起始(包含),到指定位置结束(不包含)
// 注意 起始包含,结束不包含
// de
System.out.println("abcdefg".substring(3,5));
// 13 String trim() : 去除字符串两边的空格
// a b
System.out.println(" a b ".trim());
// 14 转大写转小写
// ASDADNCA
System.out.println("asdADnca".toUpperCase());
// asdadnca
System.out.println("asdADnca".toLowerCase());
// 输出一个引用类型的时候,会自动调用该对象的toString方法
Object obj = null;
// 当obj为null时,确不会出现空指针异常
System.out.println(obj);
// 15 static String valueOf(Object obj) : 调用指定对象的toString方法,并且使用三目运算符屏蔽了空指针异常
System.out.println(String.valueOf(obj));
1.6 注意
String s1 = “ab”;
String a = “a”;
String b = “b”;
//在编译阶段就会把+号去掉，就等于是ab
//所以使用s1和s2是相等的
String s2 = “a” + “b”;
String s3 = a + b;
//编译阶段是没有办法确定a和b的，因为还没有开始运行，空间还没有
//最终还是会转换成StringBuffer进行拼接
//拼接完后在转换为String类型，转换的时候是new String()进行转换的
//所以s1s3是false
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s3);
- StringBuffer和StringBuilder
2.1 概述
- 1 StringBuffer和StringBuilder是什么？
-
是一个可变的字符串缓冲区，适合做拼接操作 -
底层也是char数组，只不过默认长度也是16 而字符串内容多少，长度就是多少
*2 原理
-
先定义好长度，以容纳更多字符 -
如果预留的空间长度不够，会进行自动扩容 -
默认长度为16，扩大容量为(当前容量+1)*2 ,16->34->70->142
*3 区别
-
Builder效率高一些 -
StringBuilder：非线程安全，在多线程环境下使用，可能出现问题，所以常用于方法中 -
StringBuffer：线程安全，在多线程环境下使用不会出现问题，所以常用于类中
2.2 使用
//创建字符串缓冲区对象
StringBuilder sb = new StringBuilder();
//尾部添加数据
sb.append(“a”);
sb.append(“b”);
sb.append(“c”);
//return this 所以可以链式调用
sb.append(“d”);
System.out.println(sb);
//1反转
System.out.println(sb.reverse());
//指定位置添加数据
sb.insert(1, "2");
sb.insert(1, "2");
sb.insert(1, "2");
sb.insert(1, "2");
sb.insert(1, "2");
sb.insert(1, "2");
sb.insert(1, "2");
sb.insert(1, "2");
sb.insert(1, "2");
sb.insert(1, "2");
sb.insert(1, "2");
sb.insert(1, "2");
sb.insert(1, "2");
System.out.println(sb);
//已有元素个数
System.out.println(sb.length());
//当前数组的容量, value.length
System.out.println(sb.capacity());
//把sb转换为String类型
String s = sb.toString();
- 包装类
3.1 概述
- 包装类：封装了基本数据类型的一些操作，更加方便使用
- java中有8种基本数据类型
-
byte java.lang.Byte -
short java.lang.Short -
int java.lang.Integer -
long java.lang.Long -
float java.lang.Float -
double java.lang.Double -
boolean java.lang.Boolean -
char java.lang.Character
3.2 使用
//基本类型
byte b1 = 10;
//引用类型
Byte b2 = new Byte(b1);
m1(b2);
}
public static void m1(Object obj) {
System.out.println(obj);
3.3 Integer
3.3.1 基本使用
//获取最大值和最小值
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Long.MAX_VALUE);
System.out.println(Byte.MAX_VALUE);
//创建Integer类型的对象
//把基本类型转换为引用类型int-->Integer
Integer i1 = new Integer(10);
//把纯数字的字符串转换为Integer类型，必须是纯数字
//因为是整数，所以小数点也不能有，否则报错
Integer i2 = new Integer("12");
System.out.println(i1 + " " + i2);
3.3.2 常用方法
//int->Integer 直接创建对象
Integer i1 = new Integer(10);
//int–>Integer
Integer i1_1 = Integer.valueOf(22);
//Integer->int
//intValue 返回其int值
int i2 = i1.intValue();
//重要：static int parseInt(String s):把纯数字的字符串转换为int类型
int i3 = Integer.parseInt("234");
double d1 = Double.parseDouble("2.5");
System.out.println(d1);
//二进制展示 返回的是字符串
String s1 = Integer.toBinaryString(10);
System.out.println(s1);
//八进制展示
String s2 = Integer.toOctalString(10);
System.out.println(s2);
//十六进制展示
String s3 = Integer.toHexString(10);
System.out.println(s3);
3.3.3 类型转换
//1 int–>Integer
Integer i1 = Integer.valueOf(19);
//2 Integer->int
int i2 = i1.intValue();
//3 String->Integer
Integer i3 = Integer.valueOf(“22”);
//4 Integer->String
String i4 = i3.toString();
//5 int->String
String i5 = i2 + “”;
//6 String->int
int i6 = Integer.parseInt(i5);
3.3.4 装箱和拆箱
-
java 1.5开始，引入了自动装箱和自动拆箱
-
自动装箱：把 基本类型 自动转换为对应的封装类类型 就是自动装箱
-
自动拆箱：把 包装类类型 自动转换为对应的基本类型 就是自动拆箱
-
装箱和拆箱是在编译阶段完成的
//1.5之前 这样写
Integer i1 = Integer.valueOf(22);
int i2 = i1.intValue();//从1.5开始 这样写 Integer i3 = 22;//编译后自动转换为 Integer.valueOf(22); int i4 = i3;//编译后自动转换为i3.intValue() //先进行自动装箱为Integer类型，然后向上转型发生多态 为Object类型 m1(3123);//转化为m1(Integer.valueOf(3123)) m1(i3);}
public static void m1(Object obj) {
System.out.println(obj);
3.3.5 整型常量池
- 深入理解自动装箱和自动拆卸
-
1 都是编译的操作，和运行无关 -
2 装箱的时候 在编译时 会把赋值操作转换为 Integer.valueOf(222); - String 还有八种封装类 都覆写了 equals，hashCode，toString方法
- 整形常量池：起始就是一个Integer数组，提前创建号256 Integer对象，放到数组中
-
范围是-128~127 -
当我们在进行valueOf()的时候，先判断这个值是否在-128~127之前，如果在直接返回数组对应的Integer对象，不需要再次创建 //这句话编译之后 就等于是127，不需要重新创建一个堆内存对象，直接使用之前创建好的 Integer i0 = 127; //这句话就等于是new Integer(128); Integer i1 = 10; Integer i2 = 10; System.out.println(i1 == i2); Integer i3 = 222; Integer i4 = 222; System.out.println(i3 == i4);
- System
System类提供的public static long currentTimeMillis()用来返回当前时 间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
此方法适于计算时间差。
System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。 该类位于java.lang包。
由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实 例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便 的进行调用。
成员变量
System类内部包含in、out和err三个成员变量，分别代表标准输入流
(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。
成员方法
native long currentTimeMillis()：
该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时
间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
void exit(int status)：
该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表
异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
-
Date
时间类, 1970.1.1 8:00:00
5.1 构造方法
//无参 获取当前系统时间
Date d1 = new Date();//传入的是毫秒数，时间远点到指定毫秒数的时间 Date d2 = new Date(1000); System.out.println(d1); System.out.println(d2);
5.2 时间格式化
*new SimpleDateFormat(时间格式)：创建格式化对象并指定格式
*
public String format(Date date):把指定时间按照固定格式进行转换，并返回该时间格式字符串
*
public Date parse(String)
//获取当前系统时间
Date d1 = new Date();
/
* 年 y
* 月M
* 日 d
* 时H
* 分m
* 秒s
* 毫秒S
*/
//创建时间格式化对象
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss SSS”);
//格式化当前时间
String strTime = sdf.format(d1);
System.out.println(strTime);
strTime = "2021年07月13日 15:51:41 346";
Date d2 = sdf.parse(strTime);
System.out.println(d2);
5.3 日历
//创建日历 不能new抽象类
Calendar calendar = Calendar.getInstance();
//public abstract class Calendar implements Serializable, Cloneable, Comparable
//获取年
int year = calendar.get(Calendar.YEAR);
//获取月
int month = calendar.get(Calendar.MONTH) + 1;
//获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);
//获取时 HOUR_OF_DAY 24小时 HOUR 12小时
int hour = calendar.get(Calendar.HOUR_OF_DAY);
//获取分
int minute = calendar.get(Calendar.MINUTE);
//获取秒
int second = calendar.get(Calendar.SECOND);
//获取星期 第一天是周日
int weekday = calendar.get(Calendar.DAY_OF_WEEK);
System.out.println(year);
System.out.println(month);
System.out.println(day);
System.out.println(hour);
System.out.println(minute);
System.out.println(second);
System.out.println(weekday);
2617
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
