java知识总结（６）

　　1、Identifiers：标识符

　　 ①Names of class,method and variable:用于类名、方法名、变量名

　　②Begin with character,"_" or "$":标识符不能以数字开头

　　③Case sensitive:大小写敏感（区分大小写）

　　④No length limitation:长度无限制

　　⑤标识符不能是Java关键字，汉字也可以做标识符，但是不建议使用（使用汉字涉及到编码问题，跨平台时回出现问题）。

　　⑥String是Java的一个类，类名是标识符，所以String可以做标识符。

　　⑦There is no sizeof operator.Java中没有sizeof运算符，所以sizeof可以作为标识符

　　⑧关键字、保留字(const、goto、true、false、null)不能用作标识符。

 1 public class Identifiers {
 2     public static void main(String[] args) {
 3         String $abc="abc1";
 4         String _abc="abc2";
 5         //编译错误，标识符不能以数字开头
 6         //String 8abc="abc3";  
 7         String 中国="China";
 8         String String="wanghao";
 9         int Integer=22;
10         //Java中没有sizeof运算符，所以sizeof可以作为标识符
11         String sizeof="sizeof";
12         System.out.println(String);//wanghao
13         System.out.println(Integer);//22
14     }
15 }

 

　　2、Keywords：关键字

　　The goto and const keyword are not used in the Java programming.

　　const 保留关键字（留儿不用）。const是从C++继承而来的，但是Java并不使用const这个关键字，由于JVM是由C++编写的，因此，虽然Java并不使用const这个关键字，但却要保留下来。和const一样goto也是保留关键字！

　　关键字全部用小写表示（53个）

　　Strictly speaking,the literals true,false,and null are not keywords but literals;however,the distinction is academic.

true,false,and null是保留字但不是关键字，只是3个值，不能用来做关键字。

　　

 　　3、Primitive data types：基本数据类型

　　Java强数据类型只能先声明后使用。

　　boolean    Boolean literals indicating true or false

　　char       Stores one 16-bit unicode character

　　　　char 同时具备字符和整数的特征。　

　　byte       8-bit integer

　　short      16-bit integer

　　int        32-bit integer

　　long       64-bit integer

　　　　Integer Data Types-byte,short,int and long

　　float       32-bit floating-point number

　　double     64-bit floating-point number

　　在范围内的常数可以自动转换类型，但是变量就不一定了。

　　小————》大  自动转换

　　大————》小  强制类型转化

　　Byte相当于截取了最后8位，前面的全部舍去

 1 public class Demo {
 2     public static void main(String[] args) {
 3         int i1 = 5;  //语句1   Right
 4         
 5         byte b1=5;   //语句2   Right
 6         byte b2=3;   //语句3   Right
 7         //byte b3=128;  //语句4  Wrong   128超出了byte的范围
 8         byte b3=(byte)128;  //语句5   Right
 9         //byte的取值范围：（-128,127）
10         byte b4=127;
11         byte b5=-128;
12         //byte b6=-129;  //-129超出了byte的范围
13         
14         long l1=5;    //语句6    Right
15         long l2=5L;   //语句7    Right
16         //b1=i1;      //语句8  Wrong   i1不能转换成b1
17         b1=(byte)i1;  //语句9  
18         l1=i1;        //语句10  Right
19         //i1=123L;    //语句11   Wrong
20         i1=(int)123L;  //语句12
21         
22         //b1=b1+b2;   //语句13   Wrong  b1+b2变成int
23         b1=(byte)(b1+b2);  //语句14
24      }
25 }

　　程序分析：

　　① 整形数据默(byte,short,int and long)认类型是int型，因此语句1正确

　　② 占用位数小的类型（简称“小类型”）向占用位数多的类型（简称“大类型”）可以自动转换，相反，大类型到小类型则要通过强制类型转换。

 　　　  如：语句6是由int---->long(自动转换)。

　　　　语句11是由long---->int(不能进行转换，提示“可能损失精度”的错误)，必须通过强制类型转换，改正后为语句12。

　　③ 语句2和语句3是由int---->byte(自动转换)，这又是怎么回事呢？

　　　　int可自动转换为byte和short而无需强制类型转换，这是因为byte和short表示的范围较小，所有小于int的整型运算，先转换为int类型，再参与运算。例如：15和20都在byte范围内但是15*20却超出了byte的表示范围，则要存放在int类型变量里面。

　　④ 既然int可以自动转换为byte和short而不需强制类型转换，那么为什么语句8会出错，需要改成语句9这样的强制类型转换呢？

　　　　语句8表面上是int---->byte但是i1是一个int型的变量，它表示(-65535----65535)范围的整数，不能确定它的值，因此需要强制类型转换。语句4中128超出了byte的表示范围，因此不能赋值给byte变量b3需要进行强制类型转换，如语句5。

　　⑤ 强制类型转换的实质是什么呢？

　　　　例如语句5执行的结果是：-128，这是为什么呢？

　　　　　　这正是强制类型转换后的结果。int类型是32-bit，128的二进制表示形式为：00000000,00000000,00000000,10000000。Byte类型是8-bit，要把int类型强制转换成byte类型，则只截取其后8-bit，把前24-bit去除掉。因此byte b3=(byte)128;执行后的结果的二进制表示形式为：10000000，对应的整数即为-128。

　　⑥ 所有小于Int的整型运算，先转成int 再运算，因此语句13出现错误，需要进行强制类型转换，如语句14。

 1 public class Float {
 2     public static void main(String[] args) {
 3         double d1=123.0;
 4         double d2=123.0F;
 5         //编译错误    Default data type is double
 6         //float f1=123.0; 
 7         //需要强制类型转换
 8         float f1=(float)123.0;
 9         
10         //int和long可以自动转换为float和double
11         float f2=123;
12         float f3=123L;
13         double d3=123;
14         double d4=123L;
15     }
16 }

　　Float Point Data Type-float and double

　　① Default data type is double

　　② A float data is 32-bit long

　　③ A double data is 64-bit long

　　④ A float data ends with 'f' or 'F'

　　⑤ A double data can end with 'd' or 'D'

　　 　　在计算机领域对于float和double只能表示他们的近似值。因为小数可以无限，但是计算机表示的精度是有限的。

　　⑥ int和long可以自动转换为float和double

 

　　Java变量类型：

　　① 基本类型：boolean,byte,char,shot,int,long,float,double

　　② 引用类型：所有类、接口、数组、枚举、标注

　　

　　Recommended Naming Rules

　　① Class names begin with uppercase character

　　② Interface names begin with uppercase character

　　③ Method names begin with lowercase character

　　④ Variable names begin with lowercase character

　　⑤ Constant variable names are in uppercase character，不同单词间用“_” 隔开，例如：USER_NAME。

　　⑥ Package names are in lowercase character

　　规范我们可以违背，但是我们提倡遵守，养成一种良好的习惯！

 

　　4、Operators　　

　　Assignment operators

　　=   +=   -=   %=   *=   /=    <<=     >>=     >>>=    &=    ^=      |=

1 public class ByteDemo {
2     public static void main(String[] args) {
3         byte b1=2;
4         byte b2=3;
5         b1=(byte)(b1+b2);  // 语句1   加法，转int
6         b1+=b2;            //语句2    赋值，不转int
7     }
8 }

　　b1+=b2;是否和语句b1=b1+b2完全等价？

　　　　答案是否定的，上面程序中的语句1和语句2给出了证明。语句1中byte类型参数与运算时要先转换为int型，因此要进行强制类型转换。而语句2中，自动进行类型转换。(我的理解：我们可以把“b11+=b2;”看做是对“b1=(byte)(b1+b2);”的优化！)

　　Comparison operators

　　>    >=     <     <=     instanceof

　　Equality operators

　　= =        !=

　　Arithmetic operators

　　+       -       *       /        %

　　Shift operators

　　>>   <<    >>>

　　Bitwise operators

　　&     |      ^（按位异或）   ~（按位取反）

　　Logic operators

　　&&  （逻辑与） &      ||  （逻辑或）  |      ！（逻辑非）

　　&&和&都是逻辑与，它们之间的区别：&&是短路逻辑与，有短路的效果，效率更高。

　　||和|都是逻辑或，它们之间的区别：||是短路逻辑或，有短路的效果，效率更高。

　　Conditional  operators

　　? :

　　Other operators

　　++    --

 1 public class Test5 {
 2     public static void main(String [] args){
 3         int i=2;
 4         System.out.println(i++);   //2
 5         System.out.println(i);      //3
 6         int a=i++ + ++i;    //3+5=8
 7         System.out.println(a);
 8         System.out.println(i);  //5
 9         for(int j=0;j<1000;j++){
10             i=i++;
11         }
12         System.out.println(i);   //5
13     }
14 }

　　程序分析：

　　为什么经过1000次循环后，i=i++;的结果仍然是5？

　　（老师讲解）++的运算符优先级高于=(赋值)运算符，i++的运算结果为5，进入寄存器，这时寄存器中存放的值为5。然后i的值变为6，继续执行赋值语句，赋值时，把寄存器中的值赋5值给i，因此i的值是5和6之间来回切换的！

　　(我的理解)++的运算符优先级高于=(赋值)运算符，因此这个表达式的执行顺序如下：①运算i++这个表达式的结果为5 。----> ②i的值自加1(i++先参与运算，再自加1)，即i的值变为6。----> ③将i++这个表达式的值，即第①部的结果赋值给变量i。("="表达式是将右边表达式的值赋值与左边的变量，因此是将5赋于i，而不是将6赋于i)。整个循环过程i的值在5和6之间来回切换。

根据约定，在使用java编程的时候应尽可能的使用现有的类库，当然你也可以自己编写一个排序的方法，或者框架，但是有几个人能写得比JDK里的还 要好呢？使用现有的类的另一个好处是代码易于阅读和维护，这篇文章主要讲的是如何使用现有的类库对数组和各种Collection容器进行排序，(文章中的一部分例子来自《Java Developers Almanac 1.4》)

　　首先要知道两个类:java.util.Arrays和java.util.Collections(注意和Collection的区 别)Collection是集合框架的顶层接口，而Collections是包含了许多静态方法。我们使用Arrays对数组进行排序，使用 Collections对结合框架容器进行排序，如ArraysList,LinkedList等。

　　例子中都要加上import java.util.*和其他外壳代码，如类和静态main方法，我会在第一个例子里写出全部代码，接下来会无一例外的省略。

 

　　对数组进行排序

　　比如有一个整型数组：

1. int[] intArray = new int[] {4, 1, 3, -23}; 

　　我们如何进行排序呢？你这个时候是否在想快速排序的算法？看看下面的实现方法：

1. import java.util.*;  
2. public class Sort{  
3.     public static void main(String[] args){  
4.         int[] intArray = new int[] {4, 1, 3, -23};  
5.         Arrays.sort(intArray);  
6.     }  
7. }  

　　这样我们就用Arrays的静态方法sort()对intArray进行了升序排序，现在数组已经变成了{-23,1,3,4}.

　　如果是字符数组:

1. String[] strArray = new String[] {"z", "a", "C"}; 

　　我们用：

1. Arrays.sort(strArray); 

　　进行排序后的结果是{C,a,z}

　　进行排序后的结果是{C,a,z},sort()会根据元素的自然顺序进行升序排序。如果希望对大小写不敏感的话可以这样写：

1. Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); 

　　当然我们也可以指定数组的某一段进行排序比如我们要对数组下表0-2的部分(假设数组长度大于3)进行排序，其他部分保持不变，我们可以使用:

1. Arrays.sort(strArray,0,3); 

　　注意：

sort(double[] a, int fromIndex, int toIndex) 参数： a - 要排序的数组。 fromIndex - 要排序的第一个元素的索引（包括）。 toIndex - 要排序的最后一个元素的索引（不包括）。

　　这样，我们只对前三个元素进行了排序，而不会影响到后面的部分，结果为{1, 3, 4, -23}。

　　当然有人会想，我怎样进行降序排序？在众多的sort方法中有一个

1. sort(T[] a, Comparator<? super T> c) 

　　我们使用Comparator获取一个反序的比较器即可，Comparator会在稍后讲解，以前面的intArray[]为例：

 

 1 public class Sort {
 2     public static void main(String[] args) {
 3         Integer[] intArray = {4, 1, 3, -23};
 4         Arrays.sort(intArray, new Comparator<Integer>() {
 5             public int compare(Integer o1, Integer o2) {
 6                 return o2-o1;
 7             }
 8         });
 9         System.out.println(Arrays.toString(intArray));
10     }
11 }

 

　　这样，我们得到的结果就是{4,3,1,-23}。如果不想修改原有代码我们也可以使用：

1. Collections.reverse(Arrays.asList(intArray)); 

1 public class Sort {
2     public static void main(String[] args) {
3         Integer[] intArray = {4, 1, 3, -23};
4         Arrays.sort(intArray);
5         Collections.reverse(Arrays.asList(intArray));
6         System.out.println(Arrays.toString(intArray));
7     }
8 }

　　得到该数组的反序。结果同样为{4,3,1,-23}。

 

　　现在的情况变了，我们的数组里不再是基本数据类型(primtive type)或者String类型的数组，而是对象数组。这个数组的自然顺序是未知的，因此我们需要为该类实现Comparable接口，比如我们有一个Name类：

 1 class Name implements Comparable<Name>{  
 2     public String firstName,lastName;  
 3     public Name(String firstName,String lastName){  
 4         this.firstName=firstName;  
 5         this.lastName=lastName;  
 6     }  
 7     //实现接口 
 8     public int compareTo(Name o) {           
 9         int lastCmp=lastName.compareTo(o.lastName);  
10         return (lastCmp!=0?lastCmp:firstName.compareTo(o.firstName));  
11     }    
12     //便于输出测试  
13     public String toString(){                
14         return firstName+" "+lastName;  
15     }  
16 }

　　这样，当我们对这个对象数组进行排序时，就会先比较lastName，然后比较firstName 然后得出两个对象的先后顺序，就像compareTo(Name o)里实现的那样。不妨用程序试一试：

 1 public class NameSort {  
 2      public static void main(String[] args) {  
 3          Name nameArray[] = {  
 4             new Name("John", "Lennon"),  
 5             new Name("Karl", "Marx"),  
 6             new Name("Groucho", "Marx"),  
 7             new Name("Oscar", "Grouch")  
 8         }; 
 9         Arrays.sort(nameArray);  
10         System.out.println(Arrays.toString(nameArray));;  
11     }  
12 } 

　　结果正如我们所愿：[Oscar Grouch, John Lennon, Groucho Marx, Karl Marx]

 

　　对集合框架进行排序

　　如果已经理解了Arrays.sort()对数组进行排序的话，集合框架的使用也是大同小异。只是将Arrays替换成了Collections,注意Collections是一个类而Collection是一个接口，虽然只差一个"s"但是它们的含义却完全不同。（Comparator and Comparable及Collections and Collection的用法和区别）

　　假如有这样一个链表：

1. LinkedList list=new LinkedList();  
2. list.add(4);  
3. list.add(34);  
4. list.add(22);  
5. list.add(2); 

　　我们只需要使用:

1. Collections.sort(list); 

　　就可以将ll里的元素按从小到大的顺序进行排序，结果就成了:

1. [2, 4, 22, 34] 

　　如果LinkedList里面的元素是String，同样会想基本数据类型一样从小到大排序。

　　如果要实现反序排序也就是从大到小排序:

1. Collections.sort(list,Collectons.reverseOrder()); 

 1 public class Sort2 {
 2     public static void main(String[] args) {
 3         LinkedList<Integer> list=new LinkedList<Integer>();  
 4         list.add(4);  
 5         list.add(34);  
 6         list.add(22);  
 7         list.add(2); 
 8         Collections.sort(list, Collections.reverseOrder());
 9         System.out.println(list.toString());
10     }
11 }

　　结果为：[34, 22, 4, 2]

　

　　如果LinkedList里面的元素是自定义的对象，可以像上面的Name对象一样实现Comparable接口，就可以让Collection.sort()为您排序了。

　　如果你想按照自己的想法对一个对象进行排序，你可以使用

1. sort(List<T> list, Comparator<? super T> c) 

　　这个方法进行排序，在给出例子之前，先要说明一下Comparator的使用，Comparable接口的格式：

1. public interface Comparator<T> {  
2.     int compare(T o1, T o2);  
3. }  

　　其实Comparator里的int compare(T o1,T o2)的写法和Comparable里的compareTo()方法的写法差不多。在上面的Name类中我们的比较是从LastName开始的，这是西方人的习惯，到了中国，我们想从fristName开始比较，又不想修改原来的代码，这个时候，Comparator就可以派上用场了：

1. final Comparator<Name> FIRST_NAME_ORDER=new Comparator<Name>() {  
2.     public int compare(Name n1, Name n2) {  
3.          int firstCmp=n1.firstName.compareTo(n2.firstName);  
4.          return (firstCmp!=0?firstCmp:n1.lastName.compareTo   
5.                  (n2.firstName));  
6.     }  
7. };  

　　这样一个我们自定义的Comparator FIRST_NAME_ORDER就写好了。

　　将上个例子里那个名字数组转化为List:

1. List<Name> list=Arrays.asList(nameArray);  
2. Collections.sort(list,FIRST_NAME_ORDER); 

　　这样我们就成功的使用自己定义的比较器设定排序。

java虚拟机内存原型

　　寄存器：我们在程序中无法控制

　　栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中

　　堆：存放用new产生的数据

　　静态域：存放在对象中用static定义的静态成员

　　常量池：存放常量

　　非RAM存储：硬盘等永久存储空间

 

　　Java内存分配中的栈

　　栈的基本单位是帧（或栈帧）： 每当一个java线程运行的时候， java虚拟机会为该线程分配一个java栈。该线程在执行某个java方法的时候， 向java栈压入一个帧， 这个帧用于存储参数、局部变量、操作数、中间运算结果等。当这个方法执行完的时候， 帧会从栈中弹出。Java栈上的所有数据是私有的，其他线程都不能该线程的栈数据。

　　在函数中定义的一些基本类型的变量数据和对象的引用变量都在函数的栈内存中分配。

　　当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当该变量退出该作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

 

　　Java内存分配中的堆

　　java虚拟机中的堆用来存放由new创建的对象和数组。 在堆中分配的内存，由Java虚拟机的自动的垃圾回收机制来管理堆的内存。

　　简单的说和栈相对,堆主要是用来存放java对象的，栈主要是用来存放对象引用的...在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。引用变量就相当于是为数组或者对象起的一个名称。

　　引用变量是普通的变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身在堆中分配，即使程序运行到使用 new 产生数组或者对象的语句所在的代码块之外，数组和对象本身占据的内存不会被释放，数组和对象在没有引用变量指向它的时候，才变为垃圾，不能在被使用，但仍然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走（释放掉）。这也是 Java 比较占内存的原因。

　　实际上，栈中的变量指向堆内存中的变量，这就是Java中的指针！

　　Java的堆是一个运行时数据区，类的(对象从中分配空间。这些对象通过new、newarray、 anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

　　栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量数据（int, short, long, byte, float, double, boolean, char）和对象句柄(引用)。

　　栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：

1 int a=3;
2 int b=3;

　　编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3；在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。

　　这时，如果再令 a=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。

　　常量池 (constant pool)

　　常量池指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。除了包含代码中所定义的各种基本类型（如int、long等等）和对象型（如String及数组）的常量值(final)还包含一些以文本形式出现的符号引用，比如：

　　1、类和接口的全限定名；

　　2、字段的名称和描述符；

　　3、方法和名称和描述符。

　　虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（string,integer和 floating point常量）和对其他类型，字段和方法的符号引用。

　　对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的， 对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。

　　在程序执行的时候,常量池会储存在Method Area,而不是堆中。