循环结构：
While（条件表达式）{执行语句}
do{执行语句}while（条件表达式）
区别在于：不论条件是否满足，do while都会至少执行一次
for(初始化表达式；循环条件表达式；循环的操作表达式){执行语句}
for和while的小区别：
1、 变量有自己的作用域，对于for来讲，如果将控制循环的增量定义在for循环中，只能在语句内有效
2、 可以互换，如果需要定义循环增量，用for更为合适
嵌套循环：
for…for嵌套
打印
*
**
***
****
*****和99乘法表
代码实现：
class ForForTest
{
public static void main(String[] args)
{
for(int x=0;x<5;x++)
{
for(int y=5-x;y<=5;y++)
{
System.out.print("*");
}
System.out.println();
}
System.out.println("———————————");
for(int x=1;x<10;x++)
{
for(int y=1;y<=x;y++)
{
System.out.print(y+"*"+x+"="+x*y+"\t");
}
System.out.println();
}
}
}
流程控制语句：break（switch语句、循环语句（能够用于跳出循环，标号只能用于循环）） continue（只能作用于循环结构，继续循环。特点：结束本次循环，继续下一次循环）
break和continue单独存在时，下面可以有任何语句，因为都执行不到。
函数：
函数就是定义在类中的具有特定功能的一段独立小程序，也称为方法。
函数格式：修饰符返回值类型函数名（参数类型形式参数1，参数类型形式参数2，…）
{
执行语句；
Return返回值；
}
函数特点：
1、 可将功能代码进行封装，便于对该功能进行复用
2、 只有被调用才执行，函数的出现提高了代码的复用性
3、 若无返回值，返回值类型可用关键字void，return若在最后可以省略不写
注意：
1、 函数只能调用函数，不能再函数内部定义函数
2、 定义函数时，函数的结果应该返回给调用者，交由调用者处理
函数的重载（overload）：在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可。
数组：同一种类型数据的集合，其实数组就是一个容器。数组可以给其中的元素从0开始编号，方便操作这些元素。
格式:
1、 元素类型【】数组名=new 元素类型【元素个数或数组长度】
eg：int【】 arr=new int【5】；
2、 元素类型【】数组名=new 元素类型【】{元素，元素……}；
int【】 arr=new int【】{3,5,7}；
int【】 arr={3,5,7}；
内存结构：
栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放
堆内存：数组和对象，通过new建立的实例都存放在堆内存中
每一个实体都有内存地址值，实体中的变量都有默认初始化值
实体不再被使用，会在不确定的时间被垃圾回收器回收
方法区、本地方法区、寄存器
java基础视频第四天重点总结：
数组的操作：
1、获取数组中的元素，通常用遍历
2、获取数组的元素个数 .length
Eg：随便定义一个数组，获取数组的长度与元素（用到数组，通常都要用到for循环）
class ArrayDemo6
{
public static void main(String[] args)
{
int[] arr={5,8,7,6,4,55,4,88};
System.out.println("length:"+arr.length);
for(int x=0;x<arr.length;x++)
{
System.out.println("arr["+x+"]="+arr[x]+";");
}
}
}
本节重点：将给定数组进行排序两种方式（选择排序和冒泡排序）
最快的排序方式：希尔排序（三层循环加位运算）
选择排序、代码实现：
class SelectSort
{
public static void main(String[] args)
{
int[] arr={8,7,5,4,9,5,88,4,5,454};
printSort(arr);
sort(arr);
printSort(arr);
}
public static void sort(int[] arr)//选择排序
{
for(int x=0;x<arr.length;x++)
{
for(int y=x+1;y<arr.length;y++)
{
if(arr[x]>arr[y])
{
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
public static void printSort(int[] arr)//进行打印的程序
{
System.out.print("[");
for(int x=0;x<arr.length;x++)
{
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
public static void bubbleSort(int[] arr)//冒泡排序
{
for(int x=0;x<arr.length-1;x++)
{
for(int y=0;y<arr.length-x-1;y++)//-x让每一次比较的元素减少，-1避免脚标越界
{
if(arr[y]>arr[y+1])
{
int temp=arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
}
}
util包中Arrays.Sort（）//java中已经定义好的排序方式，开发中使用。
折半查找：能够提高效率
//折半查找
class ArrayTest7
{
public static void main(String[] args)
{
int[] arr={1,5,7,8,9,12,45,78};
int index=arrayTest(arr,7);
System.out.println("index="+index);
}
public static int arrayTest(int[] arr,int key)
{
int min,mid,max;
min=0;
max=arr.length-1;
mid=(min+max)/2;
while(arr[mid]!=key)
{
if(key>arr[mid])
min=mid+1;
else
min=mid-1;
if(min>max)
return -1;
mid=min+max/2;
}
return mid;
}
}
查表法求十六进制：将所有的元素临时存储起来，建立对应关系
每一次&15之后的值作为索引去查建立好的表，就可以找对应的元素，这样比-10+‘A’简单。表可以通过数组的形式建立。
public static void toHex_1(int num)
{
char[] chs={‘0′,’1′,’2′,’3′,’4′,’5′,’6′,’7′,’8′,’9′,’A’,’B’,’C’,’D’,’E’,’F’};
char[] arr=new char[8];
int pos=0;
while(num!=0)
{
int temp=num&15;
arrpos++]=chs[temp];
num=num>>>4;
}
for(int x=pos-1;x>=0;x–)
{
System.out.print(arr[x]+",");
}
}
//万能进制转换
public static void trans(int num,int base,int offset)
{
if(num==0)
{
System.out.println(0);
return ;
}
char[] chs = {‘0′,’1′,’2′,’3’
,’4′,’5′,’6′,’7′
,’8′,’9′,’A’,’B’
,’C’,’D’,’E’,’F’};
char[] arr = new char[32];
int pos = arr.length;
while(num!=0)
{
int temp = num & base;
arr[–pos] = chs[temp];
num = num >>> offset;
}
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]);
}
return ;
}
失败是成功的亲娘，没有失败哪来的成功呢?诺贝尔如果不经历千万次的失败，
