Java高级特性第3节 java中常用的实用类(2)

§String类

一、创建字符串对象

采用字面值的方式赋值：String s = "abc";
用new关键字：String s = new String("vfggkf");
2种创建对象方式比较：

字符串常量池是java堆内存中一个特殊的存储区域，当创建一个String对象，假如此字符串值已经存在于常量池中，则不会创建一个新的对象，而是引用已经存在的对象。
String s1 = "abc";
String s2 = "abc";
在java中内存分为堆内存和栈内存，堆内存存放的是对象，栈内存存储对象的引用，字符串“ABC”存放在堆内存中，而s1,s2作为对象的引用则存放在栈内存中，原理如下：
　　　　　　堆内存       栈内存
 String对象  "ABC"<------ s1  String变量的引用
　　　　　　　　　 ↑<------ s2
1）String s = new String("vfggkf")：  此时创建了2个对象：用new调用了String类的构造器方法创建了一个对象，构造器方法接受的参数"vfggkf"也是一个String对象；
2）String s = "abc"：  此时创建了一个String对象“abc”；
3）String a="hello";  String b="hello";  此时创建了还是一个对象，因为相当于把字符串常量池中“hello”的引用分别赋给a和b；
4）String a="wor"+"ld";  此时创建了3个对象"wor"，"ld"，“world”；

二、String字符串的常用方法

　　1、length() 字符串的长度
　　　　例：char chars[]={'a','b'.'c'};
　　　　String s=new String(chars);
　　　　int len=s.length();
　　2、charAt() 截取一个字符
　　　　例：char ch;
　　　　ch="abc".charAt(1); 返回'b'
　　3、 getChars() 截取多个字符
　　　　void getChars(int sourceStart,int sourceEnd,char target[],int targetStart)
　　　　sourceStart指定了子串开始字符的下标，sourceEnd指定了子串结束后的下一个字符的下标。因此，子串包含从sourceStart到sourceEnd-1的字符。接收字符的数组由target指定，target中开始复制子符串的下标值是targetStart。
　　　　例：String s="this is a demo of the getChars method.";
　　　　char buf[]=new char[20];
　　　　s.getChars(10,14,buf,0);
　　4、getBytes()
　　　　替代getChars()的一种方法是将字符存储在字节数组中，该方法即getBytes()。
　　5、toCharArray() :

　　　　例：String Str = new String("www.runoob.com");

　　　　　　System.out.print("返回值 :" );

　　　　　　System.out.println( Str.toCharArray() );

　　6、equals()和equalsIgnoreCase() 、==比较两个字符串

　　　　♦==：比较引用类型，比较的是地址值是否相同　

　　　　♦equals: 比较引用类型默认也是比较地址值是否相同，而String类重写了equals()方法，比较的是内容是否相同

　　　　♦equalsIgnoreCase(): 比较的是内容（不区分大小写）是否相同

String hello="hello world";
String xx=new String("hello world");
String yy="hello world";
//输出判断内存地址是否相等
System.out.println("xx==hello : "+ (xx==hello));   //false
System.out.println("yy==hello : "+ (yy==hello)+"\n")  //true

System.out.println("yy.equals(xx) : "+ (yy.equals(xx))+"\n") //true

　　7、regionMatches() 用于比较一个字符串中特定区域与另一特定区域，它有一个重载的形式允许在比较中忽略大小写。

　　　　boolean regionMatches(int startIndex,String str2,int str2StartIndex,int numChars)
　　　　boolean regionMatches(boolean ignoreCase,int startIndex,String str2,int str2StartIndex,int numChars)
　　8、startsWith()和endsWith(): startsWith()方法决定是否以特定字符串开始，endWith()方法决定是否以特定字符串结束
　　9、compareTo()和compareToIgnoreCase() ：比较字符串
　　10、indexOf()和lastIndexOf()
　　　　indexOf() 查找字符或者子串第一次出现的地方。
　　　　lastIndexOf() 查找字符或者子串是后一次出现的地方。

　　11、substring()：它有两种形式，第一种是：String substring(int startIndex)
　　　　第二种是：String substring(int startIndex,int endIndex)

　　12、concat() 连接两个字符串："我的名字是 ".concat("Runoob");

　　13、replace() 替换：它有两种形式，
　　　　第一种形式用一个字符在调用字符串中所有出现某个字符的地方进行替换：
　　　　String replace(char original,char replacement)

　　　　例如：String s="Hello".replace('l','w');
　　　　第二种形式是用一个字符序列替换另一个字符序列，形式如下：
　　　　String replace(CharSequence original,CharSequence replacement)
　　14、trim() ：去掉起始和结尾的空格
　　15、valueOf() ：转换为字符串
　　16、toLowerCase() ：转换为小写
　　　　toUpperCase() ：转换为大写

三、StringBuffer类和StringBuilder类

StringBuffer类处理字符串
StringBuffer类是Java提供的用于处理字符串的一个类，比String更高效地存储字符串的一种引用数据类型。特别是对字符串进行连接操作时可以大大提高程序的执行效率。
1）如何使用StringBuffer类
　　此类位于java.util包中，是String的增强类。例如：StringBuffer sb = new StringBuffer("十步杀一人，千里不留行")；
2）常用方法：
　　toString() 将StringBuffer类的符串转换成String类型的字符串，例如：String s1 = sb.toString();
append() 将参数连接到字符串后并返回（注意，String类的concat()方法只能追加String类型的字符串，而StringBuffer类的append()方法可以将任何类型的值追加到字符串之后）
insert() 将参数插入到指定位置后并返回，参数可以是包括String的任何类型：字符串.insert(位置，参数)
```
package cn.UtilTest;
import java.util.*;
 
public class SbAppend {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer("青春无悔");
        int num = 666;
        //在字符串后面追加字符串
        StringBuffer stringBuffer1 = stringBuffer.append("，我心永恒");
        System.out.println(stringBuffer1);
        //在字符串后面追加字符串
        StringBuffer stringBuffer2 = stringBuffer1.append("，啊！");
        System.out.println(stringBuffer2);
        //在字符串后面追加数字
        StringBuffer stringBuffer3 = stringBuffer2.append(num);
        System.out.println(stringBuffer3);
 
    }
}
```
使用StringBuilder类处理字符串

　　java.lang.StringBuilder是JDK 5.0新增的类，他是一个可变的字符序列。他被设计为StringBuffer的一个简易替换，在大多数实现中，它比StirngBuffer执行要快。使用StringBulider处理字符串的方法与StringBuffer基本一样。

String和StringBuffer、StringBuilder类区别

　　1.String的不变性：String是不可变对象，当字符串string在内存中创建后，就不会再改变，所以对该字符串进行的所有改变操作，实际上没有改变原来的字符串，每一次的修改操作都会生成一个新的字符串，慢慢地消耗了内存。所以经常改变内容的字符串最好不要用Stirng类型。

　　2.StringBuilder和StringBuffer的方法是一样（可以说是等价的），区别是StringBuffer是线程安全的，StringBuilder是单线程的，不提供同步，理论上效率更高，StringBuffer的方法前面有synchronized关键字修饰。

　　StringBuffer线程同步，所以使用起来比较安全，但是效率较低主要是多线程和操作比较频繁时有所体现。

　　StringBuilder正好相反不同步，效率高，但是多线程使用时可能会有问题。

　　由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

　　3.字符串经常要做出修改（拼接，删除等等），那么使用StringBuffer或者StringBuilder比较好，可以在完成操作后使用toString方法转换为String类。

　　4.常用方法可参考w3school，这里是StringBuffer 的一些常用方法

方法	说明
append()	使用 append() 方法可以将其他 Java 类型数据转化为字符串后再追加到 StringBuffer 的对象中。
insert(int index, String str)	insert() 方法将一个字符串插入对象的字符序列中的某个位置。
setCharAt(int n, char ch)	将当前 StringBuffer 对象中的字符序列 n 处的字符用参数 ch 指定的字符替换，n 的值必须是非负的，并且小于当前对象中字符串序列的长度。
reverse()	使用 reverse()方法可以将对象中的字符序列翻转。
delete(int n, int m)	从当前 StringBuffer 对象中的字符序列删除一个子字符序列。这里的 n 指定了需要删除的第一个字符的下标，m 指定了需要删除的最后一个字符的下一个字符的下标，因此删除的子字符串从 n~m-1。
replace(int n, int m, String str)	用 str 替换对象中的字符序列，被替换的子字符序列由下标 n 和 m 指定。

Test.java 文件代码：
public class Test{
  public static void main(String args[]){
    StringBuffer sBuffer = new StringBuffer("yyy：");
    sBuffer.append("www");
    sBuffer.append(".baidu");
    sBuffer.append(".com");
    System.out.println(sBuffer);
  }
}
结果：yyy：www.baidu.com

§Number & Math 类

一、包装类

　　实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。Integer、Long、Byte、Double、Float、Short）是抽象类 Number 的子类，Character和Boolean是Object的子类。

public class Test{
   public static void main(String args[]){
      Integer x = 5;    //自动根据数值创建对应的 Integer对象，这就是装箱。
      int y =  x + 10;    //自动将包装类型x转换为基本数据类型
      System.out.println(y);
   }
}
结果：15
当 x 被赋为整型值时，由于x是一个对象，所以编译器要对x进行装箱。然后，为了使x能进行加运算，所以要对x进行拆箱。

二、Math 类

　　Math类是一个很有用的数学帮助类，使用也非常简单，这个类比较特殊，首先他和String类一样都是用final修饰，所以不能有子类，还有就是它的构造方法是私有的，也就是我们不能通过new的方法在其它类中构造Math对象，但它的所有的方法都是静态方法，也就是可以直接使用类名.方法名调用。

方法	说明	例子
xxxValue()	将 Number 对象转换为xxx数据类型的值并返回。	Integer x = 5; // 返回 byte 原生数据类型 System.out.println( x.byteValue() );
compareTo()	将number对象与参数比较。如果指定的数与参数相等返回0。如果指定的数小于参数返回 -1。如果指定的数大于参数返回 1。	Integer x = 5; System.out.println(x.compareTo(3)); //-1 System.out.println(x.compareTo(5)); //0 System.out.println(x.compareTo(8)); //1
equals()	判断number对象是否与参数相等。	Integer x = 5; Integer y = 10; Integer z =5; Short a = 5; System.out.println(x.equals(y)); //false System.out.println(x.equals(z)); //true System.out.println(x.equals(a)); //false
valueOf()	返回一个 Number 对象指定的内置数据类型	Integer x =Integer.valueOf(9); Double c = Double.valueOf(5); Float a = Float.valueOf("80"); Integer b = Integer.valueOf("444",16); // 使用16进制 System.out.println(x); // System.out.println(c); //5.0 System.out.println(a); //80.0 System.out.println(b); //
toString()	以字符串形式返回值。	Integer x = 5; System.out.println(x.toString()); // System.out.println(Integer.toString(12)); //
parseInt()	将字符串解析为int类型。	int x =Integer.parseInt("9"); double c = Double.parseDouble("5"); int b = Integer.parseInt("444",16); System.out.println(x); // System.out.println(c); //5.0 System.out.println(b); //
abs()	返回参数的绝对值。	float f = -90; System.out.println(Math.abs(f)); //90.0
ceil()	返回大于等于( >= )给定参数的的最小整数。	double d = 100.675; System.out.println(Math.ceil(d)); //101.0
floor()	返回小于等于（<=）给定参数的最大整数。	double d = 100.675; System.out.println(Math.floor(d)); //100.0
rint()	返回与参数最接近的整数。返回类型为double。	double d = 100.675; System.out.println(Math.rint(d)); //101.0
round()	它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整。	Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
min()	返回两个参数中的最小值。	System.out.println(Math.min(12.123, 12.456)); //12.123
max()	返回两个参数中的最大值。	System.out.println(Math.min(12.123, 12.456)); //12.456
pow()	返回第一个参数的第二个参数次方。	System.out.printf(Math.pow(3, 2)); //9
sqrt(）	求参数的算术平方根。	System.out.printf(Math.sqrt(4)); //2
random()	返回一个随机数，随机数范围为 0.0 =< Math.random < 1.0。	import java.util.Random; public class RandomTest{ public static void main(String[] args){ Random rand=new Random(); int i=(int)(Math.random()*100); // 生成0-100的随机数，不包括100 int j=rand.nextInt(100); // 这里是一个方法的重载，参数的内容是指定范围 System.out.println("i:"+i+"\nj:"+j); // 分别输出两个随机数 } } 编译执行，输出结果类似如下： i:55 j:34

§Date 和 SimpleDateFormat 类

一、Date类：java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。

　　1.第一个构造函数使用当前日期和时间来初始化对象。Date( )；

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

import java.util.Date;
public class DateDemo {
   public static void main(String args[]) {
       // 初始化 Date 对象
       Date date = new Date();
       // 使用 toString() 函数显示日期时间
       System.out.println(date.toString());   //返回例如  Mon May 04 09:51:52 CDT 2018

} }

　　2.常用方法

方法	说明	例子
long getTime( )	返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
void setTime(long time)	用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
String toString( )	把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

二、使用 SimpleDateFormat 格式化日期

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

import  java.util.*;   //导包
import java.text.*;
public class DateDemo {
   public static void main(String args[]) {
      Date dNow = new Date( );
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");   //其中 yyyy 是完整的公元年，MM 是月份，dd 是日期，HH:mm:ss 是时、分、秒。
　　　 //SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月d日 E a");
      System.out.println("当前时间为: " + ft.format(dNow));     //当前时间为: 2018-09-06 10:16:34

} }

　　日期和时间模式字符串：

字母	日期或时间元素	例子
G	Era 标志符	AD
Y	年	2018或18
m	年中的月份	`July`; `Jul`; `07`
w	年中的周数	24
W	月份中的周数	2
D	年中的天数	150
d	月份中的天数	10
F	月份中的星期	2
E	星期中的天数	`Tuesday`; `Tue`
a	Am/pm 标记	PM
H	一天中的小时数（0-23)	15
k	一天中的小时数（1-24）	24
K	am/pm 中的小时数（0-11)	10
h	am/pm 中的小时数（1-12）	2
m	小时中的分钟数	30
s	分钟中的秒数	50
S	毫秒数	999
z	时区	`Pacific Standard Time`; `PST`; `GMT-11:00`
Z	时区	-0900

　　常用模式字符串：

日期和时间模式	例子
"K:mm a, z"	0:08 PM, PDT
"yyyy.MM.dd G 'at' HH:mm:ss z"	2001.07.04 AD at 12:08:56 PDT
"yyyyy.MMMMM.dd GGG hh:mm aaa"	02001.July.04 AD 12:08 PM
"EEE, MMM d, ''yy"	Wed, Jul 4, '01
"EEE, d MMM yyyy HH:mm:ss Z"	Wed, 4 Jul 2001 12:08:56 -0700
"h:mm a"	12:08 PM
"yyMMddHHmmssZ"	010704120856-0700
"hh 'o''clock' a, zzzz"	12 o'clock PM, Pacific Daylight Time
"yyyy-MM-dd'T'HH:mm:ss.SSSZ"	2001-07-04T12:08:56.235-0700

§Character 类

　　1.Character 类用于对单个字符进行操作，Character 类在对象中包装一个基本类型 char 的值；　　

char ch = 'a';
// Unicode 字符表示形式
char uniChar = '\u039A';
// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };
 
// 使用Character的构造方法创建一个Character类对象，原始字符 'a' 装箱到 Character 对象 ch 中
Character ch = 'a';
// 原始字符 'x' 用 test 方法装箱
// 返回拆箱的值到 'c'
char c = test('x');

　　2.转义字符和常用方法

§Calender类

　　Calender是一个抽象类，它是所有日历的模板，并提供了一些所有日期通用的方法；它本身不能直接实例化，但它提供了几个静态的getInstance()方法来获取Calender对象。

　　1.public static Calendar getInstance() ：实例化，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR （使用get，set方法获取或者修改这些字段）等日历字段之间的转换提供了一些方法。

　　2.public abstract void add(int field,int amount): 根据日历的规则，为给定的日历字段添加或减去指定的时间量，这个方法常用

　 3.public final void set(int year, int month,int date)：设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值

　　4.get(int field) ：获取日期或时间
　　　　注:例2014-1-1 15:03
　　　　　 get(Calender.HOUR) 获取到的结果为 3 ---12小时制
　　　　　 get(Calender.HOUR_OF_DAY）获取到的结果为15 ---24小时制

　　5.getTime()：Calender 转换为 Date

import java.util.*;   //导包
　　import java.text.*;
　　public class Calendar _Test{
　　　　public static void main(String[] args){
　　　　　　String[ ] week = {"日","一","二","三","四","五","六"};
　　　　　　String[ ] month = {"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};
　　　　　　//获取一个Calender类的实例。
　　　　　　Calendar c = Calendar.getInstance();  //创建为当前的时间
　　　　　　/*//设置时间 　　　　　　
　　　　　　calendar.set(2018, 01, 25, 0, 0, 0);
　　　　　　//时间加5五个月
　　　　　　calendar.add(Calendar.MONTH, 5);
　　　　　　//减去9个月
　　　　　　calendar.add(Calendar.MONDAY, -9);
　　　　　　*//将Clender转换为Date 　　　　　　
　　　　　　Date date = calendar.getTime(); 　　　　　　
　　　　　　System.out.println(date);
　　　　　　//将Date格式化
　　　　　　SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
　　　　　　System.out.println(format.format(date));*/
　　　　　　//获取周中的星期几，并用中文表示，利用数组week 在week数组中获得中文表示
　　　　　　int dayOfWeek = c.get(Calendar.DAY_OF_WEEK);
　　　　　　//获得日历字段中的月，也表示用中文表示，利用数组month获得中文表示
　　　　　　int monthOfYear= c.get(Calendar.MONTH);
　　　　　　//获得完整的时间，并打印。
　　　　　　System.out.println(c.get(Calendar.YEAR)+"年"+month[monthOfYear]+c.get(Calendar.DAY_OF_MONTH)+"日"+"星期"+week[dayOfWeek]);
　　　　}
　　}
 
　　结果:     2019年二月5日 星期二