Day13 常用API

最新推荐文章于 2024-08-28 09:41:09 发布

Fairyta1e

最新推荐文章于 2024-08-28 09:41:09 发布

阅读量87

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_46311092/article/details/115528177

版权

String

是什么

字符串类
底层就是一个char数组
查询更改快,添加删除慢

长度一旦确定不可更改
字符串一旦确定不能更

为了提升字符串的效率,java提供了一个"缓存机制",字符串常量池
String是引用类型,那么字符串应该保存在堆内存中,而字符串确被保存在常量池中
在程序执行中,如果需要用到一个字符串 (“abc”),会去字符串常量池中找,是否有abc,如果有直接拿过来使用,没有就创建一个

// 创建一个字符串对象,数据为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 
		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 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 ".endsWith("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);

如果是 String s2 = “a”+“b”; 在编译阶段就等于是 ab 就会把 + 去掉
但是如果是变量相加 String s3 = a+b; String s4 = “a”+new String(“b”); 是运行时进行操作的
在运行时会创建一个StringBuffer对象,把两个字符串拼接到一起,然后转换为String,而此时 s3和s4 分别指向不同的堆内存空间
这种情况再比较的时候,只能使用equals

StringBuffer和StringBuilder

可以不断扩容分为整个长度与内容长度

String 是不可变的字符串,一旦确定长度不能更改,所以不适合做拼接操作
StringBuffer和StringBuilder 是可变的字符串缓冲区,适合做拼接操作
原理 : 预先在内存中申请一块空间,用来容纳更多的字符(字符数组)
如果预留空间不够会自动扩容,默认容量是16个字符
StringBuffer和StringBuilder的区别
StringBuffer 线程安全,多线程环境下,没有问题,所以经常用于类中
StringBuilder 非线程安全,多线程环境下,可能有问题,所以经常用于方法中

// 创建对象
		StringBuilder sb = new StringBuilder();
		// 添加(尾部追加)
		sb.append("a");
		sb.append("b");
		// 插入指定位置
		sb.insert(1, "c");
		// 已有元素个数count
		System.out.println(sb.length());
		// 返回当前的容量value.length。默认是16,容量是新插入字符的可用存储量，否则将进行分配。
		System.out.println(sb.capacity());
		// 转换为字符串 acb
		String string = sb.toString();
		System.out.println(string);
		// 反转 bca
		System.out.println(sb.reverse());

Integer

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

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

// 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");

常用方法

// 1 int --> Integer
		Integer i1 = new Integer(22);
		Integer i3 = Integer.valueOf(23);
		Integer i4 = Integer.valueOf("333");
		
		// 2 Integer --> int
		int i2 = i1.intValue();
		
		// 3 重要  static int parseInt(String s) : String --> int 必须是纯数字的字符串
		int age = Integer.parseInt("18");
		// 转换为 double
		double score = Double.parseDouble("2.3");
		
		// 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));

类型转换

	// 1 int -> Integer
		Integer i1 = Integer.valueOf(20);
		// 2 Integer -> int
		int i2 = i1.intValue();
		// 3 String -> Integer
		Integer i3 = Integer.valueOf("33");
		// 4 Integer -> String
		String s1 = i3.toString();
		// 5 int -> String
		String s2 = 10 + "";
		// 6 String -> int
		int i4 = Integer.parseInt(s2);

自动装箱/自动拆箱

在这里插入图片描述

// 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);
	}

整型常量池

深入理解自动装箱和拆箱

都是编译时概念,和运行时无关
装箱会自动转换为 Integer.valueOf(xx)
拆箱会自动转换为 i1.intValue()

八种包装类和 String 都覆写了 toString 还有 equals , hashCode方法
Integer.valueOf : 基本类型转换为Integer类型,并且里面初始化了一个整型常量池

		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代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。

// 获取时间原点到当前系统时间的毫秒数
		// 1 秒 = 1000 毫秒
		long now = System.currentTimeMillis();
		System.out.println(now/1000.0/60/60/24/365);

Date

时间类
Date() : 获取当前系统时间
Date(long) : 获取时间原点到指定毫秒数的时间

		// 创建当前系统时间
		Date date = new Date();
		System.out.println(date);
		
		// 时间原点到指定毫秒数的时间
		Date date2 = new Date(1000);
		System.out.println(date2);
		
		/*
		 * 年 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);