java基础第一篇
【重新将从基础到框架的技术全部写一遍笔记】
学习目标
将JavaEE 全部的基础知识全部掌握，并且在集合，锁，线程，反射的时候要求认真学习并记忆。
学习内容
本篇的内容将 java 的数据类型、if 分支循环、运算符、while 循环、方法、数组这些知识全部的总结一遍，至于非常简单通俗的内容并不会去写，只会写一些升华的知识点帮助我们能更好的去了解基础知识。
学习产出
数据类型、if 分支循环、运算符、while 循环、方法、数组
一、数据类型
整数类型
| 数据类型 | 占用内存空间字节数 | 数据范围 |
|---|---|---|
| byte | 1 | -128 ~ 127 |
| short | 2 | -32768 ~ 32767 |
| int | 4 | -2^31 ~ 2^31 -1 |
| long | 8 | -2^63 ~ 2^63 -1 |
浮点类型
| 数据类型 | 占用内存空间字节数 | 数据范围 |
|---|---|---|
| double | 8(64bit) | 10^308 |
| float | 4 | 10^38 |
注意点：
- 浮点类型需要注意的是在写 float 的时候，需要在数据后面写大写的F（写小写的 f 也可以，但是不符合规范，代码最好是符合规范），因为 java 会将浮点类型的数默认当为 double 型。
- 在将 double 类型转为 float 时可能会出现精度丢失的问题。
- 在将两个浮点类型的数进行加减操作时不会返回心中想的那个数，因为出现了精度丢失，后期会用BigDecimal这个包装类来解决问题。
字符型
| 数据类型 | 占用内存空间字节数 | 数据范围 |
|---|---|---|
| char | 2 | 可以存储中文 |
布尔类型
| 数据类型 | 占用内存空间字节数 | 数据范围 |
|---|---|---|
| boolean | 1. 占用一个字节 2. 占用四个字节 3. boolean类型数组 每一个布尔类型占用一个 bit 位 | true false |
AJCG 阿里巴巴Java代码开发规约
- 字符使用范围是 字母 A~Z，a~z，数字 0~9，还有唯一可以使用的 _ （下划线）
那么可能在定义类名的时候，加一些其他的符号可能不会报错能够成功创建，但是不符合规范，这个规范是对Java开发做了一个统一的标准。 - 变量要求用字母开头，不能用数字开头
- 标识符要求严格的大小写
- 见名知意，不能用拼音的拼写。如studentName（学生名字）studentMathScore（学生数学成绩）等
- 标识符命名规则
1、小驼峰，变量名，方法，
2、大驼峰，类名，接口名
3、下划线命名法 所有单词全部大写 如 MAX_VALUE（最大值）
- 不能使用保留字或者关键字
二、分支结构
需要注意的地方：
- 在代码里面，需要有一些小的空格，帮助代码看起来很整洁规范，比如在 if 后面或者一些的 () 后面都会有一些的小空格，这让代码看齐很规整，方便阅读，idea也有自动对齐代码的快捷键 Ctrl + Alt + L
- 在一大堆自增自减运算符的题目中，不要怕，挨个的写出来答案，不管加减乘除和括号，下面有介绍
2.1 if分支
if (判断语句，返回值是boolean类型) {
执行语句
}
if (判断语句，返回值是boolean类型) {
执行语句;
}else {
执行语句;
}
if (判断语句1，返回值是boolean类型) {
执行语句1;
}else if (判断语句2，返回值是boolean类型){
执行语句2;
}else if (判断语句3，返回值是boolean类型){
执行语句3;
}else {
执行语句4;
}
在 if 分支中，最多有一个分支会执行
2.2 循环分支
while (判断语句，返回值是boolean类型) {
循环语句，知道判断语句返回false则退出;
}
for (初始值;判断语句;值改变) {
循环语句;
}
do while循环是先执行一次执行语句再进行判断
do {
执行语句
} while (判断语句，返回值是boolean类型);
2.3 运算符
算数运算符
+ - * / % = += -= *= /= %=
关系运算符（返回值是boolean类型）
> < >= <= != ==
逻辑运算符
& && | || !
& 和 && 、| 和 || 区别。
两个符号的话，判断一个如果能得出结果则后面的判断全部舍弃
在&&中如果判断第一个为假，则跳出判断，后面的不进行判断，返回假
在 || 中如果判断第一个为真，则跳出判断，后面的不进行判断，返回真
自增自减
++ --
int a = 10;
int b = 5;
int c = 3;
ret = a++ * ++b - (c-- + b++)
a++ ⇒ 10
++b ⇒ 6
c-- ⇒ 3
b++ ⇒ 6
最后的结果为 10 * 6 - (3 + 6)
拆掉所有的算术运算符，包括小括号，小括号优先级有且只在自增自减结果提供之后参与。
三、方法
权限修饰符 是否静态 返回值类型 方法名(形式参数列表) { 方法体 }
3.1 方法的分类
无参无返回值
无参有返回值
有参无返回值
有参有返回值 ☆
3.2 方法的demo例题
方法的学习最好是写一些封装的方法，然后带有返回值，带有参数的那些。
以下的小作业可以进行学习：
//封装一个方法，返回两个浮点数里的较小那个
public static double test_01(double number1, double number1){
}
//封装一个方法，来判断一个字符是否是大写字母
public static boolean isMyUpper(char c) {
return num1 < num2 ? num1 : num2;
}
//封装一个方法，来判断一个字符是否是数字字符
//如果是，返回true，否则返回false!
public static boolean isMyNumber(char c) {
return c >= 'A' && c <= 'Z';
}
//封装一个方法，来判断一个字符是否是英文字母
//如果是，返回true,否则返回false!
public static boolean isMyEnglish(char c) {
return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z';
}
//封装一个方法，传入一个字符，如果是大写那么转化小写然后返回，否则保持不变返回
/*可能会有一些人会将里面的字符串替换成对应的ASICC对应的int类型
的数字，可行，但是不好，因为本身就是字符型来进行判断的
里面写int类型会不那么的好
*/
public static char toMyLower(char c) {
if (c >= 'A' && c <= 'Z') {
c += ('a' - 'A');
}
//封装一个方法，传入一个字符，如果是大写那么转化小写然后返回，否则保持不变返回
/*很多人会直接认为应该将大写的字符型+32，这样最好不要写，因为这
32默认是int类型的，char类型和int类型相加无法，需要进行
强转的操作，但是最好不要对基本数据类型进行强转。比较好的解法就是
以下的解法
*/
public static char toMyLower(char c) {
if (c >= 'A' && c <= 'Z') {
c += ('a' - 'A');
}
用户输入一个年份，判断这个年份是不是一个闰年。
核心条件:
1. 可以被 4 整除，但是不可以被 100 整除
2. 或者可以被 400 整除
1 - 3 + 5 - 7 + 9 - 11 … - 99 + 101 的结果
多种方法都可以计算
- 判断正负号来加减
- 正数的和减去负数的和
- 101 + (-2 * 25) = 51
四、数组
4.1 数组的基本信息
数组的引用数据类型
基本的格式为
数据类型[] 数组名 = new 数据类型[数组长度]
数据类型：
1、数据类型可以的基本数据类型，也可以引用数据类型
2、但是在一个数组中，里面的数据必须是相同的数据类型
数组名：
是引用类型，在栈中，指向堆中数组的首地址
new：
1、申请空间，根据后面的容量大小进行申请
2、对旧空间进行内容擦除
数组长度：
数组下标是int类型的数据，所以长度是在int类型以内的。
具体的值为 Integer.MAX_VALUE-8
地址转移的例图
4.2 数组demo例题
1、指定数组找出数组中最大值下标位置
int[] arr = {1, 3, 5, 7, 9, 21, 4, 6, 8, 10};
找出数值中最大值下标位置:
maxIndex = 5;
2 、指定数组找出数组中最小值下标位置
int[] arr = {1, 3, 5, 7, 9, 21, 4, 6, 8, 10};
找出数值中最小值下标位置:
minIndex = 0;
3 、指定数组中最大值元素个数
int[] arr = {0, 21, 5, 21, 9, 21, 4, 6, 21, 10};
最大值个数
maxValueCount = 5;
4、 指定数组中最大值元素所有对应下标位置，要求存储到另一个数组中
int[] arr = {21, 21, 5, 21, 9, 21, 4, 6, 21, 10};
其他数组:
int[] indexArray = {0, 1, 3, 5, 8};
5、 找出指定元素在指定数值中第一次出现的下标位置
6 、找出指定元素在指定数值中最后一次出现的下标位置
7、 从数组中指定下标开始，到指定下标结束，获取数据存储到新数组中
8、 复制指定数组数据内容到新数组
9、 指定数组内容逆序
10 、在数组指定下标位置添加元素
目标数组:
int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
注意:
1. 0 无效元素，仅占位使用
2. 插入数据下标的位置必须在合法范围以内
例如：
添加指定元素 20 到下标为 5 的位置
{1, 3, 5, 7, 9, 20, 11, 13, 15, 17};
11 、删除数组中指定下标元素内容
目标数组:
int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
注意:
1. 0 是无效元素，仅占位使用
2. 删除之后，要求数组元素向前移动
3. 删除数据下标的位置必须在合法范围以内
ArrayIndexOutOfBoundsException
例如:
删除指定下标 5 的元素
{1, 3, 5, 7, 9, 13, 15, 17, 19, 0}
package zpd;
import org.omg.PortableInterceptor.INACTIVE;
import java.util.Arrays;
/**
* @Description
* @Author zpd
* @Date 2023/2/22
*/
public class demo10 {
public static void main(String[] args) {
/**
* 前4题验证
*/
/* int[] arr0 = {1, 3, 5, 7, 9, 21, 4, 6, 8, 10};
int[] arr = {21, 21, 5, 21, 9, 21, 4, 6, 21, 10};
int i2 = test_01(arr0);
int i1 = test_02(arr0);
int i = test_03(arr);
int[] ints = test_04(arr);
System.out.println(i2);
System.out.println(i1);
System.out.println(i);
System.out.println(Arrays.toString(ints));*/
/**
* 第五题验证
*/
/* int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
int index = test_05(arr, 11);
System.out.println(index);*/
/**
* 第六题验证
*/
/* int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
int[] toArr = test_06(arr, 1, 4);
System.out.println(Arrays.toString(toArr));*/
/**
* 第七题验证
*/
/* int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
int[] toArr = test_07(arr);
System.out.println(Arrays.toString(toArr));*/
/**
* 第八题验证
*/
/*int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
int[] toArr = test_08(arr);
System.out.println(Arrays.toString(toArr));*/
/**
* 第九题验证
*/
/* int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
int[] arr1 = test09(arr, 20, 5);
System.out.println(Arrays.toString(arr1));*/
/**
* 第十题验证
*/
/*int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
int[] ints = test_10(arr, 5);
System.out.println(Arrays.toString(ints));*/
Integer[] integers = new Integer[5];
}
//TODO 1
/**
* 指定数组找出数组中最大值下标位置
*
* @return 最大值下标
*/
public static int test_01(int[] arr) {
int maxIndex = 0;
for (int i = 1; i < arr.length; i++) {
if (arr[maxIndex] < arr[i]) {
maxIndex = i;
}
}
return maxIndex;
}
//TODO 2
/**
* 指定数组找出数组中最小值下标位置
*
* @return 最小值下标
*/
public static int test_02(int[] arr) {
int minIndex = 0;
for (int i = 0; i < arr.length; i++) {
if (arr[minIndex] > arr[i]) {
minIndex = i;
}
}
return minIndex;
}
//TODO 3
/**
* 指定数组中最大值元素个数
*
* @return 最大值元素个数
*/
public static int test_03(int[] arr) {
int num = 1;
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]){
max = arr[i];
num = 1;
}else {
num++;
}
}
return num;
}
//TODO 4
/**
* 指定数值中最大值元素所有对应下标位置，要求存储到另一个数组中
*
* @return
*/
public static int[] test_04(int[] arr1) {
//得到最大数的个数，用来创建数组
int maxNum = test_03(arr1);
//得到最大的数的下标值
int maxIndex = test_01(arr1);
int index = 0;
int[] arr2 = new int[maxNum];
for (int i = 0; i < arr1.length; i++) {
if (arr1[maxIndex] == arr1[i]) {
arr2[index] = i;
index += 1;
}
}
return arr2;
}
//TODO 5
/**
* 找出指定元素在指定数值中第一次出现的下标位置
*
* @param arr 需要查询的数组
* @param num 查询的数据
* @return 返回数据对应的下标
*/
public static int test_05(int[] arr, int num) {
int index = 0;
for (int i = 0; i < arr.length; i++) {
if (num == arr[i]) {
index = i;
}
}
return index;
}
//TODO 6
/**
* 从数组中指定下标开始，到指定下标结束，获取数据存储到新数组中
*
* @param arr 需要截取的数组
* @param startIndex 截取的开始下标
* @param endIndex 截取的结束下标
* @return 返回新数组
*/
public static int[] test_06(int[] arr, int startIndex, int endIndex) {
if (startIndex >= arr.length || startIndex < 0 || endIndex >= arr.length || endIndex < 0) {
throw new ArrayIndexOutOfBoundsException();
}
//截取数组的长度
int[] toArray = new int[endIndex - startIndex + 1];
int index = 0;
for (int i = startIndex; i <= endIndex; i++) {
toArray[index] = arr[i];
index += 1;
}
return toArray;
}
//TODO 7
public static int[] test_07(int[] arr) {
int[] toArray = new int[arr.length];
toArray = arr;
return toArray;
}
//TODO 8
/**
* 指定数组内容逆序
*
* @param arr 需要逆序的数组
* @return 返回逆序完成后的数组
*/
public static int[] test_08(int[] arr) {
//创建新的数组来接收逆序的数组
int[] toArray = new int[arr.length];
//逆序数组的下标从最后开始接收
int index = arr.length - 1;
for (int i = 0; i < arr.length; i++) {
toArray[index] = arr[i];
index -= 1;
}
return toArray;
}
//TODO 9
/**
* 在数组指定下标位置添加元素
*
* @param arr 目标数组
* @param number 添加的元素
* @param index 对应的下标
* @return 返回添加后的元素
*/
public static int[] test09(int[] arr, int number, int index) {
if (index >= arr.length) {
throw new ArrayIndexOutOfBoundsException();
}
//5 10-5
for (int i = arr.length - 1; i > index; i--) {
arr[i] = arr[i - 1];
}
arr[index] = number;
return arr;
}
//TODO 10
/**
* 删除数组中指定下标元素内容
*
* @param arr 需要删除的数组
* @param index 删除是下标元素
* @return 删除后返回的数组
*/
public static int[] test_10(int[] arr, int index) {
if (index >= arr.length) {
throw new ArrayIndexOutOfBoundsException();
}
//直接让对应下标的数据被覆盖，然后将最后一个数据赋值为0
for (int i = index; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
}
arr[arr.length - 1] = 0;
return arr;
}
}
这里面的代码都是自己写的，并且封装成了静态方法块，也在某几个方法中进行了调用别的方法。
里面的方法可以进行优化，将两个for循环优化为一个for循环，优化了代码的效率。
4.3 排序算法
学到数组一定要做的两个简单的算法，选择排序算法和冒泡排序算法。
选择排序算法
//选择排序算
//直接写成了静态方法
public static void selectSort(int[] arr){
//外层的for循环是用来决定交换的次数
for (int i = 0; i < arr.length; i++) {
//index值默认为0，第一次和下标为0的元素交换
// 第二次和下标为1的元素交换、、、正好符合i的值
int index = i;
//初始值为i+1，则是默认为index对应的下标是极值
// 不用自己和自己比较，减少了一次判断
for (int j = i + 1; j < arr.length; j++) {
//如果index对应下标的数组值小于j下标对应的数组值
// 则将较大数据的数组值赋值为index
if (arr[index] < arr[j]){
index = j;
}
}
//如果index下标不等于原来的i值，说明下标发生了改变
// 则需要将index下标对应的值和i下标对应的值进行交换
if (index != i){
int temp = arr[index];
arr[index] = arr[i];
arr[i] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
冒泡排序算法
public static void bubbleSort(int[] arr) {
//外层循环代表循环的次数
for (int i = 0; i < arr.length; i++) {
//可能交换判断的次数
for (int j = 0; j < arr.length - i - 1; 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));
}
4.4 优化
目录4.2当中有些方法还存在优化的空间，可以尝试优化一下，后期会进行优化和详细讲解的文章
优化篇链接（待定）
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
