JAVA部分知识总结

一.数据类型

1.整数数据类型

byte：大小：8位（1字节）取值范围：-128 到 127默认值为0

short：大小：16位（2字节）取值范围：-32,768 到 32,767默认值为0

int：大小：32位（4字节）取值范围：-2,147,483,648 到 2,147,483,647默认值为0

long：大小：64位（8字节）取值范围：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807默认值为0L（注意L后缀，表示long类型）

2.小数数据类型

float：大小：32位（4字节）用于表示单精度浮点数默认值为0.0f（注意f后缀，表示float类型）

double：大小：64位（8字节）用于表示双精度浮点数默认值为0.0d（注意d后缀，表示double类型，但通常可以省略）

3.字符数据类型

char：大小：16位（2字节）用于表示单一的16位Unicode字符取值范围：'\u0000'（即0）到 '\uffff'（即65,535）默认值为空字符'\u0000'

4.布尔数据类型

boolean：可以表示true或false默认值为false

二.运算符

1.算术运算符

1）不同的运算符在表达式中进行运算的先后次序

2）（）的优先级最高

3）*和/的优先级要大于+和-

2.关系运算符

1）关系表达式运算结果有两个：

            “真” -- 1

            “假” -- 0

2）C中，非零值表示“真”，零表示“假”。

3）优先级:前四个高于后两个，低于算术运算符

4）结合性：自左至右

5）左结合性：  自左向右：    *、/、+、-

6）右结合性：  自右向左：   运算对象先与右边运算符结合

3.逻辑运算符

1）C语言对逻辑表达式求解，并不是所有的运算符都被执行，只是在必须执行后面的运算才能求出表达式时，才执行其后的运算，否则将不执行后面的运算

2）优先级：！ ——>   &&  ——>   ||

3)结合性：&&    、 ||   自左向右   ！自右向左

4.条件运算符

1）用于连接3个运算对象，是C语言中唯一的一个三目运算符 

2）结合性：自右向左     

三.程序控制     

 在Java中，控制流程结构主要包括顺序、选择、循环

1.顺序控制：代码自上而下顺序执行 

2.选择控制：使用if-else语句实现

3.循环控制：使用for, while, 和 do-while循环

4.Java中的控制流程可以包含break、continue语句来控制循环流程

1）break用于退出当前循环体

2）continue用于跳过当前循环，继续执行下一次循环

四.数组

数组是一种用于存储多个相同类型数据的数据结构。在Java中，数组是一个强类型的数据结构，意味着一旦定义了某种类型的数组，那么这个数组中只能存放这种类型的数据。

1.

1）遍历数组

for (int number : numbers) {

System.out.println(number);

}

for (int i = 0; i < names.length; i++) {

System.out.println(names[i]);

}

2）通过索引操作元素

public class Main {

public static void main(String[] args) {

                                                                                                        // 创建数组

int[] numbers = {1, 2, 3, 4, 5};

                                                                                                        // 通过索引修改元素

int index = 2;

int newValue = 10;

numbers[index] = newValue; // 将索引为2的元素修改为10

                                                                                                        // 通过索引访问元素

System.out.println(numbers[index]); // 输出10

}

}

3）获取数组的最值

import java.util.Arrays;

public class ArrayMinMax {

public static void main(String[] args) {

int[] array = {10, 32, 45, 90, 5, 78};

int min = array[0];

int max = array[0];

for (int i = 1; i < array.length; i++) {

if (array[i] > max) {

max = array[i];

}

if (array[i] < min) {

min = array[i];

}

}

System.out.println("Min: " + min);

System.out.println("Max: " + max);

}

}

2.数组排序算法

在Java中，对数组进行排序有多种算法，包括冒泡排序、插入排序、选择排序、归并排序、快速排序等。

1）冒泡排序法

public class BubbleSortExample {
    public static void main(String[] args) {
        int[] array = {4, 3, 2, 10, 12, 1, 5, 6};
        bubbleSort(array);
        for (int i : array) {
            System.out.println(i);
        }
    }
 
    public static void bubbleSort(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

2）选择排序法

public class SelectionSortExample {
    public static void main(String[] args) {
        int[] array = {9, 8, 7, 6, 5, 4, 3, 2, 1}; // 待排序数组
        selectionSort(array);
        // 打印排序后的数组
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
 
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            // 查找最小元素的索引
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换找到的最小元素与第i个位置的元素
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

3）二分查找法

public class BinarySearch {
    public static int binarySearch(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;
 
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (array[mid] == target) {
                return mid; // 找到目标值，返回索引
            } else if (array[mid] < target) {
                left = mid + 1; // 在右半区继续查找
            } else {
                right = mid - 1; // 在左半区继续查找
            }
        }
        return -1; // 未找到目标值，返回-1
    }
 
    public static void main(String[] args) {
        int[] sortedArray = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
        int target = 13;
        int index = binarySearch(sortedArray, target);
        if (index != -1) {
            System.out.println("Element found at index " + index);
        } else {
            System.out.println("Element not found");
        }
    }
}