JavaSE基础常用类，javase基础
分享于 点击 259 次 点评：4
JavaSE基础常用类，javase基础
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()); //字符串类型每次运行结果固定，不受影响
}
}
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()方法
* 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);
}
}
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);
}
}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)+" ");
}
}
}
相关文章
- 暂无相关文章
用户点评