常用类的学习
内部类有:
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
·没有类名的局部内部类(一切特征与局部内部类相同)
·必须继承一个父类或者实现一个接口
定义类、实现类、创建对象的语法合并,只能创建一个该类的对象
优点:减少代码量
缺点:可读性较差
Object类:
- 所有类的父类
- 任何类,如果没有书写extends显示继承某个类,都会默认直接继承Object类,否则为间接继承
- Object类中所定义的方法,是所有对象都具备的方法
- Object类型可以存储任何对象
1.作为参数,可以接受任何对象
2.作为返回值,可以放回任何对象
getClass()方法:
1.返回引用中存储的实际对象类型
2.应用:通用用于判断两个引用中实际存储对象类是否一致
public class Student {
private String name;
private int age;
public Student(){
}
public Student(String name,int age){
super();
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
下面是测试public class Text {
public static void main(String[] args) {
//getClass方法
Student s1=new Student("aaa",20);
Student s2=new Student("bbb",22);
//判断s1和s2是不是同一个类型
Class class1=s1.getClass();
Class class2=s2.getClass();
if(class1==class2){//s1和s2属于同一个类型
System.out.println("s1和s2属于同一个类型");
}else {
System.out.println("s1和s2不属于同一个类型");
}
}
}
hashCode()方法:
1. 返回该对象的哈希码值
2. 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
3. 一般情况下相同对象返回相同哈希码
还是用上面的类进行测试
//hashCode方法
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
Student s3=s1;
System.out.println(s3.hashCode());
toString()方法:
1. 返回该对象的字符串表示(表现形式)
2. 可以根据程序需求覆盖该方法,如:展示对象各个属性值
还是用上面的类测试(此时需要重写方法)
public class Student {
private String name;
private int age;
public Student(){
}
public Student(String name,int age){
super();
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return name+","+age;
}
}
//toString方法
System.out.println(s1.toString());
System.out.println(s2.toString());
输出结果: (不使用重写方法)会输出
aaa,20 CommonClass.getset.Student@154617c @后就是哈希码值
bbb,22 CommonClass.getset.Student@a14482
equals()方法:
比较两个对象的地址
1. 默认实现为(this == obj),比较两个对象地址是否相同
2. 可进行覆盖,比较两个对象的内容是否相同
包装类
- 基本数据类型所对应的引用数据类型
- object可统一所有数据,包装类的默认值是null
基本数据类型 | 包装类型 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
类型转换与装箱、拆箱
装箱:将基本类型转换为引用类型的过程
拆箱 :将引用类型转换为基本类型的过程
public static void main(String[] args) {
int num=10;
//类型转换:装箱,基本类型转换成引用类型的过程
//基本类型
int num1=18;
//使用Integer类创建对象
Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);//这2中方法都可以
System.out.println("装箱:");
System.out.println(integer1);
System.out.println(integer2);
//类型转换:拆箱,引用类型转换成基本类型的过程
Integer integer3 = new Integer(100);
int num2=integer3.intValue();
System.out.println("拆箱:");
System.out.println(num2);
//JDK1.5之后,提供自动装箱和拆箱
int age=20;
//自动装箱
Integer integer4=age;
System.out.println("自动装箱:");
System.out.println(integer4);
//自动拆箱
Integer age1=integer4;
System.out.println("自动拆箱:");
System.out.println(age1);
}
基本类型和字符转换
//基本类型和字符串之间的转换
//1.基本类型转换成字符串
int n1=100;
//1.1使用+号
String s1=n1+"";
//1.2使用Integer中的toString()方法
String s2=Integer.toString(n1);
System.out.println(s1);
System.out.println(s2);
//2.字符串转换成基本类型
String str="150";
//使用Integer.parseXXX();
int n2=Integer.parseInt(str);
System.out.println(n2);
//boolean字符串形式转换成基本类型,只有字符串的"true"--->true ||"true"--->false 非true都是false
String str2="true";
boolean b1=Boolean.parseBoolean(str2);
System.out.println(b1);
Integer缓冲区
- java预先创建好了256个常用的证书包装类型对象
- 在实际应用当中,堆已创建的对象进行复用
public static void main(String[] args) {
//面试题
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1==integer2);//false 他们是引用类型了放在堆里面 地址不一样所以是false
Integer integer3=100;//自动装箱Integer.valueOf
Integer integer4=100;
System.out.println(integer3==integer4);//true
Integer integer5=200;//自动装箱
Integer integer6=200;
System.out.println(integer5==integer6);//false
//思考为100是true,200为什么就是false?
//valueOf中已经创建好了常用的包装对象在-128--127之间 超过这个范围就只能重新在堆里面开辟新的
}
String类
- 字符串是常量,创建之后不可改变
- 字符串面值存储在 字符串(在方法区里面)池中,可以共享
- String s=“hello”;产生一个对象,字符串池中存储
- String s=new String(“hello”);//产生两个对象,堆、池各存储一个!
public static void main(String[] args) {
String name="hello";//"hello"常量存储在字符串池中
name="zhangsan";//把zhangsan赋值给name,给字符串赋值时,并没有修改数据,而是重新开辟一个空间。这就是不可变性,原来的hello就变成垃圾了
String name2="zhangsan";//把原来开辟的空间直接拿过来用
System.out.println(name);
System.out.println(name.equals(name2));//true
//字符串的另一种创建方式:new String
String str=new String("java");//堆和字符池中各一个java,所以出现了2个对象
//面试题
String str2=new String("java");//只要new就重新开辟
System.out.println(str==str2);//false
System.out.println(str.equals(str2));//true
}
String常用方法
- public int length():返回字符串的长度
- public char charAt(int index):根据下标获取字符
- public boolean contains(String str):判断当前字符串中是否包含str
//字符串方法的使用
//1、length();返回字符串的长度
//2、charAt(int index);返回某个位置的字符
//3、contains(String str)判断是否包含某个子字符串
String content="java是世界上最好的java编程语言,java真好用";
System.out.println(content.length());//15
System.out.println(content.charAt(content.length()-1));//言
System.out.println(content.contains("java"));//true 包含了就是true反之false
System.out.println(content.contains("php"));//false
- public char[] toCharArray():将字符串转换成数组
- public int indexOf(String str):查找str首次出现的下标,存在,则返回该下标;不存在,则返回-1
- public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的小标索引
//字符串方法的使用
//4、toCharArray();返回字符串对应的数组
//5、indexOf();返回子字符串首次出现的位置
//6、lastIndexOf();返回字符串最后一次出现的位置
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("java"));
System.out.println(content.indexOf("java",4));//4 是字符的脚标从0开始数
System.out.println(content.lastIndexOf("java"));
- public String toUpperCase():将小写转换成大写
- public String trim():去掉字符串前后的空格
- public boolean endWith(String str):判断字符串是否以str结尾
//7.trim();去掉字符串前后的空格
//8.toUpperCase();把小写转换成大写。//toLowerCase();把大写转换成小写
//9.endWith(str);判断是否以str结尾。//startWith(str);判断是否以str开头
String content2=" hello World ";
System.out.println(content2.trim());//hello World
System.out.println(content2.toUpperCase());// HELLO WORLD
System.out.println(content2.toLowerCase());// hello world
String contnet3="hello.java";
System.out.println(contnet3.endsWith("java"));//true
System.out.println(contnet3.startsWith("hello"));//true
- public String replace(char oldChar,char newChar);将旧的字符串替换成新的字符串
- public String[] split(String str);根据str做拆分
//10.replace(char old,char new);用新的字符或字符串替换旧的字符或字符串
//11.split();对字符串进行拆分
//String content="java是世界上最好的java编程语言,java真好用";
System.out.println(content.replace("java","php"));//php是世界上最好的php编程语言,php真好用
String say="java is the best programing language";
String[] arr=say.split(" ");//还可以选择多个进行拆分[ ,]就是将空格和,都拆分了
System.out.println(arr.length);//6
for (String string : arr){
System.out.println(string);
}
//补充两个方法equals、compare();比较大小
String s1="hello";
String s2="HELLO";
System.out.println(s1.equals(s2));//false
System.out.println(s1.equalsIgnoreCase(s2));//true。equalsIgnoreCase忽略大小写进行比较
String s3="abc";//a 97
String s4="xyz";//x 120
System.out.println(s3.compareTo(s4));//-23 从一个数起出现了不同就进行比较(仅此一次)上面就是a与x的比较
//另一种情况是字符同一列没有相同的了且一方字符少,那就进行长度的比较
String s5="abc";
String s6="abcopl";
System.out.println(s5.compareTo(s6));//-3
例题:
已知String str = “this is a text”;
1.将str中的单词单独获取出来
2.将str中的text替换成practice
3.在text前面插入一个easy
4.将每个单词的首字母改成大写
public static void main(String[] args) {
String str = "this is a text";
//1.将str中的单词单独获取出来
String[] arr=str.split(" ");
for (String string:arr){//遍历
System.out.println(string);
}
//2.将str中的text替换成practice
System.out.println(str.replace("text","practice"));
//也可以这样写
String str2=str.replace("text","practice");
System.out.println(str2);
//3.在text前面插入一个easy
String str3=str.replace("text","easy text");
System.out.println(str3);
//4.将每个单词的首字母改成大写
for (int i=0;i<arr.length;i++){
char first=arr[i].charAt(0);
//把第一个字符转成大写
char upperfirst=Character.toUpperCase(first);
String news=upperfirst+arr[i].substring(1);//substring截取片段 1代表从第二个字符开始截取
System.out.println(news);
}
}
可变字符串
- StringBuffer:可变长字符串,JDK1.0就开始提供了,运行效率慢、线程安全
- StringBuilder:可变长字符串,JDK5.0开始提供,运行效率快,线程不安全
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
// StringBuilder sb = new StringBuilder();//和StringBuffer一样
//1.append();追加
sb.append("java世界第一");
System.out.println(sb.toString());//java世界第一
sb.append("java真香");
System.out.println(sb.toString());//java世界第一java真香
sb.append("java好用");
System.out.println(sb.toString());//java世界第一java真香java好用
//2.insert();添加
sb.insert(0,"我在最前面");
System.out.println(sb.toString());//我在最前面java世界第一java真香java好用
//3.replace();替换
sb.replace(0,5,"hello");
System.out.println(sb.toString());//hellojava世界第一java真香java好用
//4.delete();删除
sb.delete(0,5);
System.out.println(sb.toString());//java世界第一java真香java好用
//清空
sb.delete(0,sb.length());
System.out.println(sb.toString());
}
验证StringBuilder效率高的方法如下:
public static void main(String[] args) {
//开始时间
long start=System.currentTimeMillis();
// String string="";
// for (int i=0;i<9999;i++){
// string+=i;
// }
// System.out.println(string);
StringBuilder sb = new StringBuilder();
for (int i=0;i<9999;i++){
sb.append(i);
}
System.out.println(sb.toString());
long end=System.currentTimeMillis();
System.out.println("用时:"+(end-start));//用时:351 String StringBuilder 用时:16
}
BigDecimal的使用
- 位置:java.math包中
- 作用:精确计算浮点数
- 创建方式:BigDecimal bd=new BigDecimal(“1.0”);
- 方法:
1.BigDecimal add(BigDecimal bd) 加法
2.BigDecimal subtract(BigDecimal bd) 减法
3.BigDecimal multiply(BigDecimal bd) 乘法
4.BigDecimal divide(BigDecimal bd) 除法
很多实际应用中需要精确运算,而double是近似值存储,不在符合要求,需要借助BigDecimal
public static void main(String[] args) {
double d1=1.0;
double d2=0.9;
System.out.println(d1-d2);//0.09999999999999998
//面试题
double result=(1.4-0.5)/0.9;
System.out.println(result);//0.9999999999999999
//BigDecimal,大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法
BigDecimal r1=bd1.subtract(bd2);
System.out.println(r1);//0.1
//加法
BigDecimal r2=bd1.add(bd2);
System.out.println(r2);//1.9
//乘法
BigDecimal r3=bd1.multiply(bd2);
System.out.println(r3);//09
//除法
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));//除
System.out.println(r4);//1
}
Date类
- Date表示特定的瞬间,精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
- 时间单位:
1秒=1000毫秒
1毫秒=1000微秒
1微秒=1000纳秒
public static void main(String[] args) {
//1.创建Date对象
//今天
Date date1=new Date();
System.out.println(date1);//Thu Jul 29 16:40:53 CST 2021
System.out.println(date1.toLocaleString());//2021-7-29 16:44:42
//昨天
Date date2=new Date(date1.getTime()-(60*60*24*1000));
System.out.println(date2.toLocaleString());//2021-7-28 16:44:42
//2.方法after before
boolean b1=date1.after(date2);//今天在昨天之后
System.out.println(b1);//true
boolean b2=date1.before(date2);//今天在昨天之前
System.out.println(b2);//false
//比较compareTo();
int d=date1.compareTo(date2);
System.out.println(d);//1
//比较是否相等equals();
boolean b3=date1.equals(date2);
System.out.println(b3);//false
}
Calendar类
- Calendar提供了获取或设置各种日历字段的方法
- 构造方法:
protected Calendar():由于修饰符是protected,所以无法直接创建该对象
public static void main(String[] args) {
//1.创建Calendar对象
Calendar calendar=Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());//打印本地时间
System.out.println(calendar.getTimeInMillis());//1970年到现在的毫秒
//2.获取时间信息
//获取年
int year=calendar.get(calendar.YEAR);
//月
int month=calendar.get(calendar.MONTH);
//日
int day=calendar.get(calendar.DAY_OF_MONTH);//Date
//小时
int hour=calendar.get(calendar.HOUR_OF_DAY);
//分钟
int minute=calendar.get(calendar.MINUTE);
//秒
int second=calendar.get(calendar.SECOND);
System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);
//3.修改时间
Calendar calendar2=Calendar.getInstance();
calendar2.set(calendar.DAY_OF_MONTH,28);//修改日
System.out.println(calendar2.getTime().toLocaleString());
//4.add方法修改时间
calendar2.add(calendar.HOUR,-1);//修改小时
System.out.println(calendar2.getTime().toLocaleString());
//5.补充方法
int max=calendar2.getActualMaximum(calendar.DAY_OF_MONTH);//当前月最大天数
int min=calendar2.getActualMinimum(calendar.DAY_OF_MONTH);//当前月最小天数
System.out.println(max);
System.out.println(min);
}
SimpleDateFormat类
public static void main(String[] args) throws ParseException {
//1.创建SimpleDateFormat对象 y年M月
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
//2.创建Date
Date date = new Date();
//格式化date(把日期转换成字符串)
String str=sdf.format(date);
System.out.println(str);
//解析(把字符串转换成日期)
Date date2=sdf.parse("2021/02/02");//要跟上面new的类型一致
System.out.println(date2);
}
System类
- System系统类,主要用于获取系统的属性数据和其他操作,构造方法私有的
public static void main(String[] args) {
//1.arraycopy;数组的复制
//src:源数组
//srcPos:从那个位置开始复制0
//dest:目标数组
//destPos:目标数组的位置
//length:复制的长度
int[] arr={20,18,15,8,35,26,45,90};
int[] dest=new int[8];
System.arraycopy(arr,4,dest,4,4);
for (int i=0;i<dest.length;i++){//遍历
System.out.println(dest[i]);//打印
}
//2.System.currentTimeMillis();获取毫秒数
//3.System.gc();告诉垃圾回收期回收
//4.退出JVM
System.exit(0);//后面的代码就不会执行了
System.out.println("程序结束了...");
}
总结
-
内部类:
-
在一个数的内部再定义一个完整的类
-
成员内部类、静态内部类、局部内部类、匿名内部类
-
Object类:
所有类的直接或间接父类,可存储任何对象 -
包装类:
基本数据类型所对应的引用数据类型,可以使Object统一所有数据 -
String类:
字符串是常量,创建之后不可改变,字面值保存在字符串池中,可以共享 -
BigDecimal类:
可精确计算浮点数 -
Date类
特定时间 -
Calendar类
日历 -
SimpleDateFormat类
格式化时间 -
System类
系统类