数据类型，运算符，数组

发表于 | 分类于
字数统计: 2.5k | 阅读时长 ≈ 10

变量的使用

1.变量必须先声明后使用。
2.变量都定义在其作用域内，在作用域内有效，出了作用域就失效了。
3.同一个作用域内不能声明两个同名变量。

数据类型

基本数据类型(primitive type)
整型 byte(1字节) -128~127 , short (2字节), int(4字节) , long(8字节) l或L结尾
浮点型 float(4字节) 定义时要以f或F结尾 , double(8字节)
字符型 char(2字节)
布尔型 boolean 只能取两个值之一 ：true , false
7种基本数据类型之间的计算（不包括布尔类型）:
1.自动类型提升：
容量小的数据类型变量与容量大的数据类型做运算时，运算结果自动装换为容量大的。
byte , char , short –> int –> long –> float –> double
所有的byte , short , char 类型的值将被提升为int型；
被final 修饰的变量不会自动提升其类型

​ 2.强制类型转换：
​ 使用强转符 () ，可能造成精度损失
引用数据类型(reference type)
​ 类 class
​ String类型： 声明时使用一对””，可以与8种基本数据类型做运算，+ 只能表示连接
​ 接口 interfere
​ 数组 [ ]

运算符

​ 算术运算符
​ 逻辑运算符
​ &&与&的区别：
​ & : 左边无论真假，右边进行运算
​ && ： 左边为真，右边参与运算；左边为假，右边不参与运算
​ |与||的区别：
​ ||：左边为真，右边不参与运算
​ 位运算：
​

运算符优先级：

单目乘除为(位)关系，逻辑三目后赋值。

单目：单目运算符+ –(负数) ++ – 等
乘除：算数单目运算符* / % + -
为（位）：位移单目运算符<< >>
关系：关系单目运算符> < >= <= == !=
逻辑：逻辑单目运算符&& || & | ^
三目：三目单目运算符A > B ? X : Y
后：无意义，仅仅为了凑字数
赋值：赋值=

流程控制

顺序结构
分支结构
循环结构
break : 结束当前循环
continue : 结束当次循环

数组

数组的特点:
1.数组是有序排列的
2.数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型的变量
3.创建数组对象时会在内存中开辟一整块连续的内存空间
4.数组的长度一旦确定就不能修改

一维数组的使用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class ArrayTest {
    public static void main(String[] args) {
    int[] nums;// 声明
    // 静态初始化:数组的初始化和数组元素的初始化同时进行
    // int型数组元素数量小于指定容量时，以0填充
    nums = new int[] {1,2,3,4,5,6};
    // int[] nums = {1,2,3,4,5,6}

    // 动态初始化:数组的初始化和数组元素的初始化分开进行
    String[] names = new String[6];

    // 通过角标的方式调用指定位置的元素
    names[0] = "Tom";
    names[1] = "Justin";

    // 获取数组长度： length
    System.out.println(names.length);

    // 遍历数组
    for(int i = 0;i < nums.length;i++) {
        System.out.println(nums[i]);
        }
    }
}

一维数组元素的默认初始值
基本数据类型：
整形：0
浮点型：0.0
char型：0（ASCII码值） 而非’0’
boolean型：false
引用数据类型：null

一维数组的内存解析:

在栈空间中申请一个变量用来存储堆空间中数组的首地址值
在堆空间中申请一个数组用来存放数组元素

多维数组的使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ArrayTest1 {
    public static void main(String[] args) {
        // 静态初始化
        int[][] arr =  new int [][] {{1,2,3},{4,5},{6}};

        //动态初始化
        String [][] arr1 = new String[3][2];
        String [][] arr2 = new String[3][];

        // 调用数组指定位置的元素
        System.out.println(arr[0][1]);// 2
        System.out.println(arr1[1][1]);// null

        // 获取数组的长度
        System.out.println(arr.length);// 3

        // 遍历二维数组
        for(int i = 0;i < arr.length;i++) {
            for(int j = 0;j < arr[i].length;j++)
            {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
        }
}

二维数组元素的默认初始值:
针对初始化方式一：String [][] arr1 = new String[3][2];
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组的初始化情况相同
针对初始化方式二：String [][] arr1 = new String[3][];
外层元素的初始化值为：null
内层元素的初始化值为：不能调用，否则报错

二位数组的内存解析:
在栈空间中申请一个变量用来存储堆空间中数组的首地址值
在堆空间中申请一个数组用来存放二维数组的外层元素，外层元素中存放着指向存储内层元素数组的首地址
在堆空间中申请一个数组用来存储内层元

数组中涉及的常见算法

数组元素的赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
 * @Description 打印10行杨辉三角
 * @author sweetboyZhang
 * @date 2020年1月13日上午11:26:21
 */
public class YangHui_Test {
    public static void main(String[] args) {
        // 声明并动态初始化二位数组
        int [][] yangHui = new int[10][];// 10行，列数不确定
        // 给元素赋值
        for(int i = 0;i < yangHui.length;i++) {
            yangHui[i] = new int[i+1];// 第i行有i+1个元素
            // 给首末元素赋值
            yangHui[i][0] =yangHui[i][i] = 1;//首末元素为1
            // 给其余元素赋值
            if(i > 1) {
                for(int j = 1;j < yangHui[i].length-1;j++) {
                    yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
                }
            }
        }
        // 遍历输出
        for(int i = 0;i < yangHui.length;i++) {
            for(int j = 0;j < yangHui[i].length;j++) {
                System.out.print(yangHui[i][j] + " ");    
            }
            System.out.println();
        }
    }
}

求数值型数组中元素的最大值、最小值、平均数、总和等

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
 * @Description 定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
要求：所有随机数都是两位数。
 * @author sweetboyZhang
 * @date 2020年1月13日下午2:13:41
 */
public class ArrayTest2 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        int min = 100;
        int max = 0;
        int sum = 0;
        int average = 0;
        for(int i = 0;i < arr.length;i++) {
            // 获取[a,b]范围内的随机数，(int)(Math.random()*(b-a+1)+a)
            arr[i] = (int)(Math.random()*(99-10+1)+10);
            System.out.print(arr[i]+ " ");
            if(min>arr[i]) {
                min = arr[i];
            }
            if(max<arr[i]) {
                max = arr[i];
            }
            sum+=arr[i];
            average = sum/arr.length;
        }
        System.out.println();
        System.out.println("最大值：" + max);
        System.out.println("最小值：" + min);
        System.out.println("和值：" + sum);
        System.out.println("平均值：" + average);
    }
}

赋值与复制

赋值：array2 = array1;// array1指向堆空间的地址赋给array2,不能称为数组的复制
对array2修改就是对array1进行修改
复制：for(int i = 0;i < array2.length;i++) { array2[i] = array1[i]; }
对array2修改不会影响到array1

数组的反转

1
2
3
4
5
6
String[] array1 = new String[] {"Tom","Taylor","Justin","Troye","Swift"};
for(int i = 0;i < array1.length/2;i++) {
        String temp = array1[i];
        array1[i] = array1[array1.length-1-i];
        array1[array1.length-1-i] = temp;
}

查找

  1. 线性查找
1
2
3
4
5
6
7
8
9
10
11
12
13
String[] array1 = new String[] {"Tom","Taylor","Justin","Troye","Swift"};
String dest = "Justin";
boolean isFlag = true;
for(int i = 0;i < array1.length;i++) {
    if(dest.equals(array1[i])) {
        System.out.println("元素Justin的位置为：" + i);
        isFlag = false;
        break;
    }    
}
if(isFlag) {
    System.out.println("没有找到！");    
}
  1. 二分查找
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int [] array3 = new int [] {1,2,3,4,5,6,7,8,9,10};
int number = 6;
int head = array3[0];// 初始的首索引
int end = array3[array3.length -1];// 初始的尾索引
int middle = (head + end)/2;// 二分
boolean isFlag1 = true;// 设置标志位，找到元素后置false
while(head <= end) {
    if(number == array3[middle]) {
        System.out.println("元素6的位置为：" + middle);
        isFlag1 = false;
        break;
    }else if(number < array3[middle]) {
            end = middle - 1;
    }else {
            head = middle + 1;
    }
}   
if(isFlag1) {
    System.out.println("没有找到该元素！");
}

排序

冒泡排序

排序思想：

  1. 比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步
    做完后，最后的元素会是最大的数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要
    比较为止。
1
2
3
4
5
6
7
8
9
10
11
12
13
int [] array = new int[] {1,2,8,4,6,8,6,5,3,33,1,0};
for(int i = 0;i < array.length-1;i++) {
    for(int j = 0;j < array.length-1-i;j++) {
        if(array[j]>array[j+1]) {
            int temp = array[j];
            array[j] = array[j+1];
            array[j+1] = temp;
        }
    }
}    
for(int i = 0;i < array.length;i++) {
    System.out.print(array[i] + " ");
}

Arrays工具类

java.util.Arrays ：操作数组的工具类，定义了许多操作数组的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public static void main(String[] args) {
    int[] arr1 = new int[] {1,2,3,4};
    int[] arr2 = new int[] {5,4,3,2,1};
    // 1.boolean equals(int[] a,int[] b) 判断两个数组是否相等。
        boolean isEqual =Arrays.equals(arr1, arr2);
        System.out.println(isEqual);// false

    // 2.String toString(int[] a) 输出数组信息
        String arr1Info = Arrays.toString(arr1);
        System.out.println(arr1Info);// [1,2,3,4]

    // 3.void fill(int[] a,int val) 将指定值填充到数组之中。
        Arrays.fill(arr1,6);
        System.out.println(Arrays.toString(arr1));// [6,6,6,6]

    // 4.void sort(int[] a) 对数组进行排序。
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));// [1,2,3,4,5]

    // 5.int binarySearch(int[] a,int key) 对排序后的数组进行二分法检索指定的值。
        int index = Arrays.binarySearch(arr2, 4);
        if(index >= 0 ) {
            System.out.println("元素4的索引为："+ index);
        }
        else {
            System.out.println("未找到该元素！");
        }
    // 6. List<T> asList(T... a) 返回一个List  底层是final数组
    }

数组使用的常见异常

1.数组脚标越界异常
ArrayIndexOutOfBoundsException：访问到了数组中的不存在的脚标时发生。
合理范围：[0,array.length-1]

2.空指针异常
NullPointerException：array引用没有指向实体，却在操作实体中的元素时。