黑马程序员——Java中的常用类总结

——- android培训、java培训、期待与您交流！ ———-

一，Object类

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

1. 常用方法

getClass();

源码:

//Class<?> getClass() 返回此 Object 的运行时类。
public final native Class<?> getClass();

haseCode();

源码:

// int hashCode() 返回该对象的哈希码值。
public native int hashCode();

toString(); 默认返回”对象所属的类名+@+对象的哈希值（十六进制）”

源码:

//String toString() 返回该对象的字符串表示。
public String toString() {
return getClass().getName() + "@" + Integer.toHexStrin(hashCode());
}

复写示例:

public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}

equals()

源码:

// boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
public boolean equals(Object obj) {
return (this == obj);
}

“equals()”方法与”==”区别

共同点:均用来做比较,返回类型均为boolean类型

区别:

”==”为基本运算符,即可比较基本类型数据(值比较),也可比较引用数据类型(地址比较);

“equals()”只能比较引用数据类型(地址值),底层依赖”==”运算符,一般将其复写来比较对象中的属性值.

复写示例:

public boolean equals(Object obj) {
if(!(obj instanceof Student))
throw new ClassCastException("类型错误");

Student s = (Student)obj;
return this.name.equals(s.name) && this.age == s.age;
}

注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

二，String类

1. 构造方法：重载形式

String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。

String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。

String(char[] value, int offset, int count) 分配一个新的String，它包含取自字符数组参数一个子数组的字符。

2. 常用方法：

获取：

长度：

int length() 返回此字符串的长度。

根据位置获取位置上某个字符

char charAt(int index) 根据位置获取字符。

根据字符获取该字符在字符串中的位置

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

ch - 一个字符（Unicode 代码点）。

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) 返回指定字符在此字符串中最后一次出现处的索引。

子串：

String substring(begin)

String substring(begin,end)

判断：

包含：

boolean contains(str)

特殊之处：int indexOf(String str):返回str在字符串中第一次出现的位置，如果返回-1，表示该str不在字符串中存在;所以，也可以用于对指定判断是否包含。

if(str.indexOf("aa")!=-1)

而且该方法既可以又可以获取出现的位置。

开头：boolean startsWith(str)

结尾：boolean endsWith(str)

str.endsWith(".java")

是否有内容:

boolean ifEmpty(): 原理就是判断长度是否为0

内容是否相同：

boolean equals(Object anObject) 将此字符串与指定的对象比较。

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

String s1 = "abc";//字符串常量池中创建对象
String s2 = "abc";//s2直接指向已存在的对象
String s3 = new String("abc");//堆内存中创建对象
System.out.println("s1==s2");//true
System.out.println("s1==s3");//false
System.out.println(s1.equals(s2));//true(复写了Object方法，用于比较字符串内容)

自然顺序比较。

int compareTo(String)： 相等返回0；调用>参，返回正；调用<参,返回负

转换：

将字符串转换成大写或者小写。

String toUpperCase();

String toLowerCase();

字符串两端的多个空格去除

String trim()

字符数组–>字符串

String（char[]）

String(char[],ofset,count):将字符数组中的一部分转换成字符串。

String( )初始化一个新创建的 String 对象，使其表示一个空字符序列。

String s = new String();//等效与String s ="";

static String copyValueOf(char[]data): 返回指定数组中表示该字符序列的 String

static String copyValueOf(char[]data,int offset,int count);

static String valueOf(char[])

字符串–>字符数组

byte[] toCharArray()

字节数组–>字符串

String（byte[]）

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

字符串–>字节数组

char[] getBytes(): 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中

基本数据类型–>字符串

static String ValueOf(int)

3+"";//String.valueOf(3);

static String ValueOf(double)

替换：

String replace(oldchar,newchar) 若没有找到，则返回原字符串

连接

String contact（String str）

切割

String[ ] split(regex)

concat效果与”+”连接符效果一致，但是效果更高一些

其他

String intern() 返回字符串对象的规范化表示形式。

String s1 = "abc";
String s2 = new String("abc");
String s3 = s1.intern(); //true
String s4 = s2.intern(); //false

三，StringBuffer和StringBuilder类

1. StringBuffer

字符串缓冲区，用于存储数据的容器，字符串缓冲区初始容量为16个字符，其实质还是数组

特点：

长度是可变的。

可以存储不同类型数据。

最终要转成字符串进行使用。

常用方法：

添加

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

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

删除

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

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

//清空缓冲区:
//sb=new StringBuffer();
sb.delete(0,sb.length());

修改

StringBuffer replace(start,end,string)

void setCharAt(int index,char ch)

查找

char charAt(int index)

int indexOf(String str)

int lastIndexOf(String str)

int length()

String substring(int start,int end)

反转

StringBuffer reverse();

将缓冲区中指定数据存储到指定字符数组中。

void getChars(int srcBegin,int srcEnd,char[]dst,int dstBegin)

其他方法

void setLength(int newLength);设置字符序列的长度

1.如果小于已有字符序列的长度，相当于清除缓冲区中的一部分内容。

2.如果大于已有字符序列的长度，相当于扩充缓冲区，扩充部门内容用空格字符填充。

说明：当创建的StringBuffer内容长度大于16，将会新创建一个新数组，长度比旧数组要长。然后把就数组的内容拷贝到新的数组，超出旧数组长度范围的内容将会放在新数组现在内容的后面，也可以通过StringBuffer(int capacity)构造函数指定

2. StringBuilder

概述

JDK1.5版本之后出现, 与StringBuffer功能一模一样

两者区别

StringBuffer是线程同步的，通常用于多线程。

StringBuilder是线程不同步的，通常用于单线程，它的出现能够提高程序效率。

小结：故StringBuilder多用于多个线程是不安全的，如果需要这样的同步，则建议使用StringBuffer。

升级三个因素：

提高效率

简化书写

提高安全性

四，基本类型包装类

将基本数据类型封装成了对象，在对象中定义属性和方法

基本数据类型	byte	short	int	long	char	float	double	boolean
包装类	Byte	Short	Integer	Long	Character	Float	Double	Boolean

1. 基本数据类型和包装类相互转换

基本数据类型–>包装类：

除了Character外，其他包装类都可以传入一个字符串参数构建包装类对象

包装类–>基本数据类型

包装类的实例方法 xxx xxxValue( ); // xxx表示包装类对应的基本数据类型

2. 基本类型和String之间的相互转换

String–>基本类型

除了Character外所有的包装类提供 xxx parseXxx(String str)静态方法，用于把一个特定的字符串转换成基本类型变量

int i = Integer.parseInt("16");//String --> 基本类型

基本类型–>String

String 类有静态方法valueOf()，用于将基本类型的变量转换成String类型

String s1 = String.valueOf(16);//基本类型--> String

3. 进制转换方法

十进制–>其他进制方法：

String toBinaryString(int i) 以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。

String toOctalString(int i) 以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。

String toHexString(int i) 以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。

String toString(int i,int radix) 返回用第二个参数指定基数表示的第一个参数的字符串表示形式。

其他进制–>十进制方法：

static int parseInt(String s,int radix) 使用第二个参数指定的基数，将字符串参数解析为有符号的整数。

五，Scanner类

1.概述：

一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器，位于java.util包，被final修饰，该类不可以被继承

2. 构造方法

Scanner(InputStream source)

Scanner sc = new Scanner(System.in)

3. 一般方法

hasNextXxx() 判断是否还有下一个输入项,其中Xxx可以是Int,Double等。如果需要判断是否包含下一个字符串，则可以省略Xxx

xxx nextXxx() 获取下一个输入项。Xxx的含义和上个方法中的Xxx相同,默认情况下，Scanner使用空格，回车等作为分隔符

String nextLine():获取一个String类型的值。可以接收任意类型，只要遇到\r\n就证明一行结束；建议使用该方法

六，枚举类

1. 概述

实例固定且有限的类就在Java中称作枚举类，Java从JDK1.5以后增加了对枚举类（关键字enum 与class、interface关键字的地位相同）的支持。

特点：

非抽象的枚举默认会使用fianl修饰，因此枚举不能派生子类

枚举类的构造器只能使用private访问控制，若省略默认为private

其所有实例必须在第一行显示列出，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略

在在switch语句中的可以使用

2. 手动实现方式

思路：

通过private将构造器隐藏起来；

把这个类的所有可能实例都使用public static final 修饰的类变量来保存；

如果有必要，可以提供一些静态方法，允许其他程序根据特定参数来获取与之匹配的实例

代码示例：

public abstract class Week {

public static final Week MON = new Week("星期一") {
public void show() {
System.out.println("星期一");
}
};
public static final Week TUE = new Week("星期二"){
public void show() {
System.out.println("星期二");
}
};
public static final Week WED = new Week("星期三"){
public void show() {
System.out.println("星期三");
}
};

private String name;
private Week(String name){
this.name = name;
}                       //私有构造,不让其他类创建本类对象
public String getName() {
return name;
}

public abstract void show();
}

3. 枚举类的常见方法

int ordinal() 返回枚举常量的序数（它在枚举声明中的位置，其中初始常量序数为零）。

int compareTo(E o) 比较此枚举与指定对象的顺序。

String name() 返回此枚举常量的名称，在其枚举声明中对其进行声明。

String toString()返回枚举常量的名称，它包含在声明中。

T valueOf(Class type,String name)返回带指定名称的指定枚举类型的枚举常量。

values() 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便

4. 代码示例

enum Week {
MON("星期一"){
public void show() {
System.out.println("星期一");
}
},TUE("星期二"){
public void show() {
System.out.println("星期二");
}
},WED("星期三"){
public void show() {
System.out.println("星期三");
}
};

private String name;
private Week(String name) {
this.name = name;
}
public String getName() {
return name;
}

public String toString() {
return name;
}

public abstract void show();
}

public class EnumDemo {
public static void main(String[] args) {
Week mon = Week.MON;
mon.show();

//遍历枚举类的所有枚举值
Week[] arr = Week.values();
for (Week week : arr) {
System.out.println(week);
}
}
}

运行结果：