常用API
1 谁的方法(哪个类的)
2 什么方法(静态还是成员)
3 功能是什么(这个方法能做什么)
4 入参(使用该方法需要传递什么参数)
5 出参(该方法返回值是什么)
String
String 是字符串类 , 在 java.lang.String , 所以使用不需要导包
底层就是一个char数组,所以字符串很多特性就是数组特性
数组特性 :
查询更改快,添加删除慢
长度一旦确定不可更改
字符串一旦确定 不能更改
为了提升字符串的效率,java提供了一个"缓存机制",字符串常量池
String是引用类型,那么字符串应该保存在堆内存中,而字符串确被保存在常量池中
在程序执行中,如果需要用到一个 字符串 (“abc”),会去字符串常量池中找,是否有abc,如果有 直接拿过来使用,没有就创建一个
package _01String;
public class String1 {
public static void main(String[] args) {
String s1="ab"+"c";
String s2="abc";
String s3="abc";
//同一个常量池地址
System.out.println(s1==s2);
System.out.println(s3==s2);
System.out.println(s3.equals(s2));
//new的指向堆内存,堆内存中指向常量池的se
String s4=new String("se");
String s5=new String("se");
System.out.println(s4==s5);
System.out.println(s4.equals(s5));
//
String s6="ab";
String s7="ab";
System.out.println(s6==s7);
String s8=new String("sf");
String s9=new String("sf");
System.out.println(s8==s9);
System.out.println(s8.equals(s9));
}
}
//结果:
true
true
true
false
true
true
false
true
package _01String;
public class String2 {
public static void main(String[] args) {
String[] arr={"a","b","c"};
String tem="";
//拼接完成 a,b,c,d, 这样拼接 会创建很多字符串对象,浪费空间,效率低
// 因为并不是在原有空间进行更改,而是新建
for(String string : arr){
tem+=string+",";
}
System.out.println(tem);
System.out.println(tem.length());
//
String[] a={"b","c","d"};
String tem1="";
for(String str:a){
tem1+=str+".";
}
System.out.println(tem1);
}
}
//结果:
a,b,c,
6
b.c.d.
package _01String;
/*
* 如果是 String s2 = "a"+"b"; 在编译阶段 就等于是ab就会把 + 去掉
*
* 但是如果是变量相加 String s3 = a+b;
* String s4 = "a"+new String("b"); 是运行时进行操作的
* 在运行时会创建一个StringBuffer对象,把两个字符串拼接到一起,
* 然后转换为String,而此时 s3和s4 分别指向不同的堆内存空间
* 这种情况再比较的时候,只能使用equals
*
*/
public class String5 {
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(s2==s3);
System.out.println(s2==s4);
System.out.println(s2==s1);
}
}
//
false
false
true
StringBuffer和StringBuilder
package _01String;
/* java.lang.String
* java.lang.StringBuffer
* java.lang.StringBuilder
* 1 String 是不可变的字符串,一旦确定 长度不能更改,所以不适合做拼接操作
* 2 StringBuffer和StringBuilder 是可变的字符串缓冲区,适合做拼接操作
* 原理 : 预先在内存中申请一块空间,用来容纳更多的字符(字符数组)
* 如果预留空间不够 会自动扩容,默认容量是16个字符
*
* 3 StringBuffer和StringBuilder的区别
*StringBuffer 线程安全,多线程环境下,没有问题,所以经常用于类中
*StringBuilder 非线程安全,多线程环境下,可能有问题,所以经常用于方法中
*
*/
public class String6 {
public static void main(String[] args) {
//创建对象
StringBuilder sb=new StringBuilder();
//添加
sb.append("a");
sb.append("b");
//插入指定位置
sb.insert(2, "c");
System.out.println(sb.length());
System.out.println(sb);
//返回当前的容量value.length。默认是16,
//容量是新插入字符的可用存储量,否则将进行分配。
System.out.println(sb.capacity());
//转换为字符串
String s=sb.toString();
System.out.println(s);
// 反转
System.out.println(sb.reverse());
}
}
//结果:
3
abc
16
abc
cba
package _01String;
public class String4 {
public static void main(String[] args){
//获取字符串某个位置的字
String s1="asdfgh";
char c1=s1.charAt(2);
System.out.println(c1);
//返回长度
int l=s1.length();
System.out.println(l);
//判断字符串是否以指定字符串结束
//是否以指定字符开始
System.out.println("asddfdsf".endsWith("f"));
System.out.println("afsdfadsf".startsWith("afs"));
//比较两个字符串是否相等
System.out.println("ads".equals("Ads"));
System.out.println("ads".equalsIgnoreCase("Ads"));
//把字符串转换为字节数组
byte[] bytes="Abc".getBytes();
for(byte a:bytes){
System.out.println(a);
}
//获取指定字符串的起始索引下标,找不到返回 -1
System.out.println("adfdfsadfbc".indexOf("d"));
//获取最后一次出现的索引,找不到返回 -1
System.out.println("adfdfsadfbc".lastIndexOf("d"));
//在指定位置开始找,第一次出现的索引,找不到返回-1
System.out.println("asfuox".indexOf("o", 4));
System.out.println("asfuox".lastIndexOf("o", 5));
// 把符合条件的字符用指定字符替换(不支持正则表达式)
System.out.println("ffdagdgdffdsae".replace("f", "."));
// 把符合条件的字符用指定字符替换(支持正则表达式)
System.out.println("fFfdagdgdffdsae".replaceAll("f", "."));
// 分割字符串,需要指定分隔符,支持正则表达式
String time="13331,111,22";
String[] s=time.split(",");
for(String a:s){
System.out.println(a);
}
//获取该字符串的子字符串(下标是起始位置,包含)
System.out.println("afdadf".substring(2));
// 截取字符串,开始位置(包含) 结束位置(不包含)
System.out.println("afdadf".subSequence(1, 4));
// 把字符串转换为char数组
char[] chars="acva".toCharArray();
for(char c:chars){
System.out.println(c);
}
//转大写和小写
System.out.println("asdf".toUpperCase());
System.out.println("asdf".toUpperCase().toLowerCase());
//两边去空格
System.out.println(" x sdffsd ".trim());
// 调用对象的toString方法,并解决空指针异常
Object obj=null;
//obj.toString();
System.out.println(obj);
}
}
//
d
6
true
true
false
true
65
98
99
1
7
4
4
..dagdgd..dsae
.F.dagdgd..dsae
13331
111
22
dadf
fda
a
c
v
a
ASDF
asdf
x sdffsd
null
package _01String;
public class String3 {
public static void main(String[] args) {
String s1="abc";
String s2=new String("abd");
//字节数组转字符串
byte[] bytes={97,98,99,100};
String s3=new String(bytes);
System.out.println(s3);
//字节数组中一部分转换为字符串
//从下表1开始取两个
String s4=new String(bytes,2,2);
System.out.println(s4);
//char数组转字符串
char[] chars={'a','c','c','d','e'};
String s5=new String(chars);
System.out.println(s5);
//截取部分
String s6=new String(chars,3,2);
System.out.println(s6);
}
}
//
abcd
cd
accde
de
Integer
package _02Integer;
/* 包装类 : 封装了基本数据类型的一些操作,更加方便使用,更加面向对象
* 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 class Integer1 {
public static void main(String[] args) {
// 基本类型
byte b=127;
// 引用类型,包装类
Byte b1=new Byte(b);
m1(b1);
}
public static void m1(Object o){
System.out.println(o);
}
}
//
127
基本使用
package _02Integer;
public class Integer2 {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Short.MIN_VALUE);
System.out.println(Byte.MAX_VALUE);
System.out.println(Long.MAX_VALUE);
// 创建包装类对象
// int --> Integer
Integer i1=new Integer(10);
// String --> Integer 必须是纯数字的字符串,小数点也不能有
Integer i2=new Integer("1000");
System.out.println(i1);
System.out.println(i2);
}
}
//
2147483647
-32768
127
9223372036854775807
10
1000
常用方法
package _02Integer;
public class Integer3 {
public static void main(String[] args) {
Integer i1=new Integer(22);
Integer i3=Integer.valueOf(12);
Integer i4=Integer.valueOf("134");
int i2=i1.intValue();
//3 static int parseInt(String s) : String --> int 必须是纯数字的字符串
int age=Integer.parseInt("233");
//转double
double s=Double.parseDouble("23.3");
//转二进制显示格式
String s1=Integer.toBinaryString(4);
System.out.println(s1);
//转换为八进制显示格式
System.out.println(Integer.toOctalString(10));
//转换为十六进制显示格式
System.out.println(Integer.toHexString(15));
}
}
//
100
12
f
类型转换
package _02Integer;
/**
* int , Integer , String 三种类型相互转换
* @author moon
*/
public class Integer4 {
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("23");
//4 Integer-String
String s1=i3.toString();
//5 int-String
String s2=10+"";
//6 String -int
int i4=Integer.parseInt(s2);
}
}
自动装箱/自动拆箱
package _02Integer;
/*
java1.5开始新特性
*自动装箱
*把 基本类型 自动转换为 封装类类型
*自动拆箱
*把 封装类类型 自动转换为 基本类型
* 装箱和拆箱都是编译时处理的
*/
public class Integer5 {
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 = 12;
// 先自动拆箱为int类型,再相减
System.out.println(i5 + i6);
m1(i5 - i6);
}
public static void m1(Object o) {
System.out.println(o);
}
}
//
2
32
8
整型常量池
package _02Integer;
/*
* 深入理解自动装箱和拆箱
* 1 都是编译时概念,和运行时无关
* 2 装箱 会自动转换为 Integer.valueOf(xx)
* 3 拆箱 会自动转换为 i1.intValue()
* 八种包装类 和 String 都覆写了 toString 还有 equals , hashCode方法
* Integer.valueOf : 基本类型转换为Integer类型,
* 并且里面初始化了一个整型常量池
*/
public class Integer6 {
public static void main(String[] args) {
// 编译之后 是这样 Integer i1 = Integer.valueOf(10);
//符合范围 就是要 提前准备好的对象
Integer i1=10;
Integer i2=10;
System.out.println(i1==i2);
// 编译之后 是这样 Integer i1 = Integer.valueOf(128);
//相当于 Integer i1 = new Integer(128);
i1=128;
i2=128;
System.out.println(i1 == i2);
// true, 因为覆写了equals方法
System.out.println(i1.equals(i2));
}
}
//
true
false
true
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
构造方法
无参 有参
Date() : 获取当前系统时间
Date(long) : 获取时间原点到指定毫秒数的时间
基本使用
package _03Data;
import java.util.Date;
public class Data1 {
public static void main(String[] args) {
// 获取时间原点到当前系统时间的毫秒数
long now=System.currentTimeMillis();
System.out.println(now);
Date t=new Date();
System.out.println(t);
}
}
//
1617886722508
Thu Apr 08 20:58:42 CST 2021
时间格式化
package _03Data;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Data2 {
public static void main(String[] args) throws ParseException {
//创建当前系统时间
Date t=new Date();
System.out.println(t);
// 时间原点到指定毫秒数的时间
Date t1=new Date(2000);
System.out.println(t1);
//年月日 时分秒 毫秒 yMd Hms S
// 创建时间格式化对象
SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SSS");
//将时间t格式化
String str=sdf.format(t);
System.out.println(str);
// String类型的时间,转换为Date 类型 ,
//string类型的时间格式 必须和sdf指定的格式一致
Date t2=sdf.parse(str);
System.out.println(t2);
}
}
//
Thu Apr 08 20:59:12 CST 2021
Thu Jan 01 08:00:02 CST 1970
2021/04/08 20:59:12 518
Thu Apr 08 20:59:12 CST 2021
package _03Data;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Date3 {
public static void main(String[] args) {
//时间里的分钟减少10:
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
Date date = new Date();
String time = sdf.format(date);
String[] times = time.split(":");
int h = Integer.parseInt(times[0]);
int m = Integer.parseInt(times[1])-10;
if (m < 0) {
h--;
m += 60;
}
System.out.println(h + ":" + m);
// 获取当前时间毫秒数
long currentTimeMillis = System.currentTimeMillis();
// 减去10分钟的毫秒数
currentTimeMillis = currentTimeMillis - 1000 * 60 * 10;
// 创建时间对象
SimpleDateFormat dds=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SSS");
Date t=new Date(currentTimeMillis);
String str=dds.format(t);
System.out.println(str);
}
}
//
20:49
2021/04/08 20:49:43 023