java基本要点,Java 基础要点之常用类

Object类

基本概念

Object 类是 Java 语言总层次结构的根类，也就是说每一个类都是 Object 类的直接子类或者间接子类

如果定义了一个 Java 类时没有使用 extends 关键字继承父类，那么此类的父类为 Object 类

Object 类定义了 “对象” 的基本行为，被子类继承

常用方法

方法

功能

Object()

使用无参构造方法构造对象

boolean equals(obj)

默认比较两个对象的地址是否相等，与==相同

int hashCode()

用于获取调用对象的hash码值(内存地址的编号)

String toString()

获取调用对象的字符串形式，默认返回的字符串为:包名.类名@哈希码的十六进制

Class> getClass()

返回调用对象执行时的 Class实例

equals()注意点

要比较两个对象的内容需要重写此方法，且应该也重写hashCode方法保证结果的一致性

重写equals()要遵循的原则

自反性：对于任何非空引用，x.equals(x) 应该返回 true。

对称性：对于任何非空引用 x 与 y，x.equals(y) 应该返回 true 当且仅当 y.equals(x) 也要返回 true

一致性：对于任何非空引用 x 与 y，无论多少次 x.equals(y) 都应该返回 true 或者 false ，前提是未修改对象的比较信息

传递性：对于任何非空引用 x 、y、z，如果 x.equals(y) 和 y.equals(z) 都返回 true，则 x.equals(z) 必定返回 true

对于任何非空引用，x.equals(null)应该返回false

String类

基本概念

String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描述，如：’abc‘

该类由 final 关键字修饰，表示该类不能被继承

从 Java 9 开始该类底层不使用 char[] 来存储数据，而是改成 byte[] 加上编码印记，从而节约了一些空间

该类描述的字符串内容是个常量不可更改，因为此可以被共享使用，如：String str = “abc”; 其中 “abc”这个字符串是个常量不可改变，str1 = “123”; 将 “123” 字符串的地址赋值给 str1，改变了 str1 的指向，并没有改变指向的内容。

常量池：由于 String 类型描述的字符串内容是常量不可改变，因此 Java 虚拟机将首次出现的字符串放入 到常量池中，若后续代码中出现相同字符串内容则直接使用常量池中已有的字符串对象而无需申请内存以及创建对象，从而提高了性能

考点

//判断引用

//1.下面会创建多少个对象？分别存放在什么地方

String str = new String("hello");

//可能只创建一个对象，因为“hello”可能已经在常量池中，只 new 了一个对象

//最多创建了两个对象，创建一个"hello"字符串在常量池，new 的实例对象在堆区。

//======================================================

//2.常量池与堆区对象比较

String str1 = "hello"; //常量池

String str2 = "hello";//常量池

String str3 = new String("hello");//堆区

String str4 = new String("hello");//堆区

str1 == str2;//比较地址 true

str1.equals(str2);//比较内容 true

str3 == str4;//比较地址 false

str3.equals(str4);//比较内容 true

str2 == str4;//比较地址 false

str2.equals(str2);//比较内容 true

//=======================================================

//3.常量有优化机制，变量没有

String str1 = "abcd";

String str2 = "ab" + "cd";//常量优化机制，"ab"+"cd" -->”abcd“,常量池中有，所以直接使用。

str1 == str2;//比较地址 true

String str3 = "ab";

String str4 = str3 + "cd";//str3为变量，所以没有优化机制，所以是新申请的内存地址

str4 == str1;//比较地址 false

复制代码

常用的构造方法

构造方法

功能描述

String()

无参方式构造对象的到空字符串序列

String(bytep[] bytes,int offset,int length)

使用bytes数组中下标从offset开始的length个字符串来构建对象

String(bytep[] bytes)

使用bytes数组中所有内容来构建对象

String(char[] value,int offset,int count)

使用char数组中下标从offset开始的length个字符串来构建对象

String(char[] value)

使用char数组中所有内容来构建对象

String(String original)

根据参数指定的字符串内容来构建对象，新创建对象为参数对象的副本

常用的成员方法

成员方法

功能描述

byte[] getBytes()

将当前字符串内容转换为byte数组并返回

char[] toCharArray()

将当前字符串内容转化为char数组并返回

char charAt(int index)

返回字符串指定位置的字符

int length()

返回字符串字符序列的长度

boolean isEmpty()

判断字符串内容是否为空

int compareTo(String anotherString)

用于比较调用对象和参数对象的大小比较

int compareToIgnoreCase(String anotherString)

用于比较调用对象，但是不考虑大小写

String concat(String str)

用于实现字符串的拼接

boolean contains(CharSequence s)

用于判断当前字符串是否包含参数指定的内容

String toLowCase() / String toUpperCase()

返回字符串的大小写形式

String trim()

返回去掉前导和后继空白的字符串

boolean startWith(String prefix)

判断字符串是否以参数字符串开头

boolean startWith(String prefix,int offset)

从指定位置开始是否以参数字符串为开头

int indexOf(int ch/String str)

返回第一次出现的ch/str 的下标，找不到则返回-1

int indexOf(int ch/String str,int fromIndex)

从fromIndex开始查找ch/str第一次出现的位置

int lastIndexOf(int ch/String str)

返回最后一次出现的ch/str 的下标，找不到则返回-1

int lastIndexOf(int ch/String str,int fromIndex)

从fromIndex位置开始反向查找ch/str第一次出现的位置

String substring(int beginIndex,int endIndex)

返回字符串中从下标beginIndex(包括)开始

到endIndex(不包括)结束的子字符串

String substring(int beginIndex)

返回字符串中从下标beginIndex(包括)开始

到字符串结尾的子字符串

可变字符串类

基本概念

由于String类秒数据的字符串内容是个常量不可改变，当需要在 Java 代码中描述大量类似的字符串是，只能单独申请和存储，此时会造成内存空间的浪费

为了解决上述问题，可以使用StringBuilder类和StringBuffer类来描述字符串序列可以改变的字符串

StringBuffer类是从 Jdk1.0 开始存在，属于线程安全的类，一次效率比较低

StringBuilder类是从 JDK 1.5 开始存在的，属于非线程安全的类，效率比较高

常用构造方法

方法

功能

StringBuilder()

无参构造方法，默认容量为16

StringBuilder(int capacity)

根据参数指定容量构造对象

StringBuilder(String str)

根据指定字符串构造对象，容量为16+字符串长度

常用成员方法

方法

功能

int capacity()

返回对象的容量

int length()

返回字符串的长度，也就是字符的个数

StringBuilder insert(int offset,String str)

在指定位置插入字符串，并返回

StringBuilder append(String str)

追加字符串

StringBuilder deleteCharAt(int index)

将当前字符串中下标为index位置的单个字符删除

StringBuilder delete(int start,int end)

删除下标从start到end(不包括)的字符串

StringBuilder replace(int start,int end,String str)

替换下标的字符串

StringBuilder reverse()

字符串反转

考点

//既然StringBuilder类的对象本身可以修改，那么为什么成员方法还有返回值呢？

//为了能够进行链式调用

//----------------------------

//实现 String 与 StringBuilder 之间的转换

StringBuilder sb = new StringBuilder();

String str = sb.toString();//StringBuilder 转 String

StringBuilder sb1 = new StringBuilder(str);//String 转 StringBuilder

//----------------------------

//String、StringBuilder、StringBuffer的效率排列

//String < StringBuffer < StringBuilder

复制代码

包装类

基本概念

通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类

Integer(包装了一个int类型)常用方法

方法

功能

Integer(int value/String value)

构造方法(已过时)

int intValue

获取对象中的整数值并返回

static Integer valueOf(int value)

将制定参数转化为Integer对象

static int parseInt(String value)

将字符串转化为 int 并返回

static String toString(int value)

得到参数的十进制字符串形式

static String toBinaryString(int value)

得到参数的二 进制字符串形式

static String toHexString(int value)

得到参数的十六进制字符串形式

static String toOctalString(int value)

得到参数的八进制字符串形式

考点

//从 Java 5 开始就有了一种自动装箱与自动拆箱的特性

Integer i = 20;//自动装箱，将基本数据类型 int 自动包装成包装类对象

int j = i;//自动拆箱，将包装类对象拆解为基本数据类型int

//-------------------------------------

//自动装箱池：在Integer类的内部提供了自动装箱池技术。将-128到127之间的整数已经装箱完毕，当程序中使用该范围之间的整数时，无需装箱直接取用自动装箱池中的对象即可，无需创建新的对象从而提高效率

Integer i1 = 128;

Integer i2 = 128;

Integer i3 = new Integer(128);

Integer i4 = new Integer(128);

i1 == i2;//比较地址 false

i1.equals(i2);//比较内容 true

i3 == i4;//比较地址 false

i3.equals(i4);//比较内容 true

//=========================================

Integer i1 = 127;

Integer i2 = 127;

Integer i3 = new Integer(127);

Integer i4 = new Integer(127);

i1 == i2;//比较地址 true

i1.equals(i2);//比较内容 true

i3 == i4;//比较地址 false

i3.equals(i4);//比较内容 true

复制代码