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 == 1010 == num 【墙裂建议】实际上结果一致，并且可以有效的防止一定的错误。num = 10 赋值语句正常操作10 = num 赋值语句，但是语法错误，因为常量不可以被赋值。

自增自减的面试题

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

int num = 10;
++(num++);【语法错误 一】
num = ?;++num--;【语法错误 二】【语法错误 一】1. 自增自减运算符有且只允许操作【变量】2. 小括号结果对外是一个【常量】，值，value，数代码运行之后的结果:++(常量) ==> ++常量 语法错误【语法错误 二】1. 自增自减运算符最终提供给表达式的结果是一个常量++num ==> 1111--; -- 自减运算符，操作的不是一个变量，而是常量数据语法错误

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 3Integer[] data = {1, 2, 3};
List<Integer> list = Arrays.asList(data);// 1 2 3int[] 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 重置为 1max = 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 重置为 0max = 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 < start2. end > arr.length - 13. end < 0 无效条件4. start > arr.length - 1 无效条件5. start < 0start > end || start < 0 || end > arr.length - 1数组容量为 10，有效下标为 0 ~ 9start = 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];}// 原本数组最后一个有效元素位置赋值为 0arr[arr.length - 1] = 0;return temp;
}

4.4.7 选择排序算法

分析：

​ 1.找出数组中的极值

2. 交换数据

/*** 针对于 int 类型数组选择排序算法实现** @param arr int 类型数组*/
public static void selectSort(int[] arr) {// 完成排序算法操作，执行的核心模块次数是当前数组有效元素个数 - 1for (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); // 空格 spaceSystem.out.println(num);