常用类
常用类
String
Java JDK当中内置的一个类：java.lang.String
- String表示字符串类型，属于引用数据类型。
- 在Java中使用双引号括起来的都是String对象。
- 双引号括起来的字符串是不可变的。
- 在JDK当中双引号括起来的字符串都是直接储存在方法区中的字符串常量池当中。
- 垃圾回收器不会回收常量。
import java.util.Locale;
public class StringTest {
public static void main(String[] args) {
//String类常用方法
//1.(掌握) char charAt(int index)
char c = "中国人".charAt(1);//"中国人"是一个对象。
System.out.println(c);//国
//2.(了解) int compareTo(String anotherString)
//字符串不能直接比较大小，需要使用compareTo方法
System.out.println("abc".compareTo("abc"));//0
System.out.println("abc".compareTo("abb"));//1
System.out.println("abb".compareTo("abc"));//-1
//3.(掌握) boolean contains(charSequence s)
//判断前面的字符串是否包含后面的子字符串
System.out.println("HelloWorld.java".contains("java"));//true
System.out.println("http://www.baidu.com".contains("https://"));//false
//4.(掌握) boolean endsWith(String suffix)
//判断当前字符串是否以某个字符串结尾
System.out.println("Test.txt".endsWith(".java"));//false
System.out.println("Test.txt".endsWith(".txt"));//true
//5.(掌握) boolean equals(Object anObject)
//比较两个字符串必须使用equals方法，不能使用"=="
System.out.println("abc".equals("abc"));//true
//6.(掌握) boolean equalsIgnoreCase(String anotherString)
//判断两个字符串，同时忽略大小写
System.out.println("AbC".equalsIgnoreCase("aBc"));//true
//7.(掌握) byte[] getBytes()
//将字符串对象转换为字节数组
byte[] bytes = "abcde".getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.println(bytes[i]);//97 98 99 100 101
}
//8.(掌握) int indexOf(String str)
//判断某个字符串在当前字符串第一次出现的索引(下标)
System.out.println("012345java".indexOf("java"));//6
//9.(掌握) boolean isEmpty()
//判断某个字符串是否为空
System.out.println("".isEmpty());//true
System.out.println(" ".isEmpty());//false
System.out.println("a".isEmpty());//false
//10.(掌握) int length()
//判断字符串长度
//注意：判断数组长度和字符串长度不一样
//判断数组长度是length，判断字符串是length()方法
System.out.println("abc".length());//3
System.out.println("".length());//0
//11.(掌握) int lastIndexOf(String str)
//判断某个字符串在当前字符串最后一次出现的索引(下标)
System.out.println("1234java9java".lastIndexOf("java"));//9
//12.(掌握) String replace(CharSequence target, CharSequence replacement)
//String的父接口就是：CharSequence
System.out.println("http://www.baidu.com".replace("http://", "https://"));//https://www.baidu.com
//13.(掌握) String[] split(String regex)
//拆分字符串
String[] str = "2002-02-10".split("-");
for(int i=0;i<str.length;i++){
System.out.println(str[i]);
/*
2002
02
10
*/
}
//14.(掌握) boolean startsWith(String prefix)
//判断某个字符串是否以某个子字符串开始
System.out.println("http://www.baidu.com".startsWith("http"));//true
System.out.println("http://www.baidu.com".startsWith("https"));//false
//15.(掌握) String substring(int beginIndex)
//截取字符串
System.out.println("http://www,baidu.com".substring(7));//www,baidu.com
// 16.(掌握) String substring(int beginIndex, int endIndex)
//beginIndex 起始位置（包括）
//endIndex 结束位置（不包括）
System.out.println("http://www,baidu.com".substring(7,10));//www
//17.(掌握) char[] toCharArray()
//将字符串转化为char数组
char[] chars = "我是中国人".toCharArray();
for (int i = 0; i < chars.length; i++) {
System.out.println(chars[i]);
/*
我
是
中
国
人
*/
}
//18.(掌握) String toLowerCase()
//转换为小写
System.out.println("AbCDefGhIj".toLowerCase());//abcdefghij
//19.(掌握) String toUpperCase()
//转换为大写
System.out.println("AbCDefGhIj".toUpperCase());//ABCDEFGHIJ
//20.(掌握) String trim()
//去除字符串前后空白
System.out.println(" Hello World ".trim());//Hello World
//21.(掌握) static String valueOf(*)
//String中只有一个方法是静态的，这个方法叫valueOf
//作用是将非字符串转换为字符串
//通过查看源代码发现System.out.println()方法输出任何数据的时候都是通过valueOf转换为字符串。
System.out.println(String.valueOf(100));//100
System.out.println(String.valueOf(new Object()));
}
}
StringBuffer
/**
* 思考：我们在实际的开发中，如果需要频繁的字符串拼接，会有什么问题？
* 因为Java中字符串是不可变的，每一次拼接都会产生新的字符串
* 这样会占用大量的方法区内存，造成内存的浪费
* String s = "Hello";
* s += "World";
* 就以上两行代码，就在方法区常量池中创建了三个对象
* "Hello"
* "World"
* "HelloWorld"
* 如果以后需要进行大量字符串的拼接操作，建议使用JDK自带的：
* java.lang.StringBuffer
* java.lang.StringBuilder
* 如何优化StringBuffer 的性能？
* 在创建StringBuffer 尽可能给一个初始化容量
* 减少底层数组的扩容次数（关键就是：给一个合适的初始化容量）
*/
public class StringBufferTest {
public static void main(String[] args) {
/*
StringBuffer 底层是个byte[] 数组
往StringBuffer 放入字符串，实际上是放入byte[] 数组
StringBuffer 的初始容量为16
*/
StringBuffer stringBuffer = new StringBuffer();
//创建一个初始化容量为16的byte[] (字符串缓冲区对象)
//拼接字符串，以后拼接字符统一使用append()方法
stringBuffer.append("a");
stringBuffer.append("b");
stringBuffer.append("c");
stringBuffer.append(3.14);
stringBuffer.append(100L);
stringBuffer.append(true);
//append方法底层再追加字符串的时候，如果byte数组满了，会自动扩容
System.out.println(stringBuffer);//abc3.14100true
/*
StringBuilder
StringBuffer和StringBuilder的区别
StringBuffer 的方法都是有synchronized关键字修饰，表示StringBuffer在多线程环境下是安全的
StringStringBuilder 的方法都是没有synchronized关键字修饰，表示StringBuffer在多线程环境下是不安全的
*/
}
}
基础类型对应的8个包装类
只说明Integer类，其他照葫芦画瓢就行。
-
Java中为了8种基本数据类型又对应准备了8种包装类型，8种包装类型属于引用数据类型，父类是Object
-
思考：为什么要再提供8种包装8种包装类型？
因为这样就能传输几乎所有的数据类型
import java.awt.geom.FlatteningPathIterator;
public class IntegerTest {
/*
总结一下之前的学的经典异常：
1. 空指针异常:NullPointerException
2. 类型转换异常:ClassCastException
3. 数组下标越界异常:ArrayIndexOutOfBoundsException
4. 数字格式化异常:NumberFormatException
*/
public static void main(String[] args) {
//手动装箱
Integer x = new Integer(1000);
//手动拆箱
int y = x.intValue();
System.out.println(y);
/*
Integer a = new Integer("中国");
NumberFormatException
*/
Integer a = new Integer("123");//里面得是数字字符
//1.(重点) static int parseInt(String s)
//静态方法，传参String，返回int
//网页文本框中输入的其实是字符串，但是后台的数据库储存的是数字，此时就需要这个方法来转换
System.out.println(Integer.parseInt("133")+100);//233
System.out.println(Double.parseDouble("3.14")+1);//4.140000000000001
System.out.println(Float.parseFloat("1.0")+1);//2.0
//以下有些情况可能会使用到
//static String toBinaryString(int i)
//十进制转换为二进制
System.out.println(Integer.toBinaryString(3));//11
//static String toHexString(int i)
//十进制转换为十六进制
System.out.println(Integer.toHexString(16));//10
//static String toOctalString(int i)
//十进制转换为八进制
System.out.println(Integer.toOctalString(8));//10
//static Integer valueOf(int i)
//int-->Integer
System.out.println(Integer.valueOf(100));//100
//static Integer valueOf(String s)
//String-->Integer
System.out.println(Integer.valueOf("123"));//123
//String Integer int 互转
//int-->String
String s1 = 123 + "";
//String-->int
Integer.parseInt("123");
//int-->Integer
Integer.valueOf(100);
//Integer-->int
Integer I1 = 1000;
int i2 = I1;
i2 = I1.intValue();
//String-->Integer
Integer.valueOf("233");
//Integer-->String
String.valueOf(I1);
}
}
日期相关类
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateTest {
public static void main(String[] args) throws Exception {
/*
这一段有三个知识点
1. 获取系统当前时间
2. Date-->String
3. String-->Date
*/
//获取系统当前时间
//直接调用无参构造就行
Date nowTime = new Date();
//java.util.Date包下的toString()方法已经被重写
//输出的不再是一个对象的内存地址，而是一个日期字符串，按照指定类型进行转换
// Date-->String
System.out.println(nowTime);//Sun Jan 31 12:11:34 CST 2021
//日期可以被格式化
//将日期类型Date转换为具有一定格式日期字符串
//SimpleDateFormat是java.text包下的，专门负责日期格式化
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
//SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
//SimpleDateFormat sdf = new SimpleDateFormat("yy/MM/dd HH:mm:ss");
/*
yyyy 年（4位）
MM 月（2位）
dd 天
HH 时
mm 分
ss 秒
SSS 毫秒 （3位）
注意：在日期格式中，除了y M d H m D s S 这些符号不能随便写，剩下的符号随意
*/
System.out.println(sdf1.format(nowTime));//2021-01-31 14:25:56 564
//String-->Date
String time = "2008-08-08 08:08:08 888";//格式不能随便写
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
//字符串的日期格式必须和SimpleDateFormat对象指定的日期格式一直，不然会出现异常：java.text.ParseException
Date dateTime = sdf2.parse(time);
System.out.println(dateTime);//Fri Aug 08 08:08:08 CST 2008
/*
获取自1070年1月1日 00:00:00 000到当前系统时间的毫秒数
*/
long nowTimeMillis = System.currentTimeMillis();
System.out.println(nowTimeMillis);//1612076676143
//需求：统计一个方法执行耗费的时长
//在调用目标方法前记录一个毫秒数
long begin = System.currentTimeMillis();
print();
//在调用目标方法后记录一个毫秒数
long end = System.currentTimeMillis();
System.out.println("耗费时长" + (end - begin) + "毫秒");
/*
总结以下System类相关属性和方法
System.out(out是System类集静态变量)
System.out.println()(println()方法不是System类的，而是PrintStream类的方法)
System.gc() 建议启动垃圾回收器
System.currentTimeMillis() 获取自1070年1月1日 00:00:00 000到当前系统时间的毫秒数
System.exit(0) 退出JVM
*/
Date time2 = new Date(System.currentTimeMillis()-1000*60*60*24);
System.out.println(sdf1.format(time2));//2021-01-30 15:34:12 272
}
public static void print() {
for (int i = 0; i < 1000000000; i++) {
//System.out.println("i=" + i);
}
}
}
数字相关类
import java.math.BigDecimal;
import java.text.DecimalFormat;
public class DecimalFormatTest {
public static void main(String[] args) {
//java.text.DecimalFormat专门负责数字格式化
//DecimalFormat df = new DecimalFormat("数字格式");
/*
数字格式有哪些：
#表示任意数字
,代表千分位
.代表小数点
0代表不够时补0
*/
DecimalFormat df = new DecimalFormat("###,###.##");
System.out.println(df.format(1234.56));//1,234.56
DecimalFormat df1 = new DecimalFormat("###,###.0000");
System.out.println(df1.format(1234.56));//1,234.5600
/*
1. BigDecimal 属于大数，不属于基本类型，属于Java对象（引用数据类型）
SUN公司提供的一个类，专门用于财务软件中。
2. 财务软件中double时不够用的（精度不够）
*/
BigDecimal v1 = new BigDecimal(100);
BigDecimal v2 = new BigDecimal(200);
System.out.println(v1.add(v2));//300
System.out.println(v2.divide(v1));//2
}
}
Randon
import java.util.Random;
public class RandomTest {
public static void main(String[] args) {
//创建随机数对象
Random random = new Random();
//随机产生一个int类型范围的数字
//System.out.println(random.nextInt());
//产生[0~100]之间的随机数
//nextInt表示：下一个int类型数据是101，表示只能取到100
//System.out.println(random.nextInt(101));
/*
编写程序
生成5个不重复的随机数，重复的话随机生成
将最终生成的5个随机数方到数组中
*/
int[] arr = new int[5];
int index = 0;
while (index < arr.length) {
int key;
key = random.nextInt(6);
if (isCompare(arr, key)) {
arr[index++] = key;
}
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static boolean isCompare(int[] arr, int key) {
for (int j = 0; j < arr.length; j++) {
if (key == arr[j]) {
return false;
}
}
return true;
}
}
Enum
/*
通过枚举改造程序
*/
public class EnumTest {
public static void main(String[] args) {
System.out.println(divide(1, 0));
}
/*
public static boolean divide(int a, int b) {
try {
int c = a / b;
return true;
} catch (Exception e) {
return false;
}
}
}
*/
/**
* 计算除法
* @param a int数据
* @param b int数据
* @return Result.SUCCESS表示成功 Result.FAIL表示失败
*/
public static Result divide(int a, int b) {
try {
int c = a / b;
return Result.SUCCESS;
} catch (Exception e) {
return Result.FAIL;
}
}
}
enum Result {
SUCCESS,FAIL;
}
/*
总结：
1. 枚举类型是一个引用数据类型
2. 枚举类型怎么定义，语法是？
enum 枚举类型名 {
枚举值，枚举值；
}
3. 结果只有两种情况的，建议使用布尔类型结果超过两种，而且还能一一列举出来，建议使用枚举类型
例如：颜色，四季，星期都可以使用枚举类型
4. 枚举中的每一个值可以看作常量
5. switch语句支持枚举类型，switch也支持String，int
低版本的JDK只支持int
高版本的JDK只支持int，String，枚举。
byte，short，char也可以，因为存在自动类型转换
*/
浙公网安备 33010602011771号