java基础（一）：进制，运算符，流程控制，函数，数组

一、标识符

    1、定义合法标识符规则

          1）数字不可以开头；2）不可以使用关键字 （注意：Java严格区分大小写！）

     2、Java中的名称规范

           1）包名：多单词组成时所有字母都小写 ；如：xxxyyyzzz

           2）类名接口名：多单词组成时，所有单词首字母大写； 如：XxxYyyZzz

           3）变量名和函数名：多单词组成时，第一个单词字母小写，第二个开始首字母大写；如 ： xxxYyyZzz

           4）常量名：所有字母都大写，多单词时每个单词用下划线连接

二、进制转换

     1、负数的二进制表现形式：这个数的正数的二进制取反+1；

           如：6 --> 二进制：  0000-0000 0000-0000 0000-0000 0000-0110；

                             取反的： 1111-1111  1111-1111   1111-1111   1111-1001  +   1 得：

                   -6 -->  二进制：1111-1111  1111-1111   1111-1111   1111-1010

                   负数的最高位是1

                   计算机处理各种计算时是将数据转化成二进制的数，计算完成后转换回去的；

                   各个进制中间转换时先将数转换成二进制再转换成目标进制

三、常量与变量

     1、数据类型： java是强类型语言，对于每一种数据都定义了明确的具体类型，在内存中分配了大小不同大小的内存空间

            1）基本数据类型

                  A、数值型 

                         a、整数类型

                               byte（0）         1个字节（八位）      负2的7次幂 - 正2的7次幂减1        包装类   Byte

                               short（0）        2个字节                                15                   15                            Short

                               int（0）             4个字节                                31                   31                            Integer

                               long（0L）       8个字节                                 63                   63                            Long

                         b、浮点类型

                               float（0.0F）    4个字节                                                                                        Float

                               double（0.0D）8个字节                                                                                       Double

                  B、字符型（char（'\u0000'））                                                                                       Character

                  C、布尔型（boolean（false））                                                                                     Boolean

             2）引用数据类型

                  A、类（class）

                  B、接口（interface）

                  C、数组（[ ]）

             整数默认：int         小数默认：double

             面试题： Integer   i1 = 2017，i2 = 2017；System.out.println(i1 == i2）；输出false，原因是Cache to support the object identity semantics of autoboxing for values between -128 and 127 (inclusive) as required by JLS.这是在源码中的注释，意思是说缓存支持值之间的-128和127的自动装箱的对象标识的语义（含）按JLS；

首先，i1,i2是Integer类的实例，因此“==”比较的是两个实例的内存地址。

因为整型的包装类存在常量池,一次性把从-128到127之间的所有数都初始化了.当你使用这些数的时候不是创建新对象而是直接从这个常量池里面取值.所以当你赋值100的时候是取的常量池里的100,因此两个对象内存地址一样.而赋值200的时候两个对象分别new对象,因此内存地址不同.

四、算术运算符

       引用一位大牛写的：Study Notes 写的：  Java的算数运算符、关系运算符、逻辑运算符、位运算符

       注意： b = ++a ； 为先自增再赋值给b，b = a ++ ； 先赋值给b，再自增

       

       位运算符：

      二进制数据左移右边补0，右移左边补最高位数的数。无符号右移左边补0

       &、^、|运算符

                             

 

       练习题：

       1、计算2乘以8最有效的方式是什么？

                在计算机中低层运算都是二进制做运算的，所以最有效的方式是 ：  2 << 3

       2、对两个整数变量的值进行互换（不需要第三方变量）

                1）第三方变量（temp = n;n = m;m = temp;）

                2）n = n + m;//这种方法优缺点。如果n 和 m 值比较大就容易超出int范围

                      m = n - m;

                      n = n - m;

                3）n = n ^ m;

                     m = n ^ m; // (n ^ m) ^ m;

                     n = n ^m; // n ^ (n ^ m);

                 

五、流程控制语句

       if、简化if语句（判断条件？结果1：结果2；）、if  else if else、switch（数据非常小的情况下效率比if语句高点点）、while、do while、for  

       do while和while的区别：

              while： 先判断条件，条件满足才执行循环体

              do while ：先执行循环体，再判断条件，无论条件是否满足循环体至少执行一次；

       for 和 while的区别：变量的作用域不同，while语句结束后变量仍然在栈内存中存在引用，而for循环结束后没有多余的变量存在，效率而言for稍高

       break和continue： 

              break： 用于选择结构和循环结构（跳出的意思），多重嵌套循环的时候可以给循环取名字；

                     例：

w:for(int x=0;x<3;x++){    q:for(int y=0;y<4;y++){        sop("x="+x);        break w;//此处跳出外面的for循环    }}

              continue：应用于循环结构（继续的意思）,continue后面的语句不执行

六、函数

       格式：

              修饰符  返回值类型  函数名（参数类型 形式参数1，参数类型 形式参数2，...）{

                     执行语句；

                     return 返回值；

              }

       1、重载：在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同

              特点：与返回值类型无关，只看方法名和参数列表。

              好处：方便阅读，优化程序设计。

       如：同类中

int add(int x,int y){    return x+y;}     void add(int x,int y,int z){    sop(x+y+z);}double add(double x,double y){    return x+y;}

七、数组

       1、概念：同一种类型数据的集合。是一个容器。

       2、格式：

              2.1、元素类型[ ] 数组名 = new 元素类型[元素个数或者数组长度];

              2.2、元素类型[ ] 数组名 = new 元素类型[ ]{元素，元素，元素，...};

       3、内存结构：

              栈内存：用于存储局部变量，当数据使用完，所占内存会自动释放

              堆内存：数组和对象，通过new关键字建立的实例都存放在堆内存中

                            每一个实体都有内存地址值

                            实体中的变量都有默认初始化值

                            实体不在被使用，会在不确定的时间内被垃圾回收器回收

              方法区，本地方法区，寄存器。

              当执行：int[] x = new int [3];时，在堆内存中开辟空间，并且给x指向的数组初始化赋值0

       4、数组的操作（存取数据）

              4.1、length：数组的属性，获取数组的长度（个数）。使用方式：int size = 数组名称.length；

              4.2、获取最值

//通过比较角标对应的值并记录最大值来获取最大值public static int getMax(int[] arr) {int max = arr[0];for (int x=1;x<arr.length;x++) {if (arr[x] > max) {max = arr[x];}}return max;}//通过比较角标对应的值并记录最大值角标来获取最大值public static int getMax_1(int[] arr) {int max = 0;for (int x=1;x<arr.length;x++) {if (arr[x] > arr[max]) {max = x;}}return arr[max];}

             4.3、数组排序

                     4.3.1、选择排序

                           排序原理：

                                   先拿0角标元素与0角标之后的元素比较，当0角标元素小则不动，0角标元素大则和0角标后元素小的换位置

                                   一轮完成后得到0角标最小的元素，然后用1角标元素一次和后面的元素比较。。。    

public static void selectSort(int[] arr) {for (int x=0;x<arr.length-1;x++) {for (int y=x+1;y<arr.length;y++) {if (arr[x] > arr[y]) {int temp = arr[x];arr[x] = arr[y];arr[y] = temp;}}}}

                     4.3.2、冒泡排序

                            排序原理

                                   相邻的两个元素进行比较，如果符合条件就换位。

                                   特点：最值出现在最后             

public static void bubbleSort(int[] arr) {for (int x=0;x<arr.length-1;x++) {//-x：为了让每次比较的元素减少，-1：避免角标越界for (int y=0;y<arr.length-x-1;y++) {if (arr[y] > arr[y+1]) {int temp = arr[y];arr[y] = arr[y+1];arr[y+1] = temp;}}}}

                                   排序算法最快，效率最高的是：希尔排序（三层循环+位运算）

要了解希尔排序的话最好先搞定：直接插入排序

public static void insertSort(int[] a) {// 第0位独自作为有序数列，从第1位开始向后遍历for (int i = 1; i < a.length; i++) {// 0~i-1位为有序，若第i位小于i-1位，继续寻位并插入，// 否则认为0~i位也是有序的，忽略此次循环，相当于continue//{2,1,5,3,9,8,6,4,7}if (a[i - 1] > a[i]) {System.out.println(1);// 6int temp = a[i];// 保存第i位的值int k;// 从第i-1位向前遍历并移位，直至找到小于第i位值停止// a[k] > temp ： 判断i角标的值和i前面的角标的值for (k = i - 1; k >= 0 && a[k] > temp; k--) {//如果 a[k] > temp成立，则将k角标的值向后移动一位a[k + 1] = a[k];}// 插入第i位的值a[k + 1] = temp;}}}

public static void shellSort(int[] a) {//希尔排序for (int d = a.length / 2; d > 0; d = d / 2) {System.out.println("d=" + d);for (int i = d; i < a.length; i++) {int temp = a[i];int j;for (j = i - d; j >= 0 && temp < a[j]; j = j - d) {a[j + d] = a[j];}a[j + d] = temp;}for (int z : a)System.out.println(z);}}

希尔排序转自：“深入理解”—插入排序算法

                                   选择排序和冒泡排序可以优化：将需要换位置的角标记录下来，然后再最后换，只换一次

                                          将在堆内存中的频繁位置置换优化

                                   真实开发中用：Arrays.sort(arr);

                                   选择排序优化（把频繁的堆内存换位转换成栈内存变量记录，最终只有需要换位时在堆内存中换位）：

public static void selectSort_2(int[] arr) {for (int x = 0; x < arr.length - 1; x++) {int num = arr[x];//定义两个变量记录起始值int index = x;for (int y = x + 1; y < arr.length; y++) {if (num > arr[y]) {num = arr[y];index = y;}}if (index != x){//当定义的初始量变化后换位，不变化则说明x角标代表的当前值是最值int temp = arr[x];arr[x] = arr[index];arr[index] = temp;}}}

                                 折半查找：

public static int halfSearch(int[] a,int key) {int min = 0, max = a.length -1, mid;while(min <= max) {mid = (max + min) >> 1;if (key > a[mid]) {min = mid + 1;} else if (key > a[mid]) {max = mid -1;} else {return mid;}}return -1;}

                            折半查找联系：有序数组，插入一个数还保持有序，获取插入元素在数组中的位置

public static int getIndex(int[] a,int key) {int min = 0, max = a.length -1, mid;while(min <= max) {mid = (max + min) >> 1;if (key > a[mid]) {min = mid + 1;} else if (key > a[mid]) {max = mid -1;} else {return mid;}}return min;}

             4.4、进制转换应用

public static String toBin(int num) {return trans(num,1,1);}public static String toOct(int num) {return trans(num,7,3);}public static String toHex(int num) {return trans(num,15,4);}public static String trans(int num,int base,int offset) {char[] arr = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F',};StringBuffer sb = new StringBuffer();while (num != 0) {int a = num&base;sb.append(arr[a]);num = num >>> offset;}return sb.reverse().toString();}