流程控制及数组（一维）
流程控制
目录
-
顺序结构
程序最基本的结构，从上至下，按照程序代码的编写顺序来依次执行
java: System.out.println("Hello"); System.out.println("World"); c: printf("Hello \n"); printf("World \n"); -
分支结构
-
选择分支：
-
选择性的执行某些代码。当条件成立时，执行一些代码，不成立时则执行另外一些代码
-
if语句
if(条件表达式) { 条件成立时执行的语句 } demo: public static void main(String[] args) { //将大象放入冰箱 int dx = 100; //假设大象是100个单位 int bx = 80; //冰箱的最大存储单位 if (bx >= dx) { System.out.println("将大象放入冰箱"); } System.out.println("大象进不去冰箱"); } -
if_else语句
if(条件表达式) { 条件满足执行的语句 }esle{ 条件不成立执行的语句 } demo public static void main(String[] args) { //输入一个年份 System.out.println("输入一个年份："); Scanner scanner = new Scanner(System.in); int i = scanner.nextInt(); /* 能被4整除，但不能被100整除 或者 能被400整除 */ //判断是否为闰年 if ( ( i%4==0 && i%100 !=0 ) || ( i%400==0 ) ) { System.out.println("闰年"); }else { System.out.println("平年"); } }3 if_else_if 语句
if(条件A) { 条件A满足执行的语句 }esle if(条件B) { 条件B成立执行的语句 }if { 以上条件都不满足执行的语句 } demo public static void main(String[] agrs){ Scanner sc = new Scanner(System.in); //输入以前的工资 System.out.println("输入你目前的工资"); int oldSal = sc.nextInt(); System.out.println("输入你目前的职位【 1普工 2主管 3经理 】"); int job = sc.nextInt(); if(job == 1 ){ oldSal = oldSal+100; }else if( job == 2){ oldSal = oldSal + 500; }else if( job == 3 ) { oldSal = oldSal + 1000; }else{ System.out.println("输入有误"); } //输出 System.out.println("调薪后您的薪水为："+oldSal); }4 if嵌套
在IF 的内部可以 再使用IF结构，内部的IF 外部成立才执行。 demo public static void main(String[] args){ Scanner sc = new Scanner(System.in); System.out.println("请输入一个分数"); int score = sc.nextInt(); //合法输入 if( score>=0 && score<=750 ){ //判断条件 if( score >=550 ){ System.out.println("恭喜,您的分数可以报一本院校"); }else if( score>=500 ){ System.out.println("恭喜,您的分数可以报二本院校"); }else if( score>=480 ){ System.out.println("恭喜,您的分数可以报三本院校"); }else if( score>=400 ){ System.out.println("恭喜,您的分数可以报专科院校"); }else{ System.out.println("恭喜,放牛！"); } }else{ System.out.println("非法输入"); } }switch_case
判断变量的值与case所给的值是否相等，如果相等则执行该case后的语句，一般一个cases后面配有一个break退出switch_case结构。如果都不相等，有default则执行。default可选。
case穿透
如果一个case后缺省了break，那么程序会一次向下执行，不考虑与case是否匹配，直到执行到break才退出switch_case
switch( 变量 ){ case 值A: 语句;break; case 值B: 语句;break; ...... default: 语句; } demo public static void main(String[] args){ Scanner scanner = new Scanner(System.in); System.out.println("输入星期几？【1-7】"); int day = scanner.nextInt(); switch (day) { case 1: System.out.println("吃肉"); break; case 2: System.out.println("炒面"); break; case 3: System.out.println("米饭"); break; case 4: System.out.println("火锅"); break; case 5: System.out.println("泡面"); break; case 6: System.out.println("啃馍"); break; case 7: System.out.println("没钱了"); break; default: System.out.println("输入错误"); } }
-
-
-
-
循环结构
重复执行某些程序语句
-
while
while(条件表达式) { 循环执行的语句 }条件满足时，执行循环体中的语句，语句执行完成后，再次判断条件.......，直到不满足条件时，结束循环，退出。
demo public static void main(String[] args) { //计算100以内数的和 int n = 1; int sum = 0; while (n <= 100) { //吧循环变量累计到sum上 sum += n; // sum = sum + n; n++; } System.out.println(sum); // sum = 5050; }2 do_while
do { 循环执行语句 } while（条件表达式）; 先执行循环体，再进行条件判断，判断是否满足条件，如果满足继续执行，不满足则退出。 循环语句至少执行一次demo // 找出100以内，能被3整除，不能被5整除的数 public static void main(String[] args) { int n = 0; do { if ( n%3==0 && n%5 != 0 ){ System.out.println(n); } n++; }while (n<100); }3 for循环
for( 初始化变量 ; 循环条件 ;迭代 ) { 循环语句; }
demo: public static void main(String[] args) { Scanner scanner = new Scanner(System.in); //模拟错误登录三次 for (int i = 0; i < 3; i++) { System.out.println("输入账号:"); String username = scanner.next(); System.out.println("输入密码"); String password = scanner.next(); if (username.equals("admin") && password.equals("123") ) { System.out.println("登陆成功"); //跳出循环 break; }else { System.out.println("信息有误"); } } } -
break 、 continue 、return
public static void main(String[] args) {
testBreak();
testContinue();
testReturn();
System.out.println("--主函数------------");
}
/**
* break测试方法
*/
private static void testBreak() {
for (int i = 0; i < 5; i++) {
if (i == 3) {
break;
}
System.out.println("--break------------" + i);
}
System.out.println("--break-------for循环外-----");
}
/**
* continue测试方法
*/
private static void testContinue() {
for (int i = 0; i < 5; i++) {
if (i == 3) {
continue;
}
System.out.println("--continue------------" + i);
}
System.out.println("--continue-------for循环外-----");
}
/**
* Return测试方法
*/
private static void testReturn() {
for (int i = 0; i < 5; i++) {
if (i == 3) {
return;
}
System.out.println("--return------------" + i);
}
System.out.println("--return-------for循环外-----");
}
结论：
从打印可以看出：
break： 当i = 3时，执行break后，直接到for循环外，打印--break-------for循环外-----，所以break的作用是结束循环
continue： 当i = 3时，执行continue后，没有打印接下的--continue------------3，但是下一次循环还是打印了，所以continue只是结束了本次循环，
return： 当i = 3时，执行return后，不仅结束了循环，而且结束了方法，直接回到主函数了，所以return的作用是结束了所在方法的调用
总结：
return ： 作用于方法，结束当前方法，主要用来返回方法返回值，当方法有返回值的时候，返回对应类型的返回
值，没有返回值时，可以返回空，或者不返回
continue ： 作用于语法结构，结束当前方法，结束当前结构，主要用于循环的加速
break ： 作用于语法结构，作用于结构结束当前结构，主要多用于循环和switch结构中
这里说一下，我上面说的结构，是指循环体结构结构，switch结构等，不知道怎么形容了这种东西了，哈哈，感觉语法结构咋一听也不知道是什么，解释一下哈
数组
数组是用于保存一组长度固定、类型相同的变量的集合
数组是重要的数据结构之一。
典型的线性结构（有首有尾，一对一关系，相同特性（数据类型）） 线性结构的还有：线性表、栈、队、串...
定义数组
格式：
数据类型[] 数组名 = new 数据类型 [数组长度]
示例：
int arr[] = new int[10];
//定义一个长度为10的整型数组
double arr[] = new double[8];
//定义一个长度为9的double类型数组
String arr[] = new String[6];
数组是引用数据类型，占用两块空间，new关键字的作用是在堆内存里面申请连续空间。
数组也是变量，也可以先声明，再实例化
声明语法：
数据类型[] 数组名；
int[] arr;
实例化：
数组名 = new 数据类型[数组长度]
arr = new int[100];
数组的访问：
数组一旦实例化，便有了下标，从0开始到length-1，如果超过下标的长度，将引发ArrayIndexOutOfBoundsException异常。数组的长度可用数组名.length来获得
public static void main(String[] args) {
int arr[] = new int[4];
//为数组中的每个元素赋值
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;
//访问数组中的元素
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[0])
//arr[x] x的值必须小于arr.length-1.即小于4，否则java.lang.ArrayIndexOutOfBoundsException
}
数组的遍历
通常数组的元素下标是连续变化的，这一点恰好与循环联系到一起，可以使用循环的计时器来充当数组的下标，这样就可以遍历数组中的全部内容
public static void main(String[] args) {
int arr[] = new int[10];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[5] = 4;
arr[7] = 4;
arr[8] = 4;
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
排序
解决一个问题的方法可能有很多，但能称得上算法的，首先它必须能彻底解决这个问题（称为准确性），且根据其编写出的程序在任何情况下都不能崩溃（称为健壮性）。
注意，程序和算法是完全不同的概念。算法是解决某个问题的想法、思路；而程序是在根据算法编写出来的真正可以运行的代码。例如，要依次输出一维数组中的数据元素的值，首先想到的是使用循环结构，在这个算法的基础上，我们才开始编写程序。
在满足准确性和健壮性的基础上，还有一个重要的筛选条件，即通过算法所编写出的程序的运行效率。程序的运行效率具体可以从 2 个方面衡量，分别为：
程序的运行时间。
程序运行所需内存空间的大小。
根据算法编写出的程序，运行时间更短，运行期间占用的内存更少，该算法的运行效率就更高，算法也就更好。
那么，如何衡量一个算法所编写出程序的运行效率呢？数据结构中，用时间复杂度来衡量程序运行时间的多少；用空间复杂度来衡量程序运行所需内存空间的大小。
衡量一个算法的好坏就看关键的两点：时间复杂度和算法复杂度
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！
时间复杂度：
一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
冒泡
/*
冒泡排序
使用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数
*/
// [8,7,5,6,9]
public static void maoPao(int[] arr ) {
//完成逻辑排序
//控制趟数
for (int i = 0; i < arr.length; i++) {
//嵌套内循环
for (int j = 0; j < arr.length - 1 - i; j++) {
//两两比较
if (arr[j] > arr[j+1] ) {
//交换
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.println("第“ +i+ ”趟：" + Arrays.toString(arr));
}
}
理解：
比较两个相邻的元素，将值大的元素交换到右边
思路： 依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。
(1)第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。
(2)比较第2和第3个数，将小数 放在前面，大数放在后面。
......
(3)如此继续，知道比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成
(4)在上面一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。
(5)在第二趟比较完成后，倒数第二个数也一定是数组中倒数第二大数，所以在第三趟的比较中，最后两个数是不参与比较的。
(6)依次类推，每一趟比较次数减少依次
冒泡排序的优点：每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……也就是说，没进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。
双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数
时间复杂度/空间复杂度 ---详见数据结构
选择
// 选择 排序：
/* {1,10,32,56,21,36,9,45,22,67,30}
* 思想： 先假设出最小值,为当前趟数对应下标值，然后依次和其他未元素进行比较，如果发现存在更小的元素，记录下这个最小值的下标。
* 一趟结束后观察 min 下标有无变化，有变化则交换 无则不管。
* */
public static void choose(int[] data ){
for(int i=0;i<data.length;i++){ // 控制趟数。
//假设当前趟数出的元素就是最小的
int min = i;
//用假设的这个元素 依次和后续元素比较。
for(int j=i+1; j<data.length;j++){
if( data[min] > data[j] ){
min = j; //如果有更小的记录下标
}
}
//观察是否有变化
if(min !=i){
//交换
int temp = data[min];
data[min] = data[i];
data[i] =temp;
}
}
}
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕
Arrays.sort( T[] arr )
java.util包下带的方法
public static void main(String[] args) {
int [] arr = {49,38,65,97,76,13,27,49};
Arrays.sort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
学无止境！
浙公网安备 33010602011771号