JavaSE基础部分总结

JavaSe基础部分

1.命名规范

• 字符的使用

a. 数字 0 ~ 9 
b. 英文字母 a ~ z A ~ Z
c. 唯一可以使用的标点符号 _ 下划线

• 变量定义对应的标识符要求英文字母的开头
• 标识符要求严格区分大小写
• 标识符没有严格的长度限制，但是会根据实际的开发情况决定标识符的长度
• 标识符要求见名知意，动宾结构
• 标识符的命名要求

a. 驼峰命名法
		小驼峰
			首字母小写，之后的每一个单词首字母大写
			适用于:
				变量，方法名
		大驼峰
			每一个单词首字母大写，
			适用于:
				类名，接口名
b. 下划线命名法
		所有单词全部大写，使用 _ 下划线分割。
			适用于:
				带有名称的常量

• 已经被java占用的关键字和保留字不得用于自定义标识符使用
• 标识符在一定的范围内唯一

2.基本的数据类型

• 整型的数据类型

数据类型	占用内存的字节数目	数据的范围
byte	1	-128~127
short	2	-215~215-1
int	4	-231~231-1
long	8	-263~263-1

• 浮点型数据类型

数据类型	占用内存的字节数目	数据的范围
double	8	10^308
float	4	10^38

• 字符数据类型

数据类型	占用内存的字节数目	数据的范围
char	2	可以存储中文

• 布尔的数据类型

数据类型	占用内存的字节数目	数据的范围
boolean	1. 占用一个字节 2. 占用四个字节 3. boolean类型数组 每一个布尔类型占用一个 bit 位	1 0

按照 Java 的语法规则，当前
	num == 10
	10 == num 【墙裂建议】
	实际上结果一致，并且可以有效的防止一定的错误。
	
	num = 10 赋值语句正常操作
	10 = num 赋值语句，但是语法错误，因为常量不可以被赋值。

自增自减的面试题

int a = 10;
int b = 5;
int c = 3;

int ret = a++ * ++b - (c-- + b++);


拆掉所有的算术运算符，包括小括号，小括号优先级有且只在自增自减结果提供之后参与。
拆解之后:
    a++ ==> 10
    ++b ==> 6
    c-- ==> 3
    b++ ==> 6
确定每一个自增自减运算符提供的数据之后，恢复原本的运算结构
	10 * 6 - (3 + 6) ==> 60 - 9 ==> 51


ret = 51;
a = 11;
b = 7;
c = 2;

int num = 10;
++(num++);【语法错误 一】
num = ?;

++num--;【语法错误 二】


【语法错误 一】
	1. 自增自减运算符有且只允许操作【变量】
	2. 小括号结果对外是一个【常量】，值，value，数
	代码运行之后的结果:
		++(常量) ==> ++常量 
		语法错误

【语法错误 二】
	1. 自增自减运算符最终提供给表达式的结果是一个常量
	++num ==> 11
	11--; -- 自减运算符，操作的不是一个变量，而是常量数据
	语法错误

3.方法

3.1方法的基本格式

权限修饰符 【静态修饰符】返回值类型 方法名称（形参）{方法体}

3.2 方法的分类

★有参数有返回值 
	最常用的模式，在开发中非常友好，方便代码操作

无参数无返回值
	一般为测试方法，展示方法，内置方法。
	
无参数有返回值
	生产者方法
	
有参数无返回值
	消费者方法

3.3 方法的注释

调用方法要求:
            1. 需要明确方法名
            2. 需要提供小括号，Java 中区分变量和方法的最大的区别就是 ()
            3. 需要提供方法所需实际参数
文档注释的目的，是为了在后期开发中，可以快速看到当前方法的注释内容，提示方法的功能
 
      无参数无返回值方法，当前方法没有返回值和参数，无需告知当前
      方法的调用者，该方法的相关返回值和参数信息，只需要告知调用者
      当前方法的作用 ，测试方法
     
      @param parameter 解释当前参数的用意，特征，数据需求和解释
     方法声明中的形式参数列表对应的【参数名】就是一个可以在
     方法中使用的【局部变量】
    
     在控制台展示调用者提供的 int 类型数据
     
     @param num 用户提供的 int 类型数据内容

4.数组

4.1 数组的命名格式

数据类型[] 数组名 = new 数据类型[容量];

对于命名格式的分析

数据类型
	明确当前数组存储数据类型，严格要求数据类型一致化
[] 
	1. 当前创建的为数组类型
	2. 数组名为引用数据类型
数组名
	1. 操作数组使用的名称，存储当前数组占用内存空间【首地址】
	2. 数组名为引用数据类型
new 
	1. 根据当前数据所需，在内存的【堆区】申请所需的内存空间
	2. 对于当前内存空间中数据内容进行擦除操作。
数据类型
	前后一致，严格遵从数据类型一致化要求
[容量]
	1. 在 int 范围以内
	2. 数组容量一旦确定，无法修改。

分析:
	1. 数组的下标为 整数 ==> int 
	2. 数组下标不能超出 int 范围，数组容量在 int 范围以内。
	3. 数值容量最大值是 Integer.MAX_VALUE - 8

4.2 数组中存在的址交换的操作

数组中的址交换，arr = other_arr 实际上是将 other_arr数组的地址交给了arr，然后能够实现arr的重指向，但是arr之前的数组还是在堆内存中，但是无法进行寻找调用（当然除非你之前保存了地址）。

4.3数组Arrays常用的方法

1. Arrays.asList(数组作为参数或者数据作为参数)：

作用是将数组转换成为集合

List<Integer> list = Arrays.asList(1, 2, 3);
 // 1 2 3

Integer[] data = {1, 2, 3};
List<Integer> list = Arrays.asList(data);
 // 1 2 3

int[] data = {1, 2, 3};
List<int[]> list = Arrays.asList(data);
System.out.println(list.size()); // 1
System.out.println(Arrays.toString(list.get(0))); // [1, 2, 3]

2.Arrays.fill(Object[] array, Object obj)

用来将指定元素填充整个数组，采用的方案是将数组中的元素进行替换

Integer[] data = {1, 2, 3, 4};
Arrays.fill(data, 9);
System.out.println(Arrays.toString(data)); // [9, 9, 9, 9]

3.Arrays.fill(Object[] array, int fromIndex, int toIndex, Object obj)

用指定的元素填充数组，取头不取尾，会替换到数组中的其他元素

Integer[] data = {1, 2, 3, 4};
Arrays.fill(data, 0, 2, 9);
System.out.println(Arrays.toString(data)); // [9, 9, 3, 4]

4. Arrays.sort(Object[] array)

对于数组进行串行排序操作

String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
Arrays.sort(data);
System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]

5.Arrays.sort(T[] array, Comparator<? super T> comparator)

通过使用自定义比较器，对于数组进行串行排序

String[] data = {"1", "4", "3", "2"};
System.out.println(Arrays.toString(data)); // [1, 4, 3, 2]
// 实现降序排序，返回-1放左边，1放右边，0保持不变
Arrays.sort(data, (str1, str2) -> {
    if (str1.compareTo(str2) > 0) {
		return -1;
    } else {
        return 1;
    }
});
System.out.println(Arrays.toString(data)); // [4, 3, 2, 1]

6.Arrays.parallelSort(T[] array)

对于数组的元素进行并行排序操作，当数据的规模较大的时候，会有更好的体验。

String[] data = {"1", "4", "3", "2"};
Arrays.parallelSort(data);
System.out.println(Arrays.toString(data)); // [1, 2, 3, 4]

7.Arrays.binarySearch(Object[] array, Object key)

该方法的使用前提是需要对于数组的进行排序的操作，然后才能够进行二分查找。

8.Arrays.copyOf(T[] original, int newLength)

拷贝数组，拷贝的长度是多少。

Integer[] data1 = {1, 2, 3, 4};
Integer[] data2 = Arrays.copyOf(data1, 2);
System.out.println(Arrays.toString(data2)); // [1, 2]
Integer[] data3 = Arrays.copyOf(data1, 5);
System.out.println(Arrays.toString(data3)); // [1, 2, 3, 4, null]

9.Arrays.stream(T[] array)

返回数组的流，然后我们就能够使用Stream中的多种方法

Integer[] data = {1, 2, 3, 4};
List<Integer> list = Arrays.stream(data).collect(toList());
System.out.println(list); // [1, 2, 3, 4]

10.Arrays.equals(Object[] array1, Object[] array2)

判断两个数组是否相等，数组为基本的数据类型的时候，通过比较值。当数组是引用类型的时候，依次调用equals方法进行比较

Integer[] data1 = {1, 2, 3};
Integer[] data2 = {1, 2, 3};
System.out.println(Arrays.equals(data1, data2)); // true

4.4数组常见习题

4.4.1 找到数组中的最大值，并且计算出最大值的个数

采用的是尾插法的思想：

​ 1.引入count变量；

​ 2.如果遍历的元素是最大值，count进行自增操作；如果不是最大值，从新进行count的定义，并且将交换数组中的下标。

【注意】需要对于开发的方法，进行文档注释分析，方便之后的使用

/**
 * 找出数组中最大值数据个数
 *
 * @param arr 指定查询数据的 int 类型数组
 * @return 最大值数据个数
 */
public static int getMaxValueCount(int[] arr) {
    int count = 1;
    int max = arr[0];

    // 遍历整个数组
    for (int i = 1; i < arr.length; i++) {
        if (max < arr[i]) {
            // 发现当前 max 存储的数据不是最大值
            // max 存储较大值，同时 count 重置为 1
            max = arr[i];
            count = 1;
        } else if (max == arr[i]) {
            // max 和当前数组中下标 i 的元素一致，count 计数
            count += 1;
        }
    }
    return count;
}

4.4.2 找到数组中的最大元素的下标，将找到的下标的元素保存到一个新的数组中

核心思想：

​ 1.尾插法：引用一个count变量，对最大值进行统计操作。数据所存储的下标位置

​ 2.空间和时间的效率的考虑

	/**
     * 找出元素中的最大的值得下标，然后将找到的下标元素保存到一个新的数组中
     *
     * @param arr int类型的数组
     * @param string int类型的数组【个人习惯，读者勿模仿，不规范】
     * @return 无返回值
     */
    public static void findArrIndex(int[] arr,int[] string){
        int max = 0;
        int count = 0;
        // 遍历整个数组
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                // 发现当前 max 存储的数据不是最大值
                // max 存储较大值，同时 count 重置为 0
                max = arr[i];
                count = 0;
            } else if (max == arr[i]) {
                // max 和当前数组中下标 i 的元素一致，count 计数
                string[count] = i;
                count += 1;
            }
        }

        
    }

4.4.3 从数组中指定下标开始，到指定下标结束，获取数据存储到新数组中

分析：

  1 .Java中所有的取一定范围的数据的操作，都是采取的是左闭右开的原则。

​ 2.通过下标进行内存的申请，然后将数组进行导入

 /**
     * 数组内容截取，从指定数组中，用户要求的下标位置 start 开始到 end 下标结束
     * 截取目标子数组内容
     *
     * @param arr   源数据数组
     * @param start 用户指定的开始下标
     * @param end   用户指定的结束下标
     * @return 返回值是截取的子数组内容，返回值类型是一个 int[] 数组
     */
    public static int[] subArray(int[] arr, int start, int end) {
        /*
        出现问题是因为用户提供的起始和终止下标不符合代码需求
        错误条件:
            1. end < start
            2. end > arr.length - 1
            3. end < 0 无效条件
            4. start > arr.length - 1 无效条件
            5. start < 0

         start > end || start < 0 || end > arr.length - 1
         数组容量为 10，有效下标为 0 ~ 9
            start = 15 end = 18; 错误条件
            start = 5 end = -5; 错误条件
            start = 5 end = 3; 错误条件
            start = -5 end = 6; 错误条件

         */
        if (start > end || start < 0 || end > arr.length - 1) {
            throw new IllegalArgumentException("截取数组下标不合法");
            /*
            如果封装方法，方法对外的返回值数据类型明确为 int[]
            没有合适的返回值数据内容来表明当前代码错误，也无法要求
            方法有两个类型的返回值
            【引入异常处理】
             */
        }

        /*
        计算新数组的容量
            Java 开发中，范围数据，通常在截取操作过程中，采用方式是要头不要尾
            指定 start = 1 end = 5
            新数组容量为 4
         */
        int[] subArray = new int[end - start];
        int count = 0;
        for (int i = start; i < end; i++) {
            subArray[count++] = arr[i];
        }

        return subArray;
    }
}

4.4.4 指定的数组的逆序

分析：

​ 1. 需要将现有的数据长度进行除2。

​ 2. 将顺序进行调转，就可以完成操作。

/**
 * 数组内容逆序
 *
 * @param arr 进行逆序操作的数组
 */
public static void reverse(int[] arr) {
    for (int i = 0; i < arr.length / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = temp;
    }
}

4.4.5 在指定的数组下标添加元素

分析：

​ 1.数组的容量大小是不会发生改变的。

​ 2.指定位置后的所有元素整体后移，需要考虑覆盖的问题。

​ 3.对于覆盖的问题的解决方案是：从后面进行处理。

/**
 * 在指定下标位置，添加目标数据
 *
 * @param arr    添加数据的目标数组
 * @param index  指定下标位置
 * @param number 添加的数据内容
 * @return 添加操作成功返回 true，否则返回 false
 */
public static boolean add(int[] arr, int index, int number) {
    if (index > arr.length - 1 || index < 0) {
        return false;
    }

    /*
     需要利用循环进行数组元素移动
     起始:
        最后一个有效元素位置
     终止:
        目标添加数据的下标位置
     */
    for (int i = arr.length - 1; i > index; i--) {
        arr[i] = arr[i - 1];
    }

    // 指定下标位置添加目标元素
    arr[index] = number;
    return true;
}

4.4.6 在指定的数组下标删除元素

分析：

  1. 找到数组需要删除的元素
  1. 将指定下标后的数组元素进行覆盖操作。
  1. 该操作区分上述的插入操作，只需要正序操作即可。

/**
 * 指定数组中，删除指定下标元素，返回值是被删除的元素数据内容
 *
 * @param arr   删除操作的源数据数组
 * @param index 指定删除的下标位置
 * @return 被删除的数据内容
 */
public static int remove(int[] arr, int index) {
    if (index < 0 || index > arr.length - 1) {
        throw new IllegalArgumentException("下标数据不合法！");
        /*
        方法设计当前返回值是被删除的数据内容，这里错误情况返回任何一个整数
        都有可能是一个被删除数据，无法明确的告知调用者当前方法运算失败，
        引入【异常处理】
         */
    }

    // 【核心】使用一个变量，存储被删除数据内容
    int temp = arr[index];

    // 利用循环移动数据，进行删除操作 从删除数据下标位置开始，到最后一个有效元素结束
    for (int i = index; i < arr.length - 1; i++) {
        arr[i] = arr[i + 1];
    }

    // 原本数组最后一个有效元素位置赋值为 0
    arr[arr.length - 1] = 0;
    return temp;
}

4.4.7 选择排序算法

分析：

​ 1.找出数组中的极值

2. 交换数据

/**
 * 针对于 int 类型数组选择排序算法实现
 *
 * @param arr int 类型数组
 */
public static void selectSort(int[] arr) {
    // 完成排序算法操作，执行的核心模块次数是当前数组有效元素个数 - 1
    for (int i = 0; i < arr.length - 1; i++) {
        
        // 按照排序规则要求，找极值对应的下标位置
        int index = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[index] < arr[j]) {
                index = j;
            }
        }
        
        // 进行数据交换操作，和目标存储极值对应的下标数据进行交换
        if (index != i) {
            int temp = arr[index];
            arr[index] = arr[i];
            arr[i] = temp;
        }
    }
}

4.4.8 冒泡排序

冒泡排序：

​ 将两个相近的元素进行交换。

	/**
	*核心的算法操作
    */

	int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};

    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;
            }
        }
    }
    System.out.println(Arrays.toString(arr));

5.易错点

5.1 三目运算符

条件判断 ? true 对应结果 : false 对应结果;
	细节:
		1. Java 中要求条件/三目运算符 整个表达式对外必须有数据产出
		2. 条件/三目运算符 执行对应结果调用方法的状况下，对应方法必须有返回值
		3.【使用方面】 可以用，但是不要嵌套，不要复杂

5.2 大写字母转换成为小写字母的方式

char ch = 'A';
	
	ch = ch + 32;// 错误
		错误原因
			32 是一个 int 类型，ch + int 类型数据，计算机会默认当前数据类型为 int ，使用 int 类型
			赋值给 char 类型变量数据，数据类型不一致，报错！！！
			
【重点】ch += 32;
		自带特殊功能，可以满足数据类型转换操作。
		
		ch += ('a' - 'A');
		标准形式
		char ch1 = 'a' - 'A';
        int num = 'a' - 'A';
		
		严格遵守数据类型一致化要求
        System.out.println(ch1); // 空格 space
        System.out.println(num);