Java中常见的几个类

最新推荐文章于 2024-04-05 23:04:20 发布

杨杨杨Y

最新推荐文章于 2024-04-05 23:04:20 发布

阅读量743

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_37867421/article/details/105909737

版权

常用类

第一节：Object

所有类的父类，他的所有方法是被子类默认继承的。

1.getClass  返回的是实际对象的类型
2.toString  返回的是该对象的地址的文本格式 
     public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
  根据需求选择是否重写
3.hashCode（） 返回地址的十进制   相同对象的哈希值一定相同，但是不同对象的哈希值可能一样。
4.equals(Object obj)    this == obj  判断的还是地址。 根据需求选择是否重写，目的 把相同的内容返回true

第二节：包装类

基本类型对应的包装类

byte    Byte    1字节
short   Short    2
int     Integer   4
long     Long    8
float    Float    4
double   Double    8
char     Character   2
boolean  Boolean

Integer：

装箱 :基本数据类型 转成 引用类型
拆箱： 包装类型转为基本的数据类型
//手动装箱两种方式：
 //方式一
 Integer a = new Integer(1);
 //方式二
 Integer b = Integer.valueOf(1);

 //拆箱的手动方法
 int d = Integer.intvalue(b);

//自动装箱
Integer  c = 1;  // 调用的是  valueOf    
//自动拆箱  
int d = b;  // 调用的 手动版的拆箱 

转整数   
Integer.parseInt(str)  
//特别注意  如果 字符串里有非数字格式，会报 NumberFormatException  
 //Integer在做数据运算时会自动拆箱  比如  Integer a = 1;  a+1 ==> 2

第三节：String

字符串 String final修饰的类不可被继承。不可变。

其实底层就是字符数组 char[] value // char value[]

字符串数据是常量，存储在常量池中，常量池中不允许存储相同的数据，字符串可以直接将数据赋值给对象引用。常量池的位置:jdk1.7之前，常量池的位置（jvm hotspot 永久代）在中，jdk1.7(包括1.7)之后，常量池放在堆中。(方法区是JavaSE规范中的一个概念)

字符串类型是不可变的，指的是原来指向的数据没有变化，而是新开辟一个空间

字符串传值方式和基本类型一致。

内存分配：字符串实际数据存放在串池中。

常用的构造方法：

方法名	描述
String（）	创建一个字符串对象，此字符串中没有任何字符，空字符串
String(byte[] byte,String charsetname)	通过使用指定的charset解码指定的 byte 数组，构造一个新的String
String(String str)	初始化一个新创建的String对象，使其表示一个与参数相同的

//创建一个字符串对象 
String s1="abc"; 
String s2 = new String("abc");

String中方法：

1. equals()   String重写了equals（） 内容相同即为true
2. charAt(index)  通过下标找字符
3. contains()  true/false 判断是否包含
4. toCharArray()  字符串转成 字符数组  
5. length()  获取字符串长度
6. indexOf(str) 通过字符找首次出现的下标 ，没有 返回 -1
7. lastindexOf(str) 最后一次出现的下标
8. subString(int begin)  //从开头截取到最后
    subString(int begin,int end) // [begin end)
9. trim() 去掉前后的空格
10.toUpperCase() 转大写  toLowerCase()转小写
11. startWith (str)以str开头   endwith(str) 以 str结尾
12. replace(old,new): 返回一个新字符串
13. split(分割符)  切割成数组
14. new String(char[] c)  数组转 字符串

内存中的字符串：

class StringUsageDemo01 { 
    public static void main(String[] args) { 
        //s1表示引用，存储在栈空间中，但是，“hello”存储在常量池中 
        String s1 = "hello"; 
        String s2 = "hello"; 
        //注意1：使用一个字符串常量定义两个不同的变量，这时两个变量其实在内存中是同一块内存空间 
        //原因：两个变量都拷贝了字符串常量的地址 
        System.out.println(s1 == s2);//true 
        System.out.println(s1.equals(s2));//true 
        //注意2：但凡遇到new关键字，表示开辟了不同的空间 
        //s3和s4分别指向了两个不同的有效空间 
        String s3 = new String("hello"); 
        String s4 = new String("hello"); 
        System.out.println(s3 == s4);//false 
        System.out.println(s3.equals(s4));//true 
        System.out.println(s1 == s3);//false 
        System.out.println(s1.equals(s3));//true 
        /*String s1 = "hello"; 只有一个对象，是“hello” 
        String s3 = new String("hello"); 两个对象，一个是“hello”,另外一个就是new出现的对 象 */
        //字符串是一个特殊的对象，一旦被初始化之后将不能发生改变 
        //注意3：不能发生改变指的是真正的对象【字符串常量对象和new出现的对象】
        s1 = "java"; 
        /*
        	String str = "abc"; 
        	等价于char[] arr = {'a','b','c'};
        */ 
    } 
}

第四节：StringBuffer和StringBuilder

1. StringBuffer 和 StringBuilder属于可变字符串。
2. 有一个初始长度为16的字符数组。每次添加字符串时，都是添加到该数组中，数组长度
不够存储时，会创建一个容量大的数组，通过Arrays,copyof把旧数组内容复制到新数组
中，实现扩容。
3.常用方法：  
    增加  append(String str)
    删除  delete(int start,int end)  deleteCharAt(int index)
    插入  insert(int offset,String str)
    修改  setCharAt(int index,char ch) replace(int start, int end, String str)
    查询  charAt lastIndexOf length substring
    反转  reverse()
3. StringBuffer 线程安全，效率较Builder慢一些  
   StringBuilder线程不安全，效率较快

1.每当new StringBuffer()时 ，底层会初始一个char[] value 长度为 16
    public StringBuffer() {
        super(16);
    }
2.当 存储的元素个数大于 16时，会扩容：新建一个数组，长度是原来的2倍+2，把原来数组中的元素复制过去。

第五节：Date类

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

构造方法：

方法名	描述
Date()	分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
Date(long date）	分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，

方法：

判断日期对象的前后

Date date1 = new Date();
//获取当前系统时间 
Date date2 = new Date(10000);//获取从标准基准时间起10000毫秒的时间点 boolean 
boo1 = date1.after(date2);//若date1在date2之后，则返回true，否则返回false 
boolean boo2 = date1.before(date2);//若date1在date2之前，则返回true，否则返回false

比较2个日期对象

Date date1 = new Date(); 
Date date2 = new Date(10000); 
int i = date1.compareTo(date2)

获取时间

Date date = new Date(); 
long l = date.getTime();

修改时间

Date date = new Date(); 
date.setTime(1000);

第六节：Calendar类

Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的00:00:00.000，格里高利历）的偏移量。

Calendar类时抽象类不能创建对象，可以通过Calendar类中的静态getInstance方法获取对象（一个费抽象子类对象）.

属性	描述
public static final int YEAR	指示年的字段数字
public static final int MONTH	指示月份的字段数字
public static final int DATE	指示一个月中的某天
public static final int DAY_OF_MONTH	指示一个月中的某天
public static final int DAY_OF_WEEK	指示一周中的某天
public static final int DAY_OF_WEEK_IN_MONTH	指示当月中的第几个星期
public static final int DAY_OF_YEAR	指示一年中的某天

常用方法：

获取Calendar对象

Calendar c = Calendar.getInstance();
//getInstance方法是一个静态的方法，直接通过类名 调用 
System.out.println(c);

获取日历中某个属性的值

/*
  get(int field) 参数就是指定的属性，可以使用静态常量属性名代替int值 
*/
/*注意：获取日期属性，不能直接用c.DATE，DATE属性时静态常量，
所有Calendar类对象都共享并相 同的值 
*/
Calendar c = Calendar.getInstance(); 
System.out.println(c.get(Calendar.DATE));//获取c对象所表示日历的日期属性值

修改某个日历对象的指定属性的值

/*
	set(int field, int value) 第一个参数表示属性，第二个参数表示修改的值 */
Calendar c = Calendar.getInstance(); 
c.set(Calendar.YEAR, 2017);

获取某个属性所表示的最大值、最小值

/*
	getMaximum(int field) 获取属性的最大值 
	getMinimum(int field) 获取属性的最小值 
*/
	Calendar c = Calendar.getInstance(); 
	int max = c.getMaximum(Calendar.DATE);//获取日期的最大值,无论c表示几月份,max的值都是 31 
	int min = c.getMinimum(Calendar.DATE);//获取日期的最小值,无论c表示几月份,min的值都是 1

获取执行Calendar对象的指定属性的最大值、最小值

/*
getActualMaximum(int field) 获取指定日历的指定属性的最大值 
getActualMinimum(int field) 获取指定日历的指定属性的最小值 
*/
Calendar c = Calendar.getInstance(); 
int max = c.getActualMaximum(Calendar.DATE); //若c表示的1月，则max值为31；若c表示的4月，则max值为30； 
int min = c.getActualMimimum(Calendar.DATE);//无论c表示几月份，min值都是1

第七节：SimpleDateFormat类

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

它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

通过SimpleDateFormat类将字符串和日期相互转换时，需要使用一些时间模式字母，常用的时间模式字母：

字母	日期或者时间元素	示例
y	年	1996.96
M	年中的月份	July；Jul；07
w	年中的周数	27
D	年中的天数	189
d	月份中的天数	10
a	Am/pm标记	PM
H	一天中的小时数（0-23）	0
h	am/pm中的小时数（1-12）	12
m	小时中的分钟数	30
s	分钟中的秒数	55
S	毫秒数 1秒=1000毫秒 =1000000微秒=1000000000毫微秒(纳秒)	978

格式化日期：

/*
format(Date date) 将date对象格式化成指定格式的日期字符串 
*/
String format = "yyyy-MM-dd a hh:mm:ss"; 
SimpleDateFormat sdf = new SimpleDateFormat(format); 
Date date = new Date(); 
String dateStr = sdf.format(date);

解析日期：

/*
parse(String str) 将str对象解析成一个日期对象 
*/
String dateStr = "2017-12-01 上午 10:10:10"; 
String format = "yyyy-MM-dd a hh:mm:ss"; 
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date date = sdf.parse(dateStr);

第八节：Math类

Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

Math中有2个静态常量属性：

属性	描述
public static final E	比任何其他值都更接近 e （即自然对数的底数）的double值。
public static final PI	比任何其他值都更接近 pi （即圆的周长与直径之比）的double值。

常用方法：

//Math  util包下的工具类  
		//1. 取绝对值  abs()
		int a = Math.abs(-1);
		System.out.println(a);
		//2. 取较大值
		int max = Math.max(1, 2);
		//3.取较小值
		int min = Math.min(1, 2);
		//3. 四舍五入
		long round = Math.round(3.4);
		System.out.println(round);//3
		//4.向上取整  ceil() 返回值是 一个double类型
		int ceil = (int) Math.ceil(3.1);//大于或等于这个数字的最小正数
		System.out.println(ceil);
		//5.向下取整 floor()
		double floor = Math.floor(3.999);//小于或等于这个数字的最大正数
		System.out.println(floor);

		//6. 随机数
		double random = Math.random();
		System.out.println(random); //[0 1)
		 
		 //0-50之间的随机整数
		System.out.println((int)Math.floor(Math.random()*51));
		
		char[] arr = {'z','f','a','o','p','k','e','q','g','m'};
		
		//求一个随机字符 
		// 随机四个字符，且不能重复？
		//[0 - 9]
		int r = (int)Math.floor(Math.random()*arr.length);
		
		System.out.println(arr[r]);
		
		//求平方根
		System.out.println(Math.sqrt(100));
		//求幂
		double pow = Math.pow(2, 3);
		System.out.println(pow);

第九节：Bigdecimal类

用于精确计算浮点数。

BigDecimal b1 = new BigDecimal("1.0");
BigDecimal b2 = new BigDecimal("0.9");
//相减
System.out.println(b1.subtract(b2));
//相加
System.out.println(b1.add(b2));
//相乘
System.out.println(b1.multiply(b2));
//相除
System.out.println(b1.divide(b2,4,BigDecimal.ROUND_HALF_UP)); //当除不尽时会报算术异常，由此引入了四舍五入保留小数点的方式

第十节：Random类

此类的实例用于生成伪随机数流。此类使用 48 位的种子，使用线性同余公式 (linear congruential form) 对其进行了修改所得。

构造方法：

方法名	描述
Random()	创建一个新的随机数生成器。此构造方法将随机数生成器的种子设置为某个值，该值与此构造方法的所有其他调用所用的值完全不同。
Random(long seed）	使用单个 long 种子创建一个新的随机数生成器。该种子是伪随机数生成器的内部

注意：若long种子确定，则在不同程序中，相同次数产生的随机数是相同的。

1.产生随机数
Random random = new Random(10);//以10为种子，使用线性同余公式产生伪随机数 
int i1 = random.nextInt();//产生一个随机整数 
int i2 = random.nextInt(10);//产生一个10以内的随机整数 
double d = random.nextDouble();//产生一个随机double值 
boolean b = random.nextBoolean();//产生一个随机boolean值
2.修改种子
Random random = new Random(10); 
random.setSeed(20);//将随机数种子设置为20

杨杨杨Y

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java中常见的几个类

常用类第一节：Object所有类的父类，他的所有方法是被子类默认继承的。1.getClass 返回的是实际对象的类型2.toString 返回的是该对象的地址的文本格式 public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode());...
复制链接

扫一扫