Java学习笔记(一):常用类

最新推荐文章于 2023-07-10 19:32:24 发布

qq_43367379

最新推荐文章于 2023-07-10 19:32:24 发布

阅读量120

点赞数 1

分类专栏： Java学习文章标签： java

本文链接：https://blog.csdn.net/qq_43367379/article/details/111992471

版权

Java学习专栏收录该内容

9 篇文章 0 订阅

订阅专栏

常用类

Object类

超类，基类

getClass()

public final Class<?> getClass(){}

返回引用中存储的实际对象类型

应用：通常用于判断两个引用中实际存储对象类型是否一致

Student s1 = new Student();
Student s2 = new Student();
Class class1=s1.getClass();
Class class2=s2.getClass();

if(class1 == class2) //同一类型

hashCode()

public int hashCode(){}

返回该对象的哈希码值

哈希值根据对象的地址或者字符串或数字使用hash算法计算出来的int类型的数值

一般情况下相同对象返回相同哈希码

Student s1 = new Student();
Student s2 = new Student();
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
//这两个对象的哈希值不一样 
Student s3=s1;
System.out.println(s3.hashCode());
//s1 和 s3 打印的哈希值是一样的。s3指向s1的地址，她两是同一个对象

toString()

public String toString(){}

返回该对象的字符串表示（表现形式）

可以根据程序需求覆盖该方法，如:展示对象各个属性值

Student s1 = new Student();
Student s2 = new Student();
System.out.println(s1.toString());//类的全名称@哈希值
System.out.println(s2.toString());
//例如 com.liu.cla.Student@15db9742

//可以在Student类中重写toString方法

public String toString(){
    return name+":"+age;
}

equals()

public boolean equals(Object obj){}

默认实现为(this==obj),比较两个对象地址是否相同

可进行覆盖，比较两个对象的内容是否相同

Student s1 = new Student();
Student s2 = new Student();
System.out.println(s1.equals(s2));
//结果为false
//哪怕两个对象的内容相同返回的也是false

可以在Student类中重写,当内容相同时也输出true

public boolean equals(Object obj){
    //1.判断两个对象是否是同一对象
    if(this == obj)
        return true;
    //判断obj是否为null
    if(obj == null)
        return false;
    //判断是否是统一类型
    if(obj instanceof Student){
        Student s=(Student)obj;//强制类型转换
        //比较内容
        if(this.name.equals(s.getName()))
            return true;
    }
    return false;
}

finalize()

当对象被判定为垃圾对象时，由JVM自动调用此方法，用于标记垃圾对象，进入回收队列

垃圾对象：没有有效引用指向次对象时，为垃圾对象

垃圾回收：由GC销毁垃圾对象，释放数据存储空间

自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象

手动回收机制：使用System.gc();通知JVM执行垃圾回收

包装类

基本数据类型所对应的引用数据类型

Object可统一所有类型，包装类的默认值是null

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

类型转换装箱与拆箱

装箱：基本类型转引用类型

拆箱：引用类型转基本类型

//装箱
int num1 = 18;//基本类型 在栈
//使用Integer 类创建对象
Integer integer1 = new Integer(num1);//方式一
Integer integer2 = Integer.valueOf(num1);//方法二

//拆箱
Integer integer3 = new Integer(100);
int num2=integer3.intValue();

//gdk1.5之前
//1.5之后 提供自动装箱和拆箱
int age = 30;
Integer integer4 = age;
//自动拆箱
int age2 = integer4;

基本类型和字符串之间转换

1.基本类型转为字符串

int n1=15;
//1.使用+号
String s1=n1+""; //15
//2.Integer toString
String s2=Integer.toString(n1);//15
String s3=Integer.toString(n1,16);//f 16进制属性

2.字符串转为基本类型

String str="150";
//使用Integer.parseXXX();
int n2=Integer.parseInt(str);
System.out.println(n2);//150


//Boolean字符串转为基本类型
//"true"--->true  非"true" --->false
String s2="true";
String s3="true2"
boolean boolean1=Boolean.parseBoolean(s2);//true;
boolean boolean2=Boolean.parseBoolean(s3);//false;

注意类型格式，类型不对会抛出异常

整数缓冲区

java预先创建了256个常用的整数包装类型对象

在实际应用中，对已创建的对象进行复用

面试题

Integer in1=new Integer(100);
Integer in2=new Integer(100);
System.out.println(in1 == in2);//false
//属于引用类型，在堆里面

Integer in3=100;//自动装箱->Integer.valueOf(100);
Integer in4=100;//Integer.valueOf(100);
System.out.println(in3 == in4);//true

Integer in5=200;
Integer in6=200;
System.out.println(in5==in6);//false
//-128~127 的已经创建好了调用之间把地址给了
//200 没有，要新建

String类

字符串是常量，创建之后不可改变

字符串字面值存储在字符串池中，可以共享

String name = "hello";// “hello”常量存储在字符串池中
name = "张三";  //在字符串池又开了一块空间，地址给name
//并没有修改数据 ，hello 常量就变成 垃圾
String name2="张三";//在常量池里找到了"张三"常量,把地址赋值给name2
//name,name2指向同一个对象，也就是共享

创建方式

String s="hello";//产生一个对象，字符串池中存储
String s=new String("hello");//产生两个对象，堆、池各存储一个


String str=new String("hahaha");//str指向栈里的对象，堆里的地址赋给str
String str2=new String("hahaha");
System.out.println(str==str2);//false 
//两个不同的对象
System.out.println(str.equals(str2));//true;
//比的是数据而不是地址
//String 类里面重写了equals方法，改为比较内容了

常用方法

public int length(): 返回字符串的长度
public char charAt(int index):根据下标获取字符
public boolean contains(String str):判断当前字符串中是否包含str

String str="12345";
System.out.println(str.length());//5
System.out.println(str.charAt(0));//1
System.out.println(str.contains("1"));//true;

public char[] toCharArray():将字符串转换成数组
public int indexOf(String str):查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
public int lastIndexOf(String str):查找str最后一次出现的下标

String str="abcda";

System.out.println(Array.toString(str.toCharArray()));
//[a,b,c,d,a];
System.out.println(str.indexOf("a"));
//0
System.out.println(str.lastIndexOf("a"));
//4

public String trim():去掉字符串前后的空格
public String toUpperCase(): 将小写转成大写
public String toLowerCase():将大写转成小写
public boolean endWith(String str): 判断字符串是否以str 结尾
public boolean startWith(String Str):判断字符串是否以str开头

String str=" aBCd ";
String s=str.trim();
System.out.println(s);//aBCd
System.out.println(s.toUpperCase());//ABCD
System.out.println(s.toLowerCase());//abcd
System.out.println(s.endWith("a"));//true;

public String replace(char oldChar,char newChar);//将旧字符串替换成新字符串
public String[] split(String str);根据str做拆分

String str="hello world";
str.replace(" ",""); //helloworld
String[] arr =str.split(" ");//以空格做拆分
str.split("[ ,]+");//表示选择，空格和,都可以做拆分，且可以出现多个

//补充
compareTo();//比较大小比的是编码表的位置

String s1="abc";
String s2="ABC";
s1.equals(s2);//false
s1.equalIgnoreCase(s2);//true 忽略大小写的比较
s1.compareTo(s2);//'a'-'A'
//一样是0 ，长度不同返回长度差

需求：

已知String str =“this is a text”;

1.将str中的单词单独获取

2.将str中的text替换为practice

3.在text前面插入一个easy

4.将每个单词的首字母改为大写

String str="this is a text";
//1
String[] arr=str.spllit(" ");
//2
String str2=str.replace("text","practice");
//3
String str3=str.replace("text","easy text");
//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);
}

StringBuffer

可变长字符串，JDK1.0提供运行效率慢、线程安全

//区别
/*
1效率比String高 2.比String节省内存
*/
StringBuffer sb = new StringBUffer();
//1 append();追加
sb.append("java最棒");
System.out.println(sb.toString());//java最棒

//2.insert(); 添加
sb.insert(0,"first");
System.out.println(sb.toString());//firstjava最棒
//3.replace();
sb.replace(0,5,"hello");//含头不含尾
System.out.println(sb.toString());//hellojava真棒

//4.delete() 删除
sb.delete(0,5);
//java真棒

//清空
sb.delete(0,sb.length());

StringBuilder

可变长字符串，JDK5.0提供运行效率快，线程不安全

//同上

BigDecimal

double d1=1.0;

double d2=0.9;

System.out.println(d1-d2);//0.0999999999

//面试题存的是近似值

double x=(1.4-0.5)/0.9; //0.99999999999999

位置：java.math包中

作用：精确计算浮点数

创建方式：BigDecimal bd=new BigDecimal(“1.0”);

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);
//1.9

//乘法
BigDecimal r3=bd1.multiply(bd2);
//0.90

//除法
BigDecimal r4=new BigDecimal("1.4")
    .subtract(new BigDecimal("0.5"))
    .divide(new BigDecimal("0.9"));
//(1.4-0.5)/0.9=1

//除不尽会有问题
//10/3 会报异常
BigDecimal r5=new BigDecimal("10")
    .divide(new BigDecimal("3"),2,BigDecimal
           .ROUND_HALF_UP);
//四舍五入，保留2位小数

不能直接用+-*/计算

Date

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法已经被Calendar类中的方法所取代

时间单位：

1s=1000ms

1毫秒=1000微秒

1微秒=1000纳秒

import java.util.Date;
//创建Date对象
Date date1=new Date();//
date1.toString();//当前时间

Date date2=new Date(dat1.getTime()-(60*60*24*1000));
date2.toString();//昨天的时间

boolean b1=date1.after(date2);//true ,今天是昨天之后
boolean b2=date2.before(date1);//true，昨天是今天之前

//compareTo()比较
date1.compareTo(date2);//正数  1
//
date1.equals(date2);//false

Calendar

Calendar提供了获取或设置各种日历字段的方法

构造方法

protected Calendar(): 由于修饰符是protected 所以无法直接创建该对象

其他方法

方法名	说明
static Calendar getInstance()	使用默认时区和区域获取日历
void set(int year,int month,int date,int hourofday,int minute,int second)	设置日历的年月日时分秒
int get(int field)	返回给定日历字段的值。字段不如年、月、日等
Date getTime()	返回一个Date表示此日历的时间。Calendar-Date
void setTime(Date date)	用给定的Date设置此日历的时间。Date-calendar
void add(int field,int amount)	按照日历的规则，给指定字段添加或减少时间量
long getTimeInMillies()	毫秒为单位返回该日历的时间值

//创建Calendar对象
Calendar c1=Calendar.getInstance();
System.out.println(c1.getTime().toString());//
System.out.println(c1.getTimeInMillis());//毫秒值

//获取年
int year=c1.get(Calendar.YEAR);
//月 0-11  要+1
int month=c1.get(Calendar.MONTH);
//日
int day=c1.get(Calendar.DAY_OF_MONTH);
//时
int hour=c1.get(Calendar.HOUR_OF_DAY);//24小时制
//HOUR 是12小时制
//分
int minute = c1.get(Calendar.MINUTE);
//秒
int second=c1.get(Calendar.SECOND);

//修改时间 c2.set(Calendar.DAY_OF_MONTH,5);//昨天

//add 方法修改时间
c2.add(Calendar.HOUR,1);//加一小时
//补充方法
max=c2.getActualMaximum(Calendar.DAY_OF_MOUTH);//4月最大30，5月就是31

SimpleDateFormat

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类

进行格式化（日期->文本）、解析（文本->日期）

常用的时间模式字母

字母	日期或者时间	示例
y	年	2020
M	年中月份	12
d	月中天数	30
H	1天中小时数(0-23)	22
m	分钟	16
s	秒	59
S	毫秒	333

//创建SimpleDateFormat对象
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM日dd日 HH:mm:ss");
//创建Date
Date date=new Date();
//把日期转成字符串
String str=sdf.format(date);
System.out.println(str);//2020年12月30如 15:37:48
//把字符串转成时间  按照创建时的格式
Date date2=sdf.parse("1990年05月01日 11:11:11");

System

系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的

方法名	说明
static void arraycopy(…)	复制数组
static long currentTimeMillis()	获取当前系统时间，返回的是毫秒值
static void gc()	通知JVM回收垃圾
static void exit(int status);	退出JVM，如果参数是0表示正常退出，非0表示异常退出

//src 原数组
//srcPos：从哪个位置开始 0
//dest 目标数组
//destPos 目标数组位置
//length 复制的长度
int []arr={1,2,3,4,5,6,7,8};
int []dest=new int[8];
System.arraycopy(arr,0,dest,0,arr.length);


System.out.println(System.currentTimeMillis());
//打印从1970年到现在的毫秒数
//用来计算代码的执行时间

qq_43367379

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记(一):常用类

常用类Object类超类，基类getClass()public final Class<?> getClass(){}返回引用中存储的实际对象类型应用：通常用于判断两个引用中实际存储对象类型是否一致Student s1 = new Student();Student s2 = new Student();Class class1=s1.getClass();Class class2=s2.getClass();if(class1 == class2) //同一类型h
复制链接

扫一扫