Java基础（3）常用API

常用API

常用包：lang，util，io

1，Object

toString() //返回运行时类类型。
getClass()
equals()
hashCode() //返回对象的哈希码值。
clone() //根据原对象复制一个新对象
//分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象
finalize() //释放资源

wait() //线程休眠
notify() //唤醒在该对象上等待的某个线程
notifyAll() //唤醒该对象上的等待的所有线程

clone与copy的区别

Employee tobby = new Employee(“CMTobby”,5000)
Employee cindy = tobby
这是copy，改变cindy的值，tobby的也会改变。

Employee tom= tobby.clone();
这是clone，是一个新对象，改变cindy的值，tobby的不会改变。

浅拷贝与深拷贝

clone方法执行的是浅拷贝
实现深拷贝：在类中重写clone方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vwEJOUNz-1594542740254)(Java基础.assets/1592879940804.png)]

equals()和==的区别

==判断的是两个对象的引用地址是否相同，即这两个是不是同一个对象。

object类的equals()方法实际上也是使用==实现的，但是Sting和Integer等一些类重写了equals()方法，条件是根据里面的内容判断是否相等。

2，包装类

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

包装类介绍：

基本类型的数据不具备“对象”的特性——不携带属性、没有方法可调用。 沿用它们只是为了迎合人类根深蒂固的习惯，并的确能简单、有效地进行常规数据处理。不支持面向对象编程。

每个包装类的对象可以封装一个相应的基本类型的数据，并提供了其它一些有用的方法。包装类对象一经创建，其内容（所封装的基本类型数据值）不可改变。

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

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

包装类的应用

实现 int 和 Integer 的相互转换、

intValue()

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));

}

将字符串转换为整数

Integer.parseInt()

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 无法转换为整数

将整数转换为字符串

Integer.toString()

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

自动拆箱和装箱

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

总结

1. 所有的包装类都是Number类的子类。

package java.lang;

public abstract class Number implements java.io.Serializable {
	//以下都是拆箱操作，拆成对应的方法返回类型。
    public abstract int intValue();  
    public abstract long longValue();
    public abstract float floatValue();
    public abstract double doubleValue();
    public byte byteValue() {
        return (byte)intValue();
    }
    public short shortValue() {
        return (short)intValue();
    }
    private static final long serialVersionUID = -8742448824652078965L;
}

2. Integer常用方法

//类方法
//1.两数操作
static int max(int a, int b)  //返回两个 int的较大值，就像调用 Math.max一样 。  
static int min(int a, int b)  //返回两个 int的较小值，就像调用 Math.min一样 。  
static int sum(int a, int b)  //根据+运算符将两个整数相加。  

//2.String转int
static int parseInt(String s)  //将字符串参数解析为带符号的十进制整数。  
static int parseInt(String s, int radix)  //将字符串参数解析为第二个参数指定的基数中的有符号整数。 

//3.int转String
static String toString(int i)  //返回一个 String指定整数的 String对象。 
static String toString(int i, int radix)  //返回由第二个参数指定的基数中的第一个参数的字符串表示形式。  
static String toBinaryString(int i)  //在基数2中返回整数参数的字符串表示形式为无符号整数。  
static String toHexString(int i)  //返回整数参数的字符串表示形式，作为16位中的无符号整数。  
static String toOctalString(int i)  //在基数8中返回整数参数的字符串表示形式为无符号整数。  

//4.int转Integer
static Integer valueOf(int i)  //返回一个 Integer指定的 int值的 Integer实例。  
static Integer valueOf(String s)  //返回一个 Integer对象，保存指定的值为 String 。  

//对象方法
//5.两数比较
int compareTo(Integer anotherInteger)  //数字比较两个 Integer对象。 
//6.父类Number中的对象方法。 Integer转int
int intValue()...

3，Math

//1.类属性
Math.PI 记录的圆周率
Math.E 记录e的常量

static double ceil(double a)  //向上取整（4.1 -> 5）  
static double floor(double a) //向下取整（4.8 -> 4） 

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之间的一个随机数

Math.abs //求绝对值
Math.sin //正弦函数 Math.asin 反正弦函数
Math.cos //余弦函数 Math.acos 反余弦函数
Math.tan //正切函数 Math.atan 反正切函数 Math.atan2 商的反正切函数
Math.toDegrees //弧度转化为角度 Math.toRadians 角度转化为弧度

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
}

4，Random

1. 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

2. java.util.Random

Random r1 = new Random(); //默认当前系统时间的毫秒数作为种子数:
Random r1 = new Random(20); //构造Random对象的时候指定种子

//种子数解释：
//你在创建一个Random对象的时候可以给定任意一个合法的种子数，种子数只是随机算法的起源数字，和生成的随机数的区间没有任何关系。

//常用方法 nextInt(10) nextBoolean()
protected int next(int bits)：//生成下一个伪随机数。
boolean nextBoolean()：//返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的boolean值。
void nextBytes(byte[] bytes)：//生成随机字节并将其置于用户提供的 byte 数组中。
double nextDouble()：//返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布的 double值。
float nextFloat()：//返回下一个伪随机数，它是取自此随机数生成器序列的、在0.0和1.0之间均匀分布float值。
double nextGaussian()：//返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的double值，其平均值是0.0标准差是1.0。
int nextInt()：//返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
int nextInt(int n)：//返回一个伪随机数，它是取自此随机数生成器序列的、在（包括和指定值（不包括）之间均匀分布的int值。
long nextLong()：//返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。
void setSeed(long seed)：//使用单个 long 种子设置此随机数生成器的种子。

//案例1
public static void main(String[] args) {
    Random ran1 = new Random(10);
    System.out.println("使用种子为10的Random对象生成[0,10)内随机整数序列: ");
    for (int i = 0; i < 10; i++) {
        System.out.print(ran1.nextInt(10) + " ");
    }
    System.out.println();
    Random ran2 = new Random(10);
    System.out.println("使用另一个种子为10的Random对象生成[0,10)内随机整数序列: ");
    for (int i = 0; i < 10; i++) {
        System.out.print(ran2.nextInt(10) + " ");
    }
    System.out.println("Math.random()");
    for (int i = 0; i < 10; i++) {
        System.out.print((int)(Math.random()*10) + " ");
    }
}

使用种子为10的Random对象生成[0,10)内随机整数序列: 
3 0 3 0 6 6 7 8 1 4 
使用另一个种子为10的Random对象生成[0,10)内随机整数序列: 
3 0 3 0 6 6 7 8 1 4 
Math.random()
4 9 3 1 3 7 8 9 6 3 

//案例2
int n2 = r.nextInt(10); //生成[0,10)区间的整数。
double d1 = r.nextDouble(); //生成[0,1.0)区间的小数。
double d2 = r.nextDouble() * 5; //生成[0,5.0)区间的小数。
double d3 = r.nextDouble() * 1.5 + 1; //生成[1,2.5)区间的小数。

5，Date

//构造方法
Date()  //分配一个 Date对象，并初始化它，以便它代表它被分配的时间，测量到最近的毫秒。  
Date(long date)  //分配一个 Date对象，并将其初始化为表示自称为“时代”的标准基准时间以后的指定毫秒数，即1970年1月1日00:00:00 GMT。  

//常用方法
boolean after(Date date) //若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
boolean before(Date date) //若当调用此方法的Date对象在指定日期之前返回true,否则返回false。

int compareTo(Date date) //比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
int compareTo(Object obj) //若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。

long getTime( ) //返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
void setTime(long time) //用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。

Object clone( )  //返回此对象的副本。
boolean equals(Object date) //当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
int hashCode( )  //返回此对象的哈希码值。
String toString( ) //把此 Date 对象转换为以下形式的 String： 
// dow mon dd hh:mm:ss zzz yyyy --> 星期 月份 几号 时:分:秒 时区 年份
// Sat Apr 27 15:09:43 CST 2019

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
 }

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

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

SimpleDateFormat

SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。

public static void main(String[] args){
    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date = new Date();
    String s = format.format(date);
    System.out.println(s);
	//2020-06-23 15:19:35
}

// yyyyy完整年份 yy年份后两位
// MM月份 mm分钟
// HH24小时 hh12小时

//SimpleDateFormat函数语法：
  G 年代标志符
  y 年
  M 月
  d 日
  h 时 在上午或下午 (1~12)
  H 时 在一天中 (0~23)
  m 分
  s 秒
  S 毫秒
  E 星期
  D 一年中的第几天
  F 一月中第几个星期几
  w 一年中第几个星期
  W 一月中第几个星期
  a 上午 / 下午 标记符
  k 时 在一天中 (1~24)
  K 时 在上午或下午 (0~11)
  z 时区

使用printf格式化日期

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

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

    // %tc -> 星期二 六月 23 15:35:18 CST 2020
    System.out.printf("全部日期和时间信息：%tc%n",date);

    // %tF -> 2020-06-23
    System.out.printf("年-月-日格式：%tF%n",date);

    // %tD -> 06/23/20
    System.out.printf("月/日/年格式：%tD%n",date);

    // %tr -> 03:35:18 下午
    System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date);

    // %tT -> 15:35:18
    System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date);

    // %tR -> 15:35
    System.out.printf("HH:MM格式（24时制）：%tR",date);
}

Calendar

作用：用于操作日历字段，设置和获取日期数据的特定部分：小时，日，或者分钟。

public static void main(String[] args){
    Calendar instance = Calendar.getInstance();
    System.out.println(instance);
}
/*java.util.GregorianCalendar[
time=1592898627406,areFieldsSet=true,areAllFieldsSet=true,
lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",
offset=28800000,dstSavings=0,useDaylight=false,transitions=29,lastRule=null],
firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=5,WEEK_OF_YEAR=26,WEEK_OF_MONTH=4,
DAY_OF_MONTH=23,DAY_OF_YEAR=175,DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,
HOUR=3,HOUR_OF_DAY=15,MINUTE=50,SECOND=27,MILLISECOND=406,ZONE_OFFSET=28800000,DST_OFFSET=0]
*/

常用方法

static Calendar getInstance()  //使用默认时区和区域设置获取日历。 
abstract void add(int field, int amount) //根据日历的规则，将指定的时间量添加或减去给定的日历字段。  
void set(int year, int month, int date)  //根据特定日期设置Calendar对象  
void set(int year, int month, int date, int hourOfDay, int minute)  
void set(int year, int month, int date, int hourOfDay, int minute, int second)  
int get(int field) //返回给定日历字段的值。可使用下面的类字段，也可直接输入int

类字段

Calendar.YEAR //年份(1)
Calendar.MONTH //月份(2) 1月~12月 -> 0~11
Calendar.DATE //日期(5)
Calendar.DAY_OF_MONTH //日期(5)，和上面的字段意义完全相同
Calendar.HOUR //12小时制的小时(10)
Calendar.HOUR_OF_DAY //24小时制的小时(11)
Calendar.MINUTE //分钟(12)
Calendar.SECOND //秒(13)
Calendar.DAY_OF_WEEK //星期日~星期六(7) -> 1~7

演示案例

Calendar instance = Calendar.getInstance();
instance.set(1994,0,23); 
//获得指定日期的Calender对象，如果不设置就是当前时间
//1994年1月23日
int month = instance.get(Calendar.MONTH); //输出0，1月
int date = instance.get(Calendar.DATE); //输出23
int date2 = instance.get(Calendar.DAY_OF_MONTH); //输出23
int week = instance.get(7); //等价于DAY_OF_WEEK，输出1，星期日

Calendar c1 = Calendar.getInstance();
c1.set(2009, 6 - 1, 12); //把Calendar对象c1的年月日分别设这为：2009、6、12
c1.set(Calendar.DATE,10); //设置为10号
c1.set(Calendar.YEAR,2008); //设置为2008年

c1.set(2017, 2, 1); //输出2017-2-1 -> 2017年3月1日
c1.set(2017, 2, 0); //输出2017-1-28 -> 2017年2月28日。
//date为0代表上个月最后一天
instance.set(1994,0,0); //输出1993 11 31 ->代表1993年12月31号

c1.add(Calendar.DATE, 10);
//把c1对象的日期加上10，也就是c1也就表示为10天后的日期
c1.add(Calendar.DATE, -10);
//把c1对象的日期减去10，也就是c1也就表示为10天前的日期

GregorianCalendar

public class GregorianCalendar extends Calendar
GregorianCalendar是Calendar的具体子类 ，并提供了世界上大多数国家使用的标准日历系统。

//该类特定方法
public boolean isLeapYear(int year) //确定给定年份是否是闰年

public static void main(String[] args) {

    String months[] = {
        "Jan", "Feb", "Mar", "Apr",
        "May", "Jun", "Jul", "Aug",
        "Sep", "Oct", "Nov", "Dec"};

    int year;

    // 初始化 Gregorian 日历
    // 使用当前时间和日期
    // 默认为本地时间和时区
    GregorianCalendar gcalendar = new GregorianCalendar();
    // 显示当前时间和日期的信息
    System.out.print("Date: ");
    System.out.print(months[gcalendar.get(Calendar.MONTH)]);
    System.out.print(" " + gcalendar.get(Calendar.DATE) + " ");
    System.out.println(year = gcalendar.get(Calendar.YEAR));
    System.out.print("Time: ");
    System.out.print(gcalendar.get(Calendar.HOUR) + ":");
    System.out.print(gcalendar.get(Calendar.MINUTE) + ":");
    System.out.println(gcalendar.get(Calendar.SECOND));
    // 测试当前年份是否为闰年
    if (gcalendar.isLeapYear(year)) {
        System.out.println("当前年份是闰年");
    } else {
        System.out.println("当前年份不是闰年");
    }

}
//Date: Jun 23 2020
//Time: 4:26:3
//当前年份是闰年

6，String

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

查看String源码

public final class String implements 
java.io.Serializable, Comparable<String>, CharSequence {
    //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类的值是final类型的，不能被改变的，所以只要一个值改变就会生成一个新的String类型对象，存储String数据也不一定从数组的第0个元素开始的，而是从offset所指的元素开始。

构造方法

String() //初始化一个新创建的 String 对象，使其表示一个空字符序列。
String(StringBuffer buffer) 
//分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。
String(StringBuilder builder) 
//分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。

String(byte[] bytes)
//通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
String(byte[] bytes, Charset charset) 
String(byte[] bytes, int offset, int length) 
String(byte[] bytes, int offset, int length, Charset charset) 
String(byte[] bytes, int offset, int length, String charsetName) 
String(byte[] bytes, String charsetName) 
String(char[] value) 
String(char[] value, int offset, int count) 
String(int[] codePoints, int offset, int count) 
String(String original) 

创建String对象方法

String str="hello"; //直接赋值的方式，放在方法区的常量池
String str=new String("hello"); //实例化的方式，放在堆内存

案例

public static void main(String[] args) {
    String str1 = "Lance";
    String str2 = new String("Lance");
    String str3 = str2; //引用传递，str3直接指向st2的堆内存地址
    String str4 = "Lance";
    /**
     *  ==:
     * 基本数据类型：比较的是基本数据类型的值是否相同
     * 引用数据类型：比较的是引用数据类型的地址值是否相同
     * 所以在这里的话：String类对象==比较，比较的是地址，而不是内容
     */
    System.out.println(str1==str2);//false
	System.out.println(str1==str3);//false
	System.out.println(str3==str2);//true
	System.out.println(str1==str4);//true
}

避免空指向

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

String str = null;
//此时会出现空指向异常
if(str.equals("hello")){
  ...
}
//此时equals会处理null值，可以避免空指向异常
if("hello".equals(str)){
...
}

常用方法

//1.查询操作
int length() //返回此字符串的长度。  
int indexOf(int ch)  //返回指定字符第一次出现的字符串内的索引。  
	int indexOf(int ch, int fromIndex) //以指定的索引开始搜索。  
	int indexOf(String str)   
	int indexOf(String str, int fromIndex) 
int lastIndexOf(int ch) //返回指定字符的最后一次出现的字符串中的索引。  
	int lastIndexOf(int ch, int fromIndex) //从指定的索引开始向后搜索。  
	int lastIndexOf(String str)  
	int lastIndexOf(String str, int fromIndex) 
char charAt(int index) //返回 char指定索引处的值。 

//2.转换操作
char[] toCharArray() //将此字符串转换为新的字符数组。 
static String valueOf(boolean b) //返回 boolean参数的字符串 boolean形式。   
	// 参数类型：char，char[]，double，float，int，long，Object
String toLowerCase() //全转为小写。  
String toUpperCase() //全转为大写。  

//3.替换与去除
String replace(char oldChar, char newChar) //替换全部
	String replaceAll(String regex, String replacement) //使用正则表达式替换全部
	String replaceFirst(String regex, String replacement) //使用正则替换第一个 
String trim() //删除原字符串前后空格 

//4.截取与分割
String[] split(String regex) //根据正则表达式分割
String substring(int beginIndex) //截取索引beginIndex后的所有字符。
String substring(int beginIndex, int endIndex)  //截取限定范围内的子字符串  

//5.判断操作
boolean equals(Object anObject) //判断内容是否相等  
	boolean equalsIgnoreCase(String anotherString) //忽略大小写
boolean startsWith(String prefix) //判断是否以字符串prefix开头  
	boolean startsWith(String prefix, int toffset) //判断在索引toffset处是否以字符串prefix开头
boolean endsWith(String suffix) //判断是否以字符串suffix结尾
boolean contains(CharSequence s) //是否包含s子字符串
boolean isEmpty() //length()是否为0  

//6.连接操作
String concat(String str) //返回和原字符串拼接后的新字符串  

String的不可变性

public static void main(String[] args) {
    String a = "abc";
    String b = "abc";
    String c = new String("abc");
    System.out.println(a==b);   //true
    System.out.println(a.equals(b));   //true
    System.out.println(a==c);   //false
    System.out.println(a.equals(c));   //true
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jNBUa2o4-1594542740256)(Java基础.assets/1592908385872.png)]

不可变性的好处：

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

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

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

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

7，StringBuilder和StringBuffer

StringBuilder和StringBuffer都是可变的字符序列。它们继承于AbstractStringBuilder，实现了CharSequence接口。

区别：StringBuilder非线程安全，StringBuffer线程安全。

常用方法

//1.追加到末尾
StringBuilder append(String str) //追加到原字符串的尾部
StringBuilder appendCodePoint(int codePoint) //将Unicode编码的字符串追加到尾部。 
	appendCodePoint(0x5b57);    // 0x5b57是“字”的unicode编码

//2，在尾部插入
StringBuilder insert(int offset, String str) //往指定offset位置插入字符串 

//3.替换
StringBuilder replace(int start, int end, String str) //[start,end)范围内的字符串替换为str

//4.删除
StringBuilder delete(int start, int end) //[start,end)范围内的字符串删除
StringBuilder deleteCharAt(int index) //删除指定位置index的字符

//5.查询  
char charAt(int index) //查询index位置的字符
int length() //返回字符串长度
int indexOf(String str) //查询str第一次出现的位置。 
	int indexOf(String str, int fromIndex) //从指定的索引开始。  
int lastIndexOf(String str) //查询str最后一次出现的位置。
	int lastIndexOf(String str, int fromIndex)  

//6.其他
StringBuilder reverse() //字符串翻转  
void setCharAt(int index, char ch) //修改指定索引的字符为ch 
void setLength(int newLength) //修改字符串长度，多余的将删除
CharSequence subSequence(int start, int end) //获取[start,end)范围内的子字符串
String substring(int start) // 从start开始到结尾获取子字符串
String substring(int start, int end) 获取[start,end)范围内的子字符串

8，String、StringBuffer、StringBuilder之间的区别

• String 字符串常量

• StringBuffer 字符串变量（线程安全）

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

三者速度

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

解释：

String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象。

所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

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

为什么是大多数情况呢？

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

1. String S1 = “This is only a” + “ simple” + “ test”;

2. StringBuffer Sb = new StringBuilder(“This is only a”).append(“simple”).append(“ test”);

你会很惊讶的发现，生成 String S1 对象的速度简直太快了，而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏，在 JVM 眼里，这个String S1 = “This is only a” + “ simple” + “test”;其实就是：String S1 = “This is only a simple test”;

所以当然不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的 String 对象的话，速度就没那么快了，譬如：

1. String S2 = “This is only a”;

2. String S3 = “ simple”;

3. String S4 = “ test”;

大部分情况下StringBuilder的速度要大于StringBuffer：

java.lang.StringBuilder一个可变的字符序列是5.0新增的。（大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的）此类提供一个与 StringBuffer兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer 要快。两者的方法基本相同。

对于三者使用的总结：

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

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

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

面试题：

StringBuilder与StringBuffer的区别，StringBuilder与String的区别？

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

2）String是不可变字符串，StringBuilder是可变字符串。

3）如果是简单的声明一个字符串没有后续过多的操作，使用String。
若后续对字符做频繁的添加，删除操作，或者是在循环当中动态的改变字符穿的长度应该用StringBuilder。
若后续对字符做频繁的添加，删除操作，并且要保证线程安全，使用StringBuffer。

9，File

分割符问题(separator)：

不同操作系统下文件分隔符：windows中是“\”，linux中是“/”。但事实上，无论是windows中还是linux中，永远写“/”都没有问题。
另在windows下若要用"\"，需写作"\\"，因为"\"是转义字符，故"\\"代表"\"。

//类属性
static String pathSeparator  //与系统相关的路径分隔符字符，为方便起见，表示为字符串。  
static char pathSeparatorChar //与系统相关的路径分隔符。  
static String separator //当前系统的路径分隔符。  
static char separatorChar //当前系统的路径分隔符。
// 1,2行输出\ 
// 3,4行输出;

//构造方法 
File(String pathname) //通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。  
File(String parent, String child) //从父路径名字符串和子路径名字符串创建新的 File实例。
File(File parent, String child) //从父抽象路径名和子路径名字符串创建新的 File实例。    
File(URI uri) //通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。 

//常用方法
boolean canRead() //测试应用程序是否可以读取由此抽象路径名表示的文件。
boolean canWrite() //测试应用程序是否可以修改由此抽象路径名表示的文件。
boolean exists() //测试此抽象路径名表示的文件或目录是否存在。
boolean isFile() //测试此抽象路径名表示的文件是否为普通文件。
boolean isDirectory() //测试此抽象路径名表示的文件是否为目录。 
boolean isHidden() //测试此抽象路径名命名的文件是否为隐藏文件。   
long lastModified() //返回此抽象路径名表示的文件上次修改的时间。 
String getName() //返回由此抽象路径名表示的文件或目录的名称。
String getPath() //将此抽象路径名转换为路径名字符串。 
File getParentFile() //返回此抽象路径名的父，或抽象路径名 null如果此路径名没有指定父目录。  
boolean createNewFile() //当且仅当具有该名称的文件尚不存在时，创建一个由该抽象路径名命名的新的空文件。
boolean delete() //删除由此抽象路径名表示的文件或目录。 
boolean mkdir() //创建由此抽象路径名命名的目录。  
boolean mkdirs() //创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录。

//案例
import java.io.File;
import java.io.IOException;

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("是一个文件奥");
        }
	}
}