首页 > 基础资料 博客日记
Java常用类
2023-07-24 20:14:28基础资料围观339次
Object类
===clone() ===
protected Object clone() throws CloneNotSupportedException
public class Test {
public static void main(String[] args) throws CloneNotSupportedException{
//引用类型:比较内存地址
Person p1=new Person("lerry");
Object o2=new Object();
Person p2=(Person)p1.clone();
System.out.println(p1.equals(p2)); // >false
System.out.println(p1==p2); // >false
System.out.println(p2.getClass()==p1.getClass()); // >true
}
}
class Person implements Cloneable{
private String name;
public Person(){}
public Person(String name){
this.name=name;
}
public String toString(){
return name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
protected Object clone() throws CloneNotSupportedException{
return super.clone();
}
}
* 想要实现clone方法,必须实现Cloneable接口,重写clone方法 *
clone出来的对象和原来的对象内存地址不同,是两个完全不同的对象
浅克隆:复制一个对象,如果该对象有关联对象,不会复制关联对象。
深克隆:关联对象也会被克隆。
===toString() ===
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
一般会根据项目具体情况重写toString(),实现对应功能
===getClass() ===
public final Class<?> getClass()
Person p1=new Person("lerry");
Person p2=new Person("lerry");
System.out.println(p1.getClass()); // >class com.oop.Person
返回该对象所在的类
===equals() ===
public boolean equals(Object obj) {
return (this == obj);
}
Person p1=new Person("lerry");
Person p2=new Person("lerry");
System.out.println(p1.equals(p2)); // >false
String s1="123";
String s2="123";
System.out.println(s1.equals(s2)); // >true
如果判断的是两个引用类型,比较内存地址,在String类中,已经将其重写了,判断字符串内容是否相等
===hashCode() ===
public native int hashCode();
Person p1=new Person("lerry");
Person p2=new Person("xixi");
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
System.out.println(p1.hashCode());
>
2129789493
668386784 //不同的对象,返回整数不同
2129789493 //多次调用同一个对象,返回整数一致
由对象内存地址转化为哈希编码返回,对不同的对象返回不同的整数,对同一个对象多次调用,必须返回同一个整数。
String类
String是引用类型,可共享的,final修饰,不能被继承,不能被修改
public class Test {
public static void main(String[] args) throws CloneNotSupportedException{
String s1="123";
String s2="456";
s1+=s2;
System.out.println(s1);
/*
常量池中分别存放"123","456"两个常量,s1+=s2是在常量池中先查找是否存在"123456",
如果没有就新建一个常量,然后栈里的s1对象指向这个新建的常量。
*/
String s3="123";
String s4="123";
System.out.println(s2.hashCode());
System.out.println(s3.hashCode());
System.out.println(s4.hashCode());
/*
51669
48690
48690
hashCode是根据内存地址进行编码的,字符串相同的变量,在内存中的地址也相同
*/
}
}
length方法
public int length():返回字符串长度,空格也算一个字符。
charAt方法
public char charAt(int index) :返回某个位置的字符
contains方法
public boolean contains(String str):判断是否包含某个字符串
String s2="456";
System.out.println(s2.charAt(0)); //返回第一个位置的元素
System.out.println(s2.length()); //返回s2字符串长度
System.out.println(s2.contains("3")); //判断是否包含字符3
toCharArry方法
public char[] toCharArry():字符串转换为数组
indexOf方法
public int indexOf(String str):查找字符首次出现的位置下标
lastIndexOf方法
public int lastIndexOf(String str)):查找最后一次出现字符的位置下标
String s2="456421";
System.out.println(Arrays.toString(s2.toCharArray()));
System.out.println(s2.indexOf("4"));
System.out.println(s2.lastIndexOf("4"));
>
[4, 5, 6, 4, 2, 1]
0
3
trim方法
public String trim():去掉字符串前后空格
toUpperCase方法
public String toUpperCase():小写转大写
endsWith方法
public boolean endsWith(String str) :判断是否以str结尾
String s2=" 456421 ";
String s="abdshew";
System.out.println(s2);
System.out.println(s2.trim());
System.out.println(s.toUpperCase());
System.out.println(s.endsWith("w"));
>
456421
456421
ABDSHEW
true
split方法
public String[] split(String str, int limit):字符串拆分
replace方法
public String replace(原字符串, 新字符串):字符串替换
String s2="456 421 7,26";
String s="abdshew";
System.out.println();
String[] a=s2.split("[ ,]+"); //根据空格或,进行分割,如果有连续多个空格,也可以被分割
for(String i:a){
System.out.println(i);
}
System.out.println(s.replace("abds","123"));
>
456
421
7
26
123hew
Compare方法
public int compareTo(String s2):字符串大小是否相等
从第一个字符开始比较,用s2-s1,依次比较
StringBuffer类
可变长,比String节省内存,运行效率慢,线程安全
append方法
append():追加字符串
insert方法
insert(int index,String str):添加字符串,可以在具体位置添加字符
replace方法
replace(int start,int end,String str):可以规定在某一段位置内,替换字符串
delete方法
delete(int start,int end):删除某一范围内的字符串
清空字符串:delete(0,str.length());
public class Test {
public static void main(String[] args) throws CloneNotSupportedException{
StringBuffer str= new StringBuffer();
System.out.println(str.append("java"));
System.out.println(str.insert(0,"The head "));
System.out.println(str.replace(0,8,"It's"));
System.out.println(str.delete(5,9));
}
}
StringBuilder类
可变长,比String节省内存,运行效率块,线程不安全
方法及其使用和StringBuffer都是一样的,效率会更高
Math类
===常见的数学运算===
package com.oop;
public class Test {
public static void main(String[] args) {
int a=-10;
System.out.println(Math.abs(a)); //取绝对值
int b=2;
System.out.println(Math.pow(b,3)); //幂运算,返回double类型
int c=4;
System.out.println(Math.sqrt(c)); //开平方,返回double类型
int min=100;
int max=219;
System.out.println(Math.min(min,max)); //最小值
System.out.println(Math.max(min,max)); //最大值
System.out.println("====================================");
System.out.println(Math.PI); //PI
System.out.println(Math.floor(3.14123)); //向下取整,返回double类型
System.out.println(Math.ceil(3.14123421)); //向上取整,返回double类型
System.out.println(Math.round(3.1412321)); //取整,返回long类型
}
}
Random类
Math.random():生成[0,1)之间的double类型随机数
Random a=new Random();
//生成0~xx内随机数
int i=a.nextInt(xx);
//获得四位随机数,(可以做验证码)
int m=a.nextInt(9000)+1000;
//伪随机数:此时获取的随机数唯一,不会改变
Random a=new Random(10);
UUID:通用唯一标识码
包装类
八大基本数据类型存在栈里,引用类型存在堆里。引用类型在栈里存的是堆里的地址
基本数据类型不能调用方法,包装类是将基本数据类型变成引用数据类型,可以调用方法,使其功能更丰富
类型转化
类型转换:基本类型和包装类型之间的转换
装箱
装箱:将栈里面的基本数据类型转化成堆里面的引用数据类型的过程
public class Test {
public static void main(String[] args) {
//jdk9.0之后被禁用了
Integer i1=new Integer(num2);
//手动装箱:
int num2=10;
Integer i2=Integer.valueOf(num2);
System.out.println(i2);
//自动装箱:
int num3=100;
Integer i3=num3;
System.out.println(i3);
}
}
拆箱
拆箱:将堆里面的引用数据类型转化为栈里面的基本数据类型的过程
public class Test {
public static void main(String[] args) {
//手动拆箱:
Integer i1=Integer.valueOf(210);
int num1=i1.intValue();
System.out.println(num1);
//自动拆箱
Integer i2=Integer.valueOf(200);
int num2=i2;
System.out.println(num2);
}
}
基本类型和字符串的转换
基本类型转为字符串:
public class Test {
public static void main(String[] args) {
int num=15;
//1.String s=num+"";
String s1=num+"";
System.out.println(s1);
//2.Integer调用方法
String s2=Integer.toString(num);
String s3=Integer.toString(num,16); //toString()方法重载,radix表示采用几进制
System.out.println(s2);
System.out.println(s3);
}
}
>
15
15
f
字符串转为基本类型:
parseXXX():将字符串转化为XXX类型
public class Test {
public static void main(String[] args) {
//字符串转为基本类型
String str="1837";
//是用parseInt()方法
int num=Integer.parseInt(str);
System.out.println(num);
//字符串转为boolean类型
String t="true";
String s="xxx";
boolean f=Boolean.valueOf(s);
boolean p=Boolean.valueOf(t);
System.out.println(f); //false
System.out.println(p); //true
}
}
字符串转化为boolean类型时,只有“true”-->true,其他字符串全部转化为false
思考
public class Test {
public static void main(String[] args) {
Integer c=new Integer(100);
Integer d=new Integer(100);
System.out.println(c==d); //false
/*在堆里新建了两个地址不同,值相同的对象,所以为false */
Integer a=Integer.valueOf(100);
Integer b=Integer.valueOf(100);
System.out.println(a==b); //true
Integer m=300; //自动装箱:使用Integer.valueOf()
Integer n=300;
System.out.println(m==n); //false
/*
valueOf():if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
如果i在-128~127之间,会从Integer缓冲区中存取,否则会创建新的对象。
*/
}
}
Date类
构造方法:1.无参构造:初始化Date对象
2.Date(long date): 表示从1970年1月1日起i,经过date毫秒的时间
after和before
after(Date day):测试该日期是否在指定日期day之后
before(Date day):测试该日期是否在指定日期day之前
getTime方法
toString方法
toString():把此Date对象转化为字符串
public class Test {
public static void main(String[] args) throws CloneNotSupportedException{
Date d=new Date();
Date p=new Date(2022-1-1);
System.out.println(d.after(p));
System.out.println(d.before(p));
System.out.println(d.getTime());
System.out.println(d.toString());
}
}
>
true
false
1658222182766
Tue Jul 19 17:16:22 CST 2022
SimpleDateFomat类
进行格式化(日期-->文本和解析(文本-->日期)日期的具体类
字母 | 代表日期 |
---|---|
y | 年 |
M | 月 |
d | 日 |
H | 时 |
m | 分 |
s | 秒 |
S | 毫秒 |
format
format(Date date):格式化Date对象,返回String字符串
格式化(时间->字符串):
public class Test {
public static void main(String[] args) throws CloneNotSupportedException{
//创建对象,为其设置一个格式
SimpleDateFormat time=new SimpleDateFormat("yyyy/MM/dd/");
//创建Date
Date day=new Date();
//格式化
String s=time.format(day);
//打印出按给定格式的时间字符串
System.out.println(s);
}
}
>2022/07/20/
解析(字符串->时间):
public class Test {
public static void main(String[] args) throws ParseException {
//创建对象,为其设置一个格式
SimpleDateFormat time=new SimpleDateFormat("yyyy/MM/dd/");
//依据time格式,创建字符串
//Exception in thread "main" java.text.ParseException: Unparseable date: "2021/12/01"
//格式不正确,就会抛出异常
String t="2021/12/01/";
//转换解析成Date类型
Date d=time.parse(t);
System.out.println(d);
}
}
Calender类
提供了获取和设置各种日历字段的方法
构造方法:protected Calender(){}
由于使用protected修饰符,所以无法直接创建该对象
getInstance
由于使用protected修饰符,所以无法直接创建该对象,使用getInstance创建对象
set和get
set(int year,int month,int date,int hour,int minute,int second):修改日历的年月日时分秒
get(int field):返回给定日历字段的值
setTime和getTime
setTime(Data data):用给定的Date设置时间
getTime():得到时间,返回Date类型的值
add
add(int field,amount):修改时间,可以增加或减少时间
getActualMaximum
getActualMaximum(int field):获取当月或当年的最大天数或月份
public class Test {
public static void main(String[] args) throws CloneNotSupportedException{
Calendar c=Calendar.getInstance(); //创建对象
System.out.println(c.getTime()); //获取时间
c.set(2021,12,3,12,30,15); //设置时间
System.out.println(c.getTime());
int year=c.get(Calendar.YEAR); //获取年(Calendar.YEAR) 月(Calendar.MONTH) 日(Calendar.DATE) 时hour-12小时 hourOfDay-24小时
System.out.println(year);
System.out.println("===============================");
Date date=new Date();
date.setTime(11200);
System.out.println(date);
Calendar c2=Calendar.getInstance();
c2.setTime(date); //设置时间
System.out.println(c2.getTime());
System.out.println("=========================");
Calendar ce2=Calendar.getInstance();
ce2.add(Calendar.MONTH,2); //月份添加2
System.out.println(ce2.getTime());
int month=ce2.getActualMaximum(Calendar.MONTH); //获取最大月份
int day=ce2.getActualMaximum(Calendar.DAY_OF_MONTH); //获取该月最大天数
System.out.println(month); //月份(0~11)
System.out.println(day); //获取当月天数
}
}
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若内容造成侵权/违法违规/事实不符,请联系邮箱:jacktools123@163.com进行投诉反馈,一经查实,立即删除!
标签: