JavaSE基础常用类

最新推荐文章于 2023-03-02 16:19:58 发布

zsyht_2712

最新推荐文章于 2023-03-02 16:19:58 发布

阅读量360

点赞数

本文链接：https://blog.csdn.net/zsyht_2712/article/details/78392589

版权

1.Object类

类object是类层次结构的根类，每个类都是用object作为超类（父类），所有对象（包括数组）都实现这个类的方法。

a、public int hashCode();

返回该对象的哈希码值———>通过哈希算法（哈希表：hashtable）———>得到一个地址值（但不是真正意义上的地址值）

package org.zst.Object;

public class Student extends Object {

}

package org.zst.Object;
public class Test1 {
	public static void main(String[] args){
		Student s1 = new Student();
		System.out.println(s1.hashCode());//引用类型，每次运行结果不一致
		Student s2 = new Student();
		System.out.println(s2.hashCode());
		
		System.out.println("clever".hashCode()); //字符串类型每次运行结果固定，不受影响
		
	}

}

b、public final Class getClass()返回此 Object 的运行时类 (Java反射机制中讲!)
Class类中有一个方法:public String getName()以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。即获取当前正在运行的这个类的全路径名称。

package org.zst.Object;
public class Test1 {
	public static void main(String[] args){
		Student s1 = new Student();
		//System.out.println(s1.hashCode());//引用类型
		Student s2 = new Student();
		//System.out.println(s2.hashCode());
		
		//System.out.println("clever".hashCode());
		Class c1 =s1.getClass();
		System.out.println("c1:"+c1);
		String name = c1.getName();
		System.out.println("name:"+name);//全路径名称
	}

}

2.toString类

public Strig toString()返回该对象的字符串表示（建议所有子类都重写此方法）

Integer类中有一个方法:public static String toHexString(int i)

将一个int类型的数据转换成一个十六进制的字符串表现形式
如果直接输出对象名称,想要显示当前对象的成员变量的值,那么必须重写Object类中的toString()方法

package org.zst.toString;

public class Demo {
	private String name;
	private int age;
	//无参构造
	public Demo(){
		super();
	}
	public Demo (String name,int age){
		super();
		this.name=name;
		this.age=age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	//子类重写 String toString方法  可以同通过快捷键 alt+shift+s----s 在String toString中自动生成
	public String toString(){
		return name+","+age;
	}
	public static void main(String[] args){

	}

}

package org.zst.toString;

public class Test {
	public static void main(String [] args){
		Demo d = new Demo("孙思远",19);
		//输出结果：org.zst.toString.Demo@7676438d   @是地址值标记 后跟16进制数据
		System.out.println("输出结果："+d);
		System.out.println("用toString方法调用："+d.toString());
		/**
		 * 通过查看toString()源码:
		 *  public String toString() {
        		return this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
    		}
    		
    		toString()<==> 对象名.getClass().getName() +"@" +Integer.toHexString(对象名.hashCode())
		 */
		
		System.out.println(d.getClass().getName()+"@"+Integer.toHexString(d.hashCode()));
//		System.out.println(d.toString());
		//直接对象名称,想要显示成员变量的值,怎么办?
//		System.out.println(d);
		Demo d2 = new Demo("孙思远", 19) ;
		System.out.println("Name:" +d2);
		System.out.println(d==d2);//==比较的是两个对象的地址值
	}
}

3.equals()方法

public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。

面试题:
==和equal()方法的区别
==: 比较的是两个对象的地址值是否相同
equals()方法: 默认比较的是两个对象的地址值是否相同,如果重写了Object类中的equals()方法,那么默认比较就是两个对象的内容是否相同

package org.zst.equals;
public class Demo {
	private String name;
	private int age;
	//无参构造
	public Demo(){
		super();
	}
	public Demo (String name,int age){
		super();
		this.name=name;
		this.age=age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Demo [name=" + name + ", age=" + age + "]";
	}
	//重写了Object类中的equals()方法
	@Override
	public boolean equals(Object obj) { //Demo s2 = new Demo() ;
		if (this == obj)
			return true;
		if (obj == null)  //当前传入过来的对象是否为空
			return false;
		if (getClass() != obj.getClass())	//this.getClass() != s2.getClass()		
			return false;
		Demo other = (Demo) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
}

package org.zst.equals;

public class Test {
	public static void main(String[] args){
		//创建Demo对象
		Demo s1 = new Demo("左舒婷", 20) ;
		Demo s2 = new Demo("左舒婷",20) ;
		System.out.println(s1==s2);
		System.out.println("------------------");
		Demo s3 = s1 ;
		System.out.println(s1==s3);
		System.out.println("-------------------");
		System.out.println(s1.equals(s2));   //由于重写Object中的equals()方法,所以比较的是对象的内容是否相同!
		/**
		 * equals()方法的源码
		 *   public boolean equals(Object obj) {
        	return (this == obj);
    	}
    		由于Object类中的equals()方法底层是通过"=="来实现的,所以默认比较的是地址值,如果想比较内容是否相同,需要重写equals()方法
		 * */
	}
}

没有重写子类equals方法时的运行结果：

重写子类equals方法的运行结果：

* 使用工具自动生产equals()方法
* javascript:Array对象,Number对象,String对象,valueOf():====>s1.valueOf(s2) ;比较是内容是否相同

4.finalize

protected void finalize() throws Throwable:当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法，但是什么时候调用gc不确定。

System类中的一个方法：public void gc() 运行垃圾回收器，这个垃圾回收器最终调用的就是finalize()方法。

5.clone()方法

protected Object clone() ：Object类中的clone()方法执行特定的复制操作，如果此对象的类不能实现接口Cloneable，则会抛出异常：throws CloneNotSupportedException，注意所有数组都被视为实现接口Cloneable。

package org.zst.finalize;
//要实现clone()方法，当前对象所在的类必须实现Cloneable接口
public class Demo  implements Cloneable{
	private String name;
	private int age;
	public Demo() { //shift+alt+s----+c
		super();
	}
	public Demo(String name, int age) { //shift+alt+s----+o
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {   //shift+alt+s----+r
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	//重写Object类中的clone()方法
	@Override
	protected Object clone() throws CloneNotSupportedException{
		return super.clone();
	}
}

package org.zst.finalize;

public class Test {
	public static void main(String [] args) throws CloneNotSupportedException{ //编译时期异常
		Demo d = new Demo();
		d.setName("孙思远");
		d.setAge(19);
		System.out.println(d.getName()+","+d.getAge());
		//复制d对象
		//d.clone();//无法调用，要实现clone()方法，当前对象所在的类必须实现Cloneable接口
	    //复制d对象
		Object obj = d.clone();
		//向下转型
	    Demo d1 = (Demo) obj;
	    System.out.println(d1.getName()+","+d1.getAge());
	}
}

6.scanner类

创建一个文本扫描器（键盘录入），在java.util包下，需要导包，被fianl修饰不能被继承

Scanner sc = new Scanner(System.in);

System类中的静态字段：

public static final InputStream in ：标准输入流

InputStream(字节流): InputStream is = System.in; 实质是一个抽象类多态

public static final OutputStream out ：标准输出流

package org.zst.scanner;
import java.util.Scanner;

public class Demo {
	public static void main(String [] args){
		
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入：");
		String a = sc.nextLine();
		System.out.println("打印结果："+a);
	}
}

7.nextInt() nextLine()方法

package org.zst.scanner;
import java.util.Scanner;

public class Demo2 {
	public  static void main(String [] args){
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		//java.util.InputMismatchException  输入的数据和想得到的数据类型不匹配
		System.out.println("a:"+a);
	}
}

没有提示用户录入的数据类型和想要的不匹配，此时代码报错，应在录入数据之前加上hasNextxxx()方法判断，判断是否有下一个可以录入的XXX类型数据。

public boolean hasNextXXX();

package org.zst.scanner;
import java.util.Scanner;

public class Demo2 {
	public  static void main(String [] args){
		Scanner sc = new Scanner(System.in);
		System.out.print("请您录入数据：");
		if(sc.hasNextInt()){
			//是否有下一个可以录入的int型数据
			int a = sc.nextInt();
			System.out.println("打印结果:"+a);
		}else{
			System.out.println("您输入的数据不符合要求！");
		}
		
		//java.util.InputMismatchException  输入的数据和想得到的数据类型不匹配
		//System.out.println("a:"+a);
	}
}

8.Scanner类中的注意事项

先后录入两个int类型的数据：

package org.zst.scanner;
import java.util.Scanner;

public class Demo3 {
	public static void main(String [] args){
		Scanner sc = new Scanner(System.in);
		System.out.print("请录入第一个数据：");
		int a = sc.nextInt();
		System.out.print("请录入第二个数据：");
		int b = sc.nextInt();
		System.out.println("a:"+a+",b:"+b);
	}
}

先后录入两个String类型的数据：

package org.zst.scanner;
import java.util.Scanner;

public class Demo3 {
	public static void main(String [] args){
		Scanner sc = new Scanner(System.in);
		System.out.print("请录入第一个数据：");
		String a = sc.nextLine();
		System.out.print("请录入第二个数据：");
		String b = sc.nextLine();
		System.out.println("a:"+a+",b:"+b);
	}
}

先录入String类型数据再录入int类型数据：

package org.zst.scanner;
import java.util.Scanner;

public class Demo3 {
	public static void main(String [] args){
		Scanner sc = new Scanner(System.in);
		System.out.print("请录入第一个数据：");
		String a = sc.nextLine();
		System.out.print("请录入第二个数据：");
		int b = sc.nextInt();
		System.out.println("a:"+a+",b:"+b);
	}
}

先录入int类型数据再录入String类型数据：

此时会发现接收不到第二次录入的String类型数据，直接输出结果，由于“Enter”才能接收数据，是回车换行符导致的。

package org.zst.scanner;
import java.util.Scanner;

public class Demo3 {
	public static void main(String [] args){
		Scanner sc = new Scanner(System.in);
		System.out.print("请录入第一个数据：");
		int a = sc.nextInt();
		System.out.print("请录入第二个数据：");
		String b = sc.nextLine();
		System.out.println("a:"+a+",b:"+b);
	}
}

改进方案：在第二次录入之前重新创建一个对象

package org.zst.scanner;
import java.util.Scanner;

public class Demo3 {
	public static void main(String [] args){
		Scanner sc = new Scanner(System.in);
		System.out.print("请录入第一个数据：");
		int a = sc.nextInt();
		Scanner sc1 = new Scanner(System.in);
		System.out.print("请录入第二个数据：");
		String b = sc1.nextLine();
		System.out.println("a:"+a+",b:"+b);
	}
}

改进方法二：调用next（）方法

package org.zst.scanner;
import java.util.Scanner;

public class Demo3 {
	public static void main(String [] args){
		Scanner sc = new Scanner(System.in);
		System.out.print("请录入第一个数据：");
		int a = sc.nextInt();
		//Scanner sc1 = new Scanner(System.in);
		System.out.print("请录入第二个数据：");
		String b = sc.next();
		System.out.println("a:"+a+",b:"+b);
	}
}

9.String类

String类代表字符串，Java程序中的所有字符串字面值都作为此类的实例实现。字符串一旦被赋值，其值不能在改变。

String类常用的构造方法：String():表示一个空字符序列

public String(byte[ ] bytes ,Charset ch) ：默认编码字符集（编码格式）：如果平台默认编码格式是GBK（一个中文对应两个字节）格式，可以不写第二个参数

public String(byte[ ] bytes ,int Index,int length)：将部分字节数组构造成一个字符串

public String(char[ ] value): 将字符数组构造成一个字符串

public String(char[ ] value,int Index,int length)：将部分字符数组构造成一个字符串

public String(String original)：通过字符串常量构造一个字符串对象

编码和解码：（保证格式一致）

编码：把能看懂的东西转换成看不懂的东西：String ---------->byte[ ]:public byte[ ] getBytes(String charsetName)

解码：把当前看不懂的东西转换成能看懂的（一般就是String类）：byte[ ]--------->String:public String(byte[ ] bytes ,CharsetName ch)

获取字符串长度功能：public int length()

面试题：数组中有没有length()，字符串中有没有length()，集合中有没有length()。

数组中没有length(),数组中的叫length属性，遍历元素时使用

字符串中有length()，遍历字符串使用length()

集合中没有length()，获取集合中的元素数量用size()

package org.zst.String;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Demo {
	public static void main(String[]args) throws UnsupportedEncodingException{
		String s = new String();
		System.out.println("s:"+s); //String类底层本身重写了toString方法，此时运行没有结果
		System.out.println("s.length:"+s.length());
		System.out.println("---------");
		//创建一个字节数组
		byte[] bys ={97,98,99,100,101}; //字节的值要找它对应的ASCII表 的字符
		String s2 = new String(bys);
		System.out.println("s2:"+s2);
		System.out.println("s2.length:"+s2.length());
		System.out.println("----------");
		//定义一个字符串
		String s3 = "孙思远";//[-53, -17, -53, -68, -44, -74] 一个中文对应两个字节，计算机在存储中文的时候第一个数一定是负数
		byte [] bys1 = s3.getBytes("GBK");  //编码
		System.out.println(bys1);
		//利用Arrays：数组工具类
		System.out.println(Arrays.toString(bys1));
		System.out.println("----------");
		String str= new String(bys1,"GBK"); //解码
		System.out.println(str);
		System.out.println("------------");
		//定义字符数组
		char [] ch = {'我','喜','欢','你'};
		String s4 = new String(ch);
		System.out.println(s4);
		System.out.println("s4.length"+s4.length());
		System.out.println("---------");
		
		String s5 = new String(ch,1,3);
		System.out.println("打印结果："+s5);
		System.out.println("s5.length:"+s5.length());
		System.out.println("--------");
		
		String s6 = new String("HalloWeen");
		//String s6 = "HalloWeen";
		System.out.println("s6打印结果："+s6);
		System.out.println("s6.length:"+s6.length());
	}
}

10.字符串的特点

一旦被赋值，其值不能被改变。

面试题：String s = new String("Hello")和 String s = "Hello" 有什么区别，分别创建了几个对象？

前者创建了两个对象，堆内存中有new String，字符串常量池中也会有这样一个字符串常量（开辟空间的地址）；后者创建了一个对象

package org.zst.String;

public class Demo2 {
	public static void main(String[] args){
		String s = "HalloWeen";
		s += "Happy";
		System.out.println("输出结果："+s);
	}

}

package org.zst.String;

public class Demo2 {
	public static void main(String[] args){
		String s = "HalloWeen";
		//s += "Happy";
		System.out.println("输出结果："+s);
		change(s);
	}
	public static void change(String s){
		s += "Happy";
	}
}

11.String类的判断功能：

boolean equals(Object obj):当前该对象是否obj这个对象是否相等;
boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
boolean contains(String str):判断str这个字符串是否包含在当前字符串中
boolean startsWith(String str):是否以str子字符串开头
boolean endsWith(String str):判断是否以str子字符串结尾
boolean isEmpty():判断字符串是否为空

String s = "" ;空字符
String s = " " ;字符串"空格"
String s = null ;当前字符串对象为空

package org.zst.String;
public class Demo3 {
public static void main(String[] args) {
		//定义一个字符串
		String s1 = "helloworld" ;
		String s2 = "HelloWorld" ;
		
        //boolean equals(Object obj):当前该对象是否obj这个对象是否相等;String重写equals(),比较的是两个字符串的内容是否相同
		System.out.println("equals:"+s1.equals(s2));
		//boolean equalsIgnoreCase(String str):比较字符串是否相等,忽略大小写
		System.out.println("equalsIgnoreCase:"+s1.equalsIgnoreCase(s2));
		
		//boolean contains(String str):判断str这个字符串是否包含在当前字符串中
		System.out.println("contains:"+s1.contains("owo"));
		System.out.println("contains:"+s1.contains("ak47"));
		
		//boolean startsWith(String str):是否以str子字符串开头
		System.out.println("starsWith:"+s1.startsWith("hel"));
		//boolean endsWith(String str):判断是否以str子字符串结尾  
		System.out.println("endWith:"+s1.endsWith("rld"));
		//boolean isEmpty():判断字符串是否为空
		System.out.println("isEmpty:"+s1.isEmpty());
	}
}

12.String类中常用的获取功能

int length(): 获取字符串长度功能

char charAt(int index):返回的是索引处对应的字符

int indexOf(int ch) :返回指定字符在次字符串中第一次出现处的索引

int indexOf(String str):返回指定的子字符串在此字符串中第一次出现的索引

int indexOf(int ch,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索

int indexOf(String str,int fromIndex):返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索

String substring(int start):从指定位置开始截取字符串，默认截取到末尾

String substring(int start,int end):从指定位置开始截取到指定位置结束（包前[start索引]不包后[end索引]）

package org.zst.String;

public class Demo4 {
	public static void main(String[] args){
		String s = "Halloween";
		System.out.println("该字符串长度为:"+s.length());
		System.out.println("该字符串中索引为1的元素:"+s.charAt(1));
		System.out.println("搜索e在此字符串中出现的索引："+s.indexOf('e'));
		System.out.println("搜索b在此字符串中出现的索引："+s.indexOf('b'));
		System.out.println("查找owe在此字符串中出现的索引："+s.indexOf("owe"));
		System.out.println("从指定索引处查找指定字符出现的位置："+s.indexOf('e', 3));
		System.out.println("从指定索引处查找指定字符串出现的位置："+s.indexOf("low", 2));
		System.out.println("从指定位置开始截取字符，默认截取到末尾："+s.substring(5));//返回一个新的字符串
		System.out.println("从指定位置开始截取，限制截取位置："+s.substring(4, 8)); //注意包前不包后
	}
}

13.字符串的遍历

package org.zst.String;
public class Demo5 {
	public static void main(String [] args){
		String s ="承蒙你出现够我欢喜很多年";
		//原始方法
		System.out.println(s.charAt(0));
		System.out.println(s.charAt(1));
		System.out.println(s.charAt(2));
		System.out.println(s.charAt(3));
		System.out.println(s.charAt(4));
		System.out.println(s.charAt(5));
		System.out.println(s.charAt(6));
		System.out.println(s.charAt(7));
		System.out.println(s.charAt(8));
		System.out.println(s.charAt(9));
		System.out.println(s.charAt(10));
		System.out.println(s.charAt(11));
		System.out.println("---------------");
		//由于代码重复率较高，可以使用for循环，使用String的length()和charAt()结合
		for(int x = 0;x<s.length();x++){
			System.out.print(s.charAt(x)+" ");
		}
	}
}