Java基础（）

1。 do - while语句

do{
循环语句体序列；
}while(条件表达式)

2.break 结束全部循环

//1+2+3+...+n<20,求n
//用break语句在和大于20时结束循环，输出n的值
 public static void fun2() {
        int add = 0;
        int i = 1;
        for( ; ;i++) {
            add += i;
            if(add > 20) {
                break;//走到这时用break结束全部循环体
            }
        }
        System.out.println(i);
    }
    public static void main(String[] args) {
        fun2();
    }
}

3. continue语句 结束本次循环

//求20以内即被三整除又被五整除的数；
public static void fun3(int n) {
        for(int i = 1; i<= n;i++) {
            if(i % 15 != 0) {
                continue;//如果这个值不能被三整除又能被五整除则结束本次，继续进行下一次循环。
            }
            System.out.println("i :" + i);
        }
    }
    public static void main(String[] args) {
        fun3(20);
    }
}

4.一维数组的定义

int[] arr1,arr2;     //声明数组
arr1 = new int[10];  //创建一个可以存储10个整数的数组
int[] arr3 = new int[10];//创建一个可以存储10个整数的数组：声明和实例化使用一条语句实现。
arr2 = new int[]{1,2,3,4,5};//创建并初始化一个可以存储5个正数的数组。
int[] arr4 = {1,2.3,4};//同时声明并初始化一个存储4个整数的int数组（java编译器自动创建数组）。

5.习题：（1）实现二分查找：有序的数组

public class Demo4 {
public static int binary(int[] array, int key) {
    int left, right, mid;
    left = 0;//将数组的起始下标赋给left
    int right = array.length - 1;//将数组的末尾下标赋给right
    while (left <= right) {//避免左边+右边的值溢出
        mid = (left + right) / 2;
        if (array[mid] == key)
            return mid;//如果第一次中间下标指向的值正好等于要查找的值，则返回该下标

        if (key > array[mid])//如果输入的关键值大于中值，则下次将中值+1的下标作为下一次二分查找的起始下标
            left = mid + 1; //如果输入的关键值小于中值，则将中值—1的下标作为下次查找的终止下标。
        else
            right = mid - 1;
    }
    return (-1);//当while循环结束后，如果还没查到，返回一个1
}
public static void main(String[] args) {
    int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    Scanner scanner = new Scanner(System.in);
    int key = scanner.nextInt();
    System.out.println(binary(array,key));
    }
  }

（2）.求连续子数组最大的和

public class Demo4 {
public static void binaryS(int[] array) {
    System.out.println("输出数组：" + Arrays.toString(array));
    int sum = array[0];//数组求和的定义的变量
    int max = array[0];//对各个数组求和最大值的变量
    for (int i = 1; i < array.length - 1; i++) {//
        if (sum > 0) {
            sum += array[i];//如果前几项的和与本项之和大于本项，则继续向后执行递加操作
        } else {//如果前几项的和与本项之和小于本项，则最大连续子数组的和不包括前几项，从而将当前的值赋给sum，之后的循环依次从本项开始进行
            sum = array[i];
        }
        if (sum > max) {//每次相加的和与max值比较，如果大于max的值，将和赋给max，最后返回max的值，也就求出了最大连续子数列的和
            max = sum;
        }
    }
    System.out.println("连续子数组的最大和：" + max);
}
public static void main(String[] args) {
  int[] array = {-1, -2, 3, 5, -4, -2};
        binaryS(array);
 }
}

（3）逆置数组

public class Demo4 {
public static void inverseArray(int[] array) {
    int temp = 0;//设置一个临时变量temp
    for (int i = 0, m = array.length - 1; i < m; i++, m--) {//起始下标递增，末尾下表递减，当递增的下标超过递减的下标时，结束循环
        temp = array[i];//将数组的第一个值赋给临时变量temp
        array[i] = array[m];//将数组的最后的一个值赋给数组的第一个值，从而原来的数组第一个下标值被最后一个下标值覆盖
        array[m] = temp;//再将临时变量temp = array[i]值赋给原来数组的最后一个下标的值
    }
    System.out.println("将倒置的数组输出：" + Arrays.toString(array));
}
public static void main(String[] args) {
    int[] array = {4,5,6};
     inverseArray(array);
    }

}

（4）交换两个数

//代码1
public class Demo4 {
  public static void swap(int a, int b) {
       int temp = 0;
        temp = a;
        a = b;
        b = temp;

    }

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        swap(a, b);
        System.out.println(a);//结果打印出a的值还是10
        System.out.println(b);//b的值还是20

    }
}

原因：Java中的基本元素是不支持传址的，必须是对象或数组才能传址（引用）。我们给方法传址时，实际上是传递的实参地址的拷贝，它跟我们的实参所指向的细致相同，但他们确实两个不同的实体，所以当我们给方法中的形参a和b重新赋值时，改变的只是方法里形参a和b的地址，而实参中a和b的所指向地址没有被改变，所以a和b的值不变，就会出现代码1的结果。
改进如下：

//利用数组传址
public class Demo4 {
public static void swap(int[] a ,int[] b){
    int sn = a[0]; 
        a[0] = b[0];
        b[0] = sn;
    }
      public static void main(String[] args) {
        int a[] = {3};
        int b[] = {5};
        swap(a,b);
        System.out.println(a[0]);
        System.out.println(b[0]);

    }
}