循环结构与数组
概述
循环剩下的内容，包括do…while循环和循环语句的嵌套使用；下午学习了数组的基础知识，包括：数组的基本概念及其存储过程；数组的创建，数组的初始化；数组的遍历；数组的比较；数组的冒泡排序。现总结如下：
1.1 循环结构
1.1.1do…while 循环
基本格式
do{
循环体语句；
}while（条件判断语句）；
完整格式：
初始化语句；
do{
循环体语句；
条件控制语句；
}while（条件判断语句）;
注意事项：
- 无论如何，do…while…都会执行一次循环体;
- while中的条件成立时,才会执行循环体;
- 小括号后边一定要加分号(“;”);
执行流程
-
执行初始化语句；
-
执行循环体语句；
-
执行条件控制语句；
-
执行条件判断语句，看其结果是true还是false
如果是false，循环结束；
如果是true，继续执行；
-
回到2继续。
package com.kaifamiao.statements;
import java.util.Scanner;
public class Deer {
public static void main(String[] args) {
final Scanner s = new Scanner( System.in );
int age = 0 ;
// do { 循环体 } while ( 条件 );
do {
if( age < 0 || age > 150 ) {
System.out.println( "你输入的年龄不符合正常人类的寿命范围，请重新输入" );
} else {
System.out.println( "请输入你的年龄:" );
}
age = s.nextInt();
} while ( age < 0 || age > 150 );
System.out.println( "第一个循环中输入的年龄: " + age );
String msg1 = "请输入你的年龄:";
String msg2 = "你输入的年龄不符合正常人类的寿命范围，请重新输入";
boolean error = false;
do {
System.out.println( error ? msg2 : msg1 );
age = s.nextInt();
} while ( error = age < 0 || age > 150 );
System.out.println( "第二个循环中输入的年龄: " + age );
s.close();
}
}
1.1.2 循环嵌套
在解决实际问题中,循环经常是嵌套使用,从而更好的解决问题;
package com.kaifamiao.statements;
// 用嵌套循环找出1到100之间的质数
public class Donkey {
public static void main(String[] args) {
// 第一层循环用于取遍1到100之间所有的自然数
for( int n = 2; n <= 100 ; n++ ){
// 先假设n是个质数
boolean isPrime = true;
// 判断n是否可以被除1和n之外的自然数整除
for( int p = 2 ; p <= Math.sqrt(n) ; p++ ) {
// 若自然数n能够被p整除则可以退出内层循环
if( n % p == 0 ){
// 推翻假设
isPrime = false;
break; // 跳出当前循环(终止当前循环)
}
}
if( isPrime ) {
System.out.printf("%d是质数\n", n);
}
}
}
}
1.1.3 跳转控制语句
- continue：用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行；
- break： 用在循环中，基于条件控制终止循环内容的执行，也就是说结束当前的整个循环。
package com.kaifamiao.statements;
// 鹳：Stork
public class Stork {
public static void main(String[] args) {
for ( int i = 1 ; i < 6 ; i++ ) {
System.out.println( "before break: " + i );
if( i == 2 ) {
break;
}
System.out.println( "after break: " + i );
}
System.out.println( "- ".repeat( 15 ) );
for ( int i = 1 ; i < 6 ; i++ ) {
System.out.println( "before break: " + i );
if( i == 2 ) {
continue;
}
System.out.println( "after break: " + i );
}
}
}
1.1.4 label标识的循环
package com.kaifamiao.statements;
// 鸹: Crow
public class Crow {
public static void main(String[] args) {
// 用 标签(label) 标识的循环
outer:for( int i = 1 ; i < 6 ; i++ ){
inner:for (int j = 1; j < 6; j++) {
if ( j == 3 ) {
// break;
// break inner;
break outer;
}
System.out.printf( "(%d,%d)\t", i , j );
}
System.out.println();
}
System.out.println( "\n- - - - - - - - - - - - - - - -");
// 用 标签(label) 标识的循环
outer:for( int i = 1 ; i < 6 ; i++ ){
inner:for (int j = 1; j < 6; j++) {
if ( j == 3 ) {
// continue;
// continue inner;
continue outer;
}
System.out.printf( "(%d,%d)\t", i , j );
}
System.out.println();
}
}
}
1.1.4 三种循环语句的区别
-
do…while循环先执行循环体语句，即至少执行一次;
-
在for循环里定义的变量，在循环结束后不可以使用，while的初始化语句位于循环体外边，即使循环结束，仍然可以使用;
-
死循环
/*for的死循环 //这样的形式的for循环表示for循环的条件永远为真 for(; ;) { System.out.println("for"); } / /while的死循环 while(true) { System.out.println("while"); }/ /**do...while的死循环 do{ System.out.println("do...while"); }while(true); */三种循环的区别
- for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
- do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
for和while的区别
- 条件控制语句所控制的自增变量，因为归属到for循环的语法结构中，在for循环结束之后，就不能在访问到了；
- 条件控制语句所控制的自增变量，对于while循环来说，不归属其语法结构中，在while循环结束后，该变量仍然可以继续使用。
1.2 数组
1.2.1数组的定义与创建
数组概述
- 一次性声明大量的用于存储数据的变量
- 要存储的数据通常都是同类型数据，例如：考试成绩
什么是数组
数组(array)是一种用于存储多个相同类型的数据的存储模型
数组的定义格式
-
格式一：数据类型[] 变量名
-
范例： int [] arr
-
定义了一个int类型的数组，数组名是arr
-
格式二： 数据类型 变量名[]
-
范例：int arr[]
-
定义了一个int类型的变量，变量名是arr数组
推荐使用格式一
数组初始化
java中的数组必须先初始化，然后才能使用。
所谓的初始化，就是为数组中的元素分配内存空间，并为每个数组元素赋值。
数组初始化方式
- 动态初始化
动态初始化:初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 变量名 = new 数据类型[数组长度]
范例：int [] arr = new int[3];
-
静态初始化
静态初始化：初始化时指定每个元素的初始值，由系统决定数组长度
格式: 数据类型[] 变量名 = {变量值}
package com.kaifamiao.arrays;
// 初始化数组
public class Initialization {
public static void main(String[] args) {
// 静态初始化: 定义数组变量时直接使用数组常量对数组进行初始化
short[] shorts = { 188, 29, 89, 0x24, 01 };
// 遍历数组
for( int index = 0 ; index < shorts.length ; index++ ) {
System.out.printf( "%d\t", shorts[index] );
}
System.out.println();
System.out.println( "~ ".repeat( 10 ) );
// 创建数组实例(并为每个元素赋予默认值)
int[] ints = new int[5];
// 遍历数组
for (int i = 0; i < ints.length ; i++) {
System.out.print( ints[i] + "\t");
}
System.out.println();
// 动态初始化: 在创建数组实例后再对数组进行初始化
ints[0] = 100;
ints[1] = 99;
ints[2] = 101;
ints[3] = 33;
ints[4] = 99;
// 遍历数组
for (int i = 0; i < ints.length ; i++) {
System.out.print( ints[i] + "\t");
}
System.out.println();
// 基本数据类型的数组中元素默认值:
// byte: 0
// short: 0
// int: 0
// long: 0L
// float: 0.0f
// double: 0.0
// char: '\u0000'
// boolean: false
System.out.println( "~ ".repeat( 10 ) );
// 引用类型的数组中元素默认值都是 null
Object[] objects = new Object[3];
for (int i = 0; i < objects.length; i++) {
System.out.println( objects[i] );
}
}
}
package com.kaifamiao.arrays;
// 创建数组
public class Creation {
public static void main(String[] args) {
// 在定义"数组变量"时使用"数组常量"隐式创建并初始化数组
byte[] bytes = { 10, 0, 4, 99 };
System.out.println( bytes[0] );
System.out.println( bytes[1] );
System.out.println( bytes[2] );
System.out.println( bytes[3] );
// 显式通过 new 关键字来创建"数组实例"并通过"数组产量"初始化数组
char[] chars = new char[]{ 'm', 'i', 'a', 'o' };
System.out.println( chars[0] );
System.out.println( chars[1] );
System.out.println( chars[2] );
System.out.println( chars[3] );
}
}
package com.kaifamiao.arrays;
// 理解数组基本概念: 数组类型、数组变量、数组常量、下标或索引、数组元素、数组长度
public class Concept {
public static void main(String[] args) {
int a = 100;
System.out.println( a );
// int[] 是 变量 x 的类型 (数组类型)
// x 是 变量名称 (数组变量) [也被称作数组名]
// { 1, 3, 5, 7, 9 } 是 数组常量
int[] x = { 1, 3, 5, 7, 9 };
// 通过 x[位置] 形式可以访问数组中指定的值
// 其中用来表示 位置 的数值被称作 索引 或 下标，比如 x[ 2 ]
System.out.println( x[ 2 ] );
// 在数组中存放的每个值被称作元素，比如 x[1]
// 可以通过 length 属性来获取数组长度(即数组中可以容纳的最多元素个数)
System.out.println( x.length );
// 每个数组的 length 属性都是 public 、final 修饰的
// x.length = 10; // Cannot assign a value to final variable 'length'
}
}
1.2.2 Java中内存分配
Java程序在运行时，需要在内存中分配空间，为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
数组在初始化时，会为存储空间添加默认值
- 整数默认值是0
- 浮点数默认值是0.0
- 布尔值的默认值是false
- 字符的默认值是空字符
- 引用数据类型默认值是null
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XPAvvD98-1666106453459)(.\images\array.png)]
-
栈内存：存储局部变量
局部变量：定义在方法中的变量，例如：arr，使用完毕，立即消失
-
堆内存:存储new出来的内容(实体，对象)
数组在初始化时，会为存储空间添加默认值
- 整数默认值是0
- 浮点数默认值是0.0
- 布尔值的默认值是false
- 字符的默认值是空字符
- 引用数据类型默认值是null
每一个new出来的东西都有一个地址值，使用完毕，会在垃圾回收器空闲时被回收。
1.2.3数组元素的访问
-
数组变量访问方式
-
格式：数组名
-
数组内部保存的数据的访问方式
-
格式：数组名[索引]
-
索引是数组中数据的编号方式
-
作用：索引用于访问数组中数据使用，数组名[索引]等同于变量名，是一种特殊的变量名，索引从0开始。
-
索引的特征
- 索引从0开始
- 索引是连续的
- 索引逐一增加，每次加1
1.2.4数组的遍历
所谓遍历，就是按照一定顺序访问数组中的每一个元素。
按理说就是输出或呈现数组中的每一个元素，但是当元素足够多的时候，输出语句已经不可能实现，因此，就可以采用循环的方式，对其索引套用循环。
package com.kaifamiao.arrays;
// 遍历数组
public class Traversal {
public static void main(String[] args) {
char[] chars = { '春', '眠', '不', '觉', '晓' };
// System.out.println( System.identityHashCode( chars ) );
for( int i = 0, n = chars.length; i < n ; i++ ) {
char ch = chars[i];
System.out.println(ch);
}
System.out.println( "- ".repeat( 10 ) );
// 显式创建"数组实例"并用"数组常量"初始化新数组
chars = new char[]{'处', '处', '闻', '啼', '鸟'};
// System.out.println( System.identityHashCode( chars ) );
for( int i = chars.length - 1 ; i >= 0 ; i-- ) {
char ch = chars[i];
System.out.println(ch);
}
}
}
1.2.5比较两个数组是否相等
- 判断两个不同的数组实例是否"相等":
- 首先数组长度相等(元素个数相同)
- 其次相应位置的元素都相等(相同下标处的元素相等)
package com.kaifamiao.arrays;
import java.util.Arrays;
// 判断两个不同的数组实例是否"相等":
// 1、首先数组长度相等(元素个数相同)
// 2、其次相应位置的元素都相等(相同下标处的元素相等)
public class Equal {
public static void main(String[] args) {
int[] first = { 10, 0, 4, 88 };
System.out.println( first );
int[] second = { 10, 0, 4, 88 };
System.out.println( second );
System.out.println( first == second ); // false
if( first == second ) {
System.out.println( "相等" );
} else if( first.length == second.length ) {
boolean equal = true;
for (int i = 0; i < first.length; i++) {
if( first[i] != second[i] ) {
equal = false;
break;
}
}
System.out.println( equal ? "相等" : "不相等" );
} else {
System.out.println( "两个数组不相等" );
}
System.out.println( "- ".repeat( 10 ) );
boolean result = Arrays.equals( first, second );
System.out.println( result );
}
}
1.2.6数组的冒泡排序
package com.kaifamiao.arrays;
import java.util.Arrays;
// 数组排序: 冒泡排序
public class BubbleSort {
public static void main(String[] args) {
int[] array = { 10, 2, 9, 3, 6, 7, 8, 4, 5, 1 };
// 遍历数组
for (int i = 0; i < array.length; i++) {
System.out.printf("%d\t", array[i]);
}
System.out.println();
// 冒泡排序
for( int i = 0 ; i < array.length - 1 ; i++ ) {
System.out.printf( "第%d轮\n" , i + 1 );
for (int j = 0; j < array.length - 1 - i ; j++) {
if (array[j] > array[j + 1]) {
array[j] ^= array[j + 1];
array[j + 1] ^= array[j];
array[j] ^= array[j + 1];
}
System.out.println("\t" + Arrays.toString(array));
}
}
// 遍历数组
for (int i = 0; i < array.length; i++) {
System.out.printf("%d\t", array[i]);
}
System.out.println();
// 使用冒泡排序对 char 数组进行排序
// char[] chars = { 'k','a','i','f','a','m','i','a','o'}
// 排序后的顺序是 a a a f i i k m o
}
}
2 问题及解决方式
2.1 33选7
package com.ikaifamiao.homework;
import java.util.Arrays;
import java.util.Random;
public class NumberChoose {
public static void main(String[] args) {
int[] str = new int[7];
for (int i = 0; i < 7; i++) {
Random random = new Random();
int number = random.nextInt(34);
for (int j = 0; j < i; j++) {
if (str[i] == str[j]) {
str[i] = number;
i--;
break;
}
}
}
for (int i = 0; i < 7; i++) {
System.out.println(str[i] + " ");
}
}
}
22.2 二进制转换器
package com.ikaifamiao.homework;
import java.util.Scanner;
// 二进制转换器
public class BinaryConverter {
public static void main(String[] args) {
// 创建扫描器
Scanner s = new Scanner( System.in );
System.out.println( "请输入一个整数" );
final int input = s.nextInt();
final int sign = input >= 0 ? 1 : -1;
//求取用户所输入整数的绝对值
int t = input >= 0 ? input : -input;
int[] bits = new int[32];
for (int i = 0; i < bits.length; i++) {
System.out.printf("%d", bits[i]);
}
System.out.println();
int index = bits.length - 1;
while ( t > 0 ){
int y = t % 2; // 整除2求余数
bits[ index ] = y ; // 将余数保存到数组指定位置
index--;
t = t / 2 ; // 整除2求商并赋值
}
if( sign == 1 ) {
System.out.print( input + "的二进制形式是:");
for (int i = 0; i < bits.length; i++) {
System.out.printf("%d", bits[i]);
}
System.out.println();
} else {
}
// 关闭扫描器
s.close();
}
}
22.3 六十甲子
package com.kaifamiao.arraydemo;
public class Chronology {
public static void main(String[] args) {
char[] heavenlyStems = { '甲' , '乙' , '丙' , '丁' , '戊' , '己' , '庚' , '辛' , '壬' , '癸' };
char[] earthlyBranches = { '子' , '丑' , '寅' , '卯' , '辰' , '巳' ,
'午' , '未' , '申' , '酉' , '戌' , '亥' };
int j = 0;
int year = 0;
int k = 0;
while (year <60){
for (int i = 0; i < 10; i++) {
if (j == 12){
j=0;
}
System.out.print(" "+heavenlyStems[i]+earthlyBranches[j]);
k++;
if (k==12){
System.out.println();
k=0;
}
year++;
j++;
}
}
}
}
4200
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
