Java学习2：Java语言基础组成

关键字

class、 public等

标识符

类名、函数名等

注释

单行、多行、文档注释

/**
: 这为文档注释

*/

常量变量

常量

整数常量：十进制 ,八进制0 ,十六进制0x

小数常量：0.5

布尔型常量：true /false

字符常量：’a’

字符串常量：”aa”

null常量：只有一个数值null

变量

基本数据类型

数值型：整数类型（byte(8) short(16) int(32) long(64)）、浮点类型（float(32) double(64)）
整数默认int，小数默认double，所以float a = 2.3;会出错，需要float a = 2.3f;

字符型：char(16)

布尔型：boolean

引用数据类型

类：class

接口：interface

数组：[]

类型转换

public class{    public static void main(String[] arg){        byte a = 2;//会检查2是否在byte的范围内，在的话就不会报错        a =      a       +       4;//此语句会出错，需要进行强制类型转换：a = (byte)(a + 4);     //8位  自动类型提升为32位     32位     //自动类型提升：以类型大的为主，小的向大的提升        System.out.printf(a);        System.out.println('a' + 1);//输出a        System.out.println('a' + 1);//输出98  ，因为做运算时'a'由16位提升为32位        System.out.println(char('a' + 1));//    } }

运算符

算术运算符

: +、 -、 *、 /

赋值运算符

class Demo{        public static void main(String[] arg){            System.out.println(-1%5);//-1            System.out.println(1%-5);//1            short s = 2;            s = s + 5;//编译出错，两次运算，因为5默认为32位int，所以s自动类型提升为32位int，运算之后的结果还是int类型的，无法幅值给short，赋值给s会出现丢失精度的错误            s += 5;//一次运算，和s = 2一样，自动完成强转操作            System.out.println(s);    }}

比较运算符

转义字符

\n：换行
\r：回车（window中回车符是由\n\r表示）
\b：退格，相当于backspace
\t：制表符，相当于Tab

逻辑运算符

&：无论左边是false还是true，右边都运算；
&&：当左边为false时，右边不运算（短路）。

|：两边都参与运算；
||：当左边为true时，右边不参与运算（短路）。

位运算符

<< >> >>>(无符号右移) & | ^ ~
注意：
（1）>> ：最高位补什么由原有数据的最高位值而定，最高位为0，右移后用0补空位；最高位为1，右移后用1补空位。>>>无论最高位是什么，右移后都用0补。
（2）一个数异或同一个数2次，结果还是那个数：7^4^4=7，可用作加解密。
（3）a ^ b = |a - b| 按位异或操作可以表达为按位相减取绝对值.

e.g.1 不用第3个变量交换两个数：

int n = 2; m = 8;//1.如果n和m的值都非常大，容易超过int范围n = n + m;m = n - m;//2.使用异或 n = n ^ m;//n = 3 ^ 8 m = n ^ m;//m = 3 ^ 8 ^ 8 = 3 n = n ^ m;//n = 3 ^ 8 ^ 3 = 8

e.g.2 十进制转换成八进制/十六进制：

public class Demo{    public static void main(String[] arg){        //十进制转换为八进制        int numOctal = 60;        int divOctal = 7;        int rightShift_Octal = 3;        String cOctal = "";        while(numOctal > 0){            cOctal = (numOctal & divOctal) + cOctal;    //一位位拼接            numOctal >>= rightShift_Octal;//右移3位，注意用>>>，因为负数时前面需要补0        }        System.out.println(cOctal);        //十进制转换为十六进制        int numHex = 123456789;        int divHex = 15;        int rightShift_Hex = 4;        int temp;        char c;        String cHex = "";        while(numHex > 0){            temp = numHex & divHex;            if(temp > 9){                c = (char)(temp - 10 + 'a');//如果大于9，则转换为字母a b c d e f                cHex = c + cHex;//一位位拼接            }            else{                cHex = temp + cHex;//一位位拼接            }            numHex >>>= rightShift_Hex;//右移4位，注意用>>>，因为负数时前面需要补0        }            System.out.println(cHex);        //十进制转换为二进制        int numBinary = 60;        int divBinary = 1;        int rightShift_Binary = 1;        String cBinary = "";        while(numBinary > 0){            cBinary = (numBinary & divBinary) + cBinary;    //一位位拼接            numBinary >>>= rightShift_Binary;//右移1位，注意用>>>，因为负数时前面需要补0        }        System.out.println(cBinary);    }}

语句

判断语句
if, switch

/*执行顺序：case 1 ——> case 3 ——> case 4 ——> default结果：  none  a = 1  a = 3*/public class Demo{    public static void main(String[] arg){        int a = 2;        switch(a)//!!!四种类型可以进行switch判断：byte short int char 还有字符串、枚举类型!!!        {            default:                System.out.println("none");            case 1:                System.out.println("a = " + 1);                //break;            case 3:                System.out.println("a = " + 3);                break;            case 4:                System.out.println("a = " + 4);                break;        }    }}

循环语句
while, do while, for

public class Demo{        public static void main(String[] arg){                    /*                        输出结果：                          a                          d                          c                          d                          c                          d                          c                          for(;;){}:无限循环                    */                    int x = 0;                    for(System.out.println("a"); x<3; System.out.println("c")){                        System.out.println("d");                        x++;                        }        }   }

break 、continue
标号：只能用于循环上，给循环起名的一种方式，见下例：

    public class Demo{    //结果：i=0        public static void main(String[] arg){                w:for(int i=0; i<3; i++){                    q:for(int j=0; j<4; j++){                            System.out.print("i=" + i);                            break w;                        }                   }           }    }

continue：只能用于循环结构，应用见下例：

    public class Demo{        /*结果：        i=0        i=1        i=2      */        public static void main(String[] arg){                w:for(int i=0; i<3; i++){                    q:for(int j=0; j<4; j++){                            System.out.println("i=" + i);                            continue w;                     }                   }           }    }

函数

重载：

void show(int a, char b, double c){}a:void show(int x, char y, double z){}//未重载b:int show(int a, double c, char b){}//重载，因为参数类型不同c:void show(int a, double c, char b){}//重载,因为参数类型不同，重载和返回值类型无关d:boolean show(int c, char b){}//重载，因为参数个数不同e:void show(double c){}//重载，因为参数个数不同f:double show(int x, char y, double z){}//未重载，此函数不可与给定函数同时存在于一个类中

数组

数组即容器

一维数组

1. 元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
   int[] arr = new int[5];//运行时才在堆中分配空间
2. 元素类型[] 数组名 = new 元素类型[元素, 元素, ……];
   int[] arr = new int[]{1, 2, 3, 4}; // eg: return new int[]{1, 2}; 创建元素为2的数组，并且给两个元素赋值，之后返回https://leetcode.com/problems/two-sum/solution/
   int[] arr = {1, 2, 3, 4};//上面的简化语句
   （左边相当于int arr[]）
   char[] arr = new char[8];//字符数组默认初始化为’ ‘，即\u0000

内存结构

1. 栈内存：
   用于存储局部变量，当数据使用完，所占空间会自动释放；
   
2. 堆内存：
   （1）数组和对象，通过new建立的实例都存放在堆内存中；
   （2） 每一个实体都有内存地址值；
   （3）实体中的变量都有默认初始化值；
   （4）实体不再被使用时，会在不确定的时间内被垃圾回收器回收。
   
   注意：如果此时进行赋值：x=null，则x的值由0x1077变为null，此时x不再引用堆中的数组，数组会在不确定时间内被启动的垃圾回收机制清除。

排序

冒泡排序、选择排序：

public class Demo{        public static void main(String[] arg){                int[] arr = {3,5,4,6,2,1,4,78,0,2};                printArr(arr);                bubbleSort(arr);//冒泡排序                //selectSort(arr);//选择排序                Array.sort(arr);//java中已经定义好的一种排序方式                printArr(arr);            }        //冒泡排序：相邻的两个元素进行比较，如果符合条件换位        public static void bubbleSort(int[] arr){                for(int i=0; i<arr.length-1; i++){//冒泡次数为arr.length-1                    for(int j=0; j<arr.length-1-i; j++){                        if(arr[j] > arr[j+1]){//判断是否需要交换                            int tmp = arr[j];                            arr[j] = arr[j+1];                            arr[j+1] = tmp;                         }                    }                   }        }        //选择排序：内循环结束一次，最值出现在头角标位置处        public static void selectSort(int[] arr){                for(int i=0; i<arr.length-1; i++){//遍历整个数组（除了最后一个元素）                    for(int j=i+1; j<arr.length; j++){//某个元素和后面的元素一一比较                        if(arr[i] > arr[j]){//判断是否需要交换                            int tmp = arr[i];                            arr[i] = arr[j];                            arr[j] = tmp;                           }                    }                   }        }        public static void printArr(int[] arr)        {                System.out.print("[");                for(int i=0; i<arr.length; i++){                        if(i != arr.length-1)                            System.out.print(arr[i] + ", ");                        else                            System.out.print(arr[i] + "]");                    }                   System.out.println();        }    }

PS：用C语言实现

#include<stdio.h>#include <string.h>void print(int *arr, int i, int j){    int tmp = arr[i];    arr[i] = arr[j];    arr[j] = tmp;}void buddleSort(int *arr){    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)    {        for (int j = 0; j<9 - i; j++)        {            if (arr[j] > arr[j + 1])//判断是否需要交换                print(arr, j, j + 1);        }    }}int main(){    int arr[10] = { 4, 2, 6, 4, 7, 23, 87, 5, 6, 7 };    int i = 0;    buddleSort(arr);    for (i = 0; i < 10; i++)        printf("%d\t", arr[i]);    getchar();}

折半查找法：

public class Demo{        public static void main(String[] arg){                int[] arr = {6,5,4,3,2};                int key = 6;                bubbleSort(arr);                System.out.println(halfSearch1(arr, key));            }        //冒泡排序：相邻的两个元素进行比较，如果符合条件换位        public static void bubbleSort(int[] arr){                for(int i=0; i<arr.length-1; i++){//冒泡次数为arr.length-1                    for(int j=0; j<arr.length-1-i; j++){                        if(arr[j] > arr[j+1]){//判断是否需要交换                            int tmp = arr[j];                            arr[j] = arr[j+1];                            arr[j+1] = tmp;                         }                    }                   }        }        //折半查找法实现1        public static int halfSearch(int[] arr, int key){            int min = 0;            int max = arr.length - 1;            int mid = (min + max) / 2;            while(arr[mid] != key){                if(arr[mid] > key)                    max = mid - 1;                else                  min = mid + 1;                mid = (min + max) / 2;                if(min > max)                    return -1;                          }               return mid;        }        //折半查找法实现2        public static int halfSearch1(int[] arr, int key){            int min = 0;            int max = arr.length - 1;            int mid = (min + max) / 2;            while(min <= max){                if(arr[mid] > key)                    max = mid - 1;                else if(arr[mid] < key)                    min = mid + 1;                else                  return mid;                mid = (min + max) / 2;            }               return -1;//未找到        }        //运用折半查找法实现：有一个有序数组，想要将一个元素插入到该数组中，还要保证该数组是有序的        public static int getIndex(int[] arr, int key){            int min = 0;            int max = arr.length - 1;            int mid = (min + max) / 2;            while(min <= max){                if(arr[mid] > key)                    max = mid - 1;                else if(arr[mid] < key)                    min = mid + 1;                else                    return mid;                mid = (min + max) / 2;            }            return min;//返回应该放的位置索引        }} 

进制转换

public class Demo{    //利用数组实现十进制转换成二进制、八进制、十六进制    public static void main(String[] arg){        int num = -66;        int[][] arr = { {15,4},//十六进制                        {7,3},//八进制                        {1,1}//二进制                        };        convert(num, arr[0][0], arr[0][1]);    }    public static void convert(int num, int base, int offset){            if(num ==0)            {                System.out.println("0");                return;            }        char[] indexArr = { '0', '1', '2', '3',                            '4', '5', '6', '7',                            '8', '9', 'A', 'B',                            'C', 'D', 'E', 'F'};        char[] convertResult = new char[32];        int count = 0;        while(num != 0){            convertResult[count++] = indexArr[num & base];            num >>>= offset;        }        for(int i=count-1; i>=0; i--){            System.out.print(convertResult[i]);        }    }

二维数组

int[][] y;
int y[][];
int[] y[];
int[] x, y[];//x一维，y二维