循环
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);
}
