实用类

包装类

int  i = 10;

String  s = “abc”;

Student   stu = new Student(“张三”, 18, 95.0);

一方面出于性能方面的考虑，java为数值使用基本类型，而不是对象。基本类型不是对象层次的组成部分，它们不继承Object。

另一方面有时需要创建表示基本类型的对象，例如集合类只处理对象。为了在对象中存储基本类型，需要将基本类型包装到一个类中，为此Java为8种基本数据类型分别提供了对应的包装类。本质上这些类将基本类型包装到一个类中，因此通常将它们称为类型包装器。包装器类位于Java.lang包中。

如何创建对象(构造器)，有哪些功能（方法）可以使用

八个包装类

Byte  Short  Integer Long  Float  Double Character  Boolean

byte   short    int       long   float   double      char        boolean

 示例：

inti = 10;

IntegeriObj = new Integer(10);

数值类型的包装器类

1、构造器

所有数值类型包装器都定义了用于从给定数值或数值的字符串表示形式构造对象的构造函数，例如，下面是为Integer定义的构造器：

Integer(int  num)

Integer(String  str)

如果str没有包含有效的数字值，则会抛出NumberFormatException异常。

对于Byte、Short、Integer、Long、Double类都具有两个构造器，其中一个构造器的参数为相应的数值类型、另外一个构造器的参数为字符串。

Float是个例外，有三个构造器，其中一个构造器的参数类型为double。

2、从包装器对象中提取数值

最常用类型的包装器是那些表示数值的包装器。包括Byte、Short、Integer、Long、Float以及Double。所有这些数值类型包装器都继承自抽象类Number。Number声明了以不同数字格式从对象返回数值的方法，如下所示：

byte  byteValue( )

double doubleValue( )

float floatValue( )

int intValue( )

long longValue( )

short  shortValue( )

3、将包装器对象转换成字符串

类型包装器都重写了toString()方法，该方法可以将数值转换成字符串形式。

//toString()方法的重载形式

String  str = Integer.toString(100);

自动装箱与自动拆箱

1. 自动装箱是这样一个过程，只要需要基本类型的对象，就自动将基本类型自动封装(装箱)进与之等价的类型包装器中，而不需要明确地构造对象。
2. 自动拆箱是当需要时自动抽取(拆箱)已装箱对象数值的过程。不需要调用intValue()或doubleValue()这类方法。

自动装箱和自动拆箱特性极大地简化了一些算法的编码，移除了单调乏味的手动装箱和拆箱数值操作。它们还有助于防止错误。此外，它们对于泛型非常重要，因为泛型只能操作对象。最后，集合框架需要利用自动装箱特性进行工作。

数值与字符串之间形式的转换

最常见的编程杂务之一是将数值的字符串表示形式转换成数值。数值类型的包装器类为此提供了相应的方法。例如：

• Integer类的parseInt()方法
• Long类的parseLong()方法
•  Double类的parseDouble()方法

String    to  value示例：

intI = Integer.parseInt(“100”);

doubled = Double.parseDouble(“12.3”);

Value  to String示例：

int i = 100;

Integer objI = i;  //自动装箱

String str1 = objI.toString();     //第一种方法

String str2 = Integer.toString(i);  //第二种方法

String str3 = String.valueOf(i);   //第三种方法
 
String str4 = i + "";             //第四种方法：投机取巧的方法

数值类型包装器类中其他常用的常量和方法

Integer.MAX_VALUE//java中int的最大值2147483647

Integer.MIN_VALUE//java中int的最大值-2147483648

Integer.SIZE  //长度，多少bit  32位

注意数值包装器的valueOf()方法的功能，例如：

Integer.valueOf(100);    //根据整数创建Integer对象

Integer.valueOf("100");  //根据字符串创建Integer对象

Character包装器

Character是char类型的包装器。Character的构造函数为：

Character(char ch)

其中，ch指定了将由即将创建的Character对象包装的字符。

为了获取Character对象中的char数值，可以调用charValue()，如下所示：

charValue( )：该方法返回封装的字符。

                               Character类提供一些静态方法用于判断字符属于哪一类。（经常用于判断）

静态方法	返回值
static boolean isDigit(char ch)	如果ch是数字，则返回true。
static boolean isLetter(char ch)	如果ch为字母，则返回true。
static boolean isLetterOrDigit(char eh)	如果ch为字母或数字，则返回true。
static boolean isLowerCase(char ch)	如果ch为小写字母，则返回true；
static boolean isUpperCase(char ch)	如果ch为大写字母，则返回true。
static boolean isSpaceChar(char ch)	如果ch为空格字符，则返回true。
static boolean isWhitespace(char ch)	如果ch为空白字符，则返回true。

Boolean包装器

Boolean是包装boolean值的包装器。它定义了以下构造方法：

Boolean(boolean  boolValue)

Boolean(String  boolString)

在第一个版本中，boolValue必须是true或false。在第二个版本中，如果boolString包含字符串“true”(大写或小写形式都可以)，则新的Boolean对象将为真，否则，将为假。

为了从Boolean对象获取boolean值，可以使用booleanValue()，如下所示：

boolean booleanValue( )

该方法返回与调用对象等价的boolean型值。

---

String类

String类的介绍

1. 创建的每个字符串实际上都是String类的对象。即使是字符串字面值实际上也是String对象。
2. String类型的对象是不可变的；一旦创建了一个String对象，其内容就不能再改变。即，一旦创建了一个String对象，就不能改变该对象包含的内容。
3. 所谓String类型对象中的字符串是不可改变的，是指创建了String实例后不能修改String实例的内容。但是可以修改String引用变量，使其指向其他String对象。
4. 当每次需要已存在字符串的修改版本时，会创建包含修改后内容的新String对象。原始字符串仍然没有改变。使用这种方法的原因是，实现固定的、不能修改的字符串与实现能够修改的字符串相比效率更高。
5. 对于那些需要能够修改的字符串的情况，Java提供了两个选择：StringBuffer和StringBuilder。这两个类都包含在创建之后可以进行修改的字符串。
6. String、StringBuffer和StringBuilder类都是在java.lang包中定义的。这三个类都实现了CharSequence接口。

注意：API文档的使用

String类的构造方法

• String();  //创建不包含内容的字符串对象
• String(char[ ] chars)//创建一个String对象里面包含一个char数组。
• String(char[ ] chars,int startIndex, int numChars)//第二个缩进   在数组中加入了 起始位置和最后位置
• String(String strObj)//在前一个str对象上重新创建一个对象

注意：没有使用单位字符作为参数的构造器。

//String(char  c);   没有

说明：

因为会为字符串字面值创建String对象，所以在能够使用String对象的任何地方都可以使用字符串字面值。

System.out.println("abc".length());

字符串连接

String  str1 = “abc”; //一旦创建了字符串对象，其内容不能再改变

String  str2 = “def”;

String  str1 = str1 + str2; 

String类型的引用，指向的字符串对象是不能修改的。（重新创建一个对象）

String表示不可变的字符串，只要创建了字符串对象，那么这个对象的内容就不能再改变。

字符串修改

1. String  concat(String  str)：将指定字符串连接到此字符串的结尾，concat()与“+”执行相同的功能。
2. String  replace(char  oldChar, char  newChar)：返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。
3. String  toLowerCase()：使用默认语言环境的规则将此String中的所有字符都转换为小写。
4. String  toUpperCase()：使用默认语言环境的规则将此String中的所有字符都转换为大写。
5. String  trim( )：返回字符串的副本，删除前导空白和尾部空白。

字符串比较

字符串相等比较

String类重写了equals()方法，重写后的方法比较两个字符串对象的内容是否相同。

运算符“==”比较两个String引用是否指向同一个String对象。

其他比较方法

• boolean  equalsIgnoreCase(String str)：将此String与另一个String比较，不考虑大小写。
• boolean  endsWith(String  suffix)：测试此字符串是否以指定的后缀结束。
• boolean  startsWith(String  prefix)：测试此字符串是否以指定的前缀开始。
• int  compareTo(String  str)：按照字典顺序比较两个字符串。

其中，str是将要与调用String对象进行比较的String对象。返回的比较结果及其解释如下所示：

小于0	调用字符串小于str
大于0	调用字符串小于str
0	调用字符串等于str

• int  compareToIgnoreCase(String  str)：按字典顺序比较两个字符串，不考虑大小写。

字符串查找

1、boolean  contains(CharSequence  s) //CharSequence是String的父类，

当且仅当此字符串包含指定的char值序列时，返回true。

CharSequence  表示字符串序列，是String的父类

2．int  indexOf(int ch)  和   int  indexOf(String  str)

返回指定字符/子符串第一次出现处的索引。

3．int  lastIndexOf(int  ch)   和  int  lastIndexOf(String  str)

返回指定字符/子符串最后一次出现处的索引。

说明：当没有字符/子串没有出现时，返回值为-1。可以使用该方法判断字符/子串是否存在。

4．可以使用下面这些重载形式指定查找的开始位置：

int  indexOf(int ch, int startIndex)

int  lastIndexOf(int ch, int startIndex)

int  indexOf(String str, int startIndex)

int  lastIndexOf(String str, int startIndex)

提取字符与字符串

1．char  charAt(int  index)

返回指定索引处的char值。

2．char[ ]  toCharArray()

将此字符串转换为一个新的字符数组。

3．String  substring(int  beginIndex) //注意方法名 subString

返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。

4．String  substring(int  beginIndex, int  endIndex)

返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex处开始，一直到索引endIndex-1处的字符。

其他字符串常用方法

1．int  length()

返回此字符串的长度

注意：数组的长度为数组对象.length 属性

2．String[]  split(String  regex) //分割

根据给定正则表达式的匹配拆分此字符串。最简单的使用方法是为参数regex

3．static String  valueOf( int  i)  //将基本数据类型的值转换成字符串形式

将数据从内部格式转换成人类可读的形式。它是一个静态方法。

对于大部分数组，valueOf()会返回一个相当隐蔽的字符串，表明这是某种类型的数组。然而，对于字符数组，会创建包含字符数组中字符的String对象。

---

StringBuffer和StringBuilder

String、StringBuffer、StringBuilder类的介绍

String表示长度固定、不可修改的字符序列。在修改字符串时实际是创建一个新的字符串对象，并在新的字符串对象中放入修改后的内容。因此当需要频繁修改字符串的内容时，效率低下，为此Java提供了StringBuffer类

StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

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

StringBuilder与StringBuffer，前者效率高 速度快 后者线程安全 同步

StringBuffer类的构造方法

StringBuffer()    //默认预留16个字符的空间

StringBuffer(int size) //size指定预留的字符空间

StringBuffer(String str) //额外预留16个字符的空间

StringBuffer(CharSequence chars) //额外预留16个字符的空间

提示：再次分配内存空间是很耗时的操作。此外，频繁分配空间会产生内存碎片。

StringBuffer类的构造方法

1．append ()

append()方法将各种其他类型数据的字符串表示形式连接到调用StringBuffer对象的末尾。该方法有多个重载版本，下面是其中的几个：

StringBuffer append(String  str)

StringBuffer append(int  num)  //基本的数值类型都可以

StringBuffer append(Object  obj)

当需要将许多小的字符串连接成一个大的字符串时，使用StringBuffer的append()是合理选择。

2．insert ()

在指定位置插入参数提供的内容，返回修改后的该StringBuffer对象引用。该方法有多个重载版本，下面是其中的几个：

StringBuffer  insert(int index, String str)

StringBuffer insert(int index, char ch)

StringBuffer  insert(int index, Object obj)

3．StringBuffer  delete (int start，int end)

删除从start开始到end-1为止的一段字符序列，返回修改后的该StringBuffer对象引用。

4．StringBuffer  deleteCharAt(int  index)

移除指定位置的字符，返回修改后的该StringBuffer对象引用。

5．StringBuffer  reverse()

将字符序列逆序，返回修改后的该StringBuffer对象引用。

6．StringBuffer  setCharAt( (int index，char ch)

将指定索引处的字符设置为 ch，返回修改后的该StringBuffer对象引用。

几点说明：

（1）StringBuffer对象不能使用 += 赋值

（2）注意使用StringBuffer的append()方法连接字符串与使用“+”运算符直接连接String对象的区别。

案例：

public static void main(String[] args){

StringBuffer sb = new StringBuffer();

sb += “I”;

sb.append(“like ”);

sb.append(“core java ”);

sb.append(true);

System.out.println(sb);

}

长度与容量的概念

长度是指StringBuffer中实际保存的字符的个数，容量是指已经分配的空间大小。

1．int  length()

获取StringBuffer对象的当前长度

2．void  setLength(int len)

设置StringBuffer对象中字符串的长度。当增加字符串的大小时，会向末尾添加空字符。如果调用setLength()时使用的值小于length()返回的当前值，则超出新长度的字符将丢失。

3．int capacity( )

获取StringBuffer对象的当前容量

4．void ensureCapacity(int minCapacity)

设置缓存的大小。minCapacity指定了缓存的最小尺寸。(出于效率考虑，可能会分配比minCapacity更大的缓存。)

Math类

Math介绍

Math类包含所有用于几何和三角运算的浮点函数，以及一些用于通用目的的方法，这些方法都是静态方法。Math类定义了两个静态常量：E和PI。--------位于java.lang包下。

Math的常量

1. 自然对数的底   E(约等于2.72)
2. 圆周率PI   (约等于3.14)

Math的常用方法

1．public static double abs(double a)

返回 double 值的绝对值

2．public static double  random()

返回一个随机数，大于等于0.0且小于 1.0

2．static double sqrt(double arg)

返回arg的平方根

4．static double pow(double y, double x)

返回y的x次方。例如，pow(2.0, 3.0)返回8.0

5．public static long  round(double a)

返回距离参数a最近的整数，例如a=4.51，则返回5。

//测试：-4.5  -4.51 4.5  4.51

6．public static double  ceil(double  a)

返回大于或等于a的最小整数，例如a=4.3则返回5。

7．public static double floor(double a)

返回小于或等于a的最大整数，例如a=4.6，则返回4

注意：round()、ceil()、floor()三个方法之间的区别。

Random类

Random类的介绍

Random类是伪随机数生成器，提供了比Math.random()方法更强大的随机数生成功能。Random类位于java.util包中。Random类的构造方法如下：

Random()  //使用相对唯一的种子

Random(long  seed)   //手动指定种子

常见的做法是使用当前时间（毫秒数）作为种子。

Random类与math.random()方法的区别：

Random类提供了多个法，可以生成多种形式的随机数，Math.random()方法只能随机生成[0.0, 1.0）之间的浮点数。

Random类的常用方法

1．public  int  nextInt()

返回下一个伪随机数

2．public int nextInt(int  n)  [0,100)

返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）和指定值（不包括）之间均匀分布的 int 值

int  I = random.nextInt(100);

Date和Calendar类

Date类

Date类封装了当前日期和时间。位于java.util包。

（1）类构造方法

public Date()   //使用当前日期和时间初始化对象

public Date(long date) //参数date为自从1970年1月1日子时经历的毫秒数

（2）常用方法

long getTime()

返回从1970年1月1日午夜开始已经流逝毫秒数

void setTime(long time)

将日期和时间设置为time所指定的值，time是是自从1970年1月1日午夜开始已经流逝的毫秒数

String toString()

将调用Date对象转换成字符串并返回结果

Date类实例：

importjava.util.Date;



public classDateTest {

       public static void main(String[] args) {

              Date d = new Date();

              System.out.println(d);

              //System.out.println(d.toLocaleString());

              long time1 =d.getTime();//1970-1-1 00:00:00 GMT  到现在的 总毫秒数

              System.out.println(time1);

                           

              long time2 =System.currentTimeMillis();

              System.out.println(time2);//1970-1-100:00:00 GMT  到现在的 总毫秒数

              Date d2 = new Date(time2);

              System.out.println(d2);


       }

}

Calendar与GregorianCalendar类

Calendar是抽象类，提供了一套方法将毫秒数形式的时间转换成大量有用的组分，例如年、月、日、小时、分和秒。

GregorianCalendar是Calendar的具体实现，它实现了格林尼治日历。Calendar类的getInstance()方法通常会返回一个使用默认地区和时区下的当前时间初始化的GregorianCalendar对象。

实例：

importjava.util.GregorianCalendar;

publicclass GregorianCalendarDemo {

       public static void main(String[] args) {

              GregorianCalendar g = newGregorianCalendar();


              System.out.println("年：" + g.get(Calendar.YEAR));

              System.out.println("月：" + g.get(Calendar.MONTH));

              System.out.println("日：" + g.get(Calendar.DAY_OF_MONTH));

              System.out.println("时：" + g.get(Calendar.HOUR));

              System.out.println("分：" + g.get(Calendar.MINUTE));

              System.out.println("秒：" + g.get(Calendar.SECOND));


       }

}