2021-07-13常用API

最新推荐文章于 2022-08-01 19:14:23 发布

我再睡十分钟

最新推荐文章于 2022-08-01 19:14:23 发布

阅读量145

点赞数

本文链接：https://blog.csdn.net/weixin_59544199/article/details/118708247

版权

String

1.1概述

java.lang.String 是字符串类
*
* 它的底层就是一个字符数组,所以它的很多特性就是数组的特性
*        1 字符串一旦创建,这个字符串对象不能更改
*        2 字符串需要使用 "" 双引号表示
*        3 为了提高字符串访问效率,提出了一个缓存机制,字符串常量池

1.2基本使用

public static void main(String[] args) {
		// 尽管没有new,但是 s1依然代表String的对象,因为字符串常量池
		String s1 = "abc";
		// s1没有使用final修饰.所以s1的值可以更改,只不过是让s1指向了bcd这个字符串对象,而abc这个对象没有更改
		s1 = "bcd";
		// 第二部分
		String s2 = "Hello";
		String s3 = "Hello";
		String s4 = "hello";
		// s2和s3都指向常量池中的这个字符串对象,所以内存地址都相同
		System.out.println(s2 == s3);
		// s4指向常量池中 新的字符串对象 因为h和H 是不一样的
		System.out.println(s4 == s3);
		System.out.println(s2.equals(s3));
		// 第三种
		String s5 = new String("abc");
		String s6 = new String("abc");
		String s7 = "abc";
		// s5和s6是new的方式,所以分别指向各自的堆内存,这样用== 肯定是false
		System.out.println(s5==s6);
		System.out.println(s5 == s7);
		// 但是 String类中覆写了equals方法,比较的是值,不是内存地址
		// 所以 我们比较字符串是否相等的时候,应该使用equals,而不是==
		System.out.println(s5.equals(s6));
	}
}

1.3不要频繁拼接

因为String一旦创建,字符串对象不可更改,
*
* 所以尽量不要使用String进行大量的字符串拼接操作

public static void main(String[] args) {
		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构造方法

public static void main(String[] args) {
		// 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);
		System.out.println(s4);
		
		// 5 字符数组
		char[] chars = {'a','b','c','d','e'};
		String s5 = new String(chars);
		// abcde
		System.out.println(s5);
		// 6 截取字符数组一部分
		// 下标2开始(包含),取2个
		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));

2.StringBuffer和StringBuilder

2.1概述

1 StringBuffer 和 StringBuilder是什么?
*            是一个可变的字符串缓冲区,适合做拼接操作
*            底层也是char数组,只不过默认长度是16,而字符串内容多少长度就是多少
*    2 原理
*           先定义好长度,以容纳更多字符
*            如果预留的空间长度不够,会进行自动扩容
*            默认长度为16,扩大容量为 (当前容量+1) * 2 , 16 -> 34 -> 70
* 3 StringBuffer 和 StringBuilder 区别
*            StringBuilder : 非线程安全,在多线程环境下使用,可能出现问题,所以常用于方法中
*            StringBuffer : 线程安全,在多线程环境下使用,不会出现问题,所以常用于类中

2.2使用

public static void main(String[] args) {
		// 创建字符串缓冲区对象
		StringBuilder sb = new StringBuilder();
		// 尾部添加数据
		sb.append("a");
		sb.append("b");
		// return this 所以可以链式调用
		sb.append("c").append("d");
		System.out.println(sb);

		// 1 反转
		// dcba
		System.out.println(sb.reverse());

		// 指定位置添加数据
		sb.insert(1, "2");
		// d2cba
		System.out.println(sb);
		// 已有元素个数
		System.out.println(sb.length());
		// 16 当前数组的容量,value.length
		System.out.println(sb.capacity());
		
		// 把sb转换为String类型
		String s = sb.toString();
	}
}

3.包装类

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使用

public static void main(String[] args) {
		// 基本类型
		byte b1 = 10;
		// 引用类型
		Byte b2 = new Byte(b1);
		m1(b2);
	}
	public static void m1(Object obj){
		// 由于 Byte Integer这些 都覆写toString方法,所以不是内存地址,而是值
		System.out.println(obj);
	}
}

3.3Integer

3.3.1基本使用

public static void main(String[] args) {
		// 获取最大值和最小值
		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);
		System.out.println(i2);
		// 如果不是纯数字,会报错
		//  java.lang.NumberFormatException: For input string: "2.3"
		Integer i3 = new Integer("2.3");
	}
}

3.3.2常用方法

public static void main(String[] args) {
		// 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类型转换

public static void main(String[] args) {
		// 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装箱和拆箱

java1.5开始,引入了自动装箱和自动拆箱
*
* 自动装箱 : 把基本类型自动转换为对应的封装类类型就是自动装箱
*
* 自动拆箱 : 把包装类类型自动转换为对应的基本类型就是自动拆箱
*
* 装箱和拆箱是在编译阶段完成的

深入理解自动装箱和自动拆卸
* 1 都是编译的操作,和运行无关
* 2 装箱的时候在编译时会把赋值操作转换为 Integer.valueOf(222);
*
* String 还有八种封装类都覆写了 equals,hashCode,toString方法

public static void main(String[] args) {
		// 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(Integer.valueOf(3123));
		m1(3123);
	}
	public static void m1(Object obj){
		System.out.println(obj);
	}
}

3.3.5整形常量池

整型常量池 : 其实就是一个Integer数组 , 提前创建好256个Integer对象,放到数组中
* 范围是 -128~127
* 当我们在进行valueOf() 的时候,先判断这个值是否在 -128~127之间,如果在直接返回数组对应的Integer对象,不需要再次创建

public static void main(String[] args) {
		// 这句话编译之后 就等于是 127 , 不需要重新创建一个堆内存对象,直接使用之前创建好的
		Integer i3 = 127;
		Integer i4 = 127;
		// true
		System.out.println(i3 == i4);
		System.out.println(i3.equals(i4));
		// 这句话 就等于是 new Integer(128);
		Integer i1 = 128;
		Integer i2 = 128;
		// false
		System.out.println(i1 == i2);
		System.out.println(i1.equals(i2));
	}
}

4.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) {
		// 计算时间差
		// currentTimeMillis : 获取当前系统时间对应的毫秒数
		long startTime = System.currentTimeMillis();
		System.out.println("正在执行");
		long endTime = System.currentTimeMillis();
		System.out.println("耗时 : "+(endTime-startTime));
		
		// 退出程序,0 表示正常退出
		// 一般用于图形界面 关闭窗口
		System.exit(0);
		// 执行不到
		System.out.println(222);
	}
}

5.Date

时间类, 1970.1.1 8:00:00

5.1构造方法

public static void main(String[] args) {
		// 无参 获取当前系统时间
		Date d1 = new Date();
		// 传入的是毫秒数,时间原点到指定毫秒数的时间
		Date d2 = new Date(1000);
		// Tue Jul 13 15:40:50 CST 2021
		System.out.println(d1);
		// Thu Jan 01 08:00:01 CST 1970
		System.out.println(d2);
	}
}

5.2时间格式化

new SimpleDateFormat(时间格式) : 创建格式化对象并指定格式
*
* public String format(Date date) : 把指定时间按照固定格式进行转换,并返回该时间格式的字符串
*
* public Date parse(String strTime) : 把时间格式的字符串,按照对应的格式转换为 Date对象

public static void main(String[] args) throws ParseException {
		// 获取当前系统时间
		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);
		// 2021年07月13日 15:46:01 324
		System.out.println(strTime);
		
		strTime = "2021年07月13日 15:46:01 324";
		Date d2 = sdf.parse(strTime);
		// Tue Jul 13 15:46:01 CST 2021
		System.out.println(d2);
	}
}

5.3日历

public static void main(String[] args) {
		// 创建日历
		Calendar c = Calendar.getInstance();
		// 获取年
		int year = c.get(Calendar.YEAR);
		// 获取月 , 0 表示1月,以此类推
		int month = c.get(Calendar.MONTH)+1;
		// 获取日
		int day = c.get(Calendar.DAY_OF_MONTH);
		// 获取时 , HOUR_OF_DAY 24小时  HOUR 12小时
		int hour = c.get(Calendar.HOUR_OF_DAY);
		// 获取分
		int minute = c.get(Calendar.MINUTE);
		// 获取秒
		int second = c.get(Calendar.SECOND);
		// 获取星期 , 第一天是周日
		int weekday  = c.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);
	}
}