1，2天
1、JDK，JRE，JVM
JVM是Java的虚拟机；
JRE是Java程序的运行环境；它包含JVM和Java的基础类库
JDK是Java的开发工具包；它包含JRE和编译工具javac以及调试工具
2、java如何实现跨平台
我们编写的.java程序，再经过javac编译后会生产一个.class文件，称为字节码文件；
JVM负责将字节码文件再翻译成机器码；不同的运行平台上安装不同的JVM就能将字节码翻译成对应的机器码，从而实现了跨平台；
3、注释的使用
文档注释/**.......*/
多行注释/*........*/
单行注释//
4、变量与常量
4.1变量的定义：int a;
a = 1;
或 int a = 1;
4.2变量必须初始化后才能使用；
4.3final关键字所修饰的变量，只能够赋值一次
5、标识符的命名
5.1标识符的构成规则：可由字母，数字，下划线，$构成；
5.2注意事项：仅不能以数字开头；对字母的大小写敏感；不能以关键字和保留字命名；
5.3命名规则
包名：全小写，倒域名；
类名：开头大写，驼峰式；
方法名：开头小写，驼峰式；
变量名：开头小写，驼峰式；
常量名：全大写，单词之间用下划线连接；
6、基本数据类型
布尔型boolean；
字符型char，2字节；
字节型byte，1字节；
短整型short，2字节；
整型int，4字节；
长整型long，8字节；
单精度浮点型float，4字节；
双精度浮点型double，8字节；
注意事项：
（1）浮点型的定义，float a =2f; double b = 3d;
（2）运算过程中，低字节类型会自动向高字节类型转化；
（3）char,byte,short类型相互运算的结果会自动转化成int型；
7、原码，反码，补码
8、进制转化
9、byte型，short型，int型的取值范围
补码表示的byte型的取值范围：-128~127；
补码表示的short型的取值范围：-32768~32767；
补码表示的int型的取值范围：-21 4748 3648~21 4748 3647；
3，4天
1、一个源程序中可以有多个类，但只能有一个public修饰的类，并且被public修饰的类，的类名要和文件名相同
2、运算符的介绍
2.1 算术运算符
2.2 比较运算符
2.3 赋值运算符
2.4 逻辑运算符
&&和||会存在短路，&和|不会
2.5 三目运算符
int a=a>b? 1:2;
String a = 5>2? "qwe":"rty";
只能适用于if...else类型
3、判断语句
3.1 if...else语句
3.2 switch...case语句
3.2.1 必须先从case语句执行，最后才执行default语句，不论default语句在哪个位置
3.2.2 没有break会发生，case穿透现象
4、循环语句
4.1 for循环和增强for循环（第6点讲）
4.2 while循环
4.3 do...while循环 至少会执行一次循环体
5、跳转语句
break 终止整个循环
continue 结束本次循环
return 结束整个程序
6、数组的简单介绍
6.1 数组的初始化
int[ ] a ={1,2,3};
或
int[ ] a = new int[3];
a[0] = 1;
a[1] = 2;
a[2] = 3;
6.2 数组的声明
int[ ] a;
或
int a[ ];
6.3 数组的遍历
6.3.1 取数组长度：
int length = a.length;
for(int i =0;i<length;i++){
System.out.println(a[i]);
}
6.3.2 增强for循环遍历数组：
for(int n:a){
System.out.println(n);
}
7、插入排序
7.1 第一种思路
每一次外循环，都能够将一个数插入到正确的位置，则一共需要循环len-1次；且i要从下标1开始，即为第一个要插入的数
每一次内循环，则具体实现如何把待插入的数放到正确的位置上，可将数组分成已排序和未排序两部分，先将未排序的首个
数字用临时变量保存起来，temp = a[i];再把temp和已排序部分的所有数字a[j--]逐一比较，若a[j]>temp，则把a[j+1]=a[j]，
即向后移动一位，直到a[j] < temp,此时j+1即是要插入的位置；在循环结束后加一句a[j+1]=temp;
public class Insert{
public static void main(String[] args){
int[] a = {6,5,3,1,8,7,2,4};
int len = a.length;
for(int i=1;i<len;i++){ //第一个插入的元素，下标是1
int j = i-1; //j的值，就是已排序组最后一个元素的下标
int temp = a[i]; //temp临时存储待插入元素的值
while(j>=0 && a[j]>temp){ //注意：这里不能写成while(a[j]>temp && j>=0)，因为&&会发生短路，当j为0的时候，执行j--，则j=-1会越界
a[j+1]=a[j]; //比temp值大的已排序好的元素向后移动一位，循环结束后位置j即是待插入的位置,又因为后面j--，所以最后j+1是待插入的位置
j--; //j--保证了temp会和已排序好的元素逐一比较
}
a[j+1]=temp;
//测试每次内循环结束后的数组元素
for(int n : a){
System.out.print(n+" ");
}
System.out.println();
}
//测试每整个循环结束后的数组元素
System.out.println("----------------------");
for(int n : a){
System.out.print(n+" ");
}
}
}
执行结果如下：
5 6 3 1 8 7 2 4
3 5 6 1 8 7 2 4
1 3 5 6 8 7 2 4
1 3 5 6 8 7 2 4
1 3 5 6 7 8 2 4
1 2 3 5 6 7 8 4
1 2 3 4 5 6 7 8
----------------------
1 2 3 4 5 6 7 8
7.2 第二种思路
每一次外循环，都要让一个数插入到已排序组中，共循环len-1次
每一次内循环，要解决如何将一个数插入到已排序组中；可以将待插入元素a[j]逐一和已排序组中的元素a[j-1]进行比较，
若a[j]<a[j-1],则交换位置，j--;再循环，循环结束后待插入元素则已经交换到了正确的位置上
public class Insert{
public static void main(String[] args){
int[] a = {6,5,3,1,8,7,2,4};
int len = a.length;
for(int i=1;i<len;i++){ //第一个插入的元素，下标是1
int j = i; //j的值，就是待插入元素的下标
while(j>0 && a[j]<a[j-1]){
int temp = a[j];
a[j]=a[j-1];
a[j-1]=temp;
j--; //j--保证了temp会和已排序好的元素逐一比较,然后交换
}
//测试每次内循环结束后的数组元素
for(int n : a){
System.out.print(n+" ");
}
System.out.println();
}
//测试每整个循环结束后的数组元素
System.out.println("----------------------");
for(int n : a){
System.out.print(n+" ");
}
}
}
//执行结果如下：
5 6 3 1 8 7 2 4
3 5 6 1 8 7 2 4
1 3 5 6 8 7 2 4
1 3 5 6 8 7 2 4
1 3 5 6 7 8 2 4
1 2 3 5 6 7 8 4
1 2 3 4 5 6 7 8
----------------------
1 2 3 4 5 6 7 8
8、选择排序
8.1 第一种思路
每一次外循环，都要把最小的元素放在开头的位置，依此放，只需要循环len-1次，最后一个元素自然是最大的
每一次内循环，要解决如何找到最小的元素；可以用每次的开头元素min=a[i]逐一和后面元素a[j]比较，
循环结束后会记录下min的值和其下标；再和a[i]交换位置
public class Select{
public static void main(String[] args){
int[] a = {6,5,3,1,8,7,2,4};
int len = a.length;
for(int i=0;i<len-1;i++){
int min = a[i]; //每次的开头元素，先赋值给min；再和后面元素比较
int index = i; //index保存min的下标
for(int j=i+1;j<len;j++){
if(min>a[j]){
min = a[j];
index = j;
}
}
a[index] = a[i];//交换位置，把开头元素放到最小值的位置上
a[i] = min;//再把最小值赋值到开头
//测试每次内循环结束后的数组元素
for(int n : a){
System.out.print(n+" ");
}
System.out.println();
}
//测试每整个循环结束后的数组元素
System.out.println("----------------------");
for(int n : a){
System.out.print(n+" ");
}
}
}
运行结果为：
1 5 3 6 8 7 2 4
1 2 3 6 8 7 5 4
1 2 3 6 8 7 5 4
1 2 3 4 8 7 5 6
1 2 3 4 5 7 8 6
1 2 3 4 5 6 8 7
1 2 3 4 5 6 7 8
----------------------
1 2 3 4 5 6 7 8
8.2 第二种思路
外循环一遍，让最小值置于前端
内循环一遍，通过让当前a[i]首元素和后面元素逐一比较，经过循环一次，会将最小值放到首部
public class Select{
public static void main(String[] args){
int[] a = {6,5,3,1,8,7,2,4};
int len = a.length;
for(int i=0;i<len-1;i++){
for(int j=i+1;j<len;j++){
if(a[j]<a[i]){
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
//测试每次内循环结束后的数组元素
for(int n : a){
System.out.print(n+" ");
}
System.out.println();
}
//测试每整个循环结束后的数组元素
System.out.println("----------------------");
for(int n : a){
System.out.print(n+" ");
}
}
}
运行结果如下：
1 6 5 3 8 7 2 4
1 2 6 5 8 7 3 4
1 2 3 6 8 7 5 4
1 2 3 4 8 7 6 5
1 2 3 4 5 8 7 6
1 2 3 4 5 6 8 7
1 2 3 4 5 6 7 8
----------------------
1 2 3 4 5 6 7 8
5天
1、冒泡排序
外循环一次，最大的数，放到最后位置上，len-1次
内循环一次，相邻位置比较，大的放到后面；即确定最后位置放最大元素
public class MaoPao{
public static void main(String[] args){
int[] a = {6,5,3,1,8,7,2,4};
int len = a.length;
for(int i=0;i<len-1;i++){
for(int j=0;j<len-1-i;j++){
if(a[j]>a[j+1]){
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
//测试每次内循环结束后的数组元素
for(int n : a){
System.out.print(n+" ");
}
System.out.println();
}
//测试每整个循环结束后的数组元素
System.out.println("----------------------");
for(int n : a){
System.out.print(n+" ");
}
}
}
运行结果：
5 3 1 6 7 2 4 8
3 1 5 6 2 4 7 8
1 3 5 2 4 6 7 8
1 3 2 4 5 6 7 8
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
----------------------
1 2 3 4 5 6 7 8
2、快速排序
public class Quick{
public static void main(String[] args){
int[] a = {6,5,3,1,8,7,2,4};
int len = a.length;
int start = 0;
int end = len -1;
Sort(a,start,end);
//测试每整个循环结束后的数组元素
System.out.println("----------------------");
for(int n : a){
System.out.print(n+" ");
}
}
public static void Sort(int[] a,int start,int end){
int s = start;
int e = end;
int key = a[s];
if(s>=e){
return;
}
while(s<e){
//从右到左查，找到比key值小的，则交换，跳出循环,进入从左到右查；要是比key值大则e--
while(s<e){
if(key > a[e]){
a[s] = a[e];
a[e] = key;
break;
}
e--;
}
//从左到右查，找到比key值大的，则交换，跳出循环；要是比key值小，则s++
while(s < e){
if(key < a[s]){
a[e] = a[s];
a[s] = key;
break;
}
s++;
}
}
Sort(a,start,e-1);
Sort(a,s+1,end);
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
