JAVA基础学习记录（个人参考学习）
数据类型
-
基本类型
-
数值类型
1.整数类型
byte：占1个字节范围：-128-127
short：占2个字节范围：-32768-32767
int：（最常用的）占4个字节范围：-2147483648-2147483647
long：占8个字节范围：-9223372036854775808-923372036854775807（声明变量时需要加上L）
2.浮点类型
float：占4个字节声明变量时需要加上F
double：占8个字节
3.字符类型
char：占2个字节
-
boolean类型：占1位其中值只要true和flase
-
-
引用类型
类，接口，数组。
整数拓展
java进制表示
- 二进制 0b
- 八进制 0
- 十六进制 0x 0-9 A-F
浮点数拓展
BigDecimal 数学工具类（用于金钱方向的算术不丢失精度）
float 和double 是有限离散有舍入误差的最好避免完全使用浮点数做比较
字符扩展
所有的字符本质都是数字0-65536
转义字符
- \t 制表符 跳到下一个TAB位置
- \n 换行 将当前位置移到下一行开头
- \b 退格 将当前位置移到前一列
- \f 换页 将当前位置移到下页开头
- \r 回车 将当前位置移到本行开头
- \v 垂直制表
- \\ 代表一个反斜线字符\
- \’ 代表一个单引号字符
- \’’ 代表一个双引号字符
- \0 空字符（null）
- \ddd 1-3位八进制数任意字符
- \uhhhh 1-2位十六进制任意字符
Java类型转换
强制类型转换 高到低
自动转换 低到高
转换顺序：低到高
byte,short,char->int->long->float->double
int a=3；
//强制转换
byte b=(byte) a;
java运算符
算数运算符
+，-，*，/，%，++，–
//+号相当于加法
int i=0;
i+1;//i=1;
//-号相当于减法
i-1;//i=-1
//*相当于乘法
i*1;//i=0
// /相当于除法
i/1; //i=0
//% 相当于取余数
i=4%3;//i=1
// ++相当于自增
i++ //i=1 这里注意 ++i和i++本质上是一样的但是++i是在这条语句执行前就行+1操作，i++是在这条语句后执行操作示例如下
//这里输出的值其实是0因为他会先输出当前i的值后将i+1；
System.out.println(i++);
//这里输出的值是1它会先进行i+1在输出i的值
System.out.println(++i);
//-- 同理如上
赋值运算符
=
//赋值
int i=1;
//将i的值赋值给b所以b的值是1
int b=i;
//赋值时注意
int b=i++;//此时b的值还是1因为i++会吧值赋完以后才进行i+1；如果b的值想变为2那么就需要这样写 int b=++i;此时b的值就会为2了;
关系运算符
‘>’,<,>=,<=,==,!=,instanceof
int a=1;
int b=2;
// > 大于比较
System.out.println(a>b);//此时返回的是false 因为a不大于b
// < 小于比较
System.out.println(a<b);//此时返回的是true 因为a小于b
// >= 大于等于比较
System.out.println(1>=1);//此时返回的是true 因为1大于等于1
// <= 小于比较
System.out.println(0<=1);//此时返回的是true 因为0小于等于1
// == 等于比较
System.out.println(0==0);//此时返回的是true 因为0等于0
// != 等于比较
System.out.println(0!=0);//此时返回的是false 因为0等于0
//instanceof
//java中，instanceof运算符的前一个操作符是一个引用变量，后一个操作数通常是一个类（可以是接口），用于判断前面的对象是否是后面的类，或者其子类、实现类的实例。如果是返回true，否则返回false。也就是说：使用instanceof关键字做判断时， instanceof 操作符的左右操作数必须有继承或实现关系
逻辑运算符
&&，||，！
位运算符
&，|,^,~,>>,<<,>>>
(二进制)
A 0011 1100
B 0000 1101
A&B (A与B二进制做比较如果2个位都位1就为1否者为0) 0000 1100
A|B（A或b二进制做比较如果2个位中有一个为1就为1否者为0）0011 1101
A^B （A异或B 如果两个位相同就为0否者就为1）0011 0001
~B（B取反） 1111 0010
<< 相当于乘2 如 2<<3=2×2×2×2
（>>）相当于除以2 16>>3=16/2/2/2
条件运算符
？ ：（三元运算符）
int a=0;
System.out.println( a<=0?"小于等于0" :"大于0");//如果a小于等于0那么就输出：左边否者就输出右边
扩展赋值运算符
+=，-=，*=，/=
int i=0;
//相当于 i=i+1
i+=1;
//相当于 i=i-1
i-=1;
//相当于 i=i*1
i*=1;
//相当于 i=i/1
i/=1;
工具类
Math数学工具类
java结构
-
顺序结构
java的基本结构就是顺序结构，除非特别指明，否者就是按照顺序一句一句执行。
顺序结构是最简单的算法结构
-
选择结构
if单选择结构
int a=0; if(a==0){ System.out.println("ok"); } if双选择结构
int a=0; if(a==0){ System.out.println("ok"); }else{ System.out.println("no"); } if多选择结构
int a=0; if(a==0){ System.out.println("ok"); }else if(a==1){ System.out.println("ok1"); }else if(a==2){ System.out.println("ok2"); }else{ System.out.println("no"); } 嵌套if结构
int a=10; if(a>0){ if (a<=10){ System.out.println("ok"); }else{ System.out.println("no"); } } switch多选择结构
如果case后没有加上break 就输出包括当前和下面的所有这个现象叫做case穿透
int a=0; switch(a){ case 0: System.out.println("ok"); break; case 1: System.out.println("ok2"); break; default: System.out.println("no"); } -
循环结构
while 循环 只要表达式为true 循环就会一直走下去 我们大多数情况是会让循环停止下来，我们需要一个让表达式失效的方式来结束循环
//计算1-100的总和 int i = 0; int sum=0; while (i < 100) { sum+=++i; } System.out.println(sum);do while 循环
do while 和while相似但是do while至少会执行一次循环
int i = 0; do { i++; System.out.println(i); } while (i < 0);for 循环
//for循环打印9*9乘法表 for (int i = 1; i <= 9; i++) { for (int j=1;j<=i;j++){ System.out.print(j+"*"+i+"="+(j*i)+"\t"); } System.out.println(); }增强for循环
int[] numbers = {1, 2, 3, 4};//定义数组 //变量数组 for (int i : numbers) { System.out.println(i); }
break continue
break在任何循环里语句的主体部分，都可以使用break关键字控制循环流程。break用于强行退出循环，不执行循环中剩余的语句。（break也能在switch语句中使用）
for (int i = 0; i < 100; i++) {
System.out.println(i);
if (i == 10) {//当i等于10时跳出循环
break;
}
}
continue 语句在循环语句体中，用于终止某次循环过程，即跳过循环体中的尚未执行的语句接着进行下一次是否执行循环的判定。
for (int i = 0; i < 100; i++) {
if (i == 10) {//i等于10时不执行下面的输出语句直接重新开始循环
continue;
}
System.out.println(i);
}
java方法
什么是方法
方法是解决一类问题的步骤的有序组合，方法包含于类或对象中，方法在程序中被创建，在其他地方被引用。
方法的本意是功能块，就是实现某一个功能的集合，我们设计方法时最好保持方法的原子性，就是一个方法完成一个功能。
方法的定义以及调用
方法的定义
修饰符 返回值类型 方法名（参数类型 参数名）{
方法体
return 返回值;
}
修饰符:可选的如public,static等
返回值类型：方法可能存在返回值也有可能没有返回值如果没有返回值就使用void关键字表示并且不需要return如果有返回值那么需要return 返回值类型相同的值
方法名：方法名是实际名称，方法名最好写的有意义并且遵循驼峰法制。
参数类型：参数像是一个占位符。当方法被调用时，传递给参数。这个值被称为实参或变量。参数列表是值参数的参数类型，顺序和参数个数。参数是可选的，参数可以多个。形式参数（在方法创建时定义的参数），实参（调用方法时实际传递给方法的数据）。
方法体：具体实现代码
public int add(int a,int b){
return a+b;
}
方法的调用
调用方法：对象名称.方法名称(参数列表);
方法重载
重载就是在一个类中，有相同的方法名称，但是形式参数不同的方法。
重载的规则
- 方法名称必须相同
- 参数列表必须不同（个数不同，类型不同，参数顺序不同）
- 方法的返回值可以相同也可以不同
- 仅仅返回类型不同不足以成为方法重载
可变参数
jdk1.5开始，java支持传递同类型的可变参数给一个方法，在方法声明中，在指定的参数类型后加上一个省略号，一个方法中只能指定一个可变参数，它必须是方法最后一个参数。任何普通参数必须在它之前声明。
// 可变参数 a可以传递无限个参数如 add(1，2，3，4，5)
public static void add(int... a) {
for (int i:a){
System.out.println(i);
}
}
递归
A方法调用A方法就是递归。
递归结构包括两个部分：
递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
递归体：什么时候调用自身方法。
（小计算时可以使用递归数据量多时不建议使用）
//递归代码求任意数的阶乘
public int f(int i) {
if (i == 1) {
return 1;
} else {
return i * f(i - 1);
}
}
数组
数组概念
数组是相同类型数据的有序集合，数组描述的是相同类型的若干数据，按照一定的先后顺序排列组成，其中每一个元素称作一个数组元素，每个元素可以通过下标访问。
数组的特点
数组的长度都是确定的，数组一旦被创建无法更改大小。
其中元素必须是相同的类型，不允许混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属于引用类型，数组也可以看做对象，数组中每个元素相当于该对象的成员变量。
数组本省就是对象，java的对象是在堆中，因此数组无论保存原始类型还是其他对象类型数组对象本身是在堆中。
数组声明和创建
//声明数组并分配空间 数组类型[] 数组名称
int[] nums =new int[10];//定义int数组并且分配10个长度数组下标是重0开始的所以说数组长度是0-9而不是1-10（推荐使用）
int nums[] =new int[10];//定义int数组并且分配10个长度（不推荐使用）
数组使用
//数组赋值 如果没有使用到的长度会使用默认值int默认值是0
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
//获取数组值可以使用循环方法来获取默认值，使用数组.length来获取数组长度
for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]);
}
//也可以用增强for循环来获取
for (int num : nums) {
System.out.println(num);
}
数组初始化方法
//静态初始化 创建+赋值
int[] a={1,2,3,4};
//动态初始化包含默认初始化
int[] b=new int[10];
b[0]=10;
多维数组
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
//可以看成2行5列的数组
int a[][]=new int[2][5];
//初始化
int[][] nums = {{1, 2}, {2, 3}, {3, 4}};
//遍历
for (int[] num : nums) {
for (int i : num) {
System.out.println(i);
}
}
Arrays类
数据工具类java.util.Arrays，由于数组对象本省没有什么方法可以供我们调用，但api中提供了一个工具类供我们使用，从而可以对数据对象进行一些基本操作。
Arrays类中方法都是static修饰的静态方法，在使用的时候可以直接使用类名来进行调用而不用使用对象来调用。
具体常用功能：
1. 给数组赋值：fill方法
2. 给数组排序：sort方法升序
3. 比较数组：equals
4. 查找数组元素：binarySearch方法能对排序好的数组进行二分查找法操作。
稀疏数组
稀疏数组是一个数据结构，当一个数组中大部分元素为0，或者同一值数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是：
-
记录数组一共有几行几列，有多少不同值
-
把具体不同值得元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
-
下图左边为原数组，右边为稀疏数组
如上图所示左边为原数组右边为稀疏数组稀疏数组第一行第一列的值代表原数组有多少行，第一行第二列代表原数组有多少列，第一行第三列代表原数组有多少个有效值，除第一行以外有多少个有效值就有多少行，其他行的第一列代表这个数据在原数据中的多少行，其他行的第二列代表这个数据在原数据的多少列，其他还的第三列代表原数据值。
//创建二维数组
int[][] array = new int[11][11];
array[1][2] = 1;
array[2][3] = 2;
for (int[] ints : array) {
for (int anInt : ints) {
System.out.print(anInt + " ");
}
System.out.println();
}
//转换为稀疏数组保存先记录有效值
//sum有效值
int sum = 0;
for (int[] ints : array) {
for (int anInt : ints) {
if (anInt != 0) {
sum++;
}
}
}
System.out.println(sum);
//创建一个稀疏数组行为有效值+1，列固定为4列
int[][] array2 = new int[sum + 1][3];
//记录原数组有多上行多少列多少个有效值
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历二维数组将非0的值存放稀疏数组
int count = 0;
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
if (array[i][j] != 0) {
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array[i][j];
}
}
}
//读取稀疏数组
int[][] array3=new int[array2[0][0]][array2[0][1]];
//给其中的元素还原值
for (int i = 1; i <array2.length ; i++) {
array3[array2[i][0]][array2[i][1]]=array2[i][2];
}
}
java内存分析
java内存
1. 堆
1. 存放new的对象和数组
2. 可以被所有线程共享，不会存放别的对象引用。
2. 栈
1. 存放基本变量类型（包括这个基本类型的值）
2. 引用对象的变量（会存放这个引用在堆里面的具体地址）
3. 方法区
1. 可以被所有线程共享
2. 包含所有的Class和static变量
以上总结仅供个人参考并总结不喜勿喷
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
