JAVA基础（二）

二、流控制

1.接收用户输入

input.next();与input.nextline();不能同时用。
next（必须输入有效内容）后空格/回车都结束，
nextline必须回车结束；

	public static viod main(String[] args) {
		Scanner input = new Scanner(System.in);
		//用于接收各种数据类型；
		//System.out.println("请输入一段数字：");
		//int i = input.nextInt();
		//System.out.println(i);
		
		System.out.println("请输入next接收的内容：")；
		String str2 = input.next();
		//System.out.println("请输入next接收的内容：")；
		//String str2 = input.nextLine();

		System.out.println(str1);
		//System.out.println(str2);

2.执行结构

概述：
任何简单或复杂的算法都可以由顺序结构、分子结构和循环结构这三种基本结构组合成。
它们的共同点是都包含一个入口和一个出口，它们的每个代码都有机会被执行，不会出现死循环。

顺序结构
顺序结构是一种基本的控制结构，它按照语句出现的顺序执行操作
分支结构
分支结构又被称为选择结构，根据条件成立与否来执行操作
循环结构
循环结构是一种重复结构，如果条件成立，它会重复执行某一循环体，直到出现不满足条件为止。

（1）if分支

	public static void main(String[] args) {
		System.out.println("请输入")；
		Scanner input = new Scanner(System.in);
		int s = input.nextInt();
		
		if(a>b) {
			System.out.println("a");
		}
		else {
			System.out.println("b")
		}

		if(a>b || a<0) {
			System.out.println("你输入错误")；
		}else if(a>=9) {
			System.out.println("优秀")；
		}else if(a>=7) {
			System.out.println("良好")；
		}else if(a>60) {
			System.out.println("合格");
		}else {
			System.out.println("加油！");
		}
		

（2）switch语句

表达的返回值必须是下述几种类型之一：int,byte,char,short.String;
case子句中的取值必须是常量，且所有case子句中的取值应是不同的；
default 子句是可选的；
break语句用来在执行完成一个case分支后使程序跳出switch语句块；如果case后面没有写break则直接往下面执行；
Case后面的执行体可写{}也可以不写{}

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个月份（1-12）")；
		String text = input.next();
		switch (text) {
			case "1":
			case "2":
			case "3":
				System.out.println("春季")；
				break；
			case "4":
			case "5":
			case "6":
				System.out.println("夏季")；
				break;
			case "7":
			case "8":
			case "9":
				System.out.println("秋季")；
				break；
			case "10":
			case "11":
			case "12":
				System.out.println("冬季");
			default:
				System.out.println("你输入有误");
				break;
		}
	}

（3）循环语句

while循环和do-while循环的区别：
while：先判断条件，如果条件满足，再执行循环操作
do while：先执行一遍循环操作，然后在判断条件，如果条件满足，继续执行循环操作。

	public static void main(String[] args) {
		int i=0;
		while(i<10){
		//更新循环变量
		i++;
		System.out.println("循环在执行："+i);
		}
		System.out.println("执行结束")；
	}

	public static void main(String[] arge) {
		int i = s;
		do {
			i++;
			System.out.println(i);
		}whlie(i<s);
		System.out.println("程序结束");
	}

（4）for循环

：适合循环值固定情况下

for(初始化参数；判断条件；更新循环变量) {
循环体；
}

（5）循环嵌套

	public static void main(String[] args) {
		int count = 0;
		for(int i=0;i<10;i++) {
			for(int j=0;j<10;j++) {
				count++;
				System.out.println(count);
			}
		}
	}

（6）break与continue

break与continue语句:
break是用于终止本轮所有次循环，即不执行本次循环中break后面的语句，直接跳出循环。
continue是用于终止本轮次循环。即本次循环中continue后面的代码不执行，进行下一次循环的入口判断。

	public static void main(String[] arge) {
		for(int i=0;i<10;i++) {
			if(i==5) {
				continue;
			}
			System.out.println(i);
		}
	}	

//退出多重循环
	public static void main(String[] args) {
		haha:for(int i=0;i<10;i++) {
			for(int j=0;j<10;j++) {
				System.out.println("i="+i+",j="+j);
				if(i==5 && j==5) {
					break haha;
				}
			}
		}
	}

	public static void main(String[] args) {
		//外层循环控制的是行数
		for(int j=0;j<10;i++) {
			System.out.print("*");
		}
		System.out.println();
	}		

3.图形的打印

图形1
*
***
*****
*******
	解决方案：
		外层循环控制行数：4
		内层循环控制列数：第一行循环1次，第二行循环3次，第三行循环5次，第四行循环7次
		for(int i=0;i<4;j++){
			for(int j=0;j<i*2+1;j++){
				System.out.print("*");
		}
		System.out.println();
	}

	//交付标准
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个数字")；
		//在接收输入之前判断输入的类型是否为int
		if(input.hasNext()) {
			int num = input.nextInt();
			System.out.println("你输入的是："+num);
		}else {
			System.out.println("你输入的是个锤子")；
		}

    public static void main(String[] args) {
        System.out.println("请输入年份：");
        Scanner input3 = new Scanner(System.in);
        int year = input3.nextInt();
        System.out.println("请输入月份：");
        Scanner input4 = new Scanner(System.in);
        int month = input4.nextInt();
        getMonthDays(year, month);
    }
/** * 计算该年该月天数 一年中有12个月，而每个月的天数是不一样的，其中，有7个月为31天 * 称为大月，分别为1,3,5,7,8,10,12月，有4个月为30天，称为小月，分别 * 为4,6,9,11月，还有二月比较特殊，平年的二月只有28天，而闰年的二月 * 有29天，由用户在控制台输入年份和月份，程序计算该年该月的天数。 */
public static void getMonthDays(int year, int month) {    
	int days;    
	switch (month) {        
	case 1:        
	case 3:        
	case 5:        
	case 7:        
	case 8:        
	case 10:        
	case 12:            
		days = 31;            
		System.out.println(year + "年" + month + "月天数为：" + days);            
		break;        
		case 4:        
		case 6:        
		case 9:        
		case 11:            
		days = 30;            
		System.out.println(year + "年" + month + "月天数为：" + days);            
		break;        
		case 2:            
		if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {                
		days = 29;            
		} else {                
		days = 28;            
		}            
		System.out.println(year + "年" + month + "月天数为：" + days);            
		break;    
	}
}

三、数组

概述 ：
数组是相同数据类型的多个数据的容器。
这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个 元素外，每一个元素都有唯一的后继元素。（“简单理解就是：一个跟一个顺序排列”）。
创建格式
格式 1. 数据类型[] 数组名称 = new 数据类型[数组长度];
格式 2. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3…数组内容 n};
格式 3.数据类型[] 数组名;
格式 3 属于只创建了数组引用名， 并未在内存创建数组空间。
格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3…内容 n};
下标 :
可以理解为数组中内容的数字序号，从 0 开始 ，对于长度为 n 的数组，下标的范围是 0~n-1。
可以通过下标的方式访问数组中的每一个元素。

例如： 创建 int 类型数组 arr ， 给数组 arr 的 5 下标赋值数据 ， 然后打印
int[] arr = new int[10];
arr[5] = 123;
System.out.println(arr[5]);
数组长度获取
数组名称.length

public static void main(String[] args) {
	//格式1:创建数组的同时，制定数组中的内容。
	//数据类型[] 数组名称={数据1，数据2，数据3...数据n};
	int[] ages = {10,11,12,13,14};
	//格式2:创建数组，并指定长度，不指定数组中的内容。
	//数据类型[] 数组名称 = new 数据类型[数组长度]；
	//数组长度通过int数据指定
	int[] ages2 = new int[10];

//通过下标操作数组数据的方式：
//1.给数组某个下标赋值：数组名称[下标] = 值；
ages[0] = 100;
//2.从数组某个下标取值：数组名称[下标]
System.out.println(ages[0]);
ages2[0] = 99;
System.out.pritnln(ages2[0]);

//如何获取数组的长度：数组名称.length
//数组的遍历
for(int index=0;index<ages.length;index++) {
	//index:0 1 2 3 4
	System.out.println(ages[index]);

1.不常用数组定义格式

public static void main(String[] args) {
	//数组不常用的创建方式：
	//1.创建数组，不初始化
	//格式：数据类型[] 数组名；
	int[] nums;
	//2.创建数组，并指定数组中的内容
	//格式：数据类型[] 数组名称 = new 数据类型[]{内容1，内容2，内容3...内容}；
	int[] ages = new int[] {11,12,13,14};
}

public static void main(String[] args) {
	//数组不常用的创建方式：
	//1.创建数组，不初始化
	//格式：数据类型[] 数组名；
	int[] nums;
	nums = new int[10];

注意
使用数组不当， 会出现如下问题：
数组未赋值： 空指针异常
超出长度的下标操作： 数组越界异常
注意：数组的长度在创建时就固定了。

public static void main(String[] args) {
	//常见问题
	//1.数组下标越界问题；
	//int[] nums = {10,11,12,13,14};
	//System.out.println(nums[5]);
	//2. 空指针问题
	int[] nums = null;
	System.out.println(nums[1]);
}

2.找出数组的最值

//寻找数组中最大值|最小值
public static void main(String[] args) {
	int[] nums = {10,30,40,33,22,20,11,0};
	//1.创建一个变量，用于存储遍历数组时发现的最大值
	int n = nums[0];
	//2.循环取出数组中的每一个内容，从1开始
	for(int i=1;i<nums.length;i++) {
		//将数组中的每一个内容与n比较，如果比n大，则将n的值赋值为这个内容。
		n = n<nums[i]?n:nums[i];
	}
	System.out.println(n);
}

Scanner input = new Scanner(System.in);
int[] nums = new int[10];
System.out.println("请输入10个整数：");
for (int i = 0;i < nums.length;i++) {
	nums[i]=input.nextInt();    		
}
int max=nums[0];
int min=nums[0];
for (int i = 1;i<nums.length;i++) {
	max = max>nums[i]?max:nums[i];
	min = min<nums[i]?min:nums[i];

}
System.out.println("最小值为："+min);
System.out.println("最大值为："+max);  

3.数组常用算法

冒泡排序 原理：

–比较相邻的元素。如果第一个比第二个大，就交换他们两个。
–对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的 数。
–针对所有的元素重复以上的步骤，除了最后一个。
–持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
名字由来:
是因为最小（或最大）的元素会经由交换慢慢“浮”到数列的顶端（降序或升序），就如同水中的气泡最终会上浮到 顶端一样，故名“冒泡排序”。
升序排列的口诀:
N个数字来排队
两两相比小靠前,
外层 循环length-1
内层循环length-i-1
降序排序的口诀:
N个数字来排队
两两相比大靠前,
外层 循环length-1
内层循环length-i-1

//冒泡排序
public static void main(String[] args) {
	int[] nums = {20,15,18,13,30,60};
	int temp;
	//外层循环控制的是，比较的次数
	//外层循环次数：length-1
	for(int i=0; i<nums.length-1;i++) {
		//内层循环控制的是，每轮比较的次数
		//第i轮(i从0开始计算)，比较次数为：length-i-1
		for(int j=0;j<nums.length-i-1;j++) {
			if(nums[j]>nums[j+1]) {
				//两两相比，满足移动条件
				temp = nums[j];
				nums[j] = nums[j+i];
				nums[j+1] = temp;
			}
		}
	}
	
	//排序已经完成，下面是遍历打印查看的过程
	for(int i=0; i<nums.length;i++) {
		System.out.println(nums[i]);
	}
}			

4.二分查找

概述 原理 数组动态扩容 学习集合知识点时， 重点讲解。 二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，二分查找要求数组数据必须采用顺 序存储结构有序排列。 首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；否则利用 中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查 找后子数组。
重复以上过程，直到找到满足条件的数据，则表示查找成功，
直到子数组不存在为止，表示查找不成功。

/**
*二分查找（折半查找）
*/
public static viod main(Steing[] args) {
	int[] nums = {10,20,30,40,50,60,70,80,90};
	
	int num = -100;
	
    int minIndex = 0;
    
    int maxIndex = nums.length-1;
	
	int centerIdex = (minIndex+maxIndex)/2;
	while(true) {
		System.out.println("循环了一次")；
		if(nums[centerIndex]>num) {
			//
			maxIndex = centerIndex-1;
		}else if(nums[centerIndex]<num) {
			//
			minIndex = centerIndex+1;
		}else {
			//
			break;
		}
		if(minIndex > maxIndex) {
			centerIndex = -1;
		}
		//
		centerIndex = (minIndex+maxIndex)/2:
	}
	System.out.println("位置："+centerIndex);
} 

5.多维数组

/**
*创建格式：
*		数据类型[] 数组名 = new 数据类型[长度]；
*		int[][] 二维数组名称 = new int[长度][];
*/
public static void main(String[] args) {
	int[][] nums = new int[10][];
	nums[0] = new int[] {1,2,4};
	System.out.println(nums[0][2]);
}	

import java.util.Scanner;

public class Demo01 {

	public static void main(String[] args) {
//选队长游戏训练任务
    System.out.println("输入d人数");
    Scanner scanner = new Scanner(System.in);
    //获得有多少人
    int num = scanner.nextInt();
    int[] nums = new int[num];
    for (int i = 0; i < nums.length; i++) {
        nums[i] = i + 1;
    }

    //记剩余人数
    int count = 0;
    //报数 1，2，3
    int index = 0;
    
    while (true){
        count = 0;
        //循环整个队伍
        for (int i=0; i < nums.length ;i++){
            //如果是没喊过3的人才进行报数，喊过的已经出局了，被记为-1
            if (nums[i] != -1){
                index++;
                if (index == 3){
                    //当报到3的时候归零，此时下标为i的人退出，数值变为-1
                    index = 0;
                    nums[i] = -1;
                }
            }
            if (nums[i] != -1){
                count++;
            }
        }
        if (count == 1){
            break;
        }
    }
    //遍历当前数组看哪个位置数组不为-1则输出下标
    for (int i = 1; i <= nums.length; i++) {
        if (nums[i-1] != -1){
            //从0开计数需要加1
            System.out.println("第"+(i)+"是队长");
        }
    }
}

总结

以上就是JAVA基础的内容，本文仅仅简单介绍了Java的使用方法，基础语法、流程控制、数组等。

创作不易点个赞谢谢！！！