JAVA数据类型基础

简单数据类型包括：
　　整型(Interger): byte, short, int, long
　　浮点类型(Floating): float, double
　　字符类型(Textual): char
　　布尔类型(Logical): boolean

复合数据类型包括：
　　class
　　interface
　　数组
　　String

常量：
　　用final. eg: final int NUM = 100;

变量：
　　局部变量、类变量、方法参数、例外处理参数

简单数据间的优先数据关系：
　　低-->高： byte,short,char->int->long->float->double

自动转换：
　　运算中，不同类型数据运算将自动转换，从低级到高级

强制转换：
　　高级数据要转换成低级数据，需强制转换
　　eg: int i;
　　byte b = (byte)i;

运算符：
　　基本与c语言一致，实例运算符instanceof, 内存分配运算符new

复合语句：
　　基本与c语言一致

例外处理语句：
　　包括try, catch, finally, throw

数组：（简单数据类型与复合数据类型的差别）
　　一维数组：
　　　　1. 定义
　　　　　　type intArray[];
　　　　　　eg: int intArray[];
　　　　　　      Date dateArray[];
　　　　2. 一位数组的初始化
　　　　　　静态初始化：
　　　　　　　　int intArray[] = {1, 2, 3, 4};
　　　　　　　　String stringArray[] = {"abc", "How", "You"};
　　　　　　动态初始化：
　　　　　　　　简单类型的数组：
　　　　　　　　　　int intArray[];
　　　　　　　　　　intArray = new int[];
　　　　　　　　复合类型的数组：
　　　　　　　　　　String stringArray[];
　　　　　　　　　　String stringArray = new String[3]; // 为数组中每个元素开辟引用
　　　　　　　　　　stringArray[0] = new String("How"); // 开辟空间
　　　　　　　　　　stringArray[1] = new String("are");
　　　　　　　　　　stringArray[2] = new String("you");
　　　　3. 一维数组的引用
　　　　　　arrayName[index]
　　　　　　arrayName.length属性指明数组的长度

　　多维数组：
　　　　1. 二维数组的定义：
　　　　　　type arrayName[][];
　　　　　　type [][]arrayName;
　　　　2. 二维数组的初始化：
　　　　　　静态初始化
　　　　　　　　int intArray[][] = {{1, 2}, {2, 3}, {3, 4, 5}};
　　　　　　　　java中, 把二维数组看成时数组的数组, 空间并不是连续的，并不要求每一维的大小相同
　　　　　　动态初始化
　　　　　　　　直接为每一维分配空间：
　　　　　　　　　　arrayName = new type[arrayLength1][arrayLength2];
　　　　　　　　　　int a[][] = new int[2][3];
　　　　　　　　从最高维开始，分别为每一维分配空间：
　　　　　　　　　　arrayName = new type[arrayLength1][];
　　　　　　　　　　arrayName[0] = new type[arrayLength20];
　　　　　　　　　　arrayName[1] = new type[arrayLength21];
　　　　　　　　　　...

　　　　　　　　　　eg: int a[][] = new int[2][];
　　　　　　　　　　      a[0] = new int[3];
　　　　　　　　　　　　a[1] = new int[5];
　　　　　　　　二维复合数据类型数组，只能以此种方式
　　　　　　　　　　eg: String s[][] = new String[2][];
　　　　　　　　　　　　s[0] = new String[2]; // 为最高维分配引用空间
　　　　　　　　　　　　s[1] = new String[2];
　　　　　　　　　　　　s[0][0] = new String("Good"); //分配空间
　　　　　　　　　　　　s[0][1] = new String("Luck");
　　　　　　　　　　　　s[1][0] = new String("to");
　　　　　　　　　　　　s[1][1] = new String("You");
　　　　3. 二维数组的引用：
　　　　　　arrayName[index1][index2]; eg: num[1][2];
　　　　4. 二维数组举例

 1 public class MatrixMultiply
 2 {
 3 　　public static void main(String args[]) {
 4 　　　　int i, j, k;
 5 　　　　int a[][] = new int[2][3]; 
 6 　　　　int b[][] = {{1, 5, 2, 8}, {9, 5, 10, -3}, {2, 7, -5, -18}}; 
 7 　　　　int c[][] = new int[2][4]; 
 8 　　　　for (i = 0; i < 2; i++) 
 9 　　　　　　for (j = 0; j < 3; j++)
10 　　　　　　　　a[i][j] = (i + 1) * (j + 2);
11 　　　　　　　　for (i = 0; i < 2; i++) {
12 　　　　　　　　　　for (j = 0; j < 4; j++) {
13 　　　　　　　　　　　　c[i][j] = 0;
14 　　　　　　　　　　　　for (k = 0; k < 3; k++)
15 　　　　　　　　　　　　　　c[i][j] += a[i][k] * b[k][j];
16 　　　　　　　　　　　}
17 　　　　　　　　　}
18 　　　　System.out.println("*********Matrix C***********");
19 　　　　for (i = 0; i < 2; i++) {
20 　　　　　　for (j = 0; j < 4; j++)
21 　　　　　　　　System.out.println(c[i][j] + " ");
22 　　　　　　System.out.println();
23 　　　　}
24 　　}
25 }

Java语言中，把字符串作为对象来处理，类String和StringBuffer都可以用来表示一个字符串。
　　1. 字符串常量
　　　　"Hello World"

　　2. String表示字符串常量
　　　　String(char chars[]);　// 用字符数组初始化String
　　　　String(char chars[], int startIndex, int numChars);
　　　　String(byte ascii[], int hiByte);  // 用字节数组初始化String，hiByte表示高8位，一般为0
　　　　String(byte ascii[], int hiByte, int startIndex, int numChars);

　　　　使用不同方法生成"abc"
　　　　char chars1[] = {'a', 'b', 'c'};
　　　　char chars2[] = {'a', 'b', 'c', 'd', 'e'};
　　　　String s1 = new String(chars1);
　　　　String s2 = new String(chars2, 0, 3); // 取chars2[]的前三个字符

　　　　byte ascii1[] = {97, 98, 99};
　　　　byte ascii2[] = {97, 98, 99, 100, 101};
　　　　String s3 = new String(ascii1, 0);
　　　　String s4 = new String(ascii2, 0, 0, 3); //取前三个

　　3. 用StringBuffer表示字符串
　　　　StringBuffer(); // 分配16个字符串的缓冲区
　　　　StringBuffer(int len); // 分配len个字符的缓冲区
　　　　StringBuffer(String s); // 除了按照s的大小分配空间外，再分配16个字符的缓冲区

　　4. 访问字符串
　　　　类String提供了length() charAt() indexOf() lastIndexOf() getChars() getBytes() toCharArray()等方法
　　　　　　public int length() 返回字符串的字符个数
　　　　　　public char charAt(int index) 返回字符串中index位置上的字符，index范围：0--length-1

　　　　　　public int indexOf(char ch) 返回字符ch在字符串中出现的第一个位置
　　　　　　public int lastIndexOf(char ch) 返回字符ch在字符串中出现的最后一个位置

　　　　　　public int indexOf(String str) 返回子串str在字符串中出现的第一个位置
　　　　　　public int lastIndexOf(String str) 返回子串str在字符串中出现的最后一个位置

　　　　　　public int indexOf(char ch, int fromIndex) 返回字符ch在字符串中fromIndex以后出现的第一个位置
　　　　　　public int lastIndexOf(char ch, int fromIndex) 返回字符ch在字符串中fromIndex以后出现的最后一个位置

　　　　　　public int indexOf(String str, int fromIndex) 返回子串str在字符串中fromIndex以后出现的第一个位置
　　　　　　public int lastIndexOf(String str, int fromIndex) 返回子串str在字符串中fromIndex以后出现的最后一个位置

　　　　　　public void getChars(int srcbegin, int end, char buf[], int dstbegin)
　　　　　　　　srcbegin 要提取的第一个字符在源串中的位置
　　　　　　　　end 要提取的最后一个字符在源串中的位置
　　　　　　　　buf[] 目的字符串
　　　　　　　　dstbigin 提取的字符串的在目的字符串中起始位置

　　　　　　public void getBytes(int srcbegin, int serEnd, byte[] dst, int dstBegin)
　　　　　　用法同上，只是为8位

　　　　类StringBuffer提供了length() charAt() getChars() capacity()等方法
　　　　　　capacity()用来得到资环穿缓冲区的容量，与length()方法所返回的值通常是不同的

　　5. 修改字符串
　　　　类String提供的方法 contat() replace() substring() toLowerCase() toUpperCase()
　　　　　　public String contat(string str) 将当前字符串与str连接起来
　　　　　　public String replace(char oldChar, char newChar); 将当前字符串中oldChar换成newChar

　　　　　　public String substring(int beginIndex); 返回子串
　　　　　　public String subString(int beginIndex, int endIndex);

　　　　　　public String toLowerCase(); 把串中所有字符变成小写
　　　　　　public String toUpperCase(); 把传中所有字符变成大写

　　　　类StringBuffer提供的方法 append() insert() setCharAt()
　　　　若操作后的字符已超出分配的缓冲区，系统自动为它分配额外的空间
　　　　　　public synchronized StringBuffer append(String str); 在当前字符串末尾添加一个字符串str
　　　　　　public synchronized StringBuffer insert(int offset, String str); 在当前字符串的offset处，插入str
　　　　　　public synchronized void setChatAt(int index, char ch); 设定指定index处的值

　　　　String和StringBuffer的区别在于：String是对拷贝进行操作，而StringBuffer是直接对字符串操作

　　6. 其他操作
　　　　字符串比较
　　　　　　String中的方法：
　　　　　　　　equals()
　　　　　　　　equalsIgnoreCase()
　　　　　　这两个方法与'=='的区别：'=='只关心是否引用同一对象，此两种方法关心对应的字符是否相同

　　　　字符串的转化
　　　　　　java.lang.Object中提供了方法
　　　　　　　　toString() 把对象转化为字符串

　　　　'+'操作