2019-6-27 [JavaSE] 跳转break、跳转continue.循环嵌套.数组.基本和增强for.[算法:冒泡.选择排序.插入排序]

于 2019-06-27 20:15:46 发布
阅读量277 收藏
点赞数
分类专栏： java Java 学习路线记录 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45172861/article/details/93905983
版权

文章目录

1.跳转语句

1.1 break

在这里插入图片描述
跳转语句：
场合: switch ,循环中
作用：结束循环
在这里插入图片描述
break示例：

	int sum = 0;
		for (int i = 1;i <= 10 ;i ++ ){
			sum = sum + i;
			if (sum > 5){
				System .out.println(i);//3
				break;//跳转语句：结束循环		
			}
		}

return :关键字 ；
rerturn 语句 使用场合: 方法中。
作用：结束方法。

Scanner superman = new Scanner(System.in);
		int num;
		System .out.println("--输入一个数字：");
		num = superman.nextInt();//13
		int i ;
		for (i = 2; i < num;i++ ){// 2 3,4,5,6,7  ,  12
			if (num % i == 0){
				System .out.println("不是素数");
				return ; //结束方法,后边所有代码都不执行
			}
		}
		System .out.println("是素数");

法二：

import java.util.Scanner;
/**
 * 素数 测试
 */
public class Demo1 {
	public static void main(String[] args) {
		// ctrl + shift + o
		Scanner superman = new Scanner(System.in);
		int num ;
		System.out.println("输入一个数字：");
		num = superman.nextInt();
		boolean tag = true;
		// 8  2 3 4 5 6 7 
		int i ;
		for(i = 2; i < num; i++) {
			if(num % i == 0) {
				tag = false;
				System.out.println("不是素数");
				break;//结束循环
			}
		}
			{if(tag==true)
			System.out.println("是素数");
		}
	}
}

1.2 continue

在这里插入图片描述
场合: 循环中；
作用：结束本次循环，进行下一次循环。
continue示例：偶数。

for (int i = 1; i <= 100 ; i ++ ){
			//如果是奇数
			if (i % 2 != 0){
				continue;//结束本次循环，进行下一次循环
			}
			//就不执行
			System .out.println(i);
		}

2.循环嵌套

在这里插入图片描述
外循环一次，内循环一遍 ，外循环的条件 是整个循环终止的条件。
for(1；2；4){ 外循环3
for( 1；2；4){内循环3
}
}

//1.
***
***
***
		for (int i = 1;i <= 3 ;i++ ){//行
			for (int j = 1; j <= 3 ; j++){//列
				System .out.print("*");
			}
			System .out.println();
		}
//2.
*
**
***		
		for (int i = 1;i <= 3 ;i++ ){
			for (int j = 1; j <= i;j++ ){
				System .out.print("*");
			}
			System .out.println();
		}
//3.
1
22
333
		for (int i = 1;i <= 3 ;i++ ){
			for (int j = 1; j <= i;j++ ){
				System .out.print(i);
			}
			System .out.println();
		}
//4.
O***
*O**
**O*
***O
		for (int i =1;i <= 4 ;i++ ){
			for (int j = 1;j <= 4 ;j++ ){
				if (i == j ){
					System .out.print("O");
				}else
					System .out.print("*");
			}
			System .out.println();
		}

3.循环标签

在这里插入图片描述
示例1：break,return

a:
		for (int i = 1;i <= 5 ;i ++ ){
			for (int j = 1;j <= 5 ;j ++ ){
				if(i == 3){
					//break;//结束 内循环
					//break a; 结束外循环
					return; //结束方法
				}
				System .out.print(i + "行，"+ j + "列" + "    ");
			}
			System .out.println();//
		}
		
		System .out.println("外循环后的代码");
		//
1行，1列    1行，2列    1行，3列    1行，4列    1行，5列
2行，1列    2行，2列    2行，3列    2行，4列    2行，5列
请按任意键继续. . .

示例2：continue

a:
		for (int i = 1;i <= 5 ;i ++ ){
			for (int j = 1;j <= 5 ;j ++ ){
				if(j == 3){
					//continue;// 结束本次内循环，进行下一次内循环
					continue a;//结束本次外循环，进行下一次外循环
				}
				System .out.print(i + "行，"+ j + "列" + "    ");
			}
			System .out.println();//
		}
		//
1行，1列    1行，2列    2行，1列    2行，2列    3行，1列    3行，2列    4行，1列    4行，2列    5行，1列    5行，2列    请按任意键继续. . .

循环总结：
for : 先条件判断
while ： 先条件判断的
do-while：先执行的，后条件判断

4.数组概述

概念：数组
是一个容器，只能存储相同数据类型的一组数据。
声明创建数组
数组初始化
数组存储
使用数组
注意事项
在这里插入图片描述
动态初始化：

	int n = 11;
		int m = 22;
		//==================动态初始化==========================
		//动态初始化：我们给大小，系统赋值。
		// 声明数组
		int [] arr;
		int arr [];
		// 给数组分配空间赋初始值 （初始化）
		arr = new int[3]; 
		System .out.println(arr[0]);//0 
		System .out.println(arr[1]);//0
		System .out.println(arr[2]);//0
		arr[0] = 11;
		System .out.println(arr[0]);
		System .out.println(arr[3]);//数组越界异常
		int [] a,b,c;
		int a1 [] , b1, c1;// a1[]  int b1,c1
		
		System .out.println(arr);//15db9742
		//-------------输出数组所有元素的值-------------------------
		System .out.println("--------输出-------------");
		System .out.println(arr[0]);//0 
		System .out.println(arr[1]);//0
		System .out.println(arr[2]);//0
		//循环输出
		for (int i = 0; i <= 2 ; i++){// i = 0 , 1, 2
			System .out.println(arr[i]);
		}

系统分配的初始值:
整数： 0
浮点 ： 0.0
布尔： false
字符： ‘\u0000’
字符串： String : null (空类型的值)
静态初始化：

//边声明 ，边初始化  （动态初始化）		
		int [] arr = new int[3];
		arr[0] = 11;
		arr[1] = 22;
		arr[2] = 33;		
//静态初始化：我们指定 值 ，系统 指定大小。
		int [] arr = {11,22,33}; //只能一行
		System .out.println(arr.length);//3 数组名.length
		int [] arr1 ;
		arr1 = new int[]{11,22,33};//可以一行，可以写两行

5.数组遍历：基本for和增强for

Scanner superman = new Scanner(System.in);
		int [] arr = new int [2];
		System .out.println("输入数据：");
		for (int i = 0 ; i <= arr.length-1 ; i ++){
			arr[i] = superman.nextInt();// i = 0 , 1,2
		//}
/------------------
		arr[0] = 11;
		arr[1] = 22;
		//基本for 遍历输出 (前闭，后开)
		for (int i = 0;i < arr.length ;i ++ ){
			arr[i] = arr[i] + 2;
		}
/-------------------
		for ( int a : arr ){
			a =   a + 2;
		}
		//增强for 遍历 ,作用 ：遍历集合和数组
		//   数组元素类型的变量 ： 遍历的数组
		for(int a :arr){
			System .out.println(a);
		}

基本for 和 增强 for的区别：
1.增强for只能顺序遍历
逆序遍历用基本for;
2.增强for只能遍历所有元素；
遍历一部分 使用基本for;
3.增强for不能改变数组元素；
基本for可以改变数组元素。
在这里插入图片描述
数组应用示例：计算总成绩。

public static void main(String[] args) {
		Scanner superman = new Scanner(System.in);
		int [] score;
		score = new int[6];//0 
		int sum = 0;//和
		for (int i = 0; i < score.length ; i ++ ){
			System .out.println("输入成绩:");
			score[i] = superman.nextInt();
			sum = sum + score[i];
		}
		System .out.println("展示结果:");
		System .out.println(sum);//总成绩
	
		for (int sc : score ){
			System .out.println(sc);
		}
	}

6.算法：冒泡

/**
 * 冒泡
 */
public class Demo15 {

	public static void main(String[] args) {
		int [] arr = {34,253,1,658,45,111};
		int temp;
		for(int i = 0; i < arr.length-1; i++) {//轮
			for(int j = 0; j < arr.length-1 - i; j++) {//次
				//比较 和 互换
				if(arr[j] > arr[j+1]) {
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		for(int a : arr) {
			System.out.println(a);
		}
	}
}

7.算法：选择排序

public class Demo16 {
	public static void main(String[] args) {
		int [] arr = {11,56,33,78,99};
		int temp;
		for(int i = 0; i < arr.length -1; i ++) {//位置
			for(int j = i + 1; j < arr.length; j++) {//后边所有元素
				if(arr[i] > arr[j]) {
					temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
		for(int a : arr) {
			System.out.println(a);
		}
	}
}

8.算法：插入排序

在这里插入图片描述

public class Demo17 {
	public static void main(String[] args) {
		int [] arr = {23,9,90,25,16};
		int temp;
		for(int i = 1; i < arr.length ; i++) {//位置
			for(int j = 0; j < i; j++) {//前边的所有元素
				if(arr[i] < arr[j]) {
					temp = arr[i];//存储这个位置的数字
					for(int k = i; k > j; k--) {
						//前边 覆盖 后边元素
						arr[k] = arr[k-1];
					}
					//插入元素
					arr[j] = temp;
				}
			}
		}
		for(int a: arr) {
			System.out.println(a);
		}
	}
}

9.编程：for嵌套if，计算成绩平均值

import java.util.Scanner;
public class Demo3_exam {
	public static void main(String[] args) {
		Scanner superman = new Scanner(System.in);
		int score;
		int sum = 0; //总成绩
		int i;
		for (i = 1;i <= 5 ;i++ ){
			System .out.println("录入第" + i + "门课成绩");
			score = superman.nextInt();
			if (score < 0){
				System .out.println("录入错误");
				//break;
				return;
			}
			sum += score;
		}
		System .out.println("平均成绩：" + sum / 5.0);	
	}
}

10.编程：循环嵌套，输出图形

public class Demo7_exam {
	public static void main(String[] args) {
		//1.九九乘法表
		for (int i =1;i <= 9 ;i++ ){
			for (int j = 1;j <= i ;j++ ){
				System .out.print(j + "*" + i + "=" + j * i + "\t");
			}
			System .out.println();
		}
//
1*2=2   2*2=4
1*3=3   2*3=6   3*3=9
1*4=4   2*4=8   3*4=12  4*4=16
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42    7*7=49
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48    7*8=56  8*8=64
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54    7*9=63  8*9=72  9*9=81
请按任意键继续. . .
//
		//2.等腰三角形
		for (int i = 1;i <= 5 ;i ++ ){
			for (int j = 1;j <= 2*i-1 ;j ++ ){
				System .out.print("*");
			}
			System .out.println();
		}
//
*
***
*****
*******
*********
//
		for (int i = 1;i <= 4 ;i ++ ){
			for (int j = 1; j <= 5 - i ;j++ ){
				System .out.print("*");
			}
			System .out.println();
		}
//
****
***
**
*
//
		for (int i = 1; i <= 5 ;i ++ ){
			for (int j = 1; j <= 5 -i ;j++ ){//空格
				System .out.print(" ");
			}
			for (int k = 1;k <= 2 *i -1 ;k++ ){// * 
				System .out.print("*");
			}
			System .out.println();
		}	
//
 *
   ***
  *****
 *******
*********
请按任意键继续. . .
//
	}
}

7.编程：数组，元素加密：每个元素 * 2

法一：

public class Demo14_exam {
	public static void main(String[] args) {
		int [] arr = {11,22,33,44,55};
		for (int i = 0;i < arr.length ;i ++ ){
			arr[i] = arr[i] * 2;
		}
		for (int a : arr){
			System .out.println(a);
		}
	}
}

法二：

import java.util.Scanner;
public class Demo9 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int [] score;
		score = new int[5];
		int sum = 0;
		for (int i = 0; i < score.length; i++) {
			System.out.println("输入元素");	
			score[i] = input.nextInt();
		}
		for (int i = 0; i < score.length; i++) {
			sum = 2*score[i];	
			System.out.println("加密后："+sum);
		}
	}
}

8.注意：

1.break只能结束它所在的内循环，对于外循环不起作用
2.continue加标签可以直接跳过外循环
3.声明一个叫arr的数组：
int [] arr;或者int arr [];
第一个更好。
4.代码运行：首先jvm在代码里找main，这是入口，进入之后看到主方法，在栈(Stack)里为主方法开辟一个内存空间.
5.栈：
空间小，
存储基本数据类型和引用(数组名，对象名)
频繁创建和销毁的数据结构，
后进先出的规则
6.堆：
空间大
存储对象(数组)
不会频繁创建和销毁的数据结构
7.ArrarIndexOutBoundException
数组 索引 超出 范围 （越界了）
8.直接输出数组print(arr)会输出地址
9.动态初始化：我们指定大小，系统指定值
静态初始化：我们指定值，系统指定大小
10.arr.length:可以知道数组的大小
11.增强for使用简单。

景子墨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值