Day13 常用API（部分）

最新推荐文章于 2024-08-25 09:19:32 发布

GeneralHuge

最新推荐文章于 2024-08-25 09:19:32 发布

阅读量75

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_44482359/article/details/115530577

版权

Day13 常用API
1 谁的方法(哪个类的)
2 什么方法(静态还是成员)
3 功能是什么(这个方法能做什么)
4 入参(使用该方法需要传递什么参数)
5 出参(该方法返回值是什么)

String
1.1 是什么
String 是字符串类 , 在 java.lang.String , 所以使用不需要导包
底层就是一个char数组,所以字符串很多特性就是数组特性
数组特性 :
查询更改快,添加删除慢
长度一旦确定不可更改
字符串一旦确定不能更改
为了提升字符串的效率,java提供了一个"缓存机制",字符串常量池
String是引用类型,那么字符串应该保存在堆内存中,而字符串确被保存在常量池中
在程序执行中,如果需要用到一个字符串 (“abc”),会去字符串常量池中找,是否有abc,如果有直接拿过来使用,没有就创建一个

1.2 基本使用
public static void main(String[] args) {
//创建一个字符串对象，数据为a
String s1 = “a”;
//更改的是s1的指向，不再指向a而是指向b，并不会更改a的值
s1=“b”;

	//第二部分
	String s2="abc";
	String s3="abc";
	//true 因为执行的是同一个常量池的地址
	System.out.println(s3==s2);
	//true
	System.out.println(s3.equals(s2));
	
	//第三部分
	//s4指向堆内存，而堆内存中指向常量池的def
	String s4=new String("def");
	String s5=new String("def");
	//false
	System.out.println(s4==s5);
	//true
	System.out.println(s4.equals(s5));
}

1.3 不要频繁拼接
由于字符串一旦创建不能更改,所以不适合做频繁的拼接操作

public static void main(String[] args) {
	String arr[]={"a","b","c","d"};
	String temp ="";
	//拼接完成a,b,c,d  这样拼接 会创建很多字符串对象，浪费空间，效率低
	//因为并不是在原有空间进行更改，而是新建
	for(String string:arr){
		temp+=string+",";
	}
	System.out.println(temp);

}
1.4 构造方法

public static void main(String[] args) {
// 1
String s1 =“abc”;
// 2
String s2 = new String(“abc”);

	// 3 字节数组转字符串
	byte[] bytes = {97,98,99,100};
	String s3=new String(bytes);
	//abcd
	System.out.println(s3);
	
	// 4 字节数组中一部分转换为字符串
	//从下标为1开始（包含）取2个
	String s4 = new String(bytes,1,2);
	//bc
	System.out.println(s4);
	
	// 5 char数组转字符串
	char[] chars ={'a','b','c','d'};
	String s5 =new String(chars);
	//abcd
	System.out.println(s5);
	
	// 6 截取一部分
	String s6=new String(chars,2,2);
	//cd
	System.out.println(s6);
}

1.5 常用方法

public static void main(String[] args) {
// 1 char charAt(int index): 获取字符串某个位置上的字符
String s1 = “qwert!”;
char c1 = s1.charAt(2);
// e
System.out.println(c1);

	// 2 int length() : 返回字符串长度
	int length = s1.length();
	System.out.println(length);

	// 3 boolean endsWith(String suffix) : 判断字符串是否以指定字符串结尾
	// boolean startsWith(String prefix) : 判断字符串是否以指定字符开头
	System.out.println("Hello.java".endsWith("java"));
	System.out.println("Hello.java".startsWith("java"));

	// 4 boolean equals(String anotherString) : 比较两个字符串是否相等
	// boolean equalsIgnoreCase(String anotherString) : 忽略大小写比较是否相等
	System.out.println("abcDEF".equalsIgnoreCase("AbcDef"));

	// 5 byte[] getBytes() ： 把字符串转换为字节数组
	byte[] bytes = "abc".getBytes();
	for (byte b : bytes) {
		System.out.println(b);
	}

	// 6 int indexOf(String str) : 获取指定字符串的起始索引,找不到返回 -1
	System.out.println("cbuyasbrjqjhbfas".indexOf("b"));
	// int lastIndexOf(String str) : 获取最后一次出现的索引,找不到返回 -1
	System.out.println("cbuyasbrjqjhbfas".lastIndexOf("b"));
	// int indexOf(String str,int fromIndex) : 在指定位置开始找,第一次出现的索引,找不到返回-1
	System.out.println("cbuyasbrjqjhbfas".indexOf("b", 2));
	System.out.println("cbuyasbrjqjhbfas".lastIndexOf("b", 11));

	// 7 String replaceAll(String regex,String replacement) :
	// 把符合条件的字符用指定字符替换(支持正则表达式)
	// String replace(String xx,String replacement) :
	// 把指定的字符xx用指定字符替换replacement(不支持正则表达式)
	System.out.println("hello,java".replace(",", "#"));
	System.out.println("hello,java".replaceAll(",", "#"));

	// 8 String[] split(String regex) : 分割字符串,需要指定分隔符,支持正则表达式
	String time = "2008,08,08";
	String[] ymd = time.split(",");
	for (String string : ymd) {
		System.out.println(string);
	}

	// 9 String substring(int begin) : 获取该字符串的子字符串(下标是起始位置,包含)
	// String substring(int beginIndex,int endIndex) : 截取字符串,开始位置(包含)
	// 结束位置(不包含)
	// cdefg
	System.out.println("abcdefg".substring(2));
	System.out.println("abcdefg".substring(2, 3));

	// 10 char[] toCharArray() : 把字符串转换为char数组
	char[] chars = "abc".toCharArray();
	for (char c : chars) {
		System.out.println(c);
	}

	// 11 String toUpperCase() : 转大写
	// String toLowerCase() : 转小写
	System.out.println("casd".toUpperCase());

	// 12 String trim() : 去除字符串两边的空格
	System.out.println("                 a             b                         ");
	System.out.println("                 a             b                         ".trim());

	// 13 static String valueOf(Object obj) : 调用对象的toString方法,并解决空指针异常
	Object obj = null;
	// 空指针
	// obj.toString();
	System.out.println(obj);
}

1.6 注意
如果是 String s2 = “a”+“b”; 在编译阶段就等于是 ab 就会把 + 去掉
但是如果是变量相加 String s3 = a+b; String s4 = “a”+new String(“b”); 是运行时进行操作的
在运行时会创建一个StringBuffer对象,把两个字符串拼接到一起,然后转换为String,而此时 s3和s4 分别指向不同的堆内存空间
这种情况再比较的时候,只能使用equals
public static void main(String[] args) {
String s1 = “ab”;
// 这种字面量相加，在编译阶段，就把+去掉了，等于直接是ab
String s2 = “a” + “b”;
String a = “a”;
String b = “b”;
String s3=a+b;
String s4= a+new String(“b”);
System.out.println(s1s2);//true
System.out.println(s1s3);//false,因为 a + b 相当于
System.out.println(s1==s4);//false
}

StringBuffer和StringBuilder
2.1 是什么
java.lang.String
java.lang.StringBuffer
java.lang.StringBuilder

1 String 是不可变的字符串,一旦确定长度不能更改,所以不适合做拼接操作

2 StringBuffer和StringBuilder 是可变的字符串缓冲区,适合做拼接操作
原理 : 预先在内存中申请一块空间,用来容纳更多的字符(字符数组)
如果预留空间不够会自动扩容,默认容量是16个字符

3 StringBuffer和StringBuilder的区别
StringBuffer 线程安全,多线程环境下,没有问题,所以经常用于类中
StringBuilder 非线程安全,多线程环境下,可能有问题,所以经常用于方法中

2.2 使用方式
public static void main(String[] args) {
//创建对象
StringBuffer sb =new StringBuffer();
//添加（尾部追加）
sb.append(“a”);
sb.append(“b”);
//插入指定位置
sb.insert(1, “c”);
sb.insert(2,“d”);
//已有元素个数count
System.out.println(sb.length());
//返回当前容量value.length 默认容量是16，容量是插入字符的可用存储量，如果不够，就行分配
System.out.println(sb.capacity());
//转换为字符串 acdb
String string =sb.toString();
System.out.println(string);
//反转 bdca
System.out.println(sb.reverse());
}

Integer
3.1 是什么
包装类 : 封装了基本数据类型的一些操作,更加方便使用,更加面向对象

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

要求一个方法的参数列表可以接收任何数据类型
Object
所有类都可以转型为Object类型,但是基本数据类型呢? 可以转换为对应的封装类,然后封装类再向上转型为Object即可

public static void main(String[] args) {
//基本类型
byte b=10;
//引用类型，包装类
Byte b1 =new Byte(b);
m1(b1);
}
public static void m1(Object object){
System.out.println(object);
}
3.2 基本使用
public static void main(String[] args) {
// 1 获取最大/最小值
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
System.out.println(Byte.MAX_VALUE);
System.out.println(Long.MAX_VALUE);
// 2 创建包装类对象
//int -->Integer
Integer i1=new Integer(10);
//String -->Integer必须是纯数字的字符串,小数点也不能有
Integer i2 =new Integer(“1000”);
System.out.println(i1);
System.out.println(i2);
// java.lang.NumberFormatException: For input string: “2s”
// Integer i3 = new Integer(“2s”);
}
3.3 常用方法

public static void main(String[] args) {
	// 1 int -->Integer
	Integer i1 = new Integer(55);
	Integer i2 = Integer.valueOf(44);
	Integer i3 =Integer.valueOf("5000");
	
	// 2 Integer-->int
	int i4=i1.intValue();
	
	// 3 重要 static int parseInt(String s) : String -->int
	int age=Integer.parseInt("22");
	//转换为double
	double score=Double.parseDouble("97.5");
	
	// 4 static String toBinaryString(int value) : 转换为二进制显示
	String s1 = Integer.toBinaryString(10);
	System.out.println(s1);
	
	// 5 static String toOctalString(int value) : 转换为八进制显示格式
	System.out.println(Integer.toOctalString(10));
	
	// 6 static String toHexString(int value) : 转换为十六进制显示格式
	System.out.println(Integer.toHexString(10));
}

3.4 类型转换
public static void main(String[] args) {
// 1 int -->Integer
Integer i1 = Integer.valueOf(20);
// 2 Integer–>int
int i2 =i1.intValue();
// 3 String–>Integer
Integer i3=Integer.valueOf(“32”);
// 4 Integer–>String
String s1=i3.toString();
// 5 int ->String
String s2=10+"";
// 6 String–> int
int i4=Integer.parseInt(s2);
}

3.5 自动装箱/自动拆箱
java1.5开始新特性
自动装箱
把基本类型自动转换为封装类类型
自动拆箱
把封装类类型自动转换为基本类型

装箱和拆箱都是编译时处理的

public static void main(String[] args) {
// 1.5 之前
// int --> Integer
Integer i1 = new Integer(10);
// Integer --> int
int i2 = i1.intValue();

	// 1.5 开始
	// int --> Integer
	Integer i3 = 10;
	// Integer --> int
	int i4 = i3;
	// 此时 2 会先自动装箱,然后向上转型为Object
	m1(2);
	
	Integer i5 = 20;
	Integer i6 = 10;
	// 先自动拆箱为int类型,再相减
	System.out.println(i5 - i6);
	m1(i5 - i6);
}
public static void m1(Object o){
	System.out.println(o);
}

3.6 整型常量池
深入理解自动装箱和拆箱
1 都是编译时概念,和运行时无关
2 装箱会自动转换为 Integer.valueOf(xx)
3 拆箱会自动转换为 i1.intValue()

八种包装类和 String 都覆写了 toString 还有 equals , hashCode方法

Integer.valueOf : 基本类型转换为Integer类型,并且里面初始化了一个整型常量池
public static void main(String[] args) {
Integer i1 = 10;// 编译之后是这样 Integer i1=Integer.valueOf(10);符合范围就是要
// 提前准备好的对象
Integer i2 = 10;
// true
System.out.println(i1 == i2);
i1 = 128;// 编译之后是这样 Integer i1=Integer.valueOf(128);不符合范围，相当于Integer i1
// =new Integer(128)
i2=128;
//false
System.out.println(i1==i2);
//true 因为覆写了equals方法
System.out.println(i1.equals(i2));
}

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代表正常退出，非零代表
异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
public static void main(String[] args) {
// 获取时间原点到当前系统时间的毫秒数
// 1 秒 = 1000 毫秒
long now = System.currentTimeMillis();
System.out.println(now/1000.0/60/60/24/365);
}
5. Date
5.1 是什么
时间类
5.2 构造方法
无参有参
Date() : 获取当前系统时间
Date(long) : 获取时间原点到指定毫秒数的时间
5.3 基本使用
public static void main(String[] args) throws ParseException {
// 创建当前系统时间
Date date = new Date();
System.out.println(date);

	// 时间原点到指定毫秒数的时间
	Date date2 = new Date(1000);
	System.out.println(date2);

}
5.4 时间格式化

Format : 把时间以指定格式进行转换,转换为String类型
Parse : 字符串转换为Date对象,字符串类型必须和sdf一致

/*
* 年 y
* 月 M
* 日 d
* 时 H
* 分 m
* 秒 s
* 毫秒 S
*/

	// 创建时间格式化对象
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd~ HH:mm:ss.SSS");
	// 格式化时间,得到日期格式的字符串
	String strTime = sdf.format(date);
	System.out.println(strTime);
	// String类型的时间,转换为Date 类型 , string类型的时间格式 必须和sdf指定的格式一致
	Date d2 = sdf.parse(strTime);
	System.out.println(d2);