java常用类笔记

Java常用类

Object类

大家都知道Object是所有类的父类，任何类都默认继承Object。

理论上Object类是所有类的父类，即直接或间接的继承java.lang.Object类。

由于所有的类都继承在Object类，因此省略了extends Object关键字。

该类中主要有以下方法:

• toString()

• getClass()

• equals()

• clone()

• fifinalize(）

其中toString(),getClass(),equals是其中最重要的方法。

注意： Object类中的getClass(),notify(),notifyAll(),wait()等方法被定义为fifinal类型，因此不能重写。

toString()方法

 public String toString() { 
     return getClass().getName() + "@" + Integer.toHexString(hashCode());
 }

这个toString()方法解析开来，其实就是getClass().getName()+"@"+Integer.toHexString(hashCode());

第一眼看上去感觉很复杂，我们对照刚刚打印的信息来看： getClass().getName()+"@"+Integer.toHexString(hashCode()) java.lang.Object@677327b6 1）getClass().getName()代表返回对象所属类的包名.类名，即java.lang.Object. 2）@对应@; 3）Integer.toHexString(hashCode())代表将对象的哈希值用16进制表示，其中hashCode()代表返回该对象的哈希值。

getClass()方法

 public final native Class<?> getClass();

返回次Object的运行时类类型。

不可重写，要调用的话，一般和getName()联合使用，如getClass().getName();

 public static void main(String[] args) { Object o = new Object(); System.out.println(o.getClass()); //class java.lang.Object }

equals()方法

 public boolean equals(Object obj) 
 { 
     return (this == obj); 
 }

Object中的equals方法是直接判断this和obj本身的值是否相等，即用来判断调用equals的对象和形参

obj所引用的对象是否是同一对象

所谓同一对象就是指内存中同一块存储单元，如果this和obj指向的hi同一块内存对象，则返回true,如果

this和obj指向的不是同一块内存，则返回false。

注意：即便是内容完全相等的两块不同的内存对象，也返回false。

如果是同一块内存，则object中的equals方法返回true,如果是不同的内存，则返回false

如果希望不同内存但相同内容的两个对象equals时返回true,则我们需要重写父类的equal方法

String类已经重写了object中的equals方法（这样就是比较内容是否相等了）

 

包装类

1.包装类介绍

虽然 Java 语言是典型的面向对象编程语言，但其中的八种基本数据类型并不支持面向对象编程，基本类

型的数据不具备“对象”的特性——不携带属性、没有方法可调用。 沿用它们只是为了迎合人类根深蒂固

的习惯，并的确能简单、有效地进行常规数据处理。

这种借助于非面向对象技术的做法有时也会带来不便，比如引用类型数据均继承了 Object 类的特性，要

转换为 String 类型（经常有这种需要）时只要简单调用 Object 类中定义的toString()即可，而基本数据

类型转换为 String 类型则要麻烦得多。为解决此类问题 ，Java为每种基本数据类型分别设计了对应的

类，称之为包装类(Wrapper Classes)，也有教材称为外覆类或数据类型类。

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

每个包装类的对象可以封装一个相应的基本类型的数据，并提供了其它一些有用的方法。包装类对象一

经创建，其内容（所封装的基本类型数据值）不可改变。

基本类型和对应的包装类可以相互装换：

• 由基本类型向对应的包装类转换称为装箱，例如把 int 包装成 Integer 类的对象；

• 包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象重新简化为 int。

 

2.包装类的应用

【1、 实现 int 和 Integer 的相互转换】

可以通过 Integer 类的构造方法将 int 装箱，通过 Integer 类的 intValue 方法将 Integer 拆箱。

 public static void main(String[] args) { 
     int m = 500; 
     Integer obj = new Integer(m); // 手动装箱 
     int n = obj.intValue(); // 手动拆箱 
     System.out.println("n = " + n); 
     Integer obj1 = new Integer(500); 
     System.out.println("obj 等价于 obj1？" + obj.equals(obj1)); 
 }

【2、 将字符串转换为整数】

Integer 类有一个静态的 paseInt() 方法，可以将字符串转换为整数，语法为

 parseInt(String s, int radix);

s 为要转换的字符串，radix 为进制，可选，默认为十进制。

下面的代码将会告诉你什么样的字符串可以转换为整数：

 public static void main(String[] args) 
 String[] str = {"123", "123abc", "abc123", "abcxyz"}; 
 for(String str1 : str){ 
 try{
     int m = Integer.parseInt(str1, 10); 
     System.out.println(str1 + " 可以转换为整数 " + m); 
 }catch(Exception e)
 { 
     System.out.println(str1 + " 无法转换为整数"); 
 }
 } 
 }
 //结果 123 可以转换为整数 123 123abc 无法转换为整数 abc123 无法转换为整数 abcxyz 无法转换为整数

【 3、将整数转换为字符串】

Integer 类有一个静态的 toString() 方法，可以将整数转换为字符串。或者直接在整数后面加空字符串即

可！

 public static void main(String[] args) 
 {
     int m = 500; 
     String s = Integer.toString(m); 
     String s2 = m+""; 
     System.out.println("s = " + s);
 }

3.自动拆箱和装箱

上面的例子都需要手动实例化一个包装类，称为手动拆箱装箱。Java 1.5(5.0) 之前必须手动拆箱装箱。

Java 1.5 之后可以自动拆箱装箱，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进

行，这将大大方便程序员的代码书写。

public static void main(String[] args) 
{ 
    int m = 500; 
    Integer obj = m; // 自动装箱 
    int n = obj; // 自动拆箱
    System.out.println("n = " + n); 
    Integer obj1 = 500; 
    System.out.println("obj 等价于 obj1？" + obj.equals(obj1));
}
//结果： // n = 500 // obj 等价于 obj1？true

自动拆箱装箱是常用的一个功能，需要重点掌握。

一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。然

而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问

题，Java 语言为每一个内置数据类型提供了对应的包装类。

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。

Math类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。

Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

public final class Math{ 
//数学方法 
}

【常用值与函数】

Math.PI 记录的圆周率

Math.E 记录e的常量

Math中还有一些类似的常量，都是一些工程数学常用量。

Math.abs 求绝对值

Math.sin 正弦函数 Math.asin 反正弦函数

Math.cos 余弦函数 Math.acos 反余弦函数

Math.tan 正切函数 Math.atan 反正切函数 Math.atan2 商的反正切函数

Math.toDegrees 弧度转化为角度 Math.toRadians 角度转化为弧度

Math.ceil 得到不小于某数的最大整数

Math.flfloor 得到不大于某数的最大整数

Math.IEEEremainder 求余

Math.max 求两数中最大

Math.min 求两数中最小

Math.sqrt 求开方

Math.pow 求某数的任意次方, 抛出ArithmeticException处理溢出异常

Math.exp 求e的任意次方

Math.log10 以10为底的对数

Math.log 自然对数

Math.rint 求距离某数最近的整数（可能比某数大，也可能比它小）

Math.round 同上，返回int型或者long型（上一个函数返回double型）

Math.random 返回0，1之间的一个随机数

public static void main(String[] args) { 
    /***Math.sqrt()
    //计算平方根 *Math.cbrt()
    //计算立方根 *Math.pow(a, b)
    //计算a的b次方 *Math.max( , );
    //计算最大值 *Math.min( , );
    //计算最小值 */ 
    System.out.println(Math.sqrt(16)); //4.0 
    System.out.println(Math.cbrt(8)); //2.0 
    System.out.println(Math.pow(3,2)); //9.0      
    System.out.println(Math.max(2.3,4.5));//4.5 
    System.out.println(Math.min(2.3,4.5));//2.3
    /*** abs求绝对值 */ 
    System.out.println(Math.abs(-10.4)); //10.4 
    System.out.println(Math.abs(10.1)); //10.1 
    /*** ceil天花板的意思，就是返回大的值 */ 
    System.out.println(Math.ceil(-10.1)); //-10.0 
    System.out.println(Math.ceil(10.7)); //11.0 
    System.out.println(Math.ceil(-0.7)); //-0.0 
    System.out.println(Math.ceil(0.0)); //0.0 
    System.out.println(Math.ceil(-0.0)); //-0.0 
    System.out.println(Math.ceil(-1.7)); //-1.0 
    /*** floor地板的意思，就是返回小的值 */ 
    System.out.println(Math.floor(-10.1)); //-11.0 
    System.out.println(Math.floor(10.7)); //10.0 
    System.out.println(Math.floor(-0.7)); //-1.0 
    System.out.println(Math.floor(0.0)); //0.0 
    System.out.println(Math.floor(-0.0)); //-0.0 
    /*** random 取得一个大于或者等于0.0小于不等于1.0的随机数 [0,1) */ 
    System.out.println(Math.random()); //小于1大于0的double类型的数 
    System.out.println(Math.random()+1);//大于1小于2的double类型的数 
    /*** rint 四舍五入，返回double值 * 注意.5的时候会取偶数 异常的尴尬=。= */ 
    System.out.println(Math.rint(10.1));  //10.0 
    System.out.println(Math.rint(10.7)); //11.0
    System.out.println(Math.rint(11.5)); //12.0 
    System.out.println(Math.rint(10.5)); //10.0 
    System.out.println(Math.rint(10.51)); //11.0 
    System.out.println(Math.rint(-10.5)); //-10.0 
}

 

Random类

Java中存在着两种Random函数：

一、java.lang.Math.Random;

调用这个Math.Random()函数能够返回带正号的double值，该值大于等于0.0且小于1.0，即取值范围是

[0.0,1.0)的左闭右开区间，返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。例子如下：

public static void main(String[] args) { 
// 结果是个double类型的值，区间为[0.0,1.0） 
    
System.out.println("Math.random()=" + Math.random());
    int num = (int) (Math.random() * 3); 
// 注意不要写成(int)Math.random()*3，这个结果为0或1，因为先执行了强制转换 
    System.out.println("num=" + num); 
}
//结果 
//Math.random()=0.44938147153848396 
//num=1

二、java.util.Random

下面是Random()的两种构造方法：

Random()：创建一个新的随机数生成器。

Random(long seed)：使用单个 long 种子创建一个新的随机数生成器。

你在创建一个Random对象的时候可以给定任意一个合法的种子数，种子数只是随机算法的起源数字，

和生成的随机数的区间没有任何关系。

如下面的Java代码：

【演示一】

在没带参数构造函数生成的Random对象的种子缺省是当前系统时间的毫秒数。

rand.nextInt(100)中的100是随机数的上限,产生的随机数为0-100的整数,不包括100。

public static void main(String[] args) 
{ 
Random rand =new Random(); 
int i=rand.nextInt(100); 
System.out.println(i);
}

【演示二】

对于种子相同的Random对象，无论运行多少次生成的随机数序列是一样的。

public static void main(String[] args) 
{ 
    Random ran1 = new Random(25); 
    System.out.println("使用种子为25的Random对象生成[0,100)内随机整数序列: "); 
    for (int i = 0; i < 10; i++)
    { 
        System.out.print(ran1.nextInt(100) + " "); 
    }System.out.println(); 
}

【方法摘要】

1. protected int next(int bits)：生成下一个伪随机数。

2. boolean nextBoolean()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的

boolean值。

3. void nextBytes(byte[] bytes)：生成随机字节并将其置于用户提供的 byte 数组中。

4. double nextDouble()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间

均匀分布的 double值。

5. flfloat nextFloat()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分

布flfloat值。

6. double nextGaussian()：返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（

“正 态”）分布的double值，其平均值是0.0标准差是1.0。

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

8. int nextInt(int n)：返回一个伪随机数，它是取自此随机数生成器序列的、在（包括和指定值（不

包括）之间均匀分布的int值。

9. long nextLong()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。

10. void setSeed(long seed)：使用单个 long 种子设置此随机数生成器的种子。

日期时间类

Date类

java.util 包提供了 Date 类来封装当前的日期和时间。

Date 类提供两个构造函数来实例化 Date 对象。

第一个构造函数使用当前日期和时间来初始化对象。

Date()

第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。

Date(long millisec)

Date对象创建以后，可以调用下面的方法。

序号	方法和描述
1	boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false
2	boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false
3	Object clone( ) 返回此对象的副本。
4	int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5	int compareTo(Object obj) 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6	boolean equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7	long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8	int hashCode( ) 返回此对象的哈希码值。
9	void setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10	String toString( ) 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz

【演示：获取当前日期时间】

Java中获取当前日期和时间很简单，使用 Date 对象的 toString() 方法来打印当前日期和时间

如下所示：

public static void main(String args[]) { 
    // 初始化 Date 对象
    Date date = new Date(); 
    // 使用 toString() 函数显示日期时间 
    System.out.println(date.toString()); 
    //Sat Apr 27 15:09:43 CST 2019 
}

【演示：日期比较】

使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。

public static void main(String[] args) {
    // 初始化 Date 对象 
    Date date = new Date(); 
    long time = date.getTime(); 
    long time2 = date.getTime(); 
    System.out.println(time==time2); 
}

使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2,12).before(new Date (99, 2, 18)) 返回true。

public static void main(String[] args) { 
    boolean before = new Date(97, 01, 05).before(new Date(99, 11, 16)); 
    System.out.println(before); 
}

SimpleDateFormat

【演示：使用 SimpleDateFormat 格式化日期】

SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许

你选择任何用户自定义日期时间格式来运行。例如：

public static void main(String args[]) 
{ 
    Date dNow = new Date( ); 
    SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss"); 
    System.out.println("当前时间为: " + ft.format(dNow)); 
}

其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是时、分、秒。

注意:有的格式大写，有的格式小写，例如 MM 是月份，mm 是分；HH 是 24 小时制，而 hh 是 12 小时

制。

时间模式字符串用来指定时间格式。在此模式中，所有的 ASCII 字母被保留为模式字母，定义如下：

字母	描述	示例
G	纪元标记	AD
y	四位年份	2001
M	月份	July or 07
d	一个月的日期	10
h	A.M./P.M. (1~12)格式小时	12
H	一天中的小时（0-23）	22
m	分钟数	30
s	秒数	55
S	毫秒数	234
E	星期几	Tuesday
D	一年中的日子	360
F	一个月中第几周的周几	2 (second Wed. in July)
w	一年中第几周	40
W	一个月中第几周	1
a	A.M./P.M.(0-11)标记	PM
k	一天中的小时(1~24)	24
K	A.M./P.M. (0~11)格式小时	10
z	时区	Eastern Standard Time
'	文字定界符	Delimiter
"	单引号	`

【演示：使用printf格式化日期】

printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。

public static void main(String args[]) { 
// 初始化 Date 对象 

    Date date = new Date(); //c的使用 
    System.out.printf("全部日期和时间信息：%tc%n",date); //f的使用 
    System.out.printf("年-月-日格式：%tF%n",date); //d的使用 
    System.out.printf("月/日/年格式：%tD%n",date); //r的使用 
    System.out.printf("HH:MM:SS PM格式（12时制:%tr%n",date);
    //t的使用 
    System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date); //R的使用 
    System.out.printf("HH:MM格式（24时制）：%tR",date);
}
//结果: 全部日期和时间信息：星期六 四月 27 15:23:45 CST 2019 年-月-日格式：2019-04-27 月/日/年格式：04/27/19 HH:MM:SS PM格式（12时制）：03:23:45 下午 HH:MM:SS格式（24时制）：15:23:45 HH:MM格式（24时制）：15:23 131415161718

Calendar类

我们现在已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar类。Date中有很多方法都已经废弃了！

Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。

Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明的，只需要使用getInstance方法创建即可。

创建一个指定日期的Calendar对象

使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。

//创建一个代表2019年4月27日的Calendar对象 
Calendar c1 = Calendar.getInstance(); 
c1.set(2019, 4 - 1, 27);

Calendar类对象字段类型

Calendar类中用以下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想

常量	描述
Calendar.YEAR	年份
Calendar.MONTH	月份
Calendar.DATE	日期
Calendar.DAY_OF_MONTH	日期，和上面的字段意义完全相同
Calendar.HOUR	12小时制的小时
Calendar.HOUR_OF_DAY	24小时制的小时
Calendar.MINUTE	分钟
Calendar.SECOND	秒
Calendar.DAY_OF_WEEK	星期几

// 获得年份
int year = c1.get(Calendar.YEAR); 
// 获得月份 
int month = c1.get(Calendar.MONTH) + 1; 
// 获得日期 
int date = c1.get(Calendar.DATE); 
// 获得小时 
int hour = c1.get(Calendar.HOUR_OF_DAY); 
// 获得分钟 
int minute = c1.get(Calendar.MINUTE); 
// 获得秒 
int second = c1.get(Calendar.SECOND); 
// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类 推）
int day = c1.get(Calendar.DAY_OF_WEEK); 

【演示：设置完整日期】

c1.set(2009, 6 - 1, 12);//把Calendar对象c1的年月日分别设这为：2009、6、12

【演示：设置某个字段】

c1.set(Calendar.DATE,10); 
c1.set(Calendar.YEAR,2008); 
//其他字段属性set的意义以此类推

【add设置】

//把c1对象的日期加上10，也就是c1也就表示为10天后的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, 10);
//把c1对象的日期减去10，也就是c1也就表示为10天前的日期，其它所有的数值会被重新计算 
c1.add(Calendar.DATE, -10);

String类

String概述

在API中是这样描述：

String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。 字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。

成员变量：

      1、成员变量定义在类中，在整个类中都可以被访问。

      2、成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。

      3、成员变量有默认初始化值。

  局部变量：

      1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

      2、局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

      3、局部变量没有默认初始化值 

  在使用变量时需要遵循的原则为：就近原则

  首先在局部范围找，有就使用；接着在成员位置找。

【String的成员变量】

//String的属性值 
private final char value[]; 
//数组被使用的开始位置 
private final int offset; 
//String中元素的个数 
private final int count; 
//String类型的hash值 
private int hash; // Default to 0
private static final long serialVersionUID=-6849794470754667710L; 
private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];

从源码看出String底层使用一个字符数组来维护的。

成员变量可以知道String类的值是fifinal类型的，不能被改变的，所以只要一个值改变就会生成一个新的

String类型对象，存储String数据也不一定从数组的第0个元素开始的，而是从offffset所指的元素开始。

【String的构造方法】

String() 
//初始化一个新创建的 String 对象，使其表示一个空字符序列。 
    String(byte[] bytes)
//通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。 
    String(byte[] bytes, Charset charset) 
    //通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。 
    String(byte[] bytes, int offset, int length) //通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。 
    String(byte[] bytes, int offset, int length, Charset charset) //通过使用指定的 charset 解码指定的 byte 子数组，构造一个新的 String。 
    String(byte[] bytes, int offset, int length, String charsetName) //通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。 
    String(byte[] bytes, String charsetName) //通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。 
    String(char[] value) //分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。 
    String(char[] value, int offset, int count) //分配一个新的 String，它包含取自字符数组参数一个子数组的字符。 
    String(int[] codePoints, int offset, int count) //分配一个新的 String，它包含 Unicode 代码点数组参数一个子数组的字符。
    String(String original) //初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建 的字符串是该参数字符串的副本。 
    String(StringBuffer buffer) //分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。 
    String(StringBuilder builder) //分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。

创建字符串对象方式

直接赋值方式创建对象是在方法区的常量池

String str="hello";//直接赋值的方式

通过构造方法创建字符串对象是在堆内存

String str=new String("hello");//实例化的方式

【两种实例化方式的区别】

1. 直接赋值（String str = "hello"）：只开辟一块堆内存空间，并且会自动入池，不会产生垃圾。

2. 构造方法（String str= new String("hello");）:会开辟两块堆内存空间，其中一块堆内存会变成垃圾被系统回收，而且不能够自动入池，需要通过public String intern();方法进行手工入池。

3. 在开发的过程中不会采用构造方法进行字符串的实例化

【避免空指向】

首先了解： == 和public boolean equals()比较字符串的区别

==在对字符串比较的时候，对比的是内存地址，而equals比较的是字符串内容，在开发的过程中，

equals()通过接受参数，可以避免空指向。

【String类对象一旦声明则不可以改变；而改变的只是地址，原来的字符串还是存在的，并且产生垃圾】

String常用的方法

String的判断

boolean equals(Object obj)：比较字符串的内容是否相同

boolean equalsIgnoreCase(String str)： 比较字符串的内容是否相同,忽略大小写

boolean startsWith(String str)： 判断字符串对象是否以指定的str开头

boolean endsWith(String str)： 判断字符串对象是否以指定的str结尾

String的截取

int length():获取字符串的长度，其实也就是字符个数

char charAt(int index):获取指定索引处的字符

int indexOf(String str):获取str在字符串对象中第一次出现的索引

String substring(int start):从start开始截取字符串

String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end

String的转换

char[] toCharArray()：把字符串转换为字符数组

String toLowerCase()：把字符串转换为小写字符串

String toUpperCase()：把字符串转换为大写字符串

其他方法

去除字符串两端空格：String trim()

按照指定符号分割字符串：String[] split(String str)

String的不可变性

我想大家应该就知道为什么String不可变了，String类被fifinal修饰，官方注释说明创建后不能被改变，但是为什么String要使用fifinal修饰呢

【分析】

因为String太过常用，JAVA类库的设计者在实现时做了个小小的变化，即采用了享元模式,每当生成一个新内容的字符串时，他们都被添加到一个共享池中，当第二次再次生成同样内容的字符串实例时，就共享此对象，而不是创建一个新对象，但是这样的做法仅仅适合于通过=符号进行的初始化。

需要说明一点的是，在object中，equals()是用来比较内存地址的，但是String重写了equals()方法，用来比较内容的，即使是不同地址，只要内容一致，也会返回true，这也就是为什么a.equals(c)返 回true的原因了。

【String不可变的好处】

• 可以实现多个变量引用堆内存中的同一个字符串实例，避免创建的开销。

• 我们的程序中大量使用了String字符串，有可能是出于安全性考虑。

• 大家都知道HashMap中key为String类型，如果可变将变的多么可怕。

• 当我们在传参的时候，使用不可变类不需要去考虑谁可能会修改其内部的值，如果使用可变类的话，可能需要每次记得重新拷贝出里面的值，性能会有一定的损失

StringBuilder和StringBuffer

StringBuilder 是一个可变的字符序列。它继承于AbstractStringBuilder，实现了CharSequence接口。

StringBuffffer 也是继承于AbstractStringBuilder的子类；但是，StringBuilder和StringBuffffer不同，前者是非线程安全的，后者是线程安全的。

【String、StringBuffffer、StringBuilder之间的区别】

首先需要说明的是：

String 字符串常量

StringBuffffer 字符串变量（线程安全）

StringBuilder 字符串变量（非线程安全）

在大多数情况下三者在执行速度方面的比较：StringBuilder > StringBuffffer > String

解释：

String 类型和 StringBuffffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

而如果是使用 StringBuffffer 类则结果就不一样了，每次结果都会对 StringBuffffer 对象本身进行操作，而不是生成新的对象，再改变对象引用。所以在一般情况下我们推荐使用 StringBuffffer ，特别是字符串对象经常改变的情况下。

为什么是大多数情况呢？

在某些特别情况下， String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢，而特别是以下的字符串对象生成中，String 效率是远要比 StringBuffer 快的：

对于三者使用的总结：

1）如果要操作少量的数据用 = String

2）单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

3）多线程操作字符串缓冲区 下操作大量数据 = StringBuffffer

面试题的回答

StringBuilder 与StringBuffffer的区别，StringBuilder与String的区别。

1）StringBuilder效率高，线程不安全，StringBuffffer效率低，线程安全。

2）String是不可变字符串，StringBuilder是可变字符串。为什么有这样的差异，可以深入源码去解析，

比如String类内的 priver fifinal char value[] 等方法的原因。

3）如果是简单的声明一个字符串没有后续过多的操作，使用String,StringBuilder均可，若后续对字符串做频繁的添加，删除操作,或者是在循环当中动态的改变字符穿的长度应该用StringBuilder。使用String会产生多余的字符串，占用内存空间。

File类

1. java.io.File类：文件和目录路径名的抽象表示形式。

File类的常见构造方法：

public File(String pathname)

以pathname为路径创建File对象，如果pathname是相对路径，则默认的当前路径在系统属性user.dir

中存储。

1. File的静态属性String separator存储了当前系统的路径分隔符。

2. 通过File对象可以访问文件的属性。