首页 > 基础资料 博客日记

Java常用类

2023-07-24 20:14:28基础资料围观339

文章Java常用类分享给大家,欢迎收藏Java资料网,专注分享技术知识

常用类

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:通用唯一标识码

包装类

八大基本数据类型存在栈里,引用类型存在堆里。引用类型在栈里存的是堆里的地址

基本数据类型不能调用方法,包装类是将基本数据类型变成引用数据类型,可以调用方法,使其功能更丰富

image-20220720100740158

类型转化

类型转换:基本类型和包装类型之间的转换

装箱

装箱:将栈里面的基本数据类型转化成堆里面的引用数据类型的过程

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方法

getTime():返回从1970年1月1日到现在的毫秒数

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);     //获取当月天数
      }
}

 




文章来源:https://www.cnblogs.com/lerrysee/p/16497375.html
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若内容造成侵权/违法违规/事实不符,请联系邮箱:jacktools123@163.com进行投诉反馈,一经查实,立即删除!

标签:

相关文章

本站推荐

标签云