Java技术笔记1：类与对象实例之系统常用类

待我君临天下，结发与蕊可好。@夏瑾墨

---

一直在反思最近的时间安排，知识没有总结和积累很容易发生遗忘，如果要让自己在短期内能有大的提升，那就需要每天的知识流输入，减去你生活中看起来也是重要的东西，然而性命攸关的只有一个，兼顾太多，一无所得，一学长提到贪心算法来处理利益最大化问题，最后往往都不是最好的方案。而使用动态规划（Dynamic Programming），给自己做做减法，追求一下深度而非广度，你会发现自己可以做得更好。

java类的基本概念
对象的创建与使用
对象的使用
成员的调用

再讲一下JDK(Java Development Kit) ,JDK是 Java 语言的软件开发工具包,JDK是整个java开发的核心，它包含了JAVA的运行环境，JAVA工具和JAVA基础的类库。

一，包
包就是Java提供的一种区别类名空间的机
制，是类的组织方式，包对应一个文件夹，包
中还可以再有包，称为包等级。java类库中的类和接口大多封装在特定的包里，每个包具有自己的功能
Java提供的部分常用包

二，类
类库就是Java API(Application Programming Interface，应用程序接口)，是系统提供的已实现的标准类的集合
1. 系统定义的类（是JAVA自带的，已经实现的类）
字符串类
数值（Number）类及其子类
数组类
集合类
Object类

字符串类：

---

Java语言提供两种字符串类用来实现字符串操作：
String类：用于字符串常量，也就是说字符串的值不会改变
StringBuffer类：用于字符串变量，也就是说字符串的值可以改变
字符串的使用例题：

public class StringsDemo {
  public static void main(String[] args) {
    String palindrome = "僧游云隐寺";
    int len = palindrome.length();
    StringBuffer dest = new StringBuffer(len);
    for (int i = (len - 1); i >= 0; i--) {
      dest.append(palindrome.charAt(i));
    }
    System.out.println(dest.toString());
  }
   }

String对象的其它产生方法：

// 生成一个空的字符串
String myStr = new String();

// 复制String对象的内容
String oldStr = "东岳泰山";
String myStr1 = new String(oldStr);

//复制StringBuffer对象的内容
StringBuffer oldStr2 = new StringBuffer("西岳华山");
String myStr2 = new String(oldStr2);

//复制字符数组的内容
char[] oldStr3 = {'南', '岳', '衡', '山'}; 
String myStr3 = new String(oldStr3);

StringBuffer对象的产生：

只能用new关键字产生，有3种构造方法：
// 生成一个空的字符串，这个字符串的初始容量为16个字符，但以后可以扩展
StringBuffer myStrBuf1 = new StringBuffer();

// 生成一个空的字符串，这个字符串的初始容量由length指定。
// 在本例中，字符串的初始容量为120个字符。
int length = 120;
StringBuffer myStrBuf2 = new StringBuffer(length);

// 复制String对象中的内容
String str = "北岳恒山";
StringBuffer myStrBuf3 = new StringBuffer(str);

字符串长度和字符串容量：

如果StringBuffer对象要存放的字符数大于它的容量，StringBuffer对象会自动扩大字符串容量，以放下更多的字符
     myStrBuf1.append("东岳泰山、西岳华山、南岳衡山、北岳恒山、中岳嵩山");
     System.out.println(myStrBuf1.capacity());
程序显示结果：

字符串的访问操作：

length()函数：获取字符串的长度
适用于String对象和StringBuffer对象
String myStr = "僧游云隐寺";
StringBuffer myStr2 = new StringBuffer("五岳归来不看山");
int strlen1 = myStr.length();
int strlen2 = myStr2.length();
变量strlen1中保存myStr的长度，值为5
变量strlen2中保存myStr2的长度，值为7
capacity函数：得到字符串容量
仅适用于StringBuffer对象
charAt()函数：获得字符串中的某个字符
适用于String对象和StringBuffer对象
char myChar1, myChar2;
String myStr = "僧游云隐寺";
StringBuffer myStr2 = new StringBuffer("五岳归来不看山");
myChar1 = myStr.charAt(0);
myChar2 = myStr2.charAt(6);
要循环获得字符串里的所有字符，循环应当从0开始，直到字符串长度-1为止
StringBuffer myStr2 = new StringBuffer("五岳归来不看山");
for (int i = 0; i < myStr2.length(); i++) {
  System.out.println(myStr2.charAt(i)); }
substring函数：获得字符串的子串
     String substring(int start);
返回从start指定的位置开始（包括这个字符），直到整个字符串终了的所有子串
     String substring(int start, int end);
返回从start开始（包括这个字符），直到end为止（不包括这个字符）的子串

indexOf和lastIndexOf函数：搜索字符位置
适用于String对象和StringBuffer对象
indexOf函数的作用是从前往后搜索字符第一次出现的位置
lastIndexOf函数的作用是从后往前搜索字符第一次出现的位置
indexOf和lastIndexOf函数有很多种用法
indexOf的使用例题：

public class StringDemo {
  public static void main(String[] args) {
    String str1 = "东岳泰山、西岳华山、南岳衡山、北岳恒山、中岳嵩山";
    char subChar1 = '岳';
    int pos1;
    System.out.println("这段诗中出现“岳”字的位置分别是：");
    pos1 = str1.indexOf(subChar1);
    while (pos1 >= 0) {
      System.out.println(pos1);
      pos1 = str1.indexOf(subChar1, pos1 + 1);
    } } }

字符串的修改操作：

append函数：在字符串末尾添加新的内容
append函数的形式：
append(boolean b);
append(char c);
append(char[] str);
append(char[] str, int offset, int len);
append(double d);
append(float f);
append(int i);
append(long l);
append(String str);
append(StringBuffer strbuf);
insert函数：在字符串中的特定位置插入一段子字符串
insert函数也有多种形式，可以插入整数、浮点数、逻辑值、单个字符、字符串等
例题：
StringBuffer mainStr = new StringBuffer("黄河远上白云一片孤城万仞山");
String subStr = "间";
mainStr.insert(6, subStr);
System.out.println(mainStr);

setCharAt函数和replace函数：修改字符串
setCharAt(int index, char ch);
replace(int start, int end, String str);

例题：
StringBuffer modiStr = new StringBuffer("When i am young, I'd listening to the radio");
modiStr.setCharAt(5, 'I');
modiStr.replace(7, 9, "was");
System.out.println(modiStr);

deleteCharAt，delete函数：删除字符串
deleteCharAt(int index);
delete(int start, int end);

字符串的转换操作：
toString函数：对象转换为字符串
Object类中定义了toString函数，因此所有的类也都继承了toString函数
因此Java建议每个类覆盖Object类的toString函数，产生适合自己类的字符串

valueOf函数：将数值转换成字符串
static String String.valueOf(boolean b);
static String String.valueOf(int i);
static String String.valueOf(long l);
static String String.valueOf(float f);
static String String.valueOf(double d);
static String String.valueOf(char c);
static String String.valueOf(char[] data);
static String String.valueOf(char[] data, int offset, int count);

字符串的连接：

double d = 1032705.32;
System.out.println("上月底，本公司的帐面资金余额为：" + d + "元。");

对于String对象，包括字符串文字，可以用“+”将两个或多个字符串连接起来，形成新的字符串。如下面的例子：

String str1, str2, str3;
str1 = "君不见" + "黄河之水天上来";
str2 = "奔流到海不复回";
str3 = str1 + str2;

也可以用“+”号连接字符串和整数、浮点数、逻辑值、字符等
Java自动调用String.valueOf()函数将后者转换成字符串
凡是能够用valueOf函数转换的数据类型，都可以用“+”号与字符串连接

数值（Number）类及其子类

数值类的定义与功能：
在Java中，对应byte, short, int, long, float, double等简单数据类型，分别有一个对应的数值类：Byte, Short, Integer, Long, Float, Double
它们都是从数值类Number继承而来的
数值类的作用是扩展数据处理的功能
数值类的用途：
将数字转换成字符串：
每个数值类都有toString静态函数：
static String Byte.toString(byte b);
static String Short.toString(short s);
static String Integer.toString(int i);
static String Long.toString(long l);
static String Float.toString(float f);
static String Double.toString(double d);
函数的作用是将整数或浮点数转换成字符串

toString函数应用例题：
int i = 7;
double d = 13.56;
String str1, str2;
str1 = Integer.toString(i);
str2 = Double.toString(d);
System.out.println("str1=" + str1 + "; str2=" + str2 + ";");
执行这段代码之后，屏幕显示的内容是：
str1=7; str2=13.56;

将字符串转化为数字：
valueOf函数：
static Integer Integer.valueOf(String str);
static Double Double.valueOf(String str);
valueOf函数返回的是Integer或Double型对象，还需转换成整数或浮点数：
int Integer.intValue();
double Double.doubleValue();

将字符串转化为数值的例题：
String str1 = "3532";
String str2 = "187.863";
Integer strval1;
Double strval2;
strval1 = Integer.valueOf(str1);
strval2 = Double.valueOf(str2);
int i = strval1.intValue();
double d = strval2.doubleValue();
System.out.println("i=" + i + "; d=" + d + ";");

这种方法需要转换两次，使用比较繁琐，另外一种方法只需要一次转换：
static int Integer.parseInt(String str);
static double Double.parseDouble(String str);
这两个函数都是静态函数，因此不需要建立Integer或Double对象，可以直接使用

几种特殊的浮点数：
Java中的浮点数可以包括“非数”，“正无穷大”，“负无穷大” 。例如下面的代码：
System.out.println(0.0/0.0);
System.out.println(1.0/0.0);
System.out.println(-1.0/0.0);

Double类提供了两个静态函数，来判断一个浮点数是不是这三种特殊数值：
static boolean Double.isNaN(double v);
static boolean Double.isInfinite(double v);
由此可以及时发现错误的计算数据

数组类
数组的定义与特点
数组：可以容纳很多同类型的数据的结构
数组中存放的每个数据称为数组的一个元素，元素的数量称为数组的长度
在Java语言中，数组的长度是在数组创立时就固定了的，以后不能更改
但与C++等语言不同，Java的数组长度是在运行期定下来的，而不是在设计期给定长度。因此灵活性更强一些
数组的定义与初始化
与普通变量一样，数组也是由定义、初始化两部分组成的
数组变量的定义与普通变量一样，只是在变量类型的后面加上“[]”以表示数组：
int[] array1;
double[] array2;
StringBuffer[] array3;
BoardGame[] array4;

数组也是用new关键字来初始化的，初始化时必须给出数组的长度，如下所示：
int len = 8;
array1 = new int[10];
array2 = new double[len-1];
array3 = new StringBuffer[len*2];
array4 = new BoardGame[15];
虽然也是固定长度数组，但可以在运行时用变量来指定数组长度

快速初始化数组的方法：
Java提供了一种简便的方法，可以将数组的定义、初始化和赋初值合为一体：
int[] myData1 = {0, 1, 3, 6, 8, 12, 634, 21564, 845646};
String[] myStr1 = {
“明月出天山”, “苍茫云海间”,
“长风几万里”, “吹度玉门关”,
“汉下白登道”, “胡窥青海湾”,
“由来征战地”, “不见有人还”,
“戍客望边色”, “思归多苦颜”,
“高楼当此夜”, “叹息未应闲”, };
数组的复制

数组变量也属于引用变量，因此赋值语句只能复制指针，而不能复制整个数组：
String[] myStr2;
myStr2 = myStr1;
为了复制数组，需要使用System.arraycopy函数，该函数的形式如下：
public static void System.arraycopy(Object src, int srcIndex, 
                                                           Object dest, int destIndex, 
                                                           int length);

数组的复制例题

public class ArrayCopyDemo {
  public static void main(String[] args) {
    char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e', 'i', 'n', 'a', 't', 'e', 'd' };
    char[] copyTo = new char[7];
    System.arraycopy(copyFrom, 2, copyTo, 0, 7);
    System.out.println(new String(copyTo)); } }

多重数组

数组的元素也是数组，可表示数据表格：
int[][] MagicSquare = {
  {8, 1, 6,},
  {3, 5, 7,},
  {4, 9, 2,},
};
多重数组中的元素用[][]的形式访问，如：

System.out.println(MagicSquare[1][1]);

集合类的功能
如果要求长度可变，就不能使用数组，而应当使用集合类。这里简单介绍集合中的向量类，它在功能上最接近于数组
Vector类的使用例题：

public class VectorDemo {
  public static void main(String[] args) {
    Vector strs = new Vector();
    for (int i=0; i<5; i++)
      strs.addElement(Integer.toString(i));
    for (int i=0; i<strs.size(); i++)
      System.out.println(((String)strs.elementAt(i)));
  } }

Object类

Object类的作用
在Java中，所有的类，不管有没有定义其父类，都以Object类作为直接或间接的父类
也就是说，所有的类都继承自Object类
Object类定义了基本的成员变量和成员函数
对象间的比较
将对象转换成字符串
线程的等待与通知
返回对象所属的类
Object类的成员函数
clone：将对象复制一份，并返回复制后的对象的指针。
equals/hashcode：比较两个对象是否相等。
finalize：当对象被回收时调用的，仅用于混合语言编程时，回收动态分配内存用。
toString：将对象转换成恰当的字符串。
getClass：获得当前对象所属的类，返回的是Class对象，可以用obj.getClass().getName()来获得类名
notify：唤醒一个处于等待状态的线程
notifyAll：唤醒所有处于等待状态的线程
wait：让当前线程等待，直到其它线程通过notify或notifyAll函数唤醒为止

待我君临天下，结发与蕊可好。 @夏瑾墨