CoreJava --基本语法

1.  一个java源文件只有一个public类且类名与文件名一致。注：一个可运行的java应用程序应有一个main方法，且格式固定，但不一定在public类中。

2. package语句只能有一个且放在程序的第一行。

3. 整数在内存中式按照其补码来存储的，正数的补码=原码，负数的补码=原码取反加1 ，char无符号位（0~65535）

4. 强制转换可能有数据和精度的丢失，也有可能改变数据的正负性。自动转换也会有数据和精度的丢失,如：

    int-->float , long-->float , long-->double

5.不要在程序中比较两个浮点数相等，应该用他们差的绝对值是否小于一个足够小的数来判断。

6. 给变量赋值时，所赋值范围应小于变量范围，默认整数是int型，小数是double型

7. 属性没括号，方法有括号，构造无返回值。

8. 创建实例对象的内存图：

     内存----->栈内存（后进先出，先进后出）

           ----->堆内存

           ----->代码段（方法区）

           ----->寄存器

           ----->池（常驻内存，可申请但不可回收）

     实例：Emp   e    =     new    Emp();    e.getSall(500);

     执行顺序:(2)      (3)             (1)                      (4)

          栈里先放Emp的引用e，然后是500    堆里放Emp的实例对象，除了实例变量外 堆里的静态池存放了类变量也就是静态变量                         

                                                                                                                                                           

9.操作符：移位运算符：>>右移 正数补0 负数补1   >>>无符号右移 全补0  <<左移 都补0 

             i) 对于int和小于int型的以32为基准：

                          7>>-30<=> 7>>2(移动负数位相当于负数+32的倍数)

                          7>>34 <=>7>>2 (大于32的相当于n%32 正好移动32或0位则不变)

            ii) 对于long型基准是64

    赋值运算：byte i= 5; i+=1;正确  因为赋值运算自动转换成范围大的类型；

                   byte i = 5;i=i+1;错误  要强制类型转换。。因为小于int的整数运算，先转化为int后在运算。

    位运算：& |  ^ ~ (都真才真，都假才假，不同才真，相反);

    三目运算符： a>b?5.0:3  =>输出3.0            

                        a>b?5.0:"ok" =>1.5不会输出ok 1.6可以

                     说明：若结果类型不同尽量转成相同的

    &与&&的区别：1）&是位与也是逻辑与2）&&是短路与，效率高

    优先权：++ -- + - ! ~ * / % + - << >> >>> < > <= >= instanceof 

                 == != & ^ | && || ?:  赋值

 

 10. switch(temp)   temp可选类型（int char 枚举）

       如果进入到某个没有break的分支，  则继续向下执行，而不验证case，直到遇到break或到句尾

 11. 死循环后不能放任何语句。

 12. int i = 4;

       for(int j=0;j<10;j++){

             i= i++;

       }循环完i的结果是4.。。。先i++后i=5 之后又把4赋值给i这样循环n次i的值也是不变的

 13. if else多分支与switch循环的条件应该是"小范围"放在上面。

 14. 随即数 double  a = Math.random();   [0,1)随即一个数

 15. 小技巧：for(int i=0;i<100;i++){

                           i--;返回上层循环

                   }

 16.交换a,b的值 不用中间变量 a = a+b; b = a-b; a = a-b;

 17.数组：定义  double[]  d = new double[3]

                       int[] a = {1,2,3}   return 数组的时候不能用这种初始化。

                       int[] a = new int[]{1,2,3}  长度a.length

      sun提供的操作数组的类Arrays  :public class Arrays extends Object

      1)复制数组：System.arraycopy(a1,i,a2,j,k);从a1的i位置开始复制到a2的j位置开始 复制k个数据

      2)排序数组：基本数据类型：Arrays.sort(a);    

                        字符串：Arrays.sort(s);由于String类实现了comparable接口 故可直接用sort方法

                                    其他引用类型必须实现comparable才能用sort比较

                        引用类型：Arrays.sort(Object[] a); 根据元素自然顺序，升序排列

                                       sort(Object[] a,int from(包括),int to(不包括));若from==to则排序范围空

                                       sort(T[] t,Comparator c)根据指定比较器(实现Comparator)产生的顺序进行排序

      3)做固定大小的数组：List  Arrays.asList(a);

      4)搜索数组：搜索数组之前必须对数组进行排序

                       int Arrays.binarySearch(type[] a, type key)

                       int Arrays.binarySearch(Object[] a, Object key)

                       int Arrays.binarySearch(T[] t, T key, Comparator c)

      5)相等：Arrays.equals(type[] a1,type[] a2) 两个type型数组对应的值都相等才返回true；

      6)填充数组：Arrays.fill(type[] a1, type a2) 把type型值a2赋给数组a1的每个元素

                        Arrays.fill(type[] a1,int from,int to,type a2)

      7)Arrays.toString(type[] a) 对数组中每个元素String.valueOf(a[i])然后放入[]中用","隔开,如[1,2,3]

         对于引用类型与Arrays.asList(a).toString()等价

 18.String

    public final class String extends Object implements Serializable,Comparable<String>,CharSequence

    字符串是常量，他们的值在创建之后不能被改变。字符串缓冲区支持可变的字符串。

    因为String对象是不可改变的，所以可以共享它们。

    注：String str = "abc"; 等价于char[] data = {'a','b','c'};String str = new String(data);

   构造：1)bytes[]-->String:  i) String(byte[] bytes)/String(byte[] bytes,int offset,int length)

                                                 例如：byte[] b = {1,2,3} new String(b)之后的结果不是"123"据我推测是由于该构造方法

                                                         是根据byte数组中元素与Ascii码做匹配，匹配出的字符依次连接在一起组成字符串

                                                         如；“啊”的Ascii码值是-80，-95

                                                         byte[] b = {-80,-95,-80,-95} new String(b);结果是"啊啊

                                               ii)String(byte[] bytes,String charsetName) 构造一个新的 String，方法是使用指定的字符集解码指定的字节数组

           2）char[]-->String:    String(char[] value)  分配一个新的 String，它表示当前字符数组参数中包含的字符序列。该字符数组的内容已被复制；后续对字符数组的修改不会影响新创建的字符串。

                                               例子：char[] c = {'1','2','12'};这是错误的，字符里没有'12'只有'0'到'9'

                                                        char[] c = {97} new String(c)  结果是a  与byte一样，但char都是正数(0,65535)

           3)String-->String:     String(String original) 新创建的字符串是该参数字符串的一个副本。

           4)StringBuffer-->String:  String(StringBuffer buffer)  分配一个新的字符串，它包含当前包含在字符串缓冲区参数中的字符序列。此字符串缓冲区的内容已被复制，后续对它的修改不会影响新创建的字符串。

           5)StringBuilder-->String:   String(StringBuilder builder)分配一个新的字符串，它包含当前包含在字符串生成器参数中的字符序列。此字符串生成器的内容已被复制，后续对此字符串生成器的修改不会影响新创建的字符串。

    方法： charAt(int index) 返回指定索引处的char值

               compareTo(String str) 按字典顺序比较两个字符串

               compareToIgnoreCase(String str) 不考虑大小写

               concat(String str) 将指定字符串连接到此字符串的结尾。

               contentEquals(CharSequence cs)
                当且仅当此 String 表示与指定序列相同的 char 值时，才返回 true。

    static  copyValueOf(char[] data)
                 返回指定数组中表示该字符序列的字符串。

               endsWith(String suffix) 
                此字符串是否以指定的后缀结束。

               equals(Object anObject)
                 比较此字符串与指定的对象。

               equalsIgnoreCase(String anotherString)
                  将此 String 与另一个 String 进行比较，不考虑大小写。

              getBytes()
                使用平台默认的字符集将此 String 解码为字节序列，并将结果存储到一个新的字节数组中。

              getBytes(String charsetName)
                使用指定的字符集将此 String 解码为字节序列，并将结果存储到一个新的字节数组中。

            用字符串里的值填充某字符数组

             getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
                 将字符从此字符串复制到目标字符数组。

             indexOf(int ch)
                 返回指定字符在此字符串中第一次出现处的索引。

             indexOf(int ch, int fromIndex)
                 从指定的索引开始搜索，返回在此字符串中第一次出现指定字符处的索引。

             indexOf(String str) 另个方法同上
                 返回第一次出现的指定子字符串在此字符串中的索引。

            lastIndexOf(int ch)   另个方法同上                                       
                返回最后一次出现的指定字符在此字符串中的索引。

            lastIndexOf(String str) 另个方法同上
                返回在此字符串中最右边出现的指定子字符串的索引。

            length()
               返回此字符串的长度。

            matches(String regex)
                通知此字符串是否匹配给定的正则表达式。

            replace(char oldChar, char newChar)
              返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 而生成的。

            replace(CharSequence target, CharSequence replacement)
                使用指定的字面值替换序列替换此字符串匹配字面值目标序列的每个子字符串。

           split(String regex)
              根据给定的正则表达式的匹配来拆分此字符串。

          split(String regex, int limit)  limit限制了数字的长度，如果为负数则任意长度，为0也任意长度但末尾的空字符串被丢掉

          startsWith(String prefix)
             测试此字符串是否以指定的前缀开始。

          startsWith(String prefix, int toffset)
              测试此字符串是否以指定前缀开始，该前缀以指定索引开始。

          subSequence(int beginIndex, int endIndex)
               返回一个新的字符序列，它是此序列的一个子序列。

          substring(int beginIndex)
               返回一个新的字符串，它是此字符串的一个子字符串。

          substring(int beginIndex, int endIndex)
                返回一个新字符串，它是此字符串的一个子字符串。

          toCharArray()
              将此字符串转换为一个新的字符数组。

         toLowerCase() /toUpperCase()
             使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

         trim()
             返回字符串的副本，忽略前导空白和尾部空白。

  static valueOf(type t)  (type是基本类型，这里不包括short和byte类型) 返回t的字符串形式

  static  valueOf(char[] data)
                返回 char 数组参数的字符串表示形式。

  static  valueOf(Object obj)
              返回 Object 参数的字符串表示形式。