常用类1，如Object，String，正则表达式

最新推荐文章于 2024-04-01 10:52:28 发布

域清风

最新推荐文章于 2024-04-01 10:52:28 发布

阅读量105

点赞数

分类专栏： java 文章标签：常用类 Object String

本文链接：https://blog.csdn.net/qq_42326257/article/details/98766006

版权

java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

本文介绍了Java中常用的几个类，包括Object的equals、toString、hashCode、getClass和clone方法，深入讲解了String的特性和各种方法，探讨了StringBuffer与StringBuilder的区别，并详细阐述了正则表达式的规则，如字符、预定义字符类、边界匹配器和数量词。

摘要由CSDN通过智能技术生成

1.object

1.equals

比较地址,String重写了方法，比较的是值。

2.toString

打印对象属性信息（类名和16进制的hascode）

3.hasCode

获取的对象的哈希码值,在一个工程内,可以当做当前对象的身份证(唯一的标识)

4.getclass

得到当前对象的字节码文件对象(一个类的所有对象的字节码文件相同)

5.clone

1.条件：

类必须实现了Cloneable这个接口

2.实现

clone在第一步是和new相似的，都是分配内存，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后再使用原对象中对应的各个域，填充新对象的域，填充完成之后，clone方法返回。

body newb = （body）b.clone();

3.分类

浅拷贝：只拷贝当前类，不拷贝当前类的属性中的类。

深拷贝：全部拷贝。

在这里插入图片描述

static class Body implements Cloneable{
		public Head head;
		public Body() {}
		public Body(Head head) {this.head = head;}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		Body newBody =  (Body) super.clone();
		newBody.head = (Head) head.clone();
		return newBody;
	}
	
}
static class Head implements Cloneable{
	public Head() {}
	public Head(Face face){this.face = face;}
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
} 
public static void main(String[] args) throws CloneNotSupportedException {
	
	Body body = new Body(new Head());
	
	Body body1 = (Body) body.clone();
	
	System.out.println("body == body1 : " + (body == body1) );
	
	System.out.println("body.head == body1.head : " +  (body.head == body1.head));
	}

我的理解是super.clone() 的调用就是沿着继承树不断网上递归调用直到Object 的clone方法，而跟据JavaDoc所说Object.clone()根据当前对象的类型创建一个新的同类型的空对象，然后把当前对象的字段的值逐个拷贝到新对象上，然后返回给上一层clone() 调用。

也就是说super.clone() 的浅复制效果是通过Object.clone()实现的。

注意：基本数据类型和关键字void也表示为class对象
Class类没有公共构造方法，由类加载器的defineclass构造。

2.String

1.分类

不可变

String：字符串本身不能发生改变,与指向字符串的引用无关.

可变

StringBuilder/StringBuffer：字符串本身可以发生变化,与指向可变字符串的引用无关

2.细节

1.可变

底层是final定义的数组

String a ； a指向常量池。

jdk1.8前：不可变字符串保存在常量区，且同一个字符串常量在常量区（在堆区中）只存一个。
jdk1.8：增加元空间和堆区相对独立，常量池放入元空间。

2.不可变

StringBuilder，StringBuffer：底层是数组

3.汉字编码

汉字：utf-8编码占用3个字节，GBK、GB2312收编的汉字占2个字节

3.String方法

//1.判断：
    //1.判断是否包含一个子字符串
	//boolean contains(CharSequence s) 
    //2.判断两个字符串的内容是否相同
	//boolean equals(Object anObject) 
    //3.忽略大小写判断两个字符串的内容是否相同
	//boolean equalsIgnoreCase(String anotherString) 
    //4.判断是否以某字符串开头
	//boolean startsWith(String prefix)
	//5.判断是否以某字符串结尾
	//boolean endsWith(String suffix) 
	
//2.转换：将字符数组转换成字符串
		//1:使用构造方法
		//String(char[] value) 
		//String(char[] value, int offset, int count) 
		//2:使用静态方法
		//static String copyValueOf(char[] data) 
		//static String copyValueOf(char[] data, int offset, int count) 
		//3.将字符串转成字符数组
		char[] arr1 = s.toCharArray();
		//4.将字节数组转成字符串
	    //String(byte[] bytes) 
	    //String(byte[] bytes, int offset, int length)
	    //String(byte[] bytes, String charsetName)//使用指定的编码将字节数组转换成字符成
		//5。将字符串转成字节数组
		byte[] bytes1 = string3.getBytes();
		//6.基本数据类型转换成字符串
	    //String.valueOf()
//3.替换：
		//String replace(char oldChar, char newChar) 
		String string5 = s.replace("1000", "haha");
		//1.获取子串:
		//String substring(int beginIndex)  //开始位置到结束
	    //String substring(int beginIndex, int endIndex) //开始到结束位置
		String subString1 = string6.substring(7);
		//2.大小写转换
		//String toLowerCase()   转成小写
	    //String toUpperCase()   转成大写
	    //3.将字符串两端的空格去掉
	    //String trim() 
		String string7 = "    1000phone     ";
		System.out.println(string7.trim());
		//4.按字典顺序比较两个字符串
	    //int compareTo(String anotherString)
		int value = s.compareTo("1000PHone");
		//5.切割: String[] split(String)
		//被作为刀的子字符串不会再被作为内容.
		String string8 = "a,b,c,d,e,f";
		String[] strings = string8.split(",");
        //注意，按照""切割得到的是11个，全部切割
	}

4.Stringbuffer方法

1.区别

StringBuffer:出现在jdk1.0,是线程安全的,考虑了线程安全问题

StringBuilder:出现在jdk1.5,是线程不安全的,没有考虑线程安全问题

2.方法

     //构造方法
     StringBuffer sBuffer = new StringBuffer();
	//1.存储：
	//StringBuffer append(boolean b)   从最后插入
    //2.StringBuffer insert(int offset, boolean b)   从指定位置插入各种类型
	sBuffer.insert(4, true);
    //3.删除：
    //StringBuffer delete(int start, int end)   删除一部分字符串前闭后开
    //StringBuffer deleteCharAt(int index)  删除一个字符
    //4.修改：
    //StringBuffer replace(int start, int end, String str)  替换指定的子字符串
    //void setCharAt(int index, char ch) 修改一个字符
    //5.获取：
    //char charAt(int index) 
    //6.返回指定子字符串的下标  从左到右
  	//int indexOf(String str)开始出现的位置
     //int indexOf(String str, int fromIndex)//从指定位置开始
    //int lastIndexOf(String str) 最后出现的位置
   //返回指定子字符串(从右边开始计数)在此字符串第一次出现时的索引
   //int lastIndexOf(String str, int fromIndex) 
   //返回指定子字符串(从右边开始计数,范围:当前指定的位置-0)在此字符串第一次出现时的索引 
   //int length() 
   //返回长度（字符数）。 
    //5.反转：
   //StringBuffer reverse()

3.Date日期类

分类：

java.util 对应的是java的日期类型,包括年月日时分秒

java.sql 对应的是数据库的日期类型 ,只包括年月日Calendar

注意：数据库的转java，自动转换。反之丢失精度。

日期转换：

使用自定义的日期格式转换器实现自由转换----SimpleDateFormat
SimpleDateFormat simpleDateFormat = new  SimpleDateFormat("yyyy/MM/dd  HH:mm:ss");//HH代表24小时制
String stringDate1 = simpleDateFormat.format(new Date());
System.out.println(stringDate1);

4.日历类

Calendar calendar = Calendar.getInstance();
System.out.println();
//获取当前的Date类型的时间
Date date = calendar.getTime();
System.out.println(date);
//获取指定的值
int value = calendar.get(Calendar.DATE);
System.out.println(value);

5.Arrays

//简单数据类型数组转字符串---方便我们对数组的内容进行查看
	int[] arr1 = {3,4,6,8,9};
	System.out.println(Arrays.toString(arr1));
//简单数据类型数组转集合
	List list = Arrays.asList(arr1);
	System.out.println(list.size());//1  将整个简单数据类型的数组作为了集合的一个元素
//引用数据类型数组转集合
	String[] strings = {"haha","hehe","hello"};
	List list2 = Arrays.asList(strings);
	System.out.println(list2.size());//3    //引用类型数组中的一个元素对应集合中的一个元素
	
//转过来的集合长度是固定,所以不能执行增加,删除.但是可以执行修改,更改,遍历

//二分查找
	int[] arr3 = {3,6,8,67,678};
	System.out.println(Arrays.binarySearch(arr3, 67));

//用指定元素填充整个数组（会替换掉数组中原来的元素）
Arrays.fill(Object[] array, Object obj)
//指定填充的位置
Arrays.fill(Object[] array, int fromIndex, int toIndex, Object obj)    
    
//对数组进行排序
Arrays.sort(Object[] array)
 //大量数据进行排序
Arrays.parallelSort(T[] array)
    
//数据进行比较是否相等，实际上比较哈希值
 Arrays.equals(Object[] array1, Object[] array2)

6.正则表达式

1.规则

字符

x 代表的是字符x

\ 代表的是反斜线字符’’

\t 代表的是制表符

\n 代表的是换行符

\r 代表的是回车符

预定义字符类

. 任何字符。

\d 数字：[0-9]

\w 单词字符：[a-zA-Z_0-9]如"com.itheima.tests"/finish

边界匹配器

^ 代表的是行的开头

$ 代表的是行的结尾

\b 代表的是单词边界

数量词

X? X，一次或一次也没有

X* X，零次或多次

X+ X，一次或多次

X{n} X，恰好 n 次

X{n,} X，至少 n 次

X{n,m} X，至少 n 次，但是不超过 m 次

域清风

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用类1，如Object，String，正则表达式

1.object1.equals比较地址,String重写了方法，比较的是值。2.toString打印对象属性信息（类名和16进制的hascode）3.hasCode获取的对象的哈希码值,在一个工程内,可以当做当前对象的身份证(唯一的标识)4.getclass得到当前对象的字节码文件对象(一个类的所有对象的字节码文件相同)5.clone1.条件：类必须实现了Cloneable...
复制链接

扫一扫

专栏目录