JAVA基础语法-循环及数组

循环

for循环

使用方法：如果循环的次数是确定的，一般使用for循环。例如：

int sum=0;
 
   for (int i = 0; i < 100; i++) {
				sum +=i+1;
       }
    System.out.println("100以内的和为:"+sum);

while循环

使用方法：条件表达式成立时，则执行循环体,然后再判断，依次类推,如果条件不满足，有可能一次都不执行。一般用于循环次数不确定的循环
语法：
while(条件表达式){
//语句块；
}
实例：计算100以内的能被3整除之数的和

	 int i=0;
 	 int sum=0;
 	 while (i<100){
  			if (i%3==0) {
  			 sum+=i;
          					 }
 			  i++;
			 }
  System.out.println("100以内的能被3整除之数的和为"+sum);

switch循环

使用方法:一般用来做分支的,或者是进行选择.
语法：
switch(表达式){
case 取值 1: 语句块 1;break;
case 取值 n: 语句块 n;break;
default: 语句块 n+1;break;
}
switch 语句有关规则；
表达式的返回值必须是下述几种类型之一：int, byte, char, short,String；
case 子句中的取值必须是常量，且所有 case 子句中的取值应是不同的；
default 子句是可选的；
break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块；如果 case 后面没有写 break 则直接往下面执行！
Case 后面的执行体可写{ }也可以不写{ }
实例：根据年份输出天数

switch(month){
		case 1:
		case 3:
		case 5:
		case 7:
		case 8:
		case 10:
		case 12:
System.out.println(month + "月共有 31 天");
			break;
			case 4:
			case 6:
			case 9:
			case 11:
System.out.println(month + "月共有 30 天");
				break;
				case 2:
System.out.println(month + "月共有 28 天");

数组

什么是数组

数组是相同数据类型的多个数据的容器。
这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个
元素外，每一个元素都有唯一的后继元素。（“简单理解就是：一个跟一个顺序排列”）。

创建格式

格式 1. 数据类型[] 数组名称 = new 数据类型[数组长度];
格式 2. 数据类型[] 数组名称 = {数组内容 1,数组内容 2,数组内容 3…数组内容 n};
格式 3. 数据类型[] 数组名;
格式 3 属于只创建了数组引用名， 并未在内存创建数组空间。
格式 4. 数据类型[] 数组名称 = new 数据类型[]{内容 1,内容 2,内容 3…内容 n};

数组的初始化：静态初始化、动态初始化、默认初始化

//静态初始化：
				int[] arr = { 1, 2, 3 };// 静态初始化基本类型数组；
//动态初始化：
				int[] arr = new int[2];//动态初始化数组，先分配空间；
　　　　　　arr[0]=1;//给数组元素赋值；
　　　　　　arr[1]=2;//给数组元素赋值；
//默认初始化：
					int arr[] = new int[2]; // 默认值：0,0
　　　　　　boolean[] b = new boolean[2]; // 默认值：false,false
　　　　　　String[] s = new String[2]; // 默认值：null, null

数组算法：冒泡排序

##冒泡排序：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。

• 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的
  数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

**
 *  两数之和
 * 给定一个整数数组 nums 和一个目标值 target， 请你在该数组中找出和为目标值的那两个整数， 并输出他们的数组下标
 * 假设每种输入只会对应一个答案， 不能重复利用这个数组中同样的元素。
 * 		示例:
 * 		给定 nums = [2, 7, 11, 15], target = 9
 * 		因为 nums[0] + nums[1] = 2 + 7 = 9
 * 		所以输出 0， 1
 */
public class Dome4 {
    public static void main(String[] args) {
        int[]nums={2,11,15,7,13,9};
        int temp;
        int target = 9;
        //首先冒泡排序从小到大排序 或者 arrays.sort 排序
        //外层循环控制的是， 比较的轮数。
        //外层循环次数： 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+1];
                    nums[j+1]=temp;
                }
            }
        }
        //排序已经完成。 下面是遍历打印查看的过程
        for (int i=0;i<nums.length;i++){
            System.out.println(nums[i]);
        }
    }

}

二分查找

#原理：
首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；否则利用
中间位置记录将数组分成前、后两个子数组，如果中间位置数据大于查找数据，则进一步查找前子数组，否则进一步查
找后子数组。
重复以上过程，直到找到满足条件的数据，则表示查找成功，
直到子数组不存在为止，表示查找不成功。

/**
	 * 二分查找（折半查找）
	 */
	public static void main(String[] args) {
		int[] nums = {10,20,30,40,50,60,70,80,90};
		
		//要查找的数据
		int num = 20;
		
		//关键的三个变量：
		//1.	最小范围下标
		int minIndex = 0;
		//2.	最大范围下标
		int maxIndex = nums.length-1;
		//3.	中间数据下标
		int centerIndex = (minIndex+maxIndex)/2;
		while(true) {
			System.out.println("循环了一次");
			if(nums[centerIndex]>num) {
				//中间数据较大
				maxIndex = centerIndex-1;
			}else if(nums[centerIndex]<num) {
				//中间数据较小
				minIndex = centerIndex+1;
			}else {
				//找到了数据  数据位置：centerIndex
				break;
			}
			
			if(minIndex > maxIndex) {
				centerIndex = -1;
				break;
			}
			//当边界发生变化， 需要更新中间下标
			centerIndex = (minIndex+maxIndex)/2;
		}
		
		System.out.println("位置："+centerIndex);
		
	}