黑马程序员-Java编程基础

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

目录：
1. 基本数据类型
2. 运算符
3. 数组
4. 控制语句

1. 基本数据类型

Java是一种强类型的语言，每个变量的声明都必须声明类型。

1.1 Java中的8种基本数据类型

数据类型是计算机中表示储存容量大小的单位。计算机中的数据都以2进制存储，最小的存储单位是bit（比特），8bit=1byte（8b=B）。
下面是Java中的基本数据类型

（1）整数类型

• byte 内存分配1字节，取值范围是-128～127 (2^7-1)～2^7
• short 内存分配2字节，取值范围是-32768～32767
• int 内存分配4字节，取值范围是-2^31～2^31-1

• long 内存分配4字节，取值范围是-2^63～2^63-1

  通常情况下，int类型最常用。Java中的整数默认为int类型。

  Java7增加的二进制前缀：0B或0b（如0b1100是一个二进制数值，表示十进制整数的12）。
  Java7中还可以在数字字面量中加入下划线如（1_000_000）,增加了数值的易读性。

（2）浮点类型

• float 存储4字节

• double 存储8字节

  Java中默认的浮点数类型是double

（3）boolean类型

表示true或false

（4）char类型

表示单个字符。

1.2 基本数据类型的转换

数据类型按精度从低到高排序：
byte、short、int、long、 float、double

（1）自动转换：
低精度类型数值赋值给高精度类型时候自动转换，例如int类型到float类型的转换：

    //50为int类型，a为float类型
    float a=50;     
    System.out.println(a);//打印控制台结果为50.0

    //char类型到int类型的转换
    char ch = 'c';
    int mu =ch;
    System.out.println(mu);//打印控制台结果为99

（2）强制转换

高精度类型数值赋给低精度类型时需要强制转换，例如 double类型到int类型的转换：

    double d=20.02;
    int b=(int)d;

1.3 大数值

使用基本类型数据值进行运算，例如：

    float n = (2.1f - 1.9f);
    System.out.println(n);//0.19999993

这里n并不是0.2，而是有误差的。所以在金融等对数据精确度要求严格的行业基本数据类型并不适合。这时候就需要以下类型：

BigInteger（大整形）、BigDecimal
使用方法：

    //创建BigInteger对象并实例化
    BigInteger i=new BigInteger("123");
    BigInteger j=new BigInteger("456");
    //进行加法运算
    BigInteger result=i.add(j);
    //进行乘法运算
    result=i.multiply(j);

同理，BigDecimal用法相同。

2. 运算符

（1）算术运算符：
+、-、*、/、%（称为求余或取模）

简化的二元运算符（将运算符放在赋值号左侧）：
+= -= *= /= %=

取模%使用示例：

    int a=10;
    int result=a%3;
    //等同于
    a%=3;//a==result

（2）位运算符：
&（“与”）、|（“或”）、^（“异或”）、~（“非”）

计算一个十进制整数某位的值：

    //求n第四位的值
    int x=(n&0b1000)/0b1000;

思路：n–>二进制–>与0b1000“与”运算，0与任何数“与”运算的结果是0,所以只留下n第四位与1运算–>除以0b1000，判断第四位值。

注：0b是字面二进制量（Java SE 7更新）

“>>”和“<<”运算符
同上面例子：

    int x=(n&(1<<3))>>3;

“>>>”将用0填充高位。

（3）关系运算符：
==、!=、&&（与）、||（或）、！（非）

注：与上面的位运算符不同，关系运算符具有短路效果例如：

    boolean flag=(5>9)&&(8>3);
    /*当&&左侧条件为false时候，整个表达式将被判定为false而不必计算第二个表达式的值。*/

（4）三元运算符
变量=表达式1?表达式2:表达式3;
整个表达式返回一个值。表达式1是一个boolean表达式，如果为true则返回表达式2的值，否则返回表达式3的值。
例如：

int x=(2>5)?(8/2):(3*4);
//（2>5）为false，所以返回第二个表达式（3*4）的值，x=12

（5）自增自减运算符：
++、–、
有两种情况。变量在运算符之前，比如a++是先使用a的值再进行加1运算，而++a是先加1然后才使用a的值。

例如：

    int a=10;
    //先使用后加1，打印值是10
    System.out.println(a++);
    int b=5;
    //先加1，后使用，打印值是6
    System.out.println(++b);

3. 数组

数组是Java中基本的数据存储结构，可以存储任何类型数据，同时也是性能最快的数据结构。

3.1 数组的创建

    // 声明一个数组：
    int[] arr;

    // 创建一个数组：
    arr = new int[5];
    // 注意：数组在创建的时候将被初始化，int类型默认初始化为0。

    // 数组的长度：
    int length = arr.length;// 此处为5

    // 向数组中存储值：
    arr[1] = 66;
    // 注意：数组的下标是从0开始

    // 创建数组的快速形式：
    int[] arr2 = { 1, 2, 3, 4, 5 };

    // 初始化一个匿名数组：
    arr2 = new int[] { 1, 2, 3, 4, 5 };

    // 运行时确定数组大小
    arr2 = new int[length];
    length = 8;

3.2 数组算法
（1）查询算法

    //普通查询  
    public static int search(int[] arr, int key) {
        //遍历数组
        for (int i = 0; i < arr.length - 1; i++) {
            //查询到相同的则返回数值
            if (arr[i] == key) {
                return i;
            }
        }
        //失败返回-1
        return -1;
    }

    //二分查询
    public static int binarySearch(int[] arr, int key) {
        //数组下标最小值
        int min = 0;
        //数组下标最大值
        int max = arr.length-1;
        //循环查询
        while (min <= max) {
            //计算中间下标值
            int med = (min + max) / 2;
            //查询数组中间下标对应的值
            int value=arr[med];
            //相等返回值
            if (value == key) {
                return med;
            }
            //如果获取值大于查询值，那么向下移动数组下标max
            if (value > key) {
                max = med - 1;
            } else {
                //如果获取值小于查询值，那么向上移动数组下标max
                min = med + 1;
            }
        }
        return -1;
    }

（2）排序

//冒泡排序
    public static void bubbleSort(int[] arr) {
        //外层循环，每循环一次排序一次最大值，最后一次无需循环，所以循环次数为arr.length - 1
        for (int i = 0; i < arr.length - 1; i++) {
            //两两比较，每次内层循环的最后一次比较可以省略，因为已经是最大值
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //如果表达式成立，则交换数值
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }

        }
    }

    //选择排序
    public static void selectionSort(int[] arr) {
        //外层循环，每循环一次排序一次最小值，最后一次无需循环，所以循环次数为arr.length - 1
        for (int i = 0; i < arr.length - 1; i++) {
            //固定一个下标，依次对该下标以后的数组元素进行比较
            for (int j = i + 1; j < arr.length; j++) {
                //如果表达式成立，则交换数值
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j ];
                    arr[j ] = temp;
                }
            }

        }
    }

3.3 多维数组

就是数组中的元素仍是数组，创建方法例如：

//长度为5的二维数组
int[][] arrays=new int[5][];

多维数组以此类推。

4. 控制语句
包括条件分支语句、循环语句、跳转语句。

（1）条件分支语句：
if-else语句：由一个if、else和两个复合语句按一定格式构成。格式如下：

if(表达式){
    代码...
}else{
    代码...
}

if后面的表达式语句必须是boolean类型的表达式，如果表达式为true，则执行紧跟着后面的复合语句；如果表达式的值为false，则执行else后面的复合语句。
多重if语句：由一个if、若干个else if、一个else与若干个复合语句组成。格式如下：

if(表达式1){
    代码...
}else if(表达式2){
    代码...
}else if(表达式3){
    代码...
}
...
else{
    代码...
}

（2）switch开关语句

switch(表达式){
case 常量值1：
    代码...
    break；
case 常量值2：
    代码...
    break；
case 常量值3：
    代码...
    break；
default：
    代码...
}

switch语句中的表达式语句必须是整型或字符型，常量值必须为整型或字符型。switch语句首先计算表达式里的值，如果表达式的值与某个常量值相同，就执行该case里的语句，直到遇到break。

（3）循环语句
while循环：

while(表达式){
    代码...
}

表达式为boolean类型数据的表达式和一个复合语句组成，其中的复合语句称为循环体。
do-while循环

do{
    代码...
}while(表达式)

while循环和do-while循环的区别是：do-while的循环体至少被执行一次。

（4）跳转语句
跳转语句是由关键字break或continue加上分号构成的语句。
例如：下面的循环将不打印能被2整除的10以内的整数

for(int n=0;n<=10;n++){
        if((n%2)==0){
            //中断循环的执行体，直接进行下一个循环
            continue;
        }
        System.out.println(n);
}

下面的循环，当n=5的时候将跳出循环

for(int n=0;n<=10;n++){
        if(n==5){
            //终止循环，退出到循环外部
            break;
        }
        System.out.println(n);
}