java常用类

1.Object类

1.所有类默认继承Object类，是所有类的父类。

2.clone()方法

clone 方法是浅拷贝，对象内属性引用的对象只会拷贝引用地址，而不会将引用的对象重新分配内存，相对应的深拷贝则会连引用的对象也重新创建。

详情：https://blog.csdn.net/zhangjg_blog/article/details/18369201#0-qzone-1-28144-d020d2d2a4e8d1a374a433f596ad1440

Person p = new Person(23, "zhang");
Person p1 = p; //赋值是浅拷贝，指向同一对象的堆区地址，没有为p1分配新的内存
Person p2 = (Person)p.clone();//创建了新的对象，给新的对象分配了堆区内存。但没有对对象中的所有属性进行深拷贝。
String result = p.getName() == p2.getName() ? "clone是浅拷贝的" : "clone是深拷贝的";//由于String是类，name是对String对象的引用，所以对name的clone()是一种浅拷贝。
//重写clone（）接口实现深拷贝
@Override
protected Object clone() throws CloneNotSupportedException {
    return super.clone();
}

在为了要在clone对象时进行深拷贝， 那么就要Clonable接口，覆盖并实现clone方法，除了调用父类中的clone方法得到新的对象， 还要将该类中的引用变量也clone出来。如果只是用Object中默认的clone方法，是浅拷贝的，再次以下面的代码验证：

如果在拷贝一个对象时，要想让这个拷贝的对象和源对象完全彼此独立，那么在引用链上的每一级对象都要被显式的拷贝。所以 创建彻底的深拷贝是非常麻烦的，尤其是在引用关系非常复杂的情况下， 或者在引用链的某一级上引用了一个第三方的对象， 而这个对象没有实现clone方法， 那么在它之后的所有引用的对象都是被共享的。 举例来说，如果被Head引用的Face类是第三方库中的类，并且没有实现Cloneable接口，那么在Face之后的所有对象都会被拷贝前后的两个Body对象共同引用。假设Face对象内部组合了Mouth对象，并且Mouth对象内部组合了Tooth对象， 内存结构如下图：

clone在平时项目的开发中可能用的不是很频繁，但是区分深拷贝和浅拷贝会让我们对java内存结构和运行方式有更深的了解。至于彻底深拷贝，几乎是不可能实现的，原因已经在上一节中进行了说明。深拷贝和彻底深拷贝，在创建不可变对象时，可能对程序有着微妙的影响，可能会决定我们创建的不可变对象是不是真的不可变。clone的一个重要的应用也是用于不可变对象的创建。

2.tostring()

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

3.getClass（）

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

4.finalize()方法

该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。

关于垃圾回收，有三点需要记住：
1、对象可能不被垃圾回收。只要程序没有濒临存储空间用完的那一刻，对象占用的空间就总也得不
到释放。
2、垃圾回收并不等于“析构”。
【科普：析构函数(destructor) 与构造函数相反，当对象结束其生命周期，如对象所在的函数已调用完
毕时，系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟
了一片内存空间，delete会自动调用析构函数后释放内存）。】
3、垃圾回收只与内存有关。使用垃圾回收的唯一原因是为了回收程序不再使用的内存。

5.equals()

判断调用equals的对象和形参obj所引用的对象是否是同一对象,所谓同一对象就是指内存中同一块存储单元，如果this和obj指向的hi同一块内存对象，则返回true,如果this和obj指向的不是同一块内存，则返回false

如果希望不同内存但相同内容的两个对象equals时返回true,则我们需要重写父类的equal方法
String类已经重写了object中的equals方法（这样就是比较内容是否相等了）

6.hashCode()

返回对象的哈希码值

7.wait()

wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回

8.notify()方法

public final native void notify(); 该方法唤醒在该对象上等待的某个线程。

public final native void notifyAll(); 该方法唤醒在该对象上等待的所有线程。

2.包装类

基础数据类型不具备对象特性，转换String麻烦，设计对应的包装类（外覆类，数据类型类，）

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

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

1.整数和对象转换

int m = 500;
Integer obj = new Integer(m); // 手动装箱
int n = obj.intValue(); // 手动拆箱
System.out.println("n = " + n);
Integer obj1 = new Integer(500);

2.字符串转整数

parseInt(String s, int radix);//s 为要转换的字符串，radix 为进制，可选，默认为十进制
int m = Integer.parseInt(str1, 10);

3.整数转字符串

String s = Integer.toString(m);  

4.自动装箱和拆箱

int m = 500;
Integer obj = m; // 自动装箱
int n = obj; // 自动拆箱

5.空指针问题

Integer i = null;
int j = i.intValue();

3.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.floor 得到不大于某数的最大整数
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之间的一个随机数

4.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对象的时候可以给定任意一个合法的种子数，种子数只是随机算法的起源数字，
和生成的随机数的区间没有任何关系。

【方法摘要】
\1. protected int next(int bits)：生成下一个伪随机数。

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

\2. boolean nextBoolean()：返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的
boolean值。
\3. void nextBytes(byte[] bytes)：生成随机字节并将其置于用户提供的 byte 数组中。
\4. double nextDouble()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间
均匀分布的 double值。
\5. float nextFloat()：返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分
布float值。
\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 种子设置此随机数生成器的种子。

【例子】
\1. 生成[0,1.0)区间的小数：double d1 = r.nextDouble();
\2. 生成[0,5.0)区间的小数：double d2 = r.nextDouble() * 5;
\3. 生成[1,2.5)区间的小数：double d3 = r.nextDouble() * 1.5 + 1;
\4. 生成[0,10)区间的整数：int n2 = r.nextInt(10);

5.日期时间类

1、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 yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

【演示：获取当前日期时间】
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日经历的毫秒数值），然后比较这两个值。

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

2.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. 标记	PM
k	一天中的小时(1~24)	24
K	A.M./P.M. (0~11)格式小时	10
z	时区	Eastern Standard Time
’	文字定界符	Delimiter
"	单引号

printf格式化时间

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

3、Calendar类

Calender的月份是从0开始的，但日期和年份是从1开始的

我们现在已经能够格式化并创建一个日期对象了，但是我们如何才能设置和获取日期数据的特定部分
呢，比如说小时，日，或者分钟? 我们又如何在日期的这些部分加上或者减去值呢? 答案是使用Calendar
类。Date中有很多方法都已经废弃了！
Calendar类的功能要比Date类强大很多，而且在实现方式上也比Date类要复杂一些。
Calendar类是一个抽象类，在实际使用时实现特定的子类的对象，创建对象的过程对程序员来说是透明
的，只需要使用getInstance方法创建即可。

创建一个代表系统当前日期的Calendar对象

public static void main(String args[]) {
    Calendar c = Calendar.getInstance();//默认是当前日期
    System.out.println(c);
} 
//输出
java.util.GregorianCalendar[time=1556350818634,areFieldsSet=true,areAllFields
Set=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offs
et=28800000,dstSavings=0,useDaylight=false,transitions=29,lastRule=null],firs
tDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2019,MONTH=3,WEEK_OF_YEAR=17
,WEEK_OF_MONTH=4,DAY_OF_MONTH=27,DAY_OF_YEAR=117,DAY_OF_WEEK=7,DAY_OF_WEEK_IN
_MONTH=4,AM_PM=1,HOUR=3,HOUR_OF_DAY=15,MINUTE=40,SECOND=18,MILLISECOND=634,ZO
NE_OFFSET=28800000,DST_OFFSET=0]  

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

//创建一个代表2019年4月27日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2019, 4 - 1, 27);  //Calender的月份是从0开始的，但日期和年份是从1开始的

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;//Calender的月份是从0开始的，但日期和年份是从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);
//add设置
//把c1对象的日期加上10，也就是c1也就表示为10天后的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, 10);
//把c1对象的日期减去10，也就是c1也就表示为10天前的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, -10);

6.String类

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

1.构造

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)
//分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列

2.创建字符串对象方式

1.直接赋值，创建的对象在方法区的常量池

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

【字符串常量池】
在字符串中，如果采用直接赋值的方式（String str=“Lance”）进行对象的实例化，则会将匿名对象“Lance”放入对象池，每当下一次对不同的对象进行直接赋值的时候会直接利用池中原有的匿名对象，我们可以用对象手工入池；

2.构造方法，对象在堆区

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

【两种实例化方式的区别】
\1. 直接赋值（String str = “hello”）：只开辟一块堆内存空间，并且会自动入池，不会产生垃圾。
\2. 构造方法（String str= new String(“hello”);）:会开辟两块堆内存空间，其中一块堆内存会变成垃圾被系统回收，而且不能够自动入池，需要通过public String intern();方法进行手工入池。
\3. 在开发的过程中不会采用构造方法进行字符串的实例化

3.String常用方法

1.判断

boolean equals(Object obj)：比较字符串的内容是否相同
boolean equalsIgnoreCase(String str)： 比较字符串的内容是否相同,忽略大小写
boolean startsWith(String str)： 判断字符串对象是否以指定的str开头
boolean endsWith(String str)： 判断字符串对象是否以指定的str结尾

2.截取

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

3.转换

char[] toCharArray()：把字符串转换为字符数组
String toLowerCase()：把字符串转换为小写字符串
String toUpperCase()：把字符串转换为大写字符串

4.其他

去除字符串两端空格：String trim()
按照指定符号分割字符串：String[] split(String str)

4.String不可变性

String是个常量，从一出生就注定不可变

java5.0以后出现了一个对象池的概念，Java虚拟机在启动的时候会实例化9个对象池，这9个对象池分别用来存储8种基本类型的包装类对象和String对象，String str = “abc”这样写是从对象池中取abc的对象，如果对象池中已经有了abc这个对象，那么就不会从新给它分配新的空间了，如果这样写String str = new String(“abc”);就会分配新的内存空间。

---

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

【String不可变的好处】

• 可以实现多个变量引用堆内存中的同一个字符串实例，避免创建的开销。
• 我们的程序中大量使用了String字符串，有可能是出于安全性考虑。
• 大家都知道HashMap中key为String类型，如果可变将变的多么可怕。
• 当我们在传参的时候，使用不可变类不需要去考虑谁可能会修改其内部的值，如果使用可变类的话，可能需要每次记得重新拷贝出里面的值，性能会有一定的损失

5.字符串常量池

常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。

---

Class文件中存储所有常量（包括字符串）的table。这是Class文件中的内容，还不是运行时的内容，不
要理解它是个池子，其实就是Class文件中的字节码指令

常量池表Constant_Pool table

运行时常量池 Runtime Constant Pool

字符串常量池String Pool

\1. 在Java Heap（堆）中根据"hello"字面量create一个字符串对象
\2. 将字面量"hello"与字符串对象的引用在hashtable中关联起来键 - 值
形式是：“hello” = 对象的引用地址

另外来说，当一个新的字符串出现在Runtime Constant Pool中时怎么判断需不需要在Java Heap中创建
新对象呢？
策略是这样：会先去根据equals来比较Runtime Constant Pool中的这个字符串是否和String Pool中某
一个是相等的（也就是找是否已经存在），如果有那么就不创建，直接使用其引用；反之，就如同上面
的第三步。

7.StringBuilder和StringBuffer

三者在执行速度方面的比较：StringBuilder > StringBuffer > String //3 11 1073

String类底层使用char，不可变字符序列，字符串常量

private final char value[];

StringBuilder 是一个可变的字符序列。字符串变量，它继承于AbstractStringBuilder，实现了CharSequence接口。 线程不安全，效率高

public StringBuilder() {
    super(16);//  value = new char[capacity];
}

StringBuffer 字符串变量，也是继承于AbstractStringBuilder的子类；线程安全，但效率低

 private transient char[] toStringCache;

对于三者使用的总结：
1）如果要操作少量的数据用 = String
2）单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
3）多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

String str = new String(); //char[] value = new char[0]
String str1 = new String("abc"); //char[] value = new char[]{'a','b','c'}

StringBuffer sb = new StringBuffer();//char[] value = new char[16],默认16字符的数组
System.out.println(sb.length());//返回count不是内存大小
System.out.println(sb.capacity());//容量16
sb.append('a');//value[0]='a';
System.out.println(sb.length());//1
System.out.println(sb.capacity());//容量 16，，当容量不够时扩容2倍+2，同时复制原有数组,如果容量还小，就用新字符非长度

//建议使用带参构造器        StringBuffer(int capacity)  避免后期扩容时复制
StringBuffer sb1 = new StringBuffer("abc");//char[] value = new char["abc".length+16],默认16+length字符的数组
System.out.println(sb1.length());

2.方法

增append()

删delete()

改replace() setCharAt()

查index()//找“ab”第一次出现的位置\

插insert()

---

capacity()//内存大小

length()//字符个数，长度

charAt()//指定位置字符

getChars()

toString()

8.File类

1.构造方法

public File(String pathname)//以pathname为路径创建File对象，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储

2.通过对象访问属性

public boolean canRead()
public boolean exists()
public boolean isFile()
public long lastModified()
public String getName()
public boolean canWrite()
public boolean isDirectory()
public boolean isHidden()
public long length()
public String getPath()

3.通过File对象创建空文件或目录（在该对象所指的文件或目录不存在的情况下）。

public boolean createNewFile()throws IOException
public boolean delete()
public boolean mkdir()， mkdirs()

4.实例

public class TestFile {
    /**
    * File文件类 1.代表文件 2.代表目录
    */
    public static void main(String[] args) {
    File f = new File("d:/src3/TestObject.java");
    File f2 = new File("d:/src3");
    File f3 = new File(f2, "TestFile.java");
    File f4 = new File(f2, "TestFile666.java");
    File f5 = new File("d:/src3/aa/bb/cc/dd");
    //f5.mkdirs();
    f5.delete();
    try {
        f4.createNewFile();
        System.out.println("文件创建成功！");
    } catch (IOException e) {
    	e.printStackTrace();
    } 
    if (f.isFile()) {
    	System.out.println("是一个文件！");
    } 
    if (f2.isDirectory()) {
    	System.out.println("是一个目录！");
    } 
    if (f3.isFile()) {
    	System.out.println("是一个文件奥");
    }