黑马程序员——java核心类库

最新推荐文章于 2024-07-09 23:29:46 发布

smliar

最新推荐文章于 2024-07-09 23:29:46 发布

阅读量338

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/smliar/article/details/39582147

本文深入讲解Java中的核心类，包括Object基类的功能介绍及其提供的关键方法，如equals(), toString(), hashCode()等。同时，详细解析String类的特点及操作方法，如长度获取、字符检索、字符串替换等，并对比String与StringBuffer/StringBuilder的区别。此外，还介绍了基本数据类型包装类的使用技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、Object(基类)（java所有类的父类）

是所有类的直接或者间接父类,该类中定义的肯定是所有对象都具备的共性功能。

常用方法：

1、equals(){}//比较

2、toString(){}//转成字符串

3、hashCode(){}//对象的哈希地址值

4、getClass(){}//返回运行时类

5、finalize(){}//当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。System.gc()调用垃圾回收方法

二、String类（不可变类）字符串是一个特殊的对象，字符串一旦初始化就不可以被改变。

public class StringDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		/*
		 * String类的特点：
		 * 字符串对象一旦被初始化就不会被改变。
		 * 
		 */
		stringDemo2();
	}

	public static void stringDemo2() {
		// TODO Auto-generated method stub
		
		String s = "abc";//创建一个字符串对象在常量池中。		
		String s1 = new String("abc");//创建两个对象一个new一个字符串对象在堆内存中。
		
		System.out.println(s==s1);//false
		
		System.out.println(s.equals(s1));
		//string类中的equals复写Object中的equals建立了string类自己的判断字符串对象是否相同的依据。
		//其实就是比较字符串内容。
		
		
//		System.out.println("s="+s);
//		System.out.println("s1="+s1);
		
	}

	/**
	 * 演示字符串定义的第一种方式，并明确字符串常量池的特点.
	 * 池中没有就建立，池中有，直接用。
	 */
	private static void stringDemo1() {
		String s = "abc";//"abc"存储在字符串常量池中。
//		s = "nba";
		String s1 = "abc";		
		System.out.println(s==s1);//true?
//		System.out.println("s="+s);
	}

}

1、获取：

1·）、字符串中的包含的字符数，也就是字符串的长度，int length():获取长度。

2）、根据位置获取位置上某个字符，char charAt(int index)

3）、根据字符获取该字符在字符串中位置：

int indexOf(int ch):返回的是ch在字符串中第一次出现的位置；

int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。

int indexOf(String str):返回的是str在字符串中第一次出现的位置。

int indexOf(String str, int fromIndex) :从fromIndex指定位置开始，获取str在字符串中出现的位置。

int lastIndexOf(int ch)

2、判断

1）、字符串中是否包含某一个子串，boolean contains(str):

2）、字符中是否有内容，boolean isEmpty(): 原理就是判断长度是否为0.

3）、字符串是否是以指定内容开头。boolean startsWith(str)

4）、字符串是否是以指定内容结尾。boolean endsWith(str)

5）、判断字符串内容是否相同。复写了Object类中的equals方法。boolean equals(str);

6）、判断内容是否相同，并忽略大小写。boolean equalsIgnoreCase()

3、转换

1、将字符数组转成字符串：构造函数（String(char[])， String(char[],offset,count):将字符数组中的一部分转成字符串。）

静态方法（static String copyValueOf(char[]);，static String valueOf(char[]):，static String copyValueOf(char[] data, int offset, intcount) ）

2、将字符串转成字符数组，char[] toCharArray():

3、将字节数组转成字符串。String(byte[])，String(byte[],offset,count):将字节数组中的一部分转成字符串。

4、将字符串转成字节数组。byte[] getBytes():

5、将基本数据类型转成字符串。static String valueOf(int)，static String valueOf(double)

6、特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

public class StringConstructorDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		/*
		 * 将字节数组或者字符数组转成字符串可以通过String类的构造函数完成。
		 */
		
		stringConstructorDemo2();
	}

	private static void stringConstructorDemo2() {
		char[] arr = {'w','a','p','q','x'};
		String s = new String(arr,1,3);
		
		System.out.println("s="+s);
	}

	public static void stringConstructorDemo() {
		String s = new String();//等效于String s = "";  不等效String s = null;
		
		byte[] arr = {97,66,67,68};
		
		String s1 = new String(arr);
		System.out.println("s1="+s1);
		
	}



}

4、替换

String replace(oldchar,newchar);

5、切割

String[] split(regex)

6、子串获取字符串中的一部分。

String substring(begin);，String substring(begin,end);

public class StringMethodDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		
		
		stringMethodDemo_4();
		
//		System.out.println("abc".concat("kk"));
//		System.out.println("abc"+"kk");
		
//		System.out.println(String.valueOf(4)+1);
//		System.out.println(""+4+1);
		
	}

	private static void stringMethodDemo_4() {
		
		System.out.println("abc".compareTo("aqz"));
	}

	private static void stringMethodDemo_3() {
		String s = "abc";
		System.out.println(s.equals("ABC".toLowerCase()));
		System.out.println(s.equalsIgnoreCase("ABC"));
		
		System.out.println(s.contains("cc"));
		
		String str  = "ArrayDemo.java";
		
		System.out.println(str.startsWith("Array"));
		System.out.println(str.endsWith(".java"));
		System.out.println(str.contains("Demo"));
	}

	private static void stringMethodDemo_2() {
		
		String  s = "张三,李四,王五";
		String[] arr = s.split(",");
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
		char[] chs = s.toCharArray();
		
		for (int i = 0; i < chs.length; i++) {
			System.out.println(chs[i]);
		}
		s = "ab你";
		byte[] bytes = s.getBytes();
		for (int i = 0; i < bytes.length; i++) {
			System.out.println(bytes[i]);
		}
		
		System.out.println("Abc".toUpperCase());
		
		
		String s1 = "java";
		String s2 = s1.replace('q', 'z');
		System.out.println(s1==s2);//true
		
		System.out.println("-"+"    ab  c    ".trim()+"-");
		
	}

	private static void stringMethodDemo_1() {
		
		String  s = "abcdae";
		
		System.out.println("length:"+s.length());//6
		System.out.println("char:"+s.charAt(2));//c//StringIndexOutOfBoundsException
		System.out.println("index:"+s.indexOf('k'));//0//-1 我们可以根据-1，来判断该字符或者字符串是否存在。
		System.out.println("lastIndex:"+s.lastIndexOf('a'));//4
		
		
		System.out.println("substring:"+s.substring(2,4));
	}

}

7、转换，去除空格，比较

1、将字符串转成大写或则小写。 String toUpperCase();， String toLowerCase();

2、将字符串两端的多个空格去除。String trim();

3、对两个字符串进行自然顺序的比较。int compareTo(string);

8、需要注意的小细节

1，只要访问到字符串中不存在的角标，就会在运行时期，发生该异常。s1.charAt(10);StringIndexOutOfBoundsException

2,当要替换的字符不存在时，结果是原来的字符串。

3,截取子字符串，当头尾角标相等时，结果是 “” 空字符串。

4,截取子字符串，当开始角标等于长度时，结果是 "" 空字符串。

三、StringBuffer/StringBuilder

特点：

1、字符串的组成原理就是通过该类实现的。

2、StringBuffer可以对字符串内容进行增删。

3、StringBuffer:字符串缓冲区,用于存储数据,所以它也称之为容器.

4、很多方法与String相同。

5、StingBuffer是可变长度的。

1、存储

StringBuffer append():将指定数据作为参数添加到已有数据结尾处。

StringBuffer insert(index,数据):可以将数据插入到指定index位置。

2、删除

StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。

StringBuffer deleteCharAt(index):删除指定位置的字符。

3、获取

char charAt(int index)

int indexOf(String str)

int lastIndexOf(String str)

int length()

String substring(int start, int end)

4、修改

StringBuffer replace(start,end,string);

void setCharAt(int index, char ch) ;

5、反转

StringBuffer reverse();

6、转换

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将缓冲区中指定数据存储到指定字符数组中。

public class StringBufferDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		
		bufferMethodDemo_2();
	}
	
	private static void bufferMethodDemo_2() {
		StringBuffer sb = new StringBuffer("abce");
		
//		sb.delete(1, 3);//ae
		
		//清空缓冲区。
//		sb.delete(0,sb.length());
//		sb = new StringBuffer();
		
//		sb.replace(1, 3, "nba");
//		sb.setCharAt(2, 'q');
		
//		sb.setLength(10);
		
//		System.out.println("sb:"+sb);
//		System.out.println("len:"+sb.length());
		
		System.out.println(sb.reverse());
		
		
	}

	private static void bufferMethodDemo_1() {
		StringBuffer sb = new StringBuffer("abce");
		
//		sb.append("xixi");
		sb.insert(2, "qq");
		
		System.out.println(sb.toString());
	}

	public static void bufferMethodDemo(){
		//创建缓冲区对象。
		StringBuffer sb = new StringBuffer();
		
		sb.append(4).append(false);//.append("haha");
		sb.insert(1, "haha");
//		sb.append(true);
		
		System.out.println(sb);
		
	}
	
	

}

public class StringBuilderDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		
		/*
		 * jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder
		 * 
		 * 不同的是：
		 * StringBuffer是线程同步的。通常用于多线程。
		 * StringBuilder是线程不同步的。通常用于单线程。 它的出现提高效率。
		 * 
		 * jdk升级：
		 * 1，简化书写。
		 * 2，提高效率。
		 * 3，增加安全性。
		 */
		
		
	}

}
/*

class StringBuffer jdk1.0
{
	object lock;
	public   StirngBuffer append(int x)
	{
		synchronized(lock)
		{
		}
	}
	
	
	public synchronized StringBuffer delete(int start,int end)
	{
		synchronized(lock)
		{
		}
	}
}



*/

四、基本数据类型包装类

1、byte——>Byte

2、short——>Short

3、int——>Integer

4、long——>Long

5、double——>Double

6、float——>Float

7、char——>Character

8、boolean——>Boolean

以上八种类型的常用方法：

1、字符串转成基本数据类型：xxx a = Xxx.parseXxx(String);，int a = Integer.parseInt("123");，double b = Double.parseDouble("12.23");，boolean b = Boolean.parseBoolean("true");，Integer i = new Integer("123");，int num = i.intValue();。

2、十进制转成其他进制：toBinaryString();，toHexString();，toOctalString();。

3、其他进制转成十进制：parseInt(string,radix);

public class WrapperDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		/*
		 * 基本数据类型对象包装类。
		 * 为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。
		 * 用于描述该对象的类就称为基本数据类型对象包装类。
		 * 
		 * byte		Byte
		 * short	Short
		 * int		Integer
		 * long		Long
		 * float	Float
		 * double	Double
		 * char		Character
		 * boolean	Boolean
		 * 
		 * 该包装对象主要用基本类型和字符串之间的转换。
		 * 
		 * 基本类型--->字符串
		 * 		1,基本类型数值+""
		 * 		2,用String类中的静态方法valueOf(基本类型数值);
		 * 		3,用Integer的静态方法valueO(基本类型数值);
		 * 
		 * 字符串--->基本类型
		 * 		1,使用包装类中的静态方法   xxx parseXxx("xxx类型的字符串");*****
		 * 			int parseInt("intstring");
		 * 			long parseLong("longstring");
		 * 			boolean parseBoolean("booleanstring");
		 * 			只有Character没有parse方法 
		 * 		2,如果字符串被Integer进行对象的封装。
		 * 			可使用另一个非静态的方法，intValue();
		 * 			将一个Integer对象转成基本数据类型值。
		 * 
		 * 
		 */
		
		
//		System.out.println(Integer.MAX_VALUE);
		
//		System.out.println(Integer.toBinaryString(-6));
		
//		int num = 4;
//		Integer i = new Integer(5);
		
//		int x = Integer.parseInt("123");
//		System.out.println(Integer.parseInt("123")+1);
		
//		Integer i = new Integer("123");		
//		System.out.println(i.intValue());
		
		
		/*
		 * 整数具备不同的进制体现。
		 * 
		 * 十进制-->其他进制。
		 * 		toBinaryString
		 * 		toOctalString
		 * 		toHexString
		 * 
		 * 其他进制-->十进制。
		 * 		parseInt("string",radix)
		 * 
		 */
		
//		十进制-->其他进制。
		System.out.println(Integer.toBinaryString(60));
		System.out.println(Integer.toOctalString(60));
		System.out.println(Integer.toHexString(60));
		
		
//		System.out.println(Integer.toString(60,16));
//		其他进制-->十进制。
//		System.out.println(Integer.parseInt("3c",16));
		
		
		Integer a = new Integer("89");
		Integer b = new Integer(300);
		
		System.out.println(a==b);
		
		System.out.println(a.equals(b));
		
//		System.out.println(3>3);
		System.out.println(a.compareTo(b));
		
		
		
	}

}

五、System

特点：

1、System类是最终类

2、System类不能创建对象

3、System类中的方法都是静态的

out:标准输出，默认是控制台。
in：标准输入，默认是键盘。

1、获取程序运行时间（毫秒）long currentTimeMillis()

2、终止当前正在运行的 Java 虚拟机。exit(int status)

3、获取当前的系统属性Properties getProperties()，getProperty(String key)

4、重新指定“标准”输入流目的，setIn(InputStream in)

5、重新指定“标准”输出流目的，setOut(PrintStream out)

6、设置系统属性，setProperties(Properties props) ，setProperty(String key, String value)

六、Runtime 单例设计模式设计的类

1、//获取Runtime对象，Runtime r = Runtime.getRuntime()

2、//调用exec方法,执行，r.exec("可执行性文件的路径");，r.exec("notepad.exe 文件名");

3、Process p = r.exec("可执行性文件");

4、p.destroy()只能杀Rumtime exec开启的进程,windows已有进程杀不了

七、Math

1、double ceil(double d):获取大于指定参数的最小整数的double表现形式

2、double floor(double d):获取小于指定参数的最大整数的double表现形式

3、long round(double d):四舍五入

4、double pow(double a,double b)a是底数,b是指数

5、double random():伪随机数0到1直接的小数不包括1

八、Random

1、double nextRandom()，返回下一个伪随机数，在 0.0 和 1.0 之间均匀分布的 double 值

2、int nextInt() ，返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值

3、int nextInt(int n) ，返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值。

九、Date

日期对象和毫秒值之间的转换：

1,将毫秒值转换成日期对象
//a,获取当前时间的毫秒值
long time = System.currentTimeMillis();
//b,将毫秒值转换成日期对象
Date d = new Date(time);
System.out.println(d);
//c,另一种方式,通过setTime方法
Date d1 = new Date();
d1.setTime(time);
2,将对象转换成毫秒值
Date d = new Date();
long time = d.getTime();//用Syestem.currentTimeMillis();也可以

1、测试此日期是否在指定日期之后。 boolean after(Date when)

2、测试此日期是否在指定日期之前。 boolean before(Date when)

3、比较两个日期的顺序。 int compareTo(Date anotherDate)

4、比较两个日期的相等性。 boolean equals(Object obj)