1. 枚举
枚举可以用于规范属性的值，使用enum声明类
package com.qfedu.test1;
public enum Week {
MON,TUE,WED,THUR,FRI,SAT,SUN
}
package com.qfedu.test1;
/**
* 使用枚举作为参数传入switch 实现一周中每天的打印
* @author WHD
*
*/
public class TestWeek {
public static void main(String[] args) {
Week day = Week.SAT;
switch (day) {
case MON:
System.out.println("周一");
break;
case TUE:
System.out.println("周2");
break;
case WED:
System.out.println("周3");
break;
case THUR:
System.out.println("周4");
break;
case FRI:
System.out.println("周5");
break;
case SAT:
System.out.println("周6");
break;
case SUN:
System.out.println("周日");
break;
default:
System.out.println("一周只有七天");
break;
}
printWeek(Week.MON);
}
public static void printWeek(Week day) {
switch (day) {
case MON:
System.out.println("周一");
break;
case TUE:
System.out.println("周2");
break;
case WED:
System.out.println("周3");
break;
case THUR:
System.out.println("周4");
break;
case FRI:
System.out.println("周5");
break;
case SAT:
System.out.println("周6");
break;
case SUN:
System.out.println("周日");
break;
default:
System.out.println("一周只有七天");
break;
}
}
}
2. 包装类
每个基本数据类型 都有一个对应的包装类
byte short int long float double boolean char
Byte Short Integer Long Float Double Boolean Character
2.1 包装类构造方法
所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例
除Character类外，其他包装类可将一个字符串作为参数构造它们的实例
package com.qfedu.test2;
/**
* 每个基本数据类型 都有一个对应的包装类
* byte short int long float double boolean char
* Byte Short Integer Long Float Double Boolean Character
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
Byte b1 = new Byte((byte)20);
byte b = 23;
Byte b2 = new Byte(b);
Byte b3 = new Byte("120");
System.out.println(b3);
Short s1 = new Short((short)220);
Short s2 = new Short("220");
System.out.println(s1);
Integer i1 = new Integer(200);
Integer i2 = new Integer("223");
System.out.println(i2);
Long l1 = new Long(200);
Long l2 = new Long("220");
System.out.println(l1);
Float f1 = new Float(3.14F);
Float f2 = new Float(3.14);
Float f3 = new Float("3.14");
System.out.println(f1);
Double d1 = new Double(20);
Double d2 = new Double("20");
// Boolean类 传入字符串 不区分大小写 如果内容不为true 则为false
Boolean bl1 = new Boolean(true);
Boolean bl2 = new Boolean("tRuE");
Boolean bl3 = new Boolean("abc");
System.out.println(bl1);
Character ch1 = new Character('A');
System.out.println(ch1);
}
}
2.2 包装类转换为基本数据类型
xxxValue() 将包装类转换为基本数据类型
每个包装类都提供了这样的一个方法
Boolean类构造方法参数为String类型时，若该字符串内容为true(不考虑大小写)，则该Boolean对象表示true，否则表示false
当Number包装类构造方法参数为String 类型时，字符串不能为null，且该字符串必须可解析为相应的基本数据类型的数据，否则运行不通过，运行时会抛出NumberFormatException异常
package com.qfedu.test3;
/**
* xxxValue() 将包装类转换为基本数据类型
* 每个包装类都提供了这样的一个方法
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
Byte b1 = new Byte("120");
byte b = b1.byteValue(); // shift + alt + L 生成对应的变量接收方法返回值
System.out.println(b);
Short s1 = new Short("200");
short s2 = s1.shortValue();
System.out.println(s2);
Integer i1 = new Integer("200");
int i2 = i1.intValue();
System.out.println(i2);
Long l1 = new Long(200);
long l2 = l1.longValue();
System.out.println(l2);
Float f1 = new Float(3.14F);
float f2 = f1.floatValue();
System.out.println(f2);
Double d1 = new Double(200);
double d2 = d1.doubleValue();
System.out.println(d2);
Boolean bl1 = new Boolean(false);
boolean bl2 = bl1.booleanValue();
System.out.println(bl2);
Character ch1 = new Character('A');
char ch2 = ch1.charValue();
System.out.println(ch2);
}
}
2.3 基本数据类型转换为包装类
valueOf() 每个包装类都提供了valueOf方法 用于将基本数据类型转换为包装类
package com.qfedu.test3;
/**
* valueOf() 每个包装类都提供了valueOf方法 用于将基本数据类型转换为包装类
*
* @author WHD
*
*/
public class Test2 {
public static void main(String[] args) {
Byte b1 = Byte.valueOf((byte)20);
Byte b2 = Byte.valueOf("20");
System.out.println(b1 + "---" + b2);
Short s1 = Short.valueOf((short)200);
System.out.println(s1);
Short s2 = Short.valueOf("200");
System.out.println(s2);
Integer i1 = Integer.valueOf(200);
Integer i2 = Integer.valueOf("230");
System.out.println(i1);
System.out.println(i2);
Long l1 = Long.valueOf(200);
Long l2 = Long.valueOf("230");
System.out.println(l1);
System.out.println(l2);
Float f1 = Float.valueOf(3.14F);
System.out.println(f1);
Float f2 = Float.valueOf("20.3");
System.out.println(f2);
Double d1 = Double.valueOf(200);
Double d2 =Double.valueOf("2300");
System.out.println(d1 + "---" + d2);
Character ch1 = Character.valueOf('A');
System.out.println(ch1);
Boolean bl1 = Boolean.valueOf(false);
System.out.println(bl1);
Boolean bl2 = Boolean.valueOf("abc");
System.out.println(bl2);
}
}
2.4 基本类型转为字符串
toString():以字符串形式返回包装对象表示的基本类型数据（基本类型->字符串）
package com.qfedu.test4;
/**
* toString():以字符串形式返回包装对象表示的基本类型数据（基本类型->字符串）
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
int a = 20;
System.out.println( a + "");
String str1 = Byte.toString((byte)20);
System.out.println(str1.length());
String str2 = Short.toString((short)200);
System.out.println(str2);
String str3 = Integer.toString(200);
System.out.println(str3);
String str4 = Long.toString(200);
System.out.println(str4);
String str5 = Float.toString(3.14F);
System.out.println(str5.length());
String str6 = Double.toString(3200);
System.out.println(str6);
String str7 = Boolean.toString(false);
System.out.println(str7);
String str8 = Character.toString('A');
System.out.println(str8);
}
}
2.5 字符串转换为基本数据类型
parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外）
字符串->基本类型）
package com.qfedu.test4;
/**
* parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外）
* 字符串->基本类型）
* @author WHD
*
*/
public class Test2 {
public static void main(String[] args) {
byte b1 = Byte.parseByte("23");
System.out.println(b1);
short s1 = Short.parseShort("230");
System.out.println(s1);
int i1 = Integer.parseInt("200");
System.out.println(i1);
long l1 = Long.parseLong("2300");
System.out.println(l1);
float f1 = Float.parseFloat("23.2");
System.out.println(f1);
double d1 = Double.parseDouble("231");
System.out.println(d1);
boolean bl1 = Boolean.parseBoolean("truE");
System.out.println(bl1);
}
}
2.6 自动装箱和拆箱
装箱和拆箱 ： 从JDK1.5 开始 允许包装类和基本数据类型 混合使用
装箱：将基本数据类型自动转换为包装类型
拆箱：将包装类型自动转换为基本数据类型
package com.qfedu.test5;
/**
* 装箱和拆箱 ： 从JDK1.5 开始 允许包装类和基本数据类型 混合使用
* 装箱：将基本数据类型自动转换为包装类型
* 拆箱：将包装类型自动转换为基本数据类型
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
Integer i1 = Integer.valueOf(20);
int i2 = i1.intValue();
Integer i4 = new Integer(20);
Integer i3 = 20; // 装箱
int i5 = i3; // 拆箱
Byte b1 = 20;
byte b2 = b1;
}
}
3. Math类
Math类 数学工具类 提供了常用的数学计算方法 和 两个静态常量 E PI
package com.qfedu.test6;
/**
* Math类 数学工具类 提供了常用的数学计算方法 和 两个静态常量 E PI
* @author WHD
*
*/
public class TestMath {
public static void main(String[] args) {
System.out.println(Math.E);//固定值
System.out.println(Math.PI);//圆周率Π
System.out.println(Math.max(20, 30));//最大值
System.out.println(Math.min(33, 44));//最小值
// 面试题笔试题经常出现
System.out.println(Math.ceil(3.1));//向上取整
System.out.println(Math.floor(3.6));//向下取整
System.out.println(Math.round(3.5));//四舍五入
System.out.println(Math.round(3.4));//四舍五入
System.out.println((int )(Math.random() * 100));//0-100的随机整数，强转为int类型
System.out.println((int )(Math.random() * 50));
System.out.println((int )(Math.random() * 13));
System.out.println((int )(Math.random() * 7));
}
}
4.Random类
Random类 提供了更为丰富的类型的随机数的获取方式
package com.qfedu.test6;
import java.util.Random;
/**
* Random类 提供了更为丰富的类型的随机数的获取方式
* @author WHD
*
*/
public class TestRandom {
public static void main(String[] args) {
Random ran1 = new Random();
System.out.println(ran1.nextBoolean());//随机获得一个布尔类型的值
System.out.println(ran1.nextDouble());//随机获得double类型的数值
System.out.println(ran1.nextFloat());//随机获得float类型的数值
System.out.println(ran1.nextLong());//随机获得long类型的数值
System.out.println(ran1.nextInt());//随机获得int类型的数值
System.out.println(ran1.nextInt(55));//随机获得int类型55一下的数值
// 用同一个种子值来初始化两个Random 对象，
// 然后用每个对象调用相同的方法，得到的随机数也是相同的
Random ran2 = new Random(11);
Random ran3 = new Random(11);
System.out.println(ran2.nextInt());
System.out.println(ran3.nextInt());
}
}
5.String类常用方法
length() :长度
equals():比较内容
equalsIgnoreCase()：忽略大小写比较
toLowerCase()：转换为小写
toUpperCase()：转换为大写
concat()：拼接字符串
indexOf()：搜索第一个出现的字符ch（或字符串value），如果没有找到，返回-1
lastIndexOf()：搜索最后一个出现的字符ch（或字符串value），如果没有找到，返回-1
substring(int index)提取从位置索引开始的字符串部分
substring(int beginindex, int endindex)提取beginindex和endindex之间的字符串部分
trim()返回一个前后不含任何空格的调用字符串的副本
split()拆分字符串
endsWith() 判断字符串是否以某一个字符串结尾
startsWith()判断字符串是否以某一个字符串开头
replace()替换字符串
6.String类相关面试题
1.1 String底层 实现
String类的底层实现
通过观察源代码，我们发现，String类底层维护的是一个char数组
并且这个数组是使用final修饰的，所以String类的对象是不可变的
也就是说，字符串内容一旦确定是不能发生改变的，任何对字符串改变 的操作都将产生新的字符串
通过以上分析，我们发现，不能对一个字符串内容进行频繁的改动，因为这样会产生很多的字符串
对象，这些对象将占用内存空间
1.2 StringBuffer和StringBuilder区别
StringBuffer 和 StringBuilder的区别？
这两个依然属于字符串对象，只不过内容是可变的
StringBuffer是线程安全的 源自于JDK1.0
StringBuilder线程不安全 源自于 JDK1.5
1.3 为什么不能使用==比较String对象 ？
使用==比较 不能保证内容相同 结果为true
因为如果直接使用=号赋值 字符串对象将存放在 常量池中
第二次赋值相同的内容 会先去常量池中查找是否有相同的内容
如果有 则将之前的地址重新赋值给当前变量 所以使用== 比较为true
如果没有 则将当前内容存放在常量池中
使用new关键字创建字符串对象 每一次都将开辟新的空间 所以使用==比较一定为false
所以推荐使用equals比较字符串 因为equals比较内容
package com.qfedu.test1;
/**
* String类的底层实现
* 通过观察源代码，我们发现，String类底层维护的是一个char数组
* 并且这个数组是使用final修饰的，所以String类的对象是不可变的
* 也就是说，字符串内容一旦确定是不能发生改变的，任何对字符串改变 的操作都将产生新的字符串
*
* 通过以上分析，我们发现，不能对一个字符串内容进行频繁的改动，因为这样会产生很多的字符串
* 对象，这些对象将占用内容空间
*
* 场景：比如你在电商网站搜索产品
*
* StringBuffer 和 StringBuilder的区别？
* 这两个依然属于字符串对象，只不过内容是可变的
* StringBuffer是线程安全的 源自于JDK1.0
* tringBuilder线程不安全 源自于 JDK1.5
*
*
* 为什么不能使用==比较String对象 ？
* 使用==比较 不能保证内容相同 结果为true
* 因为如果直接使用=号赋值 字符串对象将存放在 常量池中
* 第二次赋值相同的内容 会先去常量池中查找是否有相同的内容
* 如果有 则将之前的地址重新赋值给当前变量 所以使用== 比较为true
* 如果没有 则将当前内容存放在常量池中
*
* 使用new关键字创建字符串对象 每一次都将开辟新的空间 所以使用==比较一定为false
*
* 所以使用equals比较字符串 因为equals比较内容
* @author WHD
*
*/
public class TestString {
public static void main(String[] args) {
String a = "abc";
String b = "abcd";
String f = "abcd";
System.out.println(a == b);
String c = new String("abc");
String d = new String("abc");
System.out.println(c == d);
System.out.println("-------------------------------");
String str1 = "abc";
str1 += "hello";
str1 += "hhh";
str1 += "jjj";
str1 += "kkk";
StringBuilder sb1 = new StringBuilder();
sb1.append(true);
sb1.append('a');
sb1.append(200);
System.out.println(sb1);
System.out.println(sb1.length());
System.out.println(sb1.indexOf("r"));
System.out.println(sb1.delete(0, 3)); // 包前不包后
sb1.insert(0, false);
System.out.println(sb1);
}
}
7.包装类面试题
==和equals的区别？
==比较基本数据类型 比较值
==比较引用数据类型 比较地址
equals也是比较地址
Short Integer Long Character 包装类直接使用=号赋值
取值范围在-128 ~ 127 以内 不会产生新对象 == 为true
超出范围 会new新的对象 == 为false
package com.qfedu.test1;
/**
* ==和equals的区别？
* ==比较引用数据类型 比较地址
*
* Short Integer Long Character 包装类直接使用=号赋值
* 取值范围在-128 ~ 127 以内 不会产生新对象 == 为true
* 超出范围 会new新的对象 == 为false
* @author WHD
*
*/
public class Test1 {
public static void main(String[] args) {
Integer i1 = 200; // new Integer(200);
Integer i2 = 200; // new Integer(200);
System.out.println(i1 == i2); // false
Integer i3 = 127;
Integer i4 = 127;
System.out.println(i3 == i4); // true
// 当直接使用等号给包装类对象赋值，取值范围在 byte的取值范围的时候
// 两个对象 值相同 ==比较为true，超过这个范围为false
// 当你直接使用=号给包装类赋值 如果取值范围在-128 ~ 127 将从缓存数组中取值对应的元素
// 不会new新的对象 如果超出这个范围 将new新的对象
Integer i5 = new Integer(100);
Integer i6 = new Integer(100);
System.out.println(i5 == i6); // false
Short s1 = 120;
Short s2 = 120;
System.out.println(s1 == s2);
Short s3 = 220;
Short s4 = 220;
System.out.println(s3 == s4);
Long l1 = 120L;
Long l2 = 120L;
System.out.println(l1 == l2);
Character ch1 = 100;
Character ch2 = 100;
System.out.println(ch1 == ch2);
Character ch3 = 200;
Character ch4 = 200;
System.out.println(ch3 == ch4);
}
}
