JAVA--常用类

JAVA学习伊始，简单介绍几种常用类，字符串相关类与基本数据类型包装类主要是将我们常用的基础类型封装成对象使用-体现面向对象的思想，Math类提供一些常用的数学函数，File类主要是对文件的操作，枚举类解决java中面向对象中的类型问题。

1，字符串相关类（String，StringBuffer）

Java.lang.String类代表不可变的字符序列。对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.

Java.lang.StringBuffer代表可变的字符序列。向StringBuffer中赋值的时候可以通过它的append方法.

String:

是对象不是原始类型.
为不可变对象,一旦被创建,就不能修改它的值.
对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去.
String 是final类,即不能被继承.

StringBuffer:

是一个可变对象,当对他进行修改的时候不会像String那样重新建立对象
它只能通过构造函数来建立,
StringBuffer sb = new StringBuffer();
note:不能通过付值符号对他进行付值. 
sb = "welcome to here!";//error
对象被建立以后,在内存中就会分配内存空间,并初始保存一个null.向StringBuffer
中付值的时候可以通过它的append方法.
sb.append("hello");

区别：

StringBuffer和String类似，但StringBuffer可以对其字符串进行改变。如果在程序中需要对字符串进行频繁的修改连接操作的话.使用StringBuffer性能会更高

StringBuffer和String效率对比：

http://blog.csdn.net/yirentianran/article/details/2871417

http://blog.csdn.net/daheiantian/article/details/6116821

 

示例：String

public class TestString{
	public static void main(String[] args){
		String s1="Hello";
		String s2="World";
		String s3="Hello";
		System.out.println(s1 == s3);
		
		s1=new String("hello");
		s2=new String("hello");
		System.out.println(s1 == s2);
		System.out.println(s1.equals(s2));
		
		char c[]={'s','u','n',',','j','a','v','a'};
		String s4=new String(c);
		String s5=new String(c,4,4);
		System.out.println(s4);
		System.out.println(s5);
		}
}

示例：StringBuffer

public class TestStringBuffer{
	public static void main(String[] args){
		String s="Mircosoft";
		char[] a={'a','b','c'};
		StringBuffer sb1=new StringBuffer(s);
		
		sb1.append('/').append("IBM").append('/').append("Sun");
		System.out.println(sb1);
		
		StringBuffer sb2=new StringBuffer("数字");
		for(int i=0;i<=9;i++){sb2.append(i);}
		System.out.println(sb2);
		
		sb2.delete(8,sb2.length()).insert(0,a);
		System.out.println(sb2);
		System.out.println(sb2.reverse());
		
		}
}

2，基本数据类型包装类

包装类（如：Integer，Double等）这些类封装了一个相应的基本数据类型数值，并为其提供了一系列操作。

以java.lang.Integer类为例：

构造方法：Integer(int value)

Integer(String s)

 

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这些和基本数据类型对应的类统称为包装类（WrapperClass）（即为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作---用于描述该对象的类就称为基本数据类型对象包装类。）

在这八个类名中，除了Integer和Character类以后，其它六个类的类名和基本数据类型一直，只是类名的第一个字母大写即可。

a、Java有8种基本数据类型

类型	包装类	位数	最小值	最大值
byte	java.lang.Byte	8	Byte.MIN_VALUE=-128	Byte.MAX_VALUE=127
short	java.lang.Short	16	Short.MIN_VALUE=-32768	Short.MAX_VALUE=32767
int	java.lang.Integer	32	Integer.MIN_VALUE=-2147483648	Integer.MAX_VALUE=2147483647
long	java.lang.Long	64	Long.MIN_VALUE=-9223372036854775808	Long.MAX_VALUE=9223372036854775807
float	java.lang.Float	32	Float.MIN_VALUE=1.4E-45	Float.MAX_VALUE=3.4028235E38
double	java.lang.Double	64	Double.MIN_VALUE=4.9E-324	Double.MAX_VALUE=1.7976931348623157E308
char	java.lang.Character	16	Character.MIN_VALUE=0	Character.MAX_VALUE=65535
boolean	java.lang.Boolean	1	0	1

b、装箱，拆箱

 

装箱：就是把基本类型用它们相对应的引用类型包起来，使它们可以具有对象的特质，如我们可以把int型包装成Integer类的对象，或者把double包装成Double，等等。

拆箱：就是跟装箱的方向相反，将Integer及Double这样的引用类型的对象重新简化为值类型的数据

 

J2SE5.0后提供了自动装箱与拆箱的功能，此功能事实上是编译器来帮您的忙，编译器在编译时期依您所编写的方法，决定是否进行装箱或拆箱动作。

自动装箱的过程：每当需要一种类型的对象时，这种基本类型就自动地封装到与它相同类型的包装中。

自动拆箱的过程：每当需要一个值时，被装箱对象中的值就被自动地提取出来，没必要再去调用intValue()和doubleValue()方法。

 

自动装箱，只需将该值赋给一个类型包装器引用，java会自动创建一个对象。例如：

Integer i=100;//没有通过使用new来显示建立，java自动完成。

自动拆箱，只需将该对象值赋给一个基本类型即可。例如：intj=i;

int i = 10;  
Integer j =new Integer(i); //手动装箱操作    
int k = j.intValue();      //手动拆箱操作    
  
int i = 11;  
Integer j = i; //自动装箱  
int k = j //自动拆箱  

示例：

public class TestBase{
	public static void main(String[] args){
		Integer i=new Integer(100);
		Double d=new Double("123.456");
		int j=i.intValue()+d.intValue();
		float f=i.floatValue()+d.floatValue();
		System.out.println(j);
		System.out.println(f);
		
		double pi=Double.parseDouble("3.1415");
		double r=Double.valueOf("2.0").doubleValue();
		double s=pi*r*r;
		System.out.println(s);
		try{
			int k=Integer.parseInt("1.25");
		}catch(NumberFormatException e){
			System.out.println("数据格式不对");
			
			}
			System.out.println(Integer.toBinaryString(123)+"B");
			System.out.println(Integer.toHexString(123)+"H");
			System.out.println(Integer.toOctalString(123)+"O");
	}
}

3，Math类

Java.lang.Math提供了一系列静态方法用于科学计算，其方法的参数和返回值类型一般为double型。

 

4，File类

Java.io.File类代表系统文件名（路径和文件名）

常见构造方法：

PublicFile(String pathname)

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

PublicFile(String parent,String child)

以parent为父路径，child为子路径创建File对象。

 

示例：

import java.io.*;
public class TestFile{
	public static void main(String[] args){
		String separator=File.separator;
		String filename="myfile.txt";
		String directory="mydir1"+separator+"mydir2";
		File f=new File(directory,filename);
		if(f.exists()){
			System.out.println("文件名："+f.getAbsolutePath());
			System.out.println("文件大小："+f.length());
			
			}
			else{
				f.getParentFile().mkdirs();
				try{
					f.createNewFile();
					
					}
					catch(IOException e){
						e.printStackTrace();
						}
				}
		}
	}

5，枚举类

Java.lang.Enum枚举类型

使用enum关键字，只能够取特定值中的一个

 

示例：

public class TestEnum{
	public enum MyColor{red,green,blue};
	
	public static void main(String[] args){
		MyColor m=MyColor.red;
		switch(m){
			case red:
			System.out.println("red");
			break;
			case green:
			System.out.println("green");
			break;
			default:
			System.out.println("default");
			}
			System.out.println(m);
	}
}

总结：

Java类吸取了C++面向对象中类的概念，将数据封装于类中，利用类的优点，实现了程序的简洁性和便于维护性。类的封装性、继承性等有关对象的特性，使程序代码只需一次编译，然后通过上述特性反复利用。程序员只需把主要精力用在类和接口的设计和应用上。Java提供了众多的一般对象的类（如上），通过继承即可使用父类的方法。

对于JAVA的常用类进行了简单的总结，简单的解释加示例，让我们理解更加深刻，为以后的学习打基础！