Java基础，数据表示，常用类型，数据的处理，选择结构，数组，函数

基础知识

数据的表示

常用类型

	字符串、布尔类型、数值类型。。。
	十进制、二进制、8进制、16进制

变量

    本质：内存空间，内存的地址
	数组的本质：连续的一段内存空间
	命名规则(英文单词)：
				变量：首字母小写，驼峰，userName,age
				类名：首字母大写，驼峰，UserDao,UserServer
				包名：一律小写
				方法名：首字母小写，驼峰，getUserName

数据的处理

	逻辑运行:与&&   或 ||   非  ！
	算法运算：+ - * /  %

选择结构

if（判定条件）{
	
}

wwitch(2){
	Case 1:{
}
    Case 2:{
}
}

错误与调试

语法错误：非常简单，开发工具会有提示，你根据提示去修改即可。
逻辑错误：能够运行，但是结果不对。
		 先走读代码，review
		 单步调试：
		 java 开发，JS开发，都有单步调试
		 能够看到每个变量的值的情况。

循环

While（判定）{
	。。。
}
for(int I =0;i<10;i++){
}


For:循环次数知道的
While:循环次数不固定
	 死循环、

数组

语法
int [] a =  new int[5]
int []b = {1,2,4}

赋值或者取值使用下标a[1]

遍历
	foreach
	for(T v :a){
			}
快捷键：fori
应用：
顺序查找
	public static boolean dequentialSearch(int key, int[] from) {
    	boolean flag = false;
   		for (int i = 0; i < from.length; i++) {
        	if (key == from[i]) {
           		flag = true;
        	}
    	}
   		return flag;
   	}
	二分查找
	public static boolean halfSrarch(int key, int[] from) {
    boolean flag = false;
    int low = 0;
    int high = from.length - 1;
    int half;
    while (low <= high) {
        half = (low + high) / 2;
        if (key == from[half]) {
            flag = true;
            break;
        }
        if (key > from[half]) {
            low = half + 1;
        }
        else  {
            high = half - 1;
        }
    }
    return flag;
}

冒泡排序

public static int [] bubbleSort(int []a){
    for(int i = 0 ; i < a.length ;i++){
        for (int j = i+1; j< a.length; j++){
            if( a[j] > a[i]){
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
    }
    return a;
}

	选择排序
	 public static int[]  selecteSort(int []sort){
    int maxIndex = 0;
    int temp=0;
    for(int i = 0;i < sort.length;i++){
        maxIndex = i;    // i=0 ,max=0  j=
        for(int j =i+1; j<sort.length;j++){
            if(sort[j] > sort[maxIndex]){
                maxIndex = j;
            }
        }
        //将最大元素放到本次循环的前端
        temp=sort[i];
        sort[i]=sort[maxIndex];
        sort[maxIndex]=temp;
    }
    return sort;
}

	插入排序
	    public static int[] insertSort(int[] sort) {
    int tmp;
    for (int i = 1; i < sort.length; i++) {
        // 待插入数据
        tmp = sort[i];
        int j;
        //遍历已排序的数组
        for (j = i - 1; j >= 0; j--) {
            // 判断是否大于tmp，大于则后移一位
            if (sort[j] > tmp) {
                sort[j + 1] = sort[j];
            } else {
                break;
            }
        }
        //把插入的数据放到正确的位置
        sort[j + 1] = tmp;
    }return sort;
}


队列
class ArrayQueue{
//定义数组存放数据
private int [] arr;
//判断队列容量
private int size;
//第一个元素
 private int first;
 //最后一个元素
 private int last;
 //构造函数
 public ArrayQueue(int size){
     arr = new int[size];
     this.size = 0;
     first = 0;
     last = 0;
 }
//入队
 public void add(int num){
     arr[last] = num;
     size ++;

     if (last == arr.length - 1) {
         last = 0;
     } else {
         last++;
     }

 }

 //出队
 public int pop(){
     int temp = first;
     size --;

     if (first == arr.length - 1) {
         first = 0;
     } else {
         first++;
     }
     return arr[temp];
 }

 //查看第一个元素
 public int peek(){
     if(size ==0){
         return 0;
     }
     return arr[first];
 }

 }

栈
class ArrayStack{

//定义数组和指针
private   int[] arr;
private  int index;
//构造函数
public ArrayStack(int stackSize){
    arr = new int[stackSize];
    index = 0;
}

//入栈
public  void push(int num){
    if(index == arr .length){
        return;
    }
    arr[index] = num;
    index ++;
}

//出栈
public  int pop(){
    index --;
    return arr[index];
}
}

二维数组

	数组中的值，又是一个数组
	a[1][1]

函数3要素

函数名、参数（实参、形参）、返回值类型

函数本质

模块化思想，核心“大事化小”和“不计小节”，不要去考虑具体的实现，而是着眼于 “如果有一个函数帮我解决XX问题”