java常用类（转）收藏

java.applet包含一些用于创建java小应用程序的类。
java.awt包含一些用于编写与平台无关的图形界面(GUI)应用程序的类。
java.io包含一些用作输入输出(I/O)处理的类。
java.lang包含一些java语言的基本类与核心类，如String Math Integer System Runtime
提供常用的功能，这个包中的所有类是被隐式导入的。
java.net包含用于建立网络连接的类，与java.io同时使用完成与网络有关的读写。
java.util包含一些实用工具类和数据结构类。
String
java.lang.String
public final class String 不能再有派生类。
String 对象是不可变的，所以可以共享它们。例如：
String str = "abc";
等效于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
下面给出了一些如何使用字符串的更多例子：
      System.out.println("abc");
      String cde = "cde";
      System.out.println("abc" + cde);
      String c = "abc".substring(2,3);
      String d = cde.substring(1, 2);
String 类包括的方法有：检查序列的单个字符；比较字符串；搜索字符串；提取子字符串；创建字符串副本，在该副本中，所有的字符都被转换为大写或小写形式。大小写映射基于 Character 类指定的 Unicode Standard 版本。
substring()
"hamburger".substring(4, returns "urge"
"smiles".substring(1, 5) returns "mile"
String构造方法
String str1=new String("abc");
java的基本数据类型
boolean,byte,short,int,long,char,float,double
其余的都是引用类型。String和arry都是引用类型
"=="是比较两个变量的值是否相等。
"equals"是比较两个对象变量所代表的对象的内容是否相等。
定义变量是在栈内存分配一个名称，new是在堆内存分配空间创建对象。
引用实际上是对象的首地址，将首地址附给变量名，所以栈内存所存放的是变量的首地址。
equals
public boolean equals(Object anObject)
比较此字符串与指定的对象。当且仅当该参数不为 null，并且是表示与此对象相同的字符序列的 String 对象时，结果才为 true。

覆盖：
类 Object 中的 equals
如果 String 相等，则返回 true；否则返回 false。
String str1="abc";
int i=3;
System.out.println(str1+i);
输出abc3;

字符串对象和整形变量相加；
字符串对象可以和任何类型的变量相加。
int i=3;
float f=1.5f;
char ch='f';
boolean b='false';
System.out.println("as"+i+f+ch+b);
针对String类的+ 和+=是唯一重载的运算符。

String类对象是常量对象。
String str="abc";
str="def";
这样只是在str的栈内存当中值是def的引用；所以堆内存的abc是垃圾内存。
当内存不足时要回收内存。实际上str的值是不改变的。
在处理大量字符串的程序中，通常用StringBuffer来代替String类。

StringBuffer类对象的应用。主要是append和insert和toStirng方法。
x=new StringBuffer().append("a").append("4").append("c").toString();
常用方法：
append();
insert();
toString();
capacity();
charAt(int index);
delete()
deleteCharAt();
reverse();反序函数；

java.awt
awt是abstract window talke
GUI是graghic user interface

数组
函数的参数是数组的时候。
num.length是数组的元素个数，并不是数组占内存的大小。
int [] num=new int[3];

num=null;把他保存的引用清除。
没有任何变量保存的引用，首地址。
使堆内存成为垃圾内存。

转换垃圾内存，把保存引用的对象附值为空null。
对于对象而言，在不使用对象的时候，可以把他置空，这样他所占有的内存变为垃圾内存。
这样在需要使用的内存的时候编译器就会释放对象所占有的堆内存。
使用引用类型数组。
定义类学生。
Student[] students;
students=new Student[3];
内存分配图解。！！！！！！！！！！！
在堆内存里：
将student对象的首地址附值给对象数组的第一个空间。

main()方法，由java虚拟机调用，必须是public，虚拟机在调用main方法的时候，
不需要产生任何的对象，所以声明为static，由于是java虚拟机调用不需要哟返回值，
所以为void。参数(String [] args)是一个引用类型的数组，
测试：
System.out.println(args[0]);
异常
数组索引越界，数组args并没有被分配空间。
args是用来接收命令行参数的。
if(args.length>0)
{
   for(int i=0;i<args.length;i++)
    {
System.out.println(args[i]);
    }
}
不用中间变量实现数值交换
change(int x,int y)
{
x=x+y;
y=x-y;
x=x-y;
}
！！！！单纯的变量的互换不能改变他们的值。
在java中传参时，都是以传值的方式进行。
基本数据类型传递的是数据的拷贝，引用类型，传递的是引用的拷贝。
数组和对象都是引用类型，

Point由Object派生，继承了toString方法。
那么point输出格式是
getClass().getName() + '@' + Integer.toHexString(hashCode())
只有必须重载toString方法
覆盖基类当中的toString方法，返回一个类或对象的简单的描述。
class Point
{
int x,y;
public String toString()
{
   return "x="+x+","+"y="+y;
}
}


改变了引用变量代表的对象当中内容，
但有时候希望他修改的是对象的拷贝，
就是不希望在函数体内修改原始的内容。
可以用对象的刻隆来实现
protected Object.clone();
需要重载并声明为public;
在派生类中实现Cloneable接口，他是一个标识接口，没有任何的抽象方法。
克隆实现
利用Object类的clone方法。
在派生类中覆盖基类的clone方法，并声明为public。
在派生类中实现Cloneable接口。
public interface Cloneable
此类实现了 Cloneable 接口，
以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。

如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法，
则会导致抛出 CloneNotSupportedException 异常。

Cloneable接口没有抽象方法。
Cloneable接口是一个标识接口。
是为了告诉编译器可以对对象进行克隆了。

克隆返回Object类型对象。
class Student implements Cloneable
{
String name;
int age;
Student(String name,int age)
{
   this.name=name;
   this.age=age;
}
public Object clone()
{
   Object o=null;
   try
   {
    o=super.clone();
   }
   catch(CloneNotSurpportedException e)
   {
    System.out.println(e.toString());
   }
   return o;
}
}
克隆方法的对比理解。
Student s1=new Student("z1","18");
Student s2=(Student)s1.clone();
//s2=s1;
s2.name="z2";
s2.age="19";
System.out.println(s1.name,s2.age);

克隆的问题
教授类
class Professor
{
String name;
int age;
Professor()
{
   this.name=name;
   this.age=age;
}
}
教授的名字和年龄。
Professor p=new Professor("w1",50);
Student s1=new Student("z1",18,w1);
Student s2=(Student)s1.clone();
s2.p.name="lisi"
s2.p.age=30;
System.out.println(s1.p.name,s1.p.age);
只是将引用类型的引用复制了一遍。
实际上是指向同一个教授对象。
String类型也是引用类型，并没有重写clone方法。
"lisi"是一个常量，他创建后，把"lisi"的引用附给s2.name;
克隆的是p的引用。
所以s1和s2的p的引用值都是一样的。
他们指向了同一个教授对象。是对同一块内存中的对象修改的。