JAVASE----基础二（循环和数组）

自增自减

int a = 1;
System.out.println(a++);//1---先取值再自增
int b=1;
System.out.println(++b);//2---先自增再取值
int c=1;
int d = c++;
int e = ++c;
System.out.println(d);//1---先取值再自增
System.out.println(e);//3---先自增再取值

&&和&区别

执行的效率不同，&&比&的执行效率高
两者都是进行条件校验，都是条件1和条件2都为true才true
(条件1)&（条件2） 条件1和条件2都会去判断，两者都true才true
(条件1)&&（条件2） 条件1只要false条件2就不会去判断，系统更高效

分支结构

if分支

单分支：
if(判断条件){
     
       代码。。。
}
多分支：
if(判断条件){
     
       代码1。。。
}else{
     
       代码2。。。
}
嵌套分支：
if(判断条件1){
     
       代码1。。。
}else if(条件2){
     
       代码2。。。
} else if(条件3){
     
       代码3。。。
}else{
     
       代码4。。。
}

switch分支

switch(exp)中,exp是一个整数表达式， 整数表达式可以是int基本类型或Integer包装类型,由于byte,short,char都可以隐含转换为int，所以也支持

switch(变量或者表达式){
     //jdk1.7后条件新增String
       case 1:
       case 2:
       case 3:  
       case 4:  
       default:
}

case穿透

case穿透就是：当在switch语句中，执行case分支语句，如果满足case1，但是在case1的语句块中，没有加break;即使case1满足条件，程序仍然会向下执行case2，即使case2不满足条件，除非case2语句块中有break;，程序会跳出switch选择结构，否则继续执行case3，一直这样执行下去，直到整个switch语句全部执行完毕，才能结束！

switch (1) {
     
    case 1:System.out.println(1);
    case 2:System.out.println(2);
    case 3:System.out.println(3);break;
    case 4:System.out.println(4);
    case 5:System.out.println(5);
    }

输出结果为：

1
2
3

case合并

int i=5;
    switch(i){
     
    case 1 : case 2 : case 3 :
        System.out.println("Test0！");
    break;
    case 4 : case 5 : case 6 :
        System.out.println("Test1！");
    }

结果为：

Test1！

循环结构

for结构

for(循环的开始位置;循环的判断条件;循环的更改条件){
     
            要重复干的事情/循环体
        }

嵌套for循环

for(1;2;3){
     //外循环
            for(1;2;3){
     //内循环
            }
        }

外循环执行一次，内循环执行n次

for(int  i = 1 ; i <= 5 ; i++) {
     //外循环--执行5次
        for(int  j = 1 ; j <= 5 ; j++) {
     //内循环--执行5次
            System.out.print("* ");//同行展示
        }
        System.out.println();//换行
    }

外循环控制行，内循环控制列，结果：

* * * * * 
* * * * * 
* * * * * 
* * * * * 
* * * * * 

while循环

先判断，后执行

while(执行条件){
     
       代码…
}

do-while循环

先执行，后判断

do{
     
       代码…
}while(执行条件);

三种循环总结

–for(开始位置;判断条件;更改条件){循环体}
需要知道开始位置,需要知道结束位置,需要知道数据的变化规律
–while(判断条件){循环体}
只需要指定条件–先判断满足了条件就执行
–do{循环体}while(判断条件);
只需要指定条件–先执行再判断条件

break和continue

两者都是终止循环的关键字。
break: 中断当前循环，简单粗暴
continue：跳出本次循环，进入下一轮
例子：接收用户输入的100次数字，如果不是88继续输入，找到88就返回

for(int i=1;i<=100;i++){
     
         int j = new Scanner(System.in).nextInt();
         if(j!=88){
     
                continue;//继续输入下一次
         }
         if(j==88){
     
                System.out.println("找到了88...");
                break;//循环终止
         }
     }

测试

5
243
88
找到了88.

变量

概念

可以改变的数，称为变量。一般通过三部分来描述一个变量。变量类型，变量名，变量值。其中三部分都是可以改变的，根据需要来确定即可。

变量的使用原则：就近原则。尽量控制到最小范围。。

局部变量

  		定义在方法里，或者局部代码块中。
  		注意必须手动初始化，来分配内存，如：int  i =5;
  		作用域也就是方法里或者局部代码块里，方法运行完内存就释放了。

成员变量

定义在类里
不用初始化，也会自动被初始化成默认值。
作用域是整个类中，累消失了，变量才释放。

测试

package cn.tedu.arrays;
public class Test2_Variable {
     
    //1、成员变量：在类里方法外是
    //作用范围就是整个类里
    //可以不初始化，也会有默认值
    int age = 20;
    int sum = 30;
    public static void main(String[] args) {
     
       //2局部变量：在方法里是
       //作用范围就是方法里，出了这个方法就不认识了
       //必须初始化
       int sum = 10;
       System.out.println(sum);//10
       //3、变量的就近原则，附近有同名的会去执行最近的
       System.out.println(sum);//10

    }

}

方法

概述

被命名的代码块，方法可以含参数可以不含参数
可以提高代码的复用性

形式

修饰符  返回值  方法名(【参数】){
     
       方法体;
}

方法的调用

public class Test1_方法 {
     
       public static void main(String[] args) {
     
              System.out.println(1);
              f();
System.out.println(2);
       } 
       private static void f() {
     
              System.out.println(3);//132
       }
}

方法的返回值

public class tt {
     
       public static void main(String[] args) {
     
              System.out.println(1);  //1
			   int num=f3(5);			
              System.out.println(num);	//50
             String str = f4("学习使我快乐");
              System.out.println(str);//学习使我快乐，我信你个鬼
          System.out.println(2);

       }
       public static String f4(String desc){
     
              return desc+",我信你个鬼";
       }
       public static int f3(int i){
     
              return i*10;

       }
}

方法的重载

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数列表(也就是说参数的个数和类型不同)。

程序调用方法时，可以通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。

数组

	数组英文名称是Array; 标志是[]
	可以存放多个数据，要求：数据都是相同的类型
	为了方便查阅数组里存的数据，为每个数据分配了下标
	下标默认从0开始，下标的最大值是  数组的长度 -1。

数组的创建

动态初始化

动态初始化语法: 数据类型 [] 数组名 = new 数据类型[指定数组长度] ;//为了迎合C开发人员习惯[]放在数组名后也可以

int[] a = new int[5];

静态初始化

int[] b = new int[]{
     1,2,3,4,5};
int[] c = {
     1,2,3,4,5};

数组长度

length属性获取数组长度
数组一旦创建，长度不可变
允许创建长度为0的数组

数组遍历

使用循环，依次访问数组的位置

int[] a = new int[]{
     1,2,3,4,5};
    for(int i=0;i<a.length;i++){
     
           System.out.println(a[i]);
    }

结果为

1
2
3
4
5

二维数组

二维数组其实就是每一个元素为一维数组的数组

动态初始化

int a [][]=new int[2][3];
int [][] b=new int[2][3];
int[] c []=new int[2][3];
int d [][]=new int[2][ ];

错误初始化：int a[][]=new int [][3];

静态初始化

int [][] arr=new int[][]{
     {
     4,5,6,8},{
     2,3},{
     1,6,9}};

数组工具类

Arrays.toString

把数组里的数据用逗号连接成一个字符串

int a[] = new int[5];
int b[] = new int[]{
     1,2,3,4,5};
System.out.println( Arrays.toString(a));//[0, 0, 0, 0, 0]
System.out.println( Arrays.toString(b));//[1, 2, 3, 4, 5]

Arrays.sort

把数组里的数据排序

//1,创建 无序的 数组
int[] a = {
     10,5,9,1,8};
//2,排序
Arrays.sort(a);
//3,打印
System.out.println(Arrays.toString(a));//[1, 5, 8, 9, 10]

Arrays.copyOf

根据原有数组内容创建新数组

//1,定义原数组
int a[] = {
     1,3,4,6,7};
//2,完成复制
int[] b = Arrays.copyOf(a, 8);//copyOf(a, 8)--a是原数组的名称,8是新数组的长度
//3,打印数据
System.out.println(Arrays.toString(b));//[1, 3, 4, 6, 7, 0, 0, 0]--把原来的数据复制完,在后面新增位置--扩容
int[] c = Arrays.copyOf(a, 3);
//4,打印数据
System.out.println(Arrays.toString(c));//[1, 3, 4]--把原来的数据截取前面一部分复制,因为位置不够了--缩容

这个创建新数组有局限性，只能从下标为0开始复制

System.arraycopy

int a [] = {
     1,3,4,6,7};
int b [] = new int [10];
System.arraycopy(a, 0, b, 3, 5);//--被复制数组，被复制数组开始下标，新数组，新数组复制开始下标，复制长度
System.out.println(Arrays.toString(b));//--[0, 0, 0, 1, 3, 4, 6, 7, 0, 0]

排序算法

冒泡算法

import java.util.Arrays;
import java.util.Random;

public class Test1_BubbleSort {
     
    public static void main(String[] args) {
     
        int[] arr = new int [10];
        Random ran = new Random();
        for (int i = 0; i < arr.length; i++) {
     
            arr[i] = ran.nextInt(100);
        }
        System.out.println(Arrays.toString(arr));//随机生成的数组
        for (int i = 0; i < arr.length-1; i++) {
     
            for (int j = 0; j < arr.length-i-1; j++) {
     
                if (arr[j]>arr[j+1]) {
     
                    int temp = 0;
                    temp = arr[j] ;
                    arr[j]  = arr[j+1] ;
                    arr[j+1]  = temp ;
                }
            }
        }
        System.out.println(Arrays.toString(arr));//排序完成的数组
    }
}

归并排序

import java.util.Arrays;
import java.util.Random;

public class Test2_MergeSort {
     
    public static void main(String[] args) {
     
        int[] arr = new int[10];
        Random ran = new Random();
        for (int i = 0; i < arr.length; i++) {
     
            arr[i] = ran.nextInt(100);
        }
        System.out.println(Arrays.toString(arr));//随机生成的数组
        mergeSort(arr);
        System.out.println(Arrays.toString(arr));//排序完成的数组

    }

    private static void mergeSort(int[] arr) {
     
        sort(arr, 0, arr.length - 1);

    }

    private static void sort(int[] arr, int i, int j) {
     
        if (i == j) {
     
            return;
        }
        int mid = i + (j - i) / 2;
        // 递归拆分数组
        sort(arr, i, mid);
        sort(arr, mid + 1, j);
        merge(arr, i, mid, j);

    }

    private static void merge(int[] arr, int i, int mid, int j) {
     
        int temp[] = new int[j - i + 1];
        int k = 0;
        int p1 = i;
        int p2 = mid + 1;
        while (p1 <= mid && p2 <= j) {
     
            temp[k++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++]; // 精髓：将小的数取出，并且移动指针，不取的不移动
        }
        while (p1 <= mid) {
     
            temp[k++] = arr[p1++];// 没取完时自动排在后面
        }
        while (p2 <= j) {
     
            temp[k++] = arr[p2++];// 没取完时自动排在后面
        }
        for (int l = 0; l < temp.length; l++) {
     
            arr[i + l] = temp[l];// 将排好的顺序传递
        }
    }
}

二分排序

import java.util.Arrays;
import java.util.Random;

public class Test3_BinaryInsertSort {
     
    public static void main(String[] args) {
     
        int[] arr = new int[10];
        Random ran = new Random();
        for (int i = 0; i < arr.length; i++) {
     
            arr[i] = ran.nextInt(100);
        }
        System.out.println(Arrays.toString(arr));//随机生成的数组
        for (int i = 0; i < arr.length; i++) {
     
            int start, end, mid;
            start = 0;
            end = i - 1;
            mid = 0;
            int temp = arr[i];
            while (start <= end) {
     
                mid = (start + end) / 2;
                if (arr[mid] > temp) {
     
                    end = mid - 1;
                } else {
     
                    start = mid + 1;
                }
            }
            for (int j = i - 1; j > end; j--) {
     
                arr[j + 1] = arr[j];
            }
            arr[end + 1] = temp;
        }
        System.out.println(Arrays.toString(arr));//排序完成的数组
    }
}

快速排序

import java.util.Arrays;
import java.util.Random;

public class Test4_QuickSort {
     
    public static void main(String[] args) {
     
    int[] arr = new int[10];
    Random ran = new Random();
    for (int i = 0; i < arr.length; i++) {
     
        arr[i] = ran.nextInt(100);
    }
    System.out.println(Arrays.toString(arr));//随机生成的数组
    sort(arr, 0, arr.length - 1);
    System.out.println(Arrays.toString(arr));//排序完成的数组

}

private static void sort(int[] arr, int i, int j) {
     
    if(i<j) {
     
    int index = getIndex(arr, i, j);
    sort(arr, i, index - 1);
    sort(arr, index + 1, j);
    }
}

private static int getIndex(int[] arr, int i, int j) {
     
    int temp = arr[i];
    while (i < j) {
     
        while (i < j && arr[j] >= temp) {
     
            j--;
        }
        arr[i] = arr[j];
        while (i < j && arr[i] <= temp) {
     
            i++;
        }
        arr[j] = arr[i];
    }
    arr[i] = temp;
    return i;
    }
}

总结

 条件分支与循环结构都是一种控制代码执行顺序的手段，灵活使用这些结构，就可以控制代码执行的先后顺序与逻辑。

数组是一种数据结构，用来统一创建和管理相同类型的变量。