最基础的循环，你要的都在这里

Java语言滴滴滴第二周来了

在三大结构中，循环体系它它它它来了；还是有数组也来了哦；

for循环

//当你需要循环，并且还需要有一个变量随着循环而改变
//随之改变的这个值对应的类型int类型
//for-i循环
for(初始值;返回boolean类型的表达式;更新){

}

for循环的加强循环（for-each循环）

对于for-each循环都是用来遍历一个容器

//容器里面装的内容都是具有相同类型
for(类型 变量:容器对象){
    
}

循环结构

就像想多次去执行类似的代码

for循环

语法：

for(初始值;表达式;更新){
    //循环体;
}
//当这个表达式返回true进入for循环执行循环体，返回false不会进入for循环里面去执行循环体
//更新:你每次循环完都需要去更新，如果不更新，这个循环可能会出现一直循环（死循环）

for循环的执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GMQZIbCR-1627868144841)(image-20210726092745586.png)]

1、打印阶乘5！ = 5*4*3*2*1

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入一个整数");
    int num = sc.nextInt();
    int temp = 1;
    //num num -1 num-2 ... 1
    for (int i = num; i > 0; i--) {
        //temp = temp*i;
        temp*=i;
    }
    System.out.printf("%s的阶乘是：%d",num,temp);
    System.out.println();
    System.out.println(num + "的阶乘是：" + temp);
}

2、输入十个数，找出最大值和最小值

package com.lanou._20210726_;

import java.util.Scanner;

/**
 * 从控制台获取一个整数，计算这个整数的阶乘
 * @author Lenovo
 *
 */
public class Demo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入正整数，以0结束");
		int max = -1;
		for(;;) {
			int i = sc.nextInt();
			if (i == 0) {
				break;//终止整个循环
			}
			
			max = max > i?max:i;
//			if (max < i) {
//				max = i;
//			}
		}
		System.out.println("你输入的最大值是：" + max);
		
	}
}

3、操场上100多人排队，三人一组多1人，四人一组多2人，五人一组多3人，共多少人？(118，178)

4、菱形

import java.util.Scanner;

/**
 * 打印等腰三角新
 * 
 * @author Lenovo
 *
 */
public class Demo14 {
	public static void main(String[] args) {
		
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入等腰三角形的高");
		int h = scanner.nextInt();
		//h:4
		for (int i = 1; i <= h; i++) {
			//控制打印空格数
			for (int j = 1; j <= h - i; j++) {
				System.out.print(" ");
			}
			//控制每一行打印的*数
			for (int j = 1; j <= 2*i -1; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
		
		for (int i = h-1; i > 0; i--) {
			//i:3 2 1
			//1 2 3
			for (int j = 0; j < h-i; j++) {
				System.out.print(" ");
			}
			for (int j = 1; j <= 2*i -1; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

打印空心菱形

while

while(返回boolean的表达式){
    //循环体
}

do while循环

do{
    //循环体
}while(返回boolean的表达式)

对于do while循环先执行do里面的循环体，然后去看while里面的表达式是否返回true，如果返回true继续执行do里面的代码，如果返回false，整个循环结束

对于do while至少一次，对于for和while循环，第一步必须去判断表达式是否返回true

break和continue

在循环体里面遇到break，整个循环结束（跳出整个循环）,continue:是结束此次循环，进入下一次循环。

循环的嵌套

for(int i = 0,j=0;i < 10;i++,j++){
    
}

//1*1
//2*1 2*2
//3*1 3*2 3*3
//4*1 4*2 4*3 4*4
for(int i = 1;i < 10;i++){
    for(int j = 1;j <= i ;j++){
        System.out.print(i + "*" + j + "=" + (i*j) + "\t");
    }
    System.out.println();
}

想记录10个学生的成绩，并且计算总成绩和平均成绩

数组

数组：就是一个容器，而且还是存储相同类型的容器

//1、声明变量
//2、初始化
 //3、使用


int a;
a = 10;
System.out.printlm(a);

//1、声明数组
int a;
int[] arrays;//声明了一个int类型的数组，里面存储的都是int类型
int arrays[];
//2、创建数组(初始化容器的大小)
arrays = new int[10];
//3、初始化数组
//4、使用数组

默认值

byte short int 0

long：0L

float：0.0F

double：0.0

char: ‘/u0000’ ‘’

boolean:false

引用数据类型：null

数组，String

添加元素

public static void main(String[] args) {
    int[] arrays = {2,4,3,5,7,3,7};
    Scanner scanner = new Scanner(System.in);
    System.out.println("输入你要添加的元素");
    int num = scanner.nextInt();
    System.out.println("输入添加的位置");
    int index = scanner.nextInt();
    if (index < 0 || index > arrays.length) {
        System.out.println("你输入的位置不合法");
        return;
    }

    int[] newArr = new int[arrays.length + 1];

    for (int i = 0; i < newArr.length; i++) {
        if (i < index) {
            newArr[i] = arrays[i];
        }else if (i == index) {
            newArr[i] = num;
        }else {
            newArr[i] = arrays[i-1];
        }
    }

    System.out.println(Arrays.toString(newArr));
}

删除元素

public static void main(String[] args) {
    int[] arrays = {2,4,3,5,7,3,7};
    Scanner scanner = new Scanner(System.in);

    System.out.println("输入删除的位置");
    int index = scanner.nextInt();
    if (index < 0 || index >= arrays.length) {
        System.out.println("你输入的位置不合法");
        return;
    }

    int[] newArr = new int[arrays.length - 1];

    for (int i = 0; i < newArr.length; i++) {
        if (i < index) {
            newArr[i] = arrays[i];
        }else {
            newArr[i] = arrays[i + 1];
        }
    }

    System.out.println(Arrays.toString(newArr));
}

对一个有序数组进行去重

public static void main(String[] args) {    //定义一个数组    int[] nums = {1,2,3,3,4,4,5,5,6,6,7,7,8,9};  
  //快慢索引    int slow = 0,fast = 1;    
  while (fast < nums.length) {    
      if (nums[fast] != nums[slow]) {            //第一步：先移动慢索引      
            slow++;           
             nums[slow] = nums[fast];    
                 }       
                  fast++;    }    //slow存储的是最后不重复元素的索引   
                   System.out.println(slow);    
                   int[] newArr = new int[slow+1];    
                   for (int i = 0; i < newArr.length; i++) {  
                         newArr[i] = nums[i];    }   
                          System.out.println(Arrays.toString(newArr));}

多维数组

二维数组

一维数组数组里面存储的都是单个数据。

int[] arrs = {1,2,3,4,5}

int[][] arrs = {{1},{1,2},{1,2,3},{1,2,3,4}};

如何创建二维数组

里面数组的长度确定

//1、声明数组
int[] arrays;
int[][] arrays;
//2、创建数组
//在创建的时候必须给定外层数组的长度，里面的长度你可以不指定。
//内层数组指定长度的情况
arrays = new int[3][4]
   
//3、初始化数组
//arrays[2] = 12;
arrays[0][0] = 12;
arrays[0][1] = 13;
arrays[0][2] = 14;
arrays[0][3] = 15;

arrays[2][3] = 16;
for(int i = 0;i< arrays.length;i++){
    for(int j = 0;j < arrays[i].length;j++){
        arrays[i][j] = i+j;
    }
}
//4、遍历数组
for(int i = 0;i< arrays.length;i++){
    for(int j = 0;j < arrays[i].length;j++){
        System.out.print(arrays[i][j] + "\t")
    }
    System.out.println();
}

for(int[] nums: arrays){
    for(int i:nums){
        System.out.print(i + "\t")
    }
    System.out.println();
}

里面长度不确定

int[][] arrays = new int[5][];
//这种情况里面的长度确定不？但是咱们说数组一但创建的时候长度必须确定（你在使用这个数组之前这个数组的长度必须确定）
arrays[0] = new int[12];

for(int i = 0;i < arrays.length;i++){
    arrays[i] = new int[];
    
}

int[][] arrays = {{},{},{}};

package com.lanou._20210730;
/**
 * 操作矩阵
 * @author Lenovo
 *  i*j   j*k  i*k
 * sum+= a[i][j]*a[j][k] a[i][k] = sum;
 */
public class Matrix {
    public static void main(String[] args) {
        int[][] arr1 = {{1,1,1,1},{1,1,1,1},{1,1,1,1}};//3*4
        int[][] arr2 = {{1,1,1},{1,1,1},{1,1,1},{1,1,1}};//4*3
        int[][] arr3 = matrixProduct(arr1, arr2);
        dispaly(arr3);

    }



    /**
	 * 矩阵成绩
	 * @param arr1
	 * @param arr2
	 * @return
	 */
    static int[][] matrixProduct(int[][] arr1,int[][] arr2){
        int xj1 = getY(arr1, 0);
        int xj2 = getX(arr2);
        if (xj1 != xj2) {
            return null;
        }
        int xi = getX(arr1);
        int xk = getY(arr2, 0);
        int[][] arr3 = new int[xi][xk];
        //sum+= a[i][j]*a[j][k] a[i][k] = sum;
        for (int i = 0; i < xi; i++) {
            for (int k = 0; k < xk; k++) {
                int sum = 0;
                for (int j = 0; j < xj1; j++) {
                    sum += arr1[i][j]*arr2[j][k];
                }
                arr3[i][k] = sum;
            }
        }
        return arr3;
    }

    /**
	 * 获取二维数组第一个下标的范围
	 * @param arr
	 * @return
	 */
    static int getX(int[][] arr) {
        return arr.length;
    }

    /**
	 * 获取二维数组第二个下标的范围
	 * @param arr
	 * @param x
	 * @return
	 */
    static int getY(int[][] arr,int x) {
        if (x >= 0 && x < arr.length) {
            return arr[x].length;
        }
        return -1;
    }

    /**
	 * 打印二维数组的元素
	 * @param arr
	 */
    static void dispaly(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
    //存储数组的方法(通过随机数随机出来)
    //计算\对角的和
    //计算/对角的和
    //计算偶数之和
    //计算奇数之和
    //五个方法都是有返回值
    
}

来个小总结

for循环

有可能一次都不会去执行

for(int i = 0;i< 值;i++){
    //循环体;
}

foreach循环

for循环的加强循环，一般是用来遍历一个容器，去获取容器里面的所有的元素，foreach循环遍历容器，每次是直接获取容器里面的元素

for(容器里面元素的类型 变量名:容器的对象){
}

while循环

while(返回boolean类型的表达式){
    
}

有可能一次都不会去执行

do while循环

do{
    //循环体;
}while(返回boolean类型的表达式);

先执行循环体，然后才去做判断，也就是do while循环至少会执行一次

while();

数组

数组它的特点：

1、数组是定长的

2、数组存储的元素在内存里面的地址是连续的。

3、 数组存储的元素是按照索引来存储的，并且索引是从0开始的。不能超过数组的长度

4、获取数组长度的属性length

创建数组

1、创建数组并且给数组每个位置初始化

类型[] 数组名 = {};

2、先声明数组，创建数组，最后通过数组的下标来给数组的每一个位置存放元素

类型[] 数组名;
数组名 = new 类型 [长度];
数组名[i] = 值;

3、声明数组并且创建好数组，最后通过数组的下标来给数组的每一个位置存放元素

类型[] 数组名 = new 类型[长度];
数组名[i] = 值;

对于2，3这两种创建数组的方法，创建出来的数组里面每一个位置存储的都是这个类型的默认值

byte short int 0

long 0L

float：0.0F

double：0.0

char：/u0000

boolean：false

数组/对象：null

数组的遍历

for(int i = 0;i< 数组名.length;i++){
    
}

for(类型 变量名:数组名){
    
}

二维数组

在定义二维数组的时候需要写两个[][]

对于二维数组来说，相当于是一维数组里面没有一个元素换成一个一维数组

在给定二维数组的长度的时候，必须给定外围数组的长度。里面数组的长度可以先不用给定

如果内围数组的长度没有给定，那么在给这个二维数组初始化的时候，需要给内围数组指定数组的长度

方法

你们现在写的所有方法都是静态方法，需要在main方法里面调用这些方法。而main

方法本身就是一个静态方法，在java里面，在同一个类里面。静态方法只能调用静态的方法。

如果你的方法不需要有返回值，那么方法就必须使用void来修饰。如果方法有返回值，那么必须指定该方法的返回值类型，也就是把void换成你的返回值类型。并且在方法的执行流程的最后一样代码通过return把你需要返回的值返回出方法。

如果你需要从方法外面带入数组进方法。需要把方法定义成有参方法。如果你需要从方法里面带出一些数据，你就需要把方法定义成有返回值的方法。

对于你调用有参方法的话，在调用的时候把参数对应类型的值传入方法

方法名(参数值);//参数值有多个，需要使用,隔开，并且参数的位置是需要通过该方法的参数类型来定的。
方法名();//调用无参的方法

对于调用有无返回值

方法名();
//有返回的方法。如果在调用完该方法以后，不需要这个方法的返回值，那么这个时候你可以不用一个变量去接收，但是，当你调用了该方法，在方法后面需要使用这个方法的返回值，你就需要把这个方法的返回值赋值给一个变量
int i = 方法名();
int[] arr = 方法名();