day14-15 常用类
常用类
1. 枚举
枚举是由一组固定的静态常量组成的类型 枚举类不能new对象
package com.atguigu.test1;
public enum Week {
MON, TUE, WED, THUR, FRI, SAT, SUN
}
package com.atguigu.test1;
public class PrintWeek {
public static void main(String[] args) {
Week day = Week.FRI;
switch (day){
case MON:
System.out.println("周一");
break;
case TUE:
System.out.println("周二");
break;
case WED:
System.out.println("周三");
break;
case THUR:
System.out.println("周四");
break;
case FRI:
System.out.println("周五"); // 周五
break;
case SAT:
System.out.println("周六");
break;
case SUN:
System.out.println("周日");
break;
default:
System.out.println("一周只有七天");
break;
}
System.out.println("---------------------------");
printWeek(Week.SAT); // 周六
}
public static void printWeek(Week day){
switch (day){
case MON:
System.out.println("周一");
break;
case TUE:
System.out.println("周二");
break;
case WED:
System.out.println("周三");
break;
case THUR:
System.out.println("周四");
break;
case FRI:
System.out.println("周五");
break;
case SAT:
System.out.println("周六");
break;
case SUN:
System.out.println("周日");
break;
default:
System.out.println("一周只有七天");
break;
}
System.out.println("printWeek方法执行完毕"); // printWeek方法执行完毕
}
}
2. 包装类
基本数据类型和包装类
每个基本数据类型在lang包中都有与之对应的一个包装类类型 包装类相当于基本数据类型 ‘穿了一个马甲’
内部依然保存的是基本数据类型的值
byte short int long float double boolean char
Byte Short Integer Long Float Double Boolean Character(科瑞科特儿)
2.1 构造方法
构造方法：每个包装类都支持传入一个与之对应的基本数据类型的参数来构造当前实例
除了Character之外 其他的包装类还支持传入一个String类型的参数构造当前实例
在使用字符串构造数值类型的包装类对象的时候，字符串不能为null，必须可以解析为正确的数值才可以，否则将报
NumberFormatException
使用字符串构造Boolean类型实例
字符串内容不缺分大小写 如果内容为true 则表示为true 其他都表示为false
package com.atguigu.test2;
/**
* 基本数据类型和包装类
* 每个基本数据类型在long包中都有与之对应的一个包装类型 包装类相当于基本数据类型 '穿了一个马甲'
* 内部依然保存的是基本数据类型的值
*
* byte short int long float double boolean char
* Byte Short Integer Long Float Double Boolean Character(科瑞科特儿)
*
* 构造方法：每个包装类都支持传入一个与之对应的基本数据类型的参数来构造当前实例
* 除了Character之外 其他的包装类还支持传入一个String类型的参数构造当前实例
* */
public class Test1 {
public static void main(String[] args) {
Byte b1 = new Byte((byte)28);
Byte b2 = new Byte("123");
System.out.println(b1); // 28
System.out.println(b2); // 123
System.out.println(b1.toString()); // 28
System.out.println(b2.toString()); // 123
System.out.println("--------------------------");
Short s1 = new Short((short)231);
Short s2 = new Short("324");
System.out.println(s1); // 231
System.out.println(s2); // 324
System.out.println("--------------------------");
Integer i1 = new Integer(456);
Integer i2 = new Integer("2341");
System.out.println(i1); // 456
System.out.println(i2); // 2341
System.out.println("--------------------------");
Long l1 = new Long(12423);
Long l2 = new Long("122341");
System.out.println(l1); // 12423
System.out.println(l2); // 122341
System.out.println("--------------------------");
Float f1 = new Float(3.234f);
Float f2 = new Float("12313");
System.out.println(f1); // 3.234
System.out.println(f2); // 12313.0
System.out.println("--------------------------");
Boolean bl1 = new Boolean(true);
Boolean bl2 = new Boolean("tRue");
// 使用字符串构造Boolean类型实例
// 字符串内容不区分大小写 如果内容为true 则表示为true 其他都表示为false
Boolean bl3 = new Boolean("asd");
System.out.println(bl1); // true
System.out.println(bl2); // true
System.out.println(bl3); // false
System.out.println("--------------------------");
Character ch1 = new Character('A');
System.out.println(ch1); // A
}
}
2.2 包装类转基本数据类型
xxxValue():每个包装类中都提供有这样的方法 用于将包装类对象转换为基本数据类型
package com.atguigu.test3;
/**
* xxxValue(): 每个包装类中都提供有这样的方法 用于将包装类对象转换为基本数据类型
* */
public class Test1 {
public static void main(String[] args) {
// Byte转换为byte基本数据类型
Byte b1 = new Byte("123");
byte b2 = b1.byteValue();
System.out.println(b2); // 123
System.out.println("---------------------");
// Short转换为short基本数据类型
Short s1 = new Short("556");
// 在有返回值的方法名之后直接.var 表示自动生成一个对应的变量来接收方法的返回值
// 自动生成的变量直接处于选中状态 我们直接改变变量名即可
short s2 = s1.shortValue();
System.out.println(s2); // 556
System.out.println("---------------------");
// Integer转换为int基本数据类型
Integer i1 = new Integer(2323);
int i2 = i1.intValue();
System.out.println(i2); // 2323
System.out.println("---------------------");
// Long转换为long基本数据类型
Long l1 = new Long(234123);
long l2 = l1.longValue();
System.out.println(l2); // 234123
System.out.println("---------------------");
// Float转换为float基本数据类型
Float f1 = new Float(23.132f);
float f2 = f1.floatValue();
System.out.println(f2); // 23.132
System.out.println("----------------------");
// Double转换为double基本数据类型
Double d1 = new Double(123498234.123);
double d2 = d1.doubleValue();
System.out.println(d2); // 1.23498234123E8
System.out.println("----------------------");
// Boolean转换为boolean基本数据类型
Boolean bl1 = new Boolean(false);
boolean bl2 = bl1.booleanValue();
System.out.println(bl2); // false
System.out.println("----------------------");
// Character转换为char基本数据类型
Character ch1 = new Character('A');
char ch2 = ch1.charValue();
System.out.println(ch2); // A
}
}
2.3 基本数据类型转包装类
valueOf():每个包装类都提供有 valueOf方法 用于将基本数据类型转换为与之对应的包装类
package com.atguigu.test3;
import java.util.Date;
/**
* valueOf():每个包装类都提供由valueOf方法 用于将基本数据类型转换为与之对应的包装类
* */
public class Test2 {
public static void main(String[] args) {
// 将byte基本数据类型转换为Byte包装类
Byte b1 = Byte.valueOf((byte)123);
System.out.println(b1); // 123
Byte b2 = Byte.valueOf("113");
System.out.println(b2); // 113
System.out.println("--------------------");
// 将short基本数据类型转换为Short包装类
Short s1 = Short.valueOf((short) 2341);
System.out.println(s1); // 2341
Short s2 = Short.valueOf("3241");
System.out.println(s2); // 3241
System.out.println("--------------------");
// 将int基本数据类型转换为Integer包装类
Integer i1 = Integer.valueOf(98273412);
System.out.println(i1); // 98273412
Integer i2 = Integer.valueOf("12314");
System.out.println(i2); // 12314
System.out.println("--------------------");
// 将long基本数据类型转换为Long包装类
Long l1 = Long.valueOf(12398123);
System.out.println(l1);
Long l2 = Long.valueOf("12314234");
System.out.println(l2);
System.out.println("--------------------");
// 将float基本数据类型转换为Float包装类
Float f1 = Float.valueOf(123.12f);
System.out.println(f1); // 123.12
Float f2 = Float.valueOf("2341.1f");
System.out.println(f2); // 2341.1
System.out.println("--------------------");
// 将double基本数据类型转换为Double包装类
Double d1 = Double.valueOf(12312.123);
System.out.println(d1); // 12312.123
Double d2 = Double.valueOf("123.123");
System.out.println(d2); // 123.123
System.out.println("--------------------");
// 将boolean基本数据类型转换为Boolean包装类
Boolean bl1 = new Boolean(false);
System.out.println(b1); // false
Boolean bl2 = new Boolean("as");
System.out.println(bl2); // false
System.out.println("--------------------");
// 将char基本数据类型转换为Character包装类
Character ch1 = Character.valueOf('A');
Character ch2 = Character.valueOf('2');
System.out.println(ch1); // A
System.out.println(ch2); // 2
}
}
2.4 基本数据类型转字符串
toString() : 每个包装类都提供有toString(带参数)方法 用于将基本数据类型转换为字符串
package com.atguigu.test4;
/**
* toString(): 每个包装类都提供由toString(带参数)方法 用于将基本数据类型转换为字符串
* */
public class Test1 {
public static void main(String[] args) {
// 将Byte包装类转换为字符串类型
String b1 = Byte.toString((byte)20);
System.out.println(b1); // 20
System.out.println("----------------------");
// 将Short包装类转换为字符串类型
String s1 = Short.toString((short) 1234);
System.out.println(s1); // 1234
System.out.println("----------------------");
// 将Integer包装类转换为字符串类型
String i1 = Integer.toString(111);
System.out.println(i1); // 111
System.out.println("----------------------");
// 将Long包装类转换为字符串类型
String l1 = Long.toString(324241L);
System.out.println(l1); // 324241
System.out.println("----------------------");
// 将Float包装类转换为字符串类型
String f1 = Float.toString(132.12f);
System.out.println(f1); // 132.12
System.out.println("----------------------");
// 将Double包装类转换为字符串类型
String d1 = Double.toString(124234.1);
System.out.println(d1); // 124234.1
System.out.println("----------------------");
// 将Boolean包装类转换为字符串类型
String bl1 = Boolean.toString(false);
System.out.println(bl1); // false
System.out.println("----------------------");
// 将Character包装类转换为字符串类型
String ch1 = Character.toString('w');
System.out.println(ch1); // w
}
}
2.5 字符串转基本数据类型
parseXXX() : 除了Character类之外 每个包装类都提供有这个方法 用于将字符串转为基本数据类型
package com.atguigu.test4;
/**
* parseXxx(): 除了Character类之外 每个包装类都有提供这个方法 用于将字符串转换为基本数据类型
* */
public class Test2 {
public static void main(String[] args) {
// 字符串类型转换为byte基本数据类型
byte b1 = Byte.parseByte("123");
System.out.println(b1); // 123
System.out.println("------------------");
// 字符串类型转换为short基本数据类型
short s1 = Short.parseShort("12334");
System.out.println(s1); // 12334
System.out.println("------------------");
// 字符串类型转换为int基本数据类型
int i1 = Integer.parseInt("23413123");
System.out.println(i1); // 23413123
System.out.println("------------------");
// 字符串类型转换为long基本数据类型
long l1 = Long.parseLong("241232");
System.out.println(l1); // 241232
System.out.println("------------------");
// 字符串类型转换为float基本数据类型
float f1 = Float.parseFloat("123123");
System.out.println(f1); // 123123.0
System.out.println("------------------");
// 字符串类型转换为double基本数据类型
double d1 = Double.parseDouble("1234");
System.out.println(d1); // 1234.0
System.out.println("------------------");
// 字符串类型转换为boolean基本数据类型
boolean bl1 = Boolean.parseBoolean("qweoi");
System.out.println(bl1); // false
}
}
3. 自动装箱和拆箱
自动装箱和拆箱：JDK1.5开始 允许包装类对象和基本数据类型混合运算使用 这种现象就是装箱 或者 拆箱
装箱：将基本数据类型直接赋值给包装类类型
拆箱：将包装类类型直接赋值给基本数据类型
package com.atguigu.test5;
/**
* 自动装箱和拆箱：JDK1.5开始 允许包装类对象和基本数据类型混合运算使用 这种现象就是装箱或者拆箱
*
* 装箱：将基本数据类型直接赋值给包装类类型
* 拆箱：将包装类类型直接赋值给基本数据类型
* */
public class Test1 {
public static void main(String[] args) {
Integer i1 = new Integer(20);
Integer i2 = Integer.valueOf(20);
Integer i3 = 20; // 自动装箱 底层依然调用 valueOf()方法
int num = i3; // 自动拆箱 底层调用intValue()来实现
}
}
4. 包装类面试题
回顾之前讲过的 ==和equals的区别这个面试题
包装类面试题：
1.当整数数值(Short Integer Long)的包装类以及char类型的包装类(Character) 直接使用等号赋值
如果取值范围在byte以内 取值相同的两个对象==比较为true
如果取值范围超过byte 取值相同的两个对象比较为false
2.为什么会有这样的效果？
因为Integer类中帮我们维护了一个Integer类型的数组 此数组中保存 byte范围以内的数值
如果直接=号赋值在此范围以内 将从数组中取出对应的对象 所以比较为true
如果超出这个范围 将直接new一个对象 所以比较为false
3.为什么要这样设计？
这样的设计的目的用于节省内存空间 不是每次都开辟新的空间 创建新的对象
package com.atguigu.test5;
/**
* 回顾之前讲过的==和equals的区别这个面试题
*
* 包装类面试题：
* 1.当整数数值(Short Integer Long)的包装类以及char类型的包装类(Character)直接使用等号赋值
* 如果取值范围在byte以内 取值相同的两个对象==比较为true
* 如果取值范围超过byte 取值相同的两个对象比较为false
*
* 2.为什么会有这样的效果呢？
* 因为Integer类中帮我们维护了一个Integer类型的数组 此数组中保存 byte范围以内的数值
* 如果直接=号赋值在此范围以内 将从数组中去除对应的对象 所以比较为true
* 如果超出这个范围 将直接new一个对象 所以比较为false
*
* 3.为什么要这样设计？
* 这样的设计的目的用于节省内存空间 不是每次都开辟新的空间 创建新的对象
* */
public class Test2 {
public static void main(String[] args) {
Integer i1 = -128;
Integer i2 = -128;
System.out.println(i1.equals(i2)); // true
System.out.println(i1 == i2); // true
Integer i3 = -129;
Integer i4 = -129;
System.out.println(i3.equals(i4)); // true
System.out.println(i3 == i4); // false
Integer a = new Integer(1);
Integer b = new Integer(1);
System.out.println(a == b); // false
System.out.println("------------------------");
Short s1 = 127;
Short s2 = 127;
System.out.println(s1 == s2);
Short s3 = 128;
Short s4 = 128;
System.out.println(s3 == s4); // false
System.out.println("-----------------------");
// char是无符号数 0 ~ 65535
// Character ch1 = -100; // 不能为负数
Character ch1 = 127;
Character ch2 = 127;
System.out.println(ch1 == ch2); // true
Character ch3 = 128;
Character ch4 = 128;
System.out.println(ch3 == ch4); // false
}
}
5.包装类属性
包装类提供了一些属性 用于获取当前包装类相关的信息 比如 最大值 最小值 等
package com.atguigu.test5;
/**
* 包装类中的属性 比如 获取当前包装类 最大值 最小值
* */
public class Test3 {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648
System.out.println(Byte.MAX_VALUE); // 127
System.out.println(Byte.MIN_VALUE); // -128
System.out.println(Long.MAX_VALUE); // 9223372036854775807
System.out.println(Long.MIN_VALUE); // -9223372036854775808
}
}
6. Math类
Math类中提供的有常用的数学运算的方法 以及 两个静态常量 E PI
课后小练习：随机生成一个100以内的整数 提示用户猜这个数 猜大或者猜小 进行提示 直到猜对 统计猜了几次
package com.atguigu.test6;
/**
* Math类中提供的有常用的数学运算的方法 以及 两个静态常量 E PI
* 课后小练习：随机生成一个100以内的整数 提示用户才这个数 猜大或者猜小 进行提示 直到猜对 统计猜了几次
* */
public class TestMath {
public static void main(String[] args) {
System.out.println("自然对数的底数：" + Math.E); // 自然对数的底数：2.718281828459045
System.out.println("圆周率：" + Math.PI); // 圆周率：3.141592653589793
System.out.println("绝对值：" + Math.abs(-33)); // 绝对值：33
System.out.println("3.3向上取整：" + Math.ceil(3.3)); // 3.3向上取整：4.0
System.out.println("3.6向下取整：" + Math.floor(3.6)); // 3.6向下取整：3.0
System.out.println("3.5四舍五入：" + Math.round(3.5)); // 3.5四舍五入：4
System.out.println("大于0.0 小于1.0随机double类型的小数：" + Math.random()); // 大于0.0 小于1.0随机double类型的小数：0.7837207369982422
System.out.println("100以内的随机整数：" + (int)(Math.random() * 100));
System.out.println("15以内的随机整数：" + (int)(Math.random() * 15));
}
}
7. Random类
Random类可以生成更多类型的随机数
nextBoolean()
nextDouble()
nextFloat()
nextInt()
nextInt(int bound)
package com.atguigu.test6;
import java.util.Random;
/**
* Random类可以生成更多类型的随机数
* nextBoolean()
* nextDouble()
* nextFloat()
* nextInt()
* nextInt(int bound)
* */
public class TestRandom {
public static void main(String[] args) {
Random rand1 = new Random();
// 随机生成double类型的小数
System.out.println(rand1.nextDouble()); // 0.8066395068217753
// 随机生成float类型的小数
System.out.println(rand1.nextFloat()); // 0.40055525
// 随机生成int类型的整数
System.out.println(rand1.nextInt()); // 1421085858
// 随机生成指定范围内的int类型的整数
System.out.println(rand1.nextInt(100)); // 64
// 随机生成long类型的整数
System.out.println(rand1.nextLong()); // 1202525455539240436
// 随机生成boolean类型的数
System.out.println(rand1.nextBoolean()); // false
}
}
8. String类
String类
length() 获取字符串长度
equals() 比较字符串内容是否相同
equalsIgnoreCase() 忽略大小写比较字符串内容是否相同
toLowerCase() 将字符串内容转换为小写
toUpperCase() 将字符串内容转换为大写
concat() 拼接字符串
indexOf() 查找某个字符串第一次出现的位置 如未找到 返回-1
lastIndexOf() 查找某个字符串最后一次出现的位置 如未找到 返回-1
substring(int index) :从指定位置截取字符串到末尾
substring(int beginIndex,int endIndex) :从指定位置截取字符串到 指定结束位置 包前不包后
trim() 去除空格 只能去除首尾的空格 不能去除中间的空间
split() 拆分字符串
charAt(int index) :根据指定下标获取当对应的字符
endsWith(String str) :判断字符串是否以某一个字符串结尾
startsWith(String str):判断字符串是否以某一个字符串开头
contains(String str):判断字符串中是否包含某个字符串
replace(String oldStr,String newStr):替换字符串
toCharArray() ：将字符串转换为char数组
package com.atguigu.test7;
/**
* String类
* length() 获取字符串长度
* equals() 比较字符串内容是否相同
* equalsIgnoreCase() 忽略大小写比较字符串内容是否相同
* toLowerCase() 将字符串内容转化为小写
* toUpperCase() 将字符串内容转换为大写
* concat() 拼接字符串
* */
public class TestString1 {
public static void main(String[] args) {
String str1 = "abcdef";
System.out.println("数组的长度：" + str1.length()); // 数组的长度：6
System.out.println("-----------------------");
String str2 = "abcdef";
System.out.println(str1.equals(str2)); // true
System.out.println("-----------------------");
String str3 = "helloWorLD";
String str4 = "HeLLOwORLd";
// equals() 比较字符串内容是否相同
System.out.println(str3.equals(str4)); // false
// equalsIgnoreCase() 忽略大小写比较字符串内容是否相同
System.out.println(str3.equalsIgnoreCase(str4)); // true
System.out.println("-----------------------");
// toUpperCase() 将字符串内容转换为大写
String str5 = "abc"; // ABC
System.out.println(str5.toUpperCase());
// toLowerCase() 将字符串内容转化为小写
String str6 = "ABC"; // abc
System.out.println(str6.toLowerCase());
System.out.println("-----------------------");
String str7 = "abc";
String str8 = "666";
System.out.println(str7 + str8); // abc666
// concat() 拼接字符串
System.out.println(str7.concat(str8)); // abc666
}
}
package com.atguigu.test7;
/**
* indexOf() 查找某个字符串第一次出现的位置 如未找到 返回-1
* lastIndexOf() 查找某个字符串最后一次出现的位置 如未找到 返回-1
*
* substring(int index): 从指定位置截取字符串到末尾
* substring(int beginIndex, int endIndex): 从指定位置截取字符串到指定结束位置 包前不包后
*
* trim() 去除空格 只能取出首尾的空格 不能去除中间的空间
* */
public class TestString2 {
public static void main(String[] args) {
String str1 = "A中bcHelloAbc中";
// 查找某个字符串第一次出现的位置 如未找到 返回-1
System.out.println(str1.indexOf("A")); // 0 第一个索引
System.out.println(str1.indexOf("B")); // -1 未找到
System.out.println(str1.indexOf(65)); // // 0 第一个索引
System.out.println(str1.indexOf(20013)); // 1 第二个索引
System.out.println("----------------------");
System.out.println(str1.indexOf("S")); // -1
// lastIndexOf() 查找某个字符串最后一次出现的位置 如未找到 返回-1
System.out.println(str1.lastIndexOf("S")); // -1
System.out.println(str1.lastIndexOf("A")); // 9
System.out.println(str1.indexOf("A")); // 0
System.out.println("----------------------");
String str2 = "abcHello666";
// substring(int index): 从指定位置截取字符串到末尾
System.out.println(str2.substring(2)); // cHello666
System.out.println(str2.substring(5, 8)); // llo
System.out.println("----------------------");
// trim() 去除空格 只能取出首尾的空格 不能去除中间的空间
String str3 = " a b c ";
System.out.println(str3.trim()); // a b c
}
}
package com.atguigu.test7;
/**
* split() 拆分字符串
* */
public class TestString3 {
public static void main(String[] args) {
String str = "长亭外 古道边 芳草碧连天 晚风拂柳 笛声残 夕阳山外山";
String[] strs = str.split(" ");
for (int i = 0;i < strs.length;i++){
System.out.println(strs[i]);
}
}
}
package com.atguigu.test7;
import java.util.Scanner;
/**
* 使用split方法实现查找字符在字符串中出现的次数
* */
public class TestString4 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("请输入一段文字：");
String str = scan.next();
System.out.print("请输入要查找的文字：");
String findStr = scan.next();
// 第一种方式
// String[] split = str.split("");
//
// int count = 0;
// for (int i = 0;i < split.length;i++){
// if (findStr.equals(split[i])){
// count++;
// }
// }
// System.out.println(str + "字符串中出现了" + count + "次:" + findStr);
// 第二种方式
String[] res = str.split(findStr);
System.out.println(str + "字符串中出现了" + (res.length - 1) + "次:" + findStr);
}
}
package com.atguigu.test1;
/**
* charAt(int index):根据指定下标获取对应的字符
* endsWith(String str):判断字符串是否以某一个字符串结尾
* startsWith(String str):判断字符串是否以某一个字符串开头
* contains(String str):判断字符串是否包含某个字符串
* replace(String oldStr, String newStr):转换字符串
* toCharArray(): 将字符串转化为char数组
* */
public class TestString1 {
public static void main(String[] args) {
String str = "abcHello";
// charAt(int index):根据指定下标获取对应的字符
System.out.println(str.charAt(0)); // a
// endsWith(String str):判断字符串是否以某一个字符串结尾
System.out.println(str.endsWith("abc")); // false
// startsWith(String str):判断字符串是否以某一个字符串开头
System.out.println(str.startsWith("abc")); // true
// contains(String str):判断字符串是否包含某个字符串
System.out.println(str.contains("el")); // true
// replace(String oldStr, String newStr):转换字符串
System.out.println(str.replace("abc", "666")); // 666Hello
// toCharArray(): 将字符串转化为char数组
char[] chars = str.toCharArray();
for (int i = 0;i < chars.length;i++){
System.out.println(chars[i]);
}
}
}
9. String 类面试题
String类相关面试题：
String对象被设计为不可变对象，
任何对字符串内容的改变都将产生一个新的字符串对象
为什么String对象是不可变对象？
1.String类不能被继承 因为此类使用final修饰
2.每一个String对象底层都是使用final修饰的char数组维护的
3.这个final修饰的char数组是private
有没有其他的方法可以改变字符串对象？
有，使用反射
final修饰的变量称之为常量
final修饰基本数据类型 其值不能被改变
final修饰引用数据类型 引用不能改变 但是引用中的内容可以改变
面试题：代码阅读
String str1 = “abc”;
String str2 = “abc”;
String str3 = new String(“abc”);
System.out.println(str1 == str2);
System.out.println(str1 == str3);
System.out.println(str2 == str3);
package com.atguigu.test1;
/**
* String类相关面试题：
* String对象被设计为不可变对象
* 任何对字符串内容的改变都将产生一个新的字符串对象
*
* 为什么String对象是不可变对象？
* 1.String类不能被继承 因为此类使用final修饰
* 2.每一个String对象底层都是使用final修饰的char数组维护的
* 3.这个final修饰的char数组是private
*
*
* final修饰的变量称之为常量
* final修饰基本数据类型 其值不能被改变
* final修饰引用数据类型 引用不能改变 但是引用中的内容可以改变
*
* 面试题：代码阅读
* String str1 = "abc";
* String str2 = "abc";
* String str3 = new String("abc");
*
* System.out.println(str1 == str2);
* System.out.println(str1 == str3);
* System.out.println(str2 == str3);
* */
public class TestString2 {
public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
String str3 = new String("abc");
String str4 = new String("abc");
System.out.println(str1 == str2); // true
System.out.println(str1 == str3); // false
System.out.println(str2 == str3); // false
System.out.println(str3 == str4); // false
}
}
package com.atguigu.test1;
/**
* final修饰的变量称之为常量
* final修饰的基本数据类型 其值不能被改变
* final修饰引用数据类型 引用不能改变 但是引用中的内容可以改变
* */
public class TestString3 {
final char[] chs = {'a', 'b', 'c'};
final char ch1 = 'A';
public static void main(String[] args) {
TestString3 ts3 = new TestString3();
// ts3.ch1 = 'B'; // 报错 final修饰的变量无法被修改
// ts3.chs = new char[3]; // 报错 final修饰的引用数据类型 无法修改
ts3.chs[0] = '中';
ts3.chs[1] = '国';
ts3.chs[2] = '人';
System.out.println(ts3.chs[0]); // 中
System.out.println(ts3.chs[1]); // 国
System.out.println(ts3.chs[2]); // 人
}
}
9. StringBuffer&StringBuilder
String类是一个不可变对象 任何对字符串内容的改变 都会产生新的字符串对象
所以 如果我们在开发中 需要频繁的对某个字符串内容改变 不推荐使用String类型
推荐使用StringBuffer或者StringBuilder
举例：比如我们通过 电商平台搜索商品
String、StringBuffer和StringBuilder的区别？
String是不可变对象 StringBuffer和StringBuilder是可变对象
StringBuffer线程安全 JDK1.0
StringBuilder线程不安全 JDK1.5
package com.atguigu.test2;
/**
* String类是一个不可变对象 任何对字符串内容的改变 都会产生新的字符串对象
* 所以 如果我们在开发中 需要频繁的对某个字符串内容改变 不推荐使用String类型
* 推荐使用StringBuffer或者StringBuilder
*
* 举例：比如我们通过电商平台搜索商品
*
* String、StringBuffer和StringBuilder的区别？
* String是不可变对象 StringBuffer和StringBuilder是可变对象
* StringBuffer线程安全 JDK1.0
* StringBuilder线程不安全 JDK1.5
*
* */
public class StringBufferAndStringBuilder {
public static void main(String[] args) {
String condition = "电脑";
condition += "笔记本";
condition += "联想";
condition += "拯救者";
condition += "12代i7";
condition += "3060 135W";
System.out.println(condition); // 电脑笔记本联想拯救者12代i73060 135W
System.out.println("-----------------");
StringBuilder sb = new StringBuilder();
// append() 把参数当作字符串追加
sb.append(23);
sb.append(3.5);
sb.append(false);
sb.append("abc");
System.out.println(sb); // 233.5falseabc
// delete(int start, int end) 删除指定范围内的字符 包前不包后
System.out.println(sb.delete(3, 7)); // 233lseabc
// insert(int offset, String str) 在指定索引前插入数据
System.out.println(sb.insert(0, "hello666")); // hello666233lseabc
// 反转
System.out.println(sb.reverse()); // cbaesl332666olleh
}
}
10. System类
java.lang.System 此类位于lang包 使用不必导包 此类不能new对象
package com.atguigu.test3;
/**
* java.lang.System 此类位于lang包 使用不必导包 此类不能new对象
* */
public class TestSystem {
public static void main(String[] args) {
System.out.println("正常输出语句");
System.err.println("错误打印语句");
// 获取从1970年1月1日 0点0时0秒到目前的毫秒数
// 因为linux操作系统认为1970年是计算机诞生的元年
System.out.println("当前系统时间毫秒数：" + System.currentTimeMillis()); // 当前系统时间毫秒数：1663646223932
String str1 = "abc";
// 调用此方法并不能保证立即回收垃圾对象
// gc Garbage Collection
System.gc();
System.out.println(str1); // abc 依然可以访问str1
// System类提供有获取当前系统相关信息的方法
// 比如 系统版本号 JDK版本 JVM编码格式等
// 这些信息都以键值对的形式存在 比如 身份证号(键 key) ------> 名字(值 value)
System.out.println(System.getProperty("user.name"));
System.out.println(System.getProperty("file.encoding")); // UTF-8
System.out.println(System.getProperty("java.version")); // 1.8.0_131
// 显示所有
System.getProperties().list(System.out);
// 参数为int类型状态码 目前传入任何int类型的整数都可以退出JVM虚拟机
// 0表示正常退出
// 非0表示非正常退出
System.exit(100); // Process finished with exit code 100
}
}
11.Runtime类
Runtime类 不能new对象 类中提供了一个方法getRuntime()用于获取此类对象
此类被设计为单例(程序执行过程中只有一个其只能有一个此类的实例)模式
Runtime类中提供了用于获取程序运行期间信息的方法
package com.atguigu.test3;
import java.io.IOException;
/**
* Runtime类 不能new对象 类中提供了一个方法getRuntime()用于获取此类对象
* 此类被设计为单例(程序执行过程中只有一个且只能由一个此类的实例)模式
*
* Runtime类中提供了用于获取程序允许期间信息的方法
* */
public class TestRuntime {
public static void main(String[] args) throws IOException {
Runtime runtime = Runtime.getRuntime();
// runtime.exec("D:\\阿里云盘\\aDrive\\aDrive.exe");
runtime.gc(); // 与System中的gc()方法属于同一个方法
// 默认以字节为单位 / 1024 / 1024 以兆为单位显示
System.out.println("空间内存：" + runtime.freeMemory() / 1024 / 1024); // 空间内存：232
System.out.println("最大内存：" + runtime.maxMemory() / 1024 / 1024); // 最大内存：3499
System.out.println("总内存：" + runtime.totalMemory() / 1024 / 1024); // 总内存：236
runtime.exit(1); // 退出JVM虚拟机 System类中的exit() 也使用这个方法
}
}
12. 日期API
12.1 java.util.Date
java.util.Date : 次类中提供的有用于获取时间 设置时间的各种方法
大部分已弃用 依然可以使用 但是不推荐使用
package com.atguigu.test4;
import java.util.Date;
/**
* java.util.Date: 此类中提供的用于获取时间 设置时间的各种方法
*
* 大部分已弃用 依然可以使用 但不推荐使用
* */
public class TestDate {
public static void main(String[] args) {
Date date1 = new Date();
// 获取当前年份 需+1900
System.out.println("年份：" + (date1.getYear() + 1900)); // 年份：2022
// 获取当前月份 从0开始算的 所以需要加1
System.out.println("月份：" + (date1.getMonth() + 1)); // 月份：9
// 获取本月的第几天
System.out.println("一月中的第几天：" + date1.getDate()); // 一月中的第几天：20
// 获取本周的第几天
System.out.println("一周中的第几天：" + date1.getDay()); // 一周中的第几天：2
System.out.println("小时：" + date1.getHours()); // 小时：14
System.out.println("分钟：" + date1.getMinutes()); // 分钟：41
System.out.println("秒钟：" + date1.getSeconds()); // 秒钟：17
System.out.println(date1); // Tue Sep 20 14:43:04 CST 2022
System.out.println("-------------------------------------");
System.out.println("当前系统时间的毫秒数：" + System.currentTimeMillis()); // 当前系统时间的毫秒数：1663656237026
Date date2 = new Date(System.currentTimeMillis());
System.out.println(date2); // Tue Sep 20 14:43:57 CST 2022
System.out.println("-------------------------------------");
Date date3 = new Date(12, 10, 1, 10, 10, 10);
System.out.println(date3); // Fri Nov 01 10:10:10 CST 1912
m1();
}
// 注解 表示当前方法已弃用
@Deprecated
public static void m1(){
System.out.println("version 1.0 m1 method");
}
}
12.2 SimpleDateFormat
java.text.SimpleDateFormat ：此类专门用于对日期进行格式化处理
String format(java.util.Date date) :将日期对象转换为字符串
java.util.Date parse(String source):将字符串对象转换为日期对象
package com.atguigu.test4;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* java.text.SimpleDateFormat: 此类专门用于对日期进行格式化处理
*
* String format(java.util.Date date): 将日期对象转换为字符串
* java.util.Date parse(String source): 将字符串对象转换为日期对象
*
* */
public class TestSimpleDateFormat {
public static void main(String[] args) throws ParseException {
Date date1 = new Date();
// 自定义格式化
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
String dateStr = sdf1.format(date1);
System.out.println(dateStr); // 2022/09/20 14-49-17
System.out.println("----------------------------");
// 默认格式
SimpleDateFormat sdf2 = new SimpleDateFormat();
String dateStr2 = sdf2.format(date1);
System.out.println(dateStr2); // 22-9-20 下午3:49
System.out.println("----------------------------");
String dateStr3 = "22-9-20 下午3:49";
SimpleDateFormat sdf3 = new SimpleDateFormat();
// 字符串格式转成Date类型
Date parseDate1 = sdf3.parse(dateStr3);
System.out.println(parseDate1); // Tue Sep 20 15:49:00 CST 2022
System.out.println("----------------------------");
// 自定义字符串格式转成Date类型，两者格式需一致
String dataStr4 = "2022/12/12 11:11:11";
SimpleDateFormat sdf4 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date parseDate2 = sdf4.parse(dataStr4);
System.out.println(parseDate2); // Mon Dec 12 11:11:11 CST 2022
}
}
12.3 Calendar
java.util.Calendar 日历类：用于取代java.util.Date类中的大部分方法 功能
此类不能直接new对象
package com.atguigu.test4;
import java.util.Calendar;
/**
* java.utils.Calendar 日历类：用于取代java.util.Date类中的大部分方法 功能
* 此类不能直接new对象
* */
public class TestCalendar {
public static void main(String[] args) {
Calendar instance = Calendar.getInstance();
System.out.println("年份：" + instance.get(Calendar.YEAR)); // 年份：2022
System.out.println("月份：" + (instance.get(Calendar.MONTH) + 1)); // 月份：9 从0开始算 需加1
System.out.println("一周中的第几天：" + instance.get(Calendar.DAY_OF_WEEK)); // 一周中的第几天：3 从0开始算
System.out.println("一月中的第几天：" + instance.get(Calendar.DAY_OF_MONTH)); // 一月中的第几天：20
System.out.println("时：" + instance.get(Calendar.HOUR)); // 时：4
System.out.println("分：" + instance.get(Calendar.MINUTE)); // 分：39
System.out.println("秒：" + instance.get(Calendar.SECOND)); // 秒：6
}
}
12.4 LocalDate
JDK8新增的日期API
LocalDate : 只包含年月日
package com.atguigu.test5;
import java.time.LocalDate;
/**
* JDK8新增的日期API
* LocalDate：只包含年月日
* */
public class TestLocalDate {
public static void main(String[] args) {
LocalDate localDate = LocalDate.now();
System.out.println("年：" + localDate.getYear()); // 年：2022
System.out.println("月：" + localDate.getMonth()); // 月：SEPTEMBER
System.out.println("一周中第几天：" + localDate.getDayOfWeek()); // 一周中第几天：TUESDAY
System.out.println("一月中第几天：" + localDate.getDayOfMonth()); // 一月中第几天：20
System.out.println("一年中第几天：" + localDate.getDayOfYear()); // 一年中第几天：263
System.out.println(localDate); // 2022-09-20
// 指定年月日转换成LocalDate类型
LocalDate localDate1 = LocalDate.of(2019, 12, 11);
System.out.println(localDate1); // 2019-12-11
}
}
12.5 LocalTime
JDK8新增的日期API
LocalTime : 只包含时分秒
package com.atguigu.test5;
import java.time.LocalTime;
/**
* 只包含时分秒
* */
public class TestLocalTime {
public static void main(String[] args) {
LocalTime localTime = LocalTime.now();
System.out.println("小时：" + localTime.getHour()); // 小时：18
System.out.println("分钟：" + localTime.getMinute()); // 分钟：15
System.out.println("秒钟：" + localTime.getSecond()); // 秒钟：19
// 1秒等于10亿纳秒
System.out.println("纳秒：" + localTime.getNano()); // 纳秒：572000000
System.out.println(localTime); // 18:15:19.572
System.out.println("------------------------------");
// 指定时分秒转换成LocalTime类型
LocalTime localTime1 = LocalTime.of(10, 10, 10);
System.out.println(localTime1); // 10:10:10
}
}
12.6 LocalDateTime
JDK8新增的日期API
LocalDateTime：包含年月日 时分秒
package com.atguigu.test5;
import java.time.LocalDateTime;
/**
* LocalDateTime：包含年月日 时分秒
* */
public class TestLocalDateTime {
public static void main(String[] args) {
LocalDateTime now = LocalDateTime.now();
System.out.println("年：" + now.getYear()); // 年：2022
System.out.println("月：" + now.getMonth()); // 月：SEPTEMBER
System.out.println("一周中第几天：" + now.getDayOfWeek()); // 一周中第几天：TUESDAY
System.out.println("一月中第几天：" + now.getDayOfMonth()); // 一月中第几天：20
System.out.println("一年中第几天：" + now.getDayOfYear()); // 一年中第几天：263
System.out.println("小时：" + now.getHour()); // 小时：18
System.out.println("分钟：" + now.getMinute()); // 分钟：31
System.out.println("秒钟：" + now.getSecond()); // 秒钟：24
// 1秒等于10亿纳秒
System.out.println("纳秒：" + now.getNano()); // 纳秒：269000000
// 指定年月日时分秒转换成LocalDateTime类型
LocalDateTime localDateTime = LocalDateTime.of(2011, 10, 12, 11, 11, 11);
System.out.println(localDateTime);
}
}
13.BigInteger & BigDecimal
BigInteger : 可以保存任意大的整数
package com.atguigu.test6;
import javax.jws.soap.SOAPBinding;
import java.math.BigInteger;
/**
* BigInteger：可以保存任意大的整数
* */
public class TestBigInteger {
public static void main(String[] args) {
BigInteger b1 = new BigInteger("1232846182746381237468235467812541123");
System.out.println(b1);
BigInteger b2 = new BigInteger("123234123143");
// add() 相加 参数必须是BigInteger类型
System.out.println(b1.add(b2)); // 1232846182746381237468235591046664266
// subtract() 相减 参数必须是BigInteger类型
System.out.println(b1.subtract(b2)); // 1232846182746381237468235344578417980
// multiply() 相乘 参数必须是BigInteger类型
System.out.println(b1.multiply(b2)); // 151928718300945027355785255191330905591533509589
// divide() 相除 参数必须是BigInteger类型
System.out.println(b1.divide(b2)); // 10004097495916738057625012
}
}
BigDecimal:可以保存任意大 任意精度的小数
package com.atguigu.test6;
import java.math.BigDecimal;
import java.math.RoundingMode;
/**
* BigDecimal:可以保存任意大 任意精度的小数
* */
public class TestBigDecimal {
public static void main(String[] args) {
BigDecimal b1 = new BigDecimal("12398264816487164131.2342397529835672834");
System.out.println(b1); // 12398264816487164131.2342397529835672834
BigDecimal b2 = new BigDecimal("128361287.2354234");
// add() 相加 参数必须是BigDecimal类型
System.out.println(b1.add(b2)); // 12398264816615525418.4696631529835672834
// subtract() 相减 参数必须是BigDecimal类型
System.out.println(b1.subtract(b2)); // 12398264816358802843.9988163529835672834
// multiply() 相乘 参数必须是BigDecimal类型
System.out.println(b1.multiply(b2)); // 1591457231329952864063248149.29274370541086928978679156
// divide() 相除 参数必须是BigDecimal类型
// 第一个参数 除数
// 第二个参数 保留几位小数
// 第三个参数 小数位保留策略 四舍五入
System.out.println(b1.divide(b2, 5, RoundingMode.HALF_UP));
}
}
14. 内部类
内部类：一个类中又书写了另外一个或者多个类 写在内部的类 就称之为内部类
内部类生成的class文件名格式为 ：外部类$内部类.class
什么情况下会使用内部类呢？
当我们需要使用一个类来描述某个信息 而这个类没有必要对外界开放访问 那么就可以使用内部类
内部类分类：
1.普通内部类(了解)
2.静态内部类(了解)
3.局部内部类(了解)
4.匿名内部类(必须掌握)
内部类介绍
package com.atguigu.test7;
/**
* 内部类：一个类中又书写了另外一个或者多个类 写在内部的类 被称之为内部类
* 内部类生成的class文件名格式为：外部类&内部类.class
*
* 什么情况下会使用内部类？
* 当我们需要使用一个类来描述某个线下 而这个类没有必要对外界开放访问 那么久可以使用内部类
*
* 内部类分类：
* 1.普通内部类(了解)
* 2.静态内部类(了解)
* 3.局部内部类(了解)
* 4.匿名内部类(必须掌握)
* */
public class Test1 {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.age = 20;
stu1.name = "赵四";
stu1.address = stu1.new Address();
// 创建内部类Address对象
Student.Address addr1 = new Student().new Address();
// 创建内部类Address对象
Student.Address addr2 = stu1.new Address();
addr1.m1();
addr2.m1();
}
}
class Student{
String name;
int age;
Address address;
class Address{
private String province;
private String city;
private String area;
private String street;
public void m1(){
System.out.println(name);
System.out.println(age);
System.out.println(address);
System.out.println("内部类m1方法");
}
}
}
class Outer{
class inner{
}
}
静态内部类
package com.atguigu.test7;
/**
* 静态内部类
* */
public class Test2 {
public static void main(String[] args) {
// 创建内部类Inner2对象
Outer2.Inner2 inner2 = new Outer2.Inner2();
inner2.m2(); // 内部类m2方法
// 直接通过类名调用方法
Outer2.Inner2.m3(); // 内部类m3方法
System.out.println(inner2.c); // 0
System.out.println(inner2.d); // 0.0
}
}
class Outer2{
int a;
String b;
public void m1(){
System.out.println("外部类m1方法");
}
static class Inner2{
int c;
double d;
public void m2(){
System.out.println("内部类m2方法");
}
public static void m3(){
System.out.println("内部类m3方法");
}
}
}
局部内部类
package com.atguigu.test7;
/**
* 局部内部类
* */
public class Test3 {
public static void main(String[] args) {
Outer3 outer3 = new Outer3();
outer3.m1();
}
}
class Outer3{
int a;
double b;
public void m1(){
System.out.println("外部类m1方法");
class Inner3{
int d;
char c;
public void m2(){
System.out.println("局部内部类m2方法");
}
}
Inner3 inner3 = new Inner3();
inner3.m2();
}
}
匿名内部类
package com.atguigu.test7;
/**
* 匿名内部类：没有名字的类
* */
public class Test4 {
public static void main(String[] args) {
A a = new A() {
@Override
void m1() {
System.out.println("匿名内部类的方式实现m1方法");
}
};
a.m1(); // 匿名内部类的方式重写m1方法
B b = new B() {
@Override
public void m2() {
System.out.println("匿名内部类的方式实现m2方法");
}
};
b.m2();
C c = new C() {
@Override
void m1() {
System.out.println("匿名内部类方式实现m1");
}
@Override
void m2() {
System.out.println("匿名内部类方式实现m2");
}
@Override
void m3() {
System.out.println("匿名内部类方式实现m3");
}
};
c.m1(); // 匿名内部类方式实现m1
c.m2(); // 匿名内部类方式实现m2
c.m3(); // 匿名内部类方式实现m3
}
}
abstract class A{
abstract void m1();
}
interface B{
void m2();
}
abstract class C{
abstract void m1();
abstract void m2();
abstract void m3();
}
lambda表达式
lambda表达式 因为匿名内部类的写法太不美观 所以从JDK8开始 引入lambda表达式优化匿名内部类
这种啰嗦 臃肿的写法
lambda要求：使用lambda表达式 只能是接口 并且接口中只能有一个抽象方法
@FunctionalInterface:此注解只能用于修饰接口 表示此接口属于函数式接口
函数式接口要求接口中只能有一个抽象方法
package com.atguigu.test7;
/**
* lambda表达式 因为匿名内部类的写法太不美观 所以从JDK8开始 引入lambda表达式优化匿名内部类这种啰嗦 臃肿的写法
*
* lambda要求：使用lambda表达式 只能是接口 并且接口中只能有一个抽象方法
*
* @FunctionalInterface:此注解只能用于修饰接口 表示此接口属于函数式接口
*
* */
public class Test5 {
public static void main(String[] args) {
E e1 = new E() {
@Override
public void m1() {
System.out.println("匿名内部类方式重写m1");
}
};
e1.m1(); // 匿名内部类方式重写m1
// 使用lambda表达式
E e2 = ()-> System.out.println("lambda表达式重写m1");
e2.m1(); // lambda表达式重写m1
E e3 = ()-> {
System.out.println("lambda表达式重写m1 1");
System.out.println("lambda表达式重写m1 2");
System.out.println("lambda表达式重写m1 3");
};
e3.m1();
}
}
@FunctionalInterface
interface E{
void m1();
}