Java基础笔记1——变量、循环、数组

Java基础笔记1
一．初识Java
Java SE：Java Platform Standard Edition Java平台标准版
Java EE：Java Platform Enterprise Edition Java平台企业版
Java ME：Java Platform Mircro Edition Java平台微型版
Java语言特性：简单、安全、面向对象、跨平台、多线程
面向对象特征：多态、继承、封装
JDK=Java Development Kit Java开发工具包
JRE=Java Runtime Environment Java运行时环境
JVM=Java Virtual Machine Java虚拟机——跨平台（可移植性）的基础
Java可移植性的基本原理：java用编译器编译成字节码，字节码用解释器运行，同一字节码可以在不同的操作系统下被不同的解释器运行，从而实现Java的跨平台性也就可移植性.
Eclipse简介：SUN公司耗资4000万美金开发，是开源的集成开发环境。
Eclipse本身是一个实时编译
Eclipse常用快捷键
注意：快捷键可能和搜狗输入法冲突，需先取消搜狗输入法的快捷键设置
Alt + / 快捷提示键
ctrl+/ 单行注释或取消单行注释
ctrl + shift + / 多行注释
ctrl + shift + \ 取消多行注释
Ctrl + D 删除整行
Ctrl + Z 撤销上一步操作
Alt + ↑ 整行上移
Alt + ↓ 整行下移
Ctrl + Alt + ↑ 复制整行，把复制的放在原来的代码上面
Ctrl + Alt + ↓ 复制整行，把复制的放在原来的代码下 面
Alt + Shift + S 打开source （选择Format可以调整格式）
Ctrl + Shift + F 快速调整格式
Ctrl+shift+o 自动导包(输完需导包的语句后）
Ctrl+O 移动鼠标到类名，用此快捷键可以显示类中方法和属性的大纲，能快速定位类的方法和属性。
Ctrl+M 当前窗口最大化和还原
Ctrl+K 快速向下查找选定的内容
Ctrl+shift+K 快速向上查找选定的内容
Ctrl+Shift+T 通过关键字快速查找工作空间（Workspace）里的.class文件，可以使用“*”、“？”等通配符
Ctrl+Shift+R 查找工作空间（Workspace）中的所有文件（包括Java文件），也可以使用通配符
ALT+Shift+W 点击Package Explorer可以快速定位包视图的位置,点击System Explorer打开文件所在项目中的路径，Outline→大纲
Ctrl+L 定位到当前编辑器的某一行
Alt+← 后退历史记录
Alt+→ 前进历史记录
F4 显示类的继承关系，并打开类继承视图
F3 快速定位光标位置的某个类、方法和属性
Ctrl+Shift+B 在当前行设置断点或取消设置的断点
F11 调试最后一次执行的程序
Ctrl+F11 运行最后一次执行的程序
F5 跟踪到方法中，当程序执行到某方法时，可以按【F5】键跟踪到方法中
F6 单步执行程序
F7 执行完方法，返回到调用此方法的后一条语句
F8 继续执行，到下一个断点或程序结束
Ctrl+Shift+X 把当前选中的文本全部变为小写
Ctrl+Shift+Y 把当前选中的文本全部变为大写
Alt+Shift+R 重命名，自动定位所有同名，全部修改，enter键完成操作
Alt+Shift+Z 为选中内容添加常用结构，如try…catch/finally、for、while、if循环
Alt+Shift+M 快速抽取方法
Alt+Shift+L 快速抽取返回值
Ctrl+1 将光标放在;后面按ctrl+1,弹出 Assign statement to new local varible,enter即可自动生成返回值对象
Ctrl+Shift+Delete快捷键用于清除浏览器缓存。
安装Eclipse，需先安装JDK，配置环境变量JAVA_HOME及path(和classpath)。
java中path的作用:path 是一个环境变量, 路径，是java编译时需要调用的程序（如java，javac等）所在的地方
classpath 类的路径，在编译运行java程序时，如果有调用到其他类的时候，在classpath中寻找需要的类。
 磁盘操作系统（Disk Operating System）
打开方式：1.快捷键——系统键+R，输入“cmd”,Enter
2.右键开始菜单，点击“运行”，输入“cmd”,Enter
DOS命令符：
不区分大小写
D: 直接切换到D盘
cd Program Files 进入当前盘符目录Program Files
cd. 当前目录
cd… 向上退一层
cd/ 直接退回到根目录
dir 显示当前目录详细信息
md 在当前路径创建目录（文件夹）
mkdir 在当前路径创建目录（文件夹）
rmdir 移除目录
javac 编译java文件的命令，生成class文件
javadoc 提取/** */注释，输出的是一个HTML文件
javac -d ./ 在当前java文件所在目录下建子文件，文件名与package名一致
javap 查看程序的底层运行过程
javah 和c/c++语言交互
javaw 查看java进程
exit 退出DOS窗口
calc 打开计算器
notepad 打开记事本
mspaint 打开画图工具
jar cvf Im.jar/ 压缩jar包
netstat -ano 列出所有端口的情况
netstat -aon|findstr “49157” 查看被占用端口对应的PID（其中49157是端口号）
tasklist|findstr “2720” 查看是哪个进程或者程序占用了2720端口
taskkill /f /t /im Tencentdl.exe 结束Tencentdl.exe进程
①在没有package的情况下可以直接编译运行java文件。

②运行package下的java文件，需要
javac -d ./ 在当前目录创建包名文件夹存放.class文件

Java生成文件后缀.java，编译文件后缀.class
批处理文件后缀.bat
可执行文件后缀.exe
java中所有的关键字都是小写的。
Java关键字
abstract抽象的 assert断言 boolean布尔 break打断 byte字节
case实例，情况 catch捕获 char字符型 class类 const常量
continue default默认值 do做，执行 double双倍的 else其它
enum枚举 extends继承 final最终的 finally最后 float浮点型
for goto转到 if假如 implements元素 import导入
instanceof实例，运算符 int整数型 interface接口 long长整型 native本来的
new新的 package包 private私有的 protected受保护的 public公共的
return返回 strictfp精准 short短整型 static静态的 super超级的，父类的
switch转换 synchronized同步的 this这个 throw抛 throws（复数）抛出
transient短暂的 try尝试 void无返回值 volatile爆炸性的，不稳定的 while当……的时候

数据Data在计算机中的表现形式：
二进制binary/'baɪnərɪ/ 
八进制octonary/'ɒktə(ʊ)n(ə)rɪ/
十进制decimal/'desɪm(ə)l/ 
十六进制hexadecimal/,heksə’desɪm(ə)l/
字节是计算机信息技术用于计量存储容量的一种计量单位。
1字节=8位（二进制数）
1KB=1024Byte(字节)
1MB=1024KB
1GB=1024MB
二、变量
变量的访问：
1.未经声明的变量不能使用
2.变量初始化后才能使用
3.变量超出作用域会报错（作用域在定义变量{}里）
4.一条语句可以声明多个同类型变量，如int a=1,b=2,c=3;
5.可以对变量的值进行存储操作。如int a=1;a=a+100;
6.变量的操作必须与类型匹配
7.赋值运算符=；等于==
特殊字符如果要表示成普通字符，需要用 \ 转义，如"\t"表示制表符。
变量名称不能用关键字。变量可以用”_”、”$”及字母、数字表示，但不能以数字开头。
命名遵循驼峰命名法，首字母小写，后面单词首字母大写。
包名package命名单词直接用“.”隔开。
不同值类型有不同取值范围。
boolean类型，1个字节，取值范围：true/false
byte类型，1个字节，取值范围：-128~127
short类型，2个字节，取值范围：-32768~32767
char类型，2个字节，取值范围：0~65535，采用Unicode字符集编码
char a=’A’; //字符直接量
char b=65; //整型直接量
char c=’\u0041’; //Unicode字符的十六进制形式
A-Z整型表示：65-90
a-z整型表示：97-122
0-9整型表示：48-57
int类型，4个字节，取值范围：-2147483648~2147483647，数值默认型。运算超出范围溢出。
long类型，8个字节，取值范围：-263~263-1，表示形式：加后缀l或L
在java虚拟机中整数有byte、short、int、long四种 分别表示 8位、16位、32位、64位有符号整数。整数使用补码表示。
float类型，4个字节，取值范围：float的取值范围： 负无穷 ~ −2128，−2−149 ~ 0 ~ 2−149，2128 ~正无穷，表示形式：加后缀f或F
double类型，8个字节，取值范围：-Infinity(负无穷) ~21024 ， −2−1074 ~ 0 ~2−1074 ，21024~Infinity(正无穷)，当运算结果超出范围，显示infinity或-infinity.
小数避免做精确判断。
运算类型小于int型会自动转换。
运算溢出不报错，应尽量避免。
正数过大溢出结果为负数，负数过大溢出结果为正数。
默认编码：GBK
注意：位移运算仅针对整数。
！（非）：只需要一个操作数，如果操作数为true则返回false，如果操作数是false，则返回true。
^（异或）：两个操作数不同时返回true，否则返回false。
==（等于）
&&（与）短路
&（与）不短路：判断整个表达式
||（或）短路
|（或）不短路
位运算符
①　&：按位与——两个操作数都是1，结果才为1，否则为0
②　|：按位或——两个位只要有一个1，结果就是1，否则为0
③　_{：按位非——位为0，结果是1；位为1，结果是0，规律：}i = -i-1，例~2=-3；
④　^：按位异或——位相同结果为0，不同结果为1
⑤　<<：左移
⑥　>>：右移
⑦　>>>：无符号右移
<<n左移n位，值×2n，高位舍弃，低位补0。>>n右移n位，值÷2n，高位补符号，正数为0，负数为1，低位舍弃。
正数的原码、反码、补码一致，负数反码是原码的绝对值取反，补码是反码+1。所有运算都是以补码的形式进行，负数运算结束值减1，取反得到原码即结果。
2的补码：0000 0010，~非运算后1111 1101，减1得1111 1100，取反1000 0011。注意符号位不参与取反。
经典案例：-2>>1结果为-1；-2>>>1结果为2147483647
int型有32位
-2二进制表示：1000 0000 0000 0000 0000 0000 0000 0010
-2反码：1111 1111 1111 1111 1111 1111 1101
-2补码：1111 1111 1111 1111 1111 1111 1110
右移一位：1111 1111 1111 1111 1111 1111 1111 1111
减1后： 1111 1111 1111 1111 1111 1111 1111 1110
取反得结果：1000 0000 0000 0000 0000 0000 0000 0001 即-1

无符号右移，移位后符号位始终补0：0111 1111 1111 1111 1111 1111 1111 1111
正数原码、反码、补码一致，所以结果为：0111 1111 1111 1111 1111 1111 1111 1111
230+229+……20=2147483647
运算符优先级
优先级 名称 运算符
1 分隔符 . [] () , ;
2 单目运算符 ++ – ~ ！
3 强制类型转换运算符 (type)
4 乘法/除法/求余运算符 * / %
5 加法/减法运算符 + -
6 移位运算符 << >> >>>
7 关系运算符 < <= > >= >instanceof
8 等价运算符 == !=
9 按位与运算符 &
10 按位异或运算符 ^
11 按位或运算符 |
12 条件与运算符 &&
13 条件或运算符 ||
14 条件三目运算符 ?:
15 赋值运算符 = += -= = /= &= |= ^= %= <<= >>= >>>=
运算顺序：从右看向左 i=5, i+=i-=i=++i;
i=5+(5-(5*6))=-20
整数/0 — ArithmeticException
非零小数/0 非零数字/0.0 Infinity
0.0/0 0/0.0 0.0/0.0 NaN
产生随机数据
导包import java.util.Random;
Random random=new Random(); //生成Random对象
int a=random.nextInt(100); //得到0-100之间的随机正数
double b=random.nextDouble(); //得到0.0-1.0之间的随机浮点数
//获取用户输入的字符
Scanner scan=new Scanner(System.in);
char c=scan.next().trim().charAt(0); //去空白字符，取输入的第一个字符
三、选择结构
判断结构：符合条件就执行代码块
if(条件）{代码块；}
if(条件）{代码块；} else{代码块；}
if(条件）{代码块；} else if{代码块；}……
if(条件）{代码块；} else if{代码块；}……else{代码块；}
分支结构：依次匹配
switch(表达式）{
case 常量1：代码块1；break;
case 常量2：代码块2；break;
……
default：代码块n；break;
}
注意：swtich表达式类型只能是byte、short、char、int，JDK1.7新增String类型。
break结束，使后面的代码不再执行。
case和default的顺序不讲究。
注意：①case后面若没有break则自上而下依次执行下面的语句。
②没有符合case的语句则只执行default语句。
四、循环结构
while(boolean表达式){代码块;}
当boolean值为true时，代码块被反复执行，直到boolean值变为false时结束。
注意：while循环一定要保证条件有变为false的时候，否则就变成死循环。
do{代码块;}
while(boolean表达式);
无论boolean是否为true都会先执行一次do里面的代码块。
for(表达式1;表达式2;表达式3){
代码块; //被循环执行
}
表达式1：赋值语句，为循环变量赋初始值，int i=0;
表达式2：条件语句，循环执行下去的条件，i<100;
表达式3：赋值语句，循环结构的迭代部分，通常用来修改循环条件，i++
增强for循环：遍历输出
for(临时变量：数组){执行语句;}
for(int tmp:arr){System.out.println(tmp);}//遍历数组中的每一个元素，循环次数为数组的长度
循环控制：
break：完全中止循环本身。跳出一层循环结构——用于选择或循环结构
continue：跳出本次循环，继续下一次循环。——只能用于循环结构
五、数组
存储多个同一类型的数据——容器——大小固定，也是一种对象。
数组对放入其中的元素编号，编号从0开始。
定义数组：
1.数据类型[] 数组名=new 数据类型[];
int[] arr=new int[5]; //定义了一个能存储5个整型元素的数组
arr[2]=10;//定义数组下标为2的位置上放入元素10
int i=arr[2];
2.数据类型[] 数组名=new 数据类型[]{元素1，元素2，元素3……};
int[] arr=new int[]{1,2,3,4,5,6}; //数组大小为6
3.数据类型[] 数组名={元素1，元素2，元素3……};
int[] arr={1,2,3,4,5,6}; //arr.length=6;
注意：数组定义的时候就要初始化，如int[]arr;arr= {1,2,3,4,5,6};会报错。
4.数据类型 数组名[]=new 数据类型[];
int arr[]=new int[5];
注意：[]可以在数组名之前，也可以在之后，但带来的效果不一样。
[]在数组名后，只有第一个是数组
①int arr1[],arr2; //arr1[]是数组，arr2是变量
[]在数组名前，后面接的变量都是数组类型
②int[] arr1,arr2; //arr1是数组，arr2是数组
注意：当使用的下标超过了数组的最大下标的时候就会出现：ArrayIndexOutOfBoundsException — 数组下标越界异常
数组的应用

1. 获取数组的元素 — 数组名[下标]
2. 获取数组的长度 — 数组名.length
   数组的内存
   Java将所占用的内存划分为5块：栈内存、堆内存、方法区、本地方法栈、寄存器（PC计数器）。
   栈内存：用于变量的存储。变量在定义之后会在栈内存中占用一块空间，如果在程序中给变量赋值，才会在栈内存的对应空间中保存这个值。这个变量用完以后会立即移除栈内存。
   int[] arr=new int[5]; //在堆内存中new一个空间存放数组元素，初始值为{0,0,0,0,0}
   arr存的只是一个地址： [I@25203875
   [ 表示数组
   I 表示元素类型是int
   @ 只是一个标记，表示后边是地址
   25203875 表示地址的哈希码的十六进制表现形式
   堆内存：存储的是对象。堆内存会对存入其中的元素赋予一个默认值。在存入对内存中的对象使用完成之后，不会立即移除出堆内存，而是在不定的某个时刻被释放。
   ①int、byte、short默认值0
   ②long类型默认值0L
   ③float类型默认值0.0f
   ④double类型默认值0.0
   ⑤char类型默认值’\u0000’（表示空字符）
   ⑥boolean类型默认值是false
   ⑦除以上类型默认值全是null
   int[] arr=new int[6];
   int[] arr2=arr; //将arr的地址复制给arr2
   arr2=new int[2]; //开辟一个新的内存空间，重新给arr2一个地址，舍弃旧的地址

遍历数组
方法一：
int[]arr={1,2,3,4,5,6};
int i=0;
while(i<arr.length) {
System.out.println(arr[i]);
i++;
}
方法二：
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
方法三：
for(int tmp:arr){System.out.println(tmp);} //遍历数组中的每一个元素，循环次数为数组的长度

利用Arrays
import java.util.Arrays; //导工具包
int[]arr={1,2,3,4,5,6};
String str=Arrays.toString(arr); //将数组拼接成字符串
System.out.println(str); //输出结果[1, 2, 3, 4, 5, 6]
获取数组的最大值
int[]arr={1,2,3,4,5,6};
int max=arr[0];
for(int i=1;i<arr.length;i++) {
if(arr[i]>max) { //如果下标为i的元素大于max，则将arr[i]的值赋给max
max=arr[i]; //循环执行，直到max变为最大值，跳出循环
}
}
System.out.println(max);
冒泡排序：相邻两个元素一一比较。需要判断(n-1)(n-i)=n2-(i+1)n+i次，时间复杂度：O(n2)
时间复杂度：找到这个程序中重复执行的这段代码，把重复的这段代码执行的时间认定为单位1，执行这个单位1的次数就是时间复杂度。
时间复杂度计算的时候一定找到表达式最高阶，只考虑项不考虑系数。例3n2时间复杂度：O(n2)
时间复杂度用O()表示，表现形式nx,(logn)x,nx(logn)y。
int temp=arr[j-1];
arr[j-1]=arr[j];
arr[j]=temp;
无论数组长度多少，需要额外花费3个变量空间。
空间复杂度：这段代码在执行过程中需要额外花费的变量的空间的个数。
空间复杂度的表现形式和时间复杂度一样。3=3n0，空间复杂度为o(1)。
注意：时间复杂度用大写O，空间复杂度用小写o。
时间复杂度表示了代码被重复执行的次数不决定时间长短，空间复杂度表示了这段代码执行需要耗费的空间大小。
时间复杂度一样，但耗费时间不一定一样。
选择排序：选定一位，然后依次和其他位上的元素进行比较。
选定第1个元素和余下（n-1）元素比较排序，第1个元素位置固定后选定第2个元素和余下(n-2)元素比较排序，第1、2个元素位置固定后选定第i位元素和余下(n-i)元素比较排序……直到n-i=1。
(n-1)(n-i)=n2-(1+i)n=i 时间复杂度为O(n2)
3=3n0，空间复杂度为o(1)。
Arrays.sort(arr);只能进行升序排序
数组的反转：头尾互换
时间复杂度为O(n)，空间复杂度为O(n)。
for(int i=0,j=arr.length-1;i<j;i++,j–) {
int tmp=arr[i];
arr[i]=arr[j];
arr[j]=tmp;
}
数组的查找：
获取指定元素的下标：如果数组无序，可以通过遍历数组的方式来查找
折半查找/二分查找：min mid max，针对有序数组，每次比较中间值，重新定义最小值和最大值。
复制数组：
①原数组 = Arrays.copyOf(数组，长度); —本质上就是数组的复制—必然会产生一个新的数组，所以数组扩容完成之后地址一定会发生改变。
② System.arraycopy(复制数组源, 开始复制下标位置, 新数组, 开始粘贴下标位置, 复制长度);
int[] arr= {15,24,30,40,44,53,60};
int[] arr2=new int[5];
//复制数组arr中前4个元素到新数组arr3
int[] arr3=Arrays.copyOf(arr, 4);
System.out.println(Arrays.toString(arr3));
//从数组arr中下标为3的元素开始复制3个元素到新数组arr2中，从arr2下标为1的位置开始放置元素。
System.arraycopy(arr, 3, arr2, 1, 3);
System.out.println(Arrays.toString(arr2));
利用数组复制的方法移除指定下标的元素
String[] arr= {“I”,“like”,“you”,“very”,“much”};
//从数组arr下标为1的元素开始复制来自数组arr下标从2开始的3个元素
System.arraycopy(arr, 2, arr, 1,3 );
//例如数组复制的另一个方法进行缩容操作（减少数组元素）
arr=Arrays.copyOf(arr,4); //数组元素从5个减少为4个
System.out.println(Arrays.toString(arr));//输出 [I, you, very, much]
二维数组
存储数组的数组------里面存储的元素都是一维数组。
定义格式：
①数据类型[][] 数组名=new 数据类型[二位数组的大小][一维数组的大小];
int[][] arr=new int[3][5];//表示有3个包含5个元素的一维数组
②数据类型[][] 数组名=new 数据类型[二位数组的大小][];
未指定一维数组时，默认值为null。
int[][] arr=new int[3][];//表示这个二维数组中能存储3个一维数组
arr[0]=new int[5];
arr[1]=new int[4];
arr[2]=new int[3];
③数据类型[][] 数组名={{数组1},{数组2},{数组3}……};
④数据类型 数组名[][]=new 数据类型[二位数组的大小][一维数组的大小];
int arr[][]=new int[3][5];
⑤数据类型[] 数组名[]=new 数据类型[二位数组的大小][一维数组的大小];
int[] arr[]=new int[3][5];
难点：int[] x[],y;//x是二维数组，y是一维数组
正确赋值 x[0]=y; x[0][0]=y[0];
arr存的只是一个地址：[[I@15db9742
[[ 表示二维数组
I 表示元素类型是int
@ 只是一个标记，表示后边是地址
15db9742 二维数组的十六进制地址，里面存放一维数组的地址
二维数组的内存存储

遍历二维数组
for(int[] is:arr) {
for(int i:is) {
System.out.println(i);
}
}
练习：
1.一维数组中无序存放了1~n中的n-1个数，如果找到没有放到数组中的数？
2.一组数字，除了其中一个元素以外，其余元素都出现了偶数次，而有一个是奇数次，找到这个奇数次的元素。
1,1,2,2,2,3,3,3,3,3,2,2,2,4,4,4,4,4,4,5,5,5,5,6,6,7,7,7,8,7,8,9,8,9,8…
int n = 0;
for(int i = 0; i < arr.length; i++){
n ^= arr[i];