一、循环结构---重复运行
1.for循环
结构:for(初始条件;判断条件;循环增量/减量){
java代码
}
初始条件--决定循环的开始
判断条件--决定循环的结束
循环增量/减量--控制初始条件值
执行过程:
先执行初始条件,再执行判断条件,
判断条件的结果为true,执行{java代码},接下来执行循环增量/减量,接着执行判断条件
判断条件的结果为false,循环结束。
1. 循环输出1-10的整数
public class ForDemo{
public static void main(String args[]){
// 循环输出1-10的整数
for(int i=1;i<=10;i++){
System.out.println("i="+i);
}
}
}
2.循环输出20-1的整数
public class ForDemo{
public static void main(String args[]){
//循环输出20-1的整数
for(int j=20;j>=1;j--){
System.out.println("j="+j);
}
}
}
3.计算1-15的整数和
public class ForDemo{
public static void main(String args[]){
//计算1-15的整数和
int sum=0;
for( int k=1;k<=15;k++){
sum=sum+k;
}
System.out.println("sum="+sum);
}
}
2.while循环
结构:while(判断条件){
java代码;
}
执行过程:
先执行判断条件,判断条件结果为true时,执行{java代码},再执行增量/减量条件,继续执行判断条件,判断条件结果为false时,结束循环
注意1:初始条件定义在while循环的格式之外。
注意2:把循环增量/减量的条件写在java代码.....最后一句
1.循环输出1-10的整数
public class WhileDemo{
public static void main(String args[]){
//循环输出1-10的整数
int i=1;
while(i<=10){
System.out.println("i="+i);
i++;
}
}
}
2.循环输出20-1的整数
public class WhileDemo{
public static void main(String args[]){
//循环输出20-1的整数
int j=20;
while(j>=1){
System.out.println("j="+j);
j--;
}
}
}
3.计算1-15的整数和
public class WhileDemo{
public static void main(String args[]){
//循环输出1-10的整数和
int k=1;
int sum=0;
while(k<=10){
sum=sum+k;
k++;
}
System.out.println( "sum="+sum);
}
}
3.Do……Whlie循环
结构:
do{
java代码;
}while(判断条件);
执行过程:
先执行{java代码},再执行判断条件,
判断条件的结果为true,继续执行{java代码},接着执行判断条件
判断条件的结果为false,结束循环
注意1:初始条件定义在do...while循环的格式之外。
注意2:把循环增量/减量的条件写在{java代码.....最后一句}
1.循环输出1-10的整数
public class DoWhileDemo{
public static void main(String args[]){
int i=1;
do{
System.out.println("i="+i);
i++;
}while(i<=10);
}
}
2.循环输出20-1的整数
public class DoWhileDemo{
public static void main(String args[]){
int j=20;
do{
System.out.println("j="+j);
j--;
}while(j>=1);
}
}
3.计算1-15的整数和
public class DoWhileDemo{
public static void main(String args[]){
int k=1;
int sum=0;
do{
sum=sum+k;
k++;
}while(k<=15);
System.out.println("sum="+sum);
}
}
4.三者区别
For循环有定义循环增量/减量的具体位置;While循环和Do…while循环没有定义循环增量/减量的具体位置,往往都是自己定义在循环体中的最后一句。for循环需要明确循环次数while和do……while循环不需要考虑循环次数
while循环与do……while循环的区别,while循环先判断后执行,do……while循环先执行后判断,初始判断条件的结果为false的时候,do……while循环会比while多执行一次循环体。
例1:无限循环,可以任意终止
import java.util.Scanner;
public class Test1{
public static void main(String args[]){
//创建输入对象
Scanner input=new Scanner(System.in);
boolean flag=true; //控制循环持续执行
while(flag){
//得到第一个运算数字
System.out.println("请输入第一个运算数字:");
int num1=input.nextInt();
//得到一个运算符号
System.out.println("请输入一个运算符号:");
String op=input.next();
//得到第二个运算数字
System.out.println("请输入第二个运算数字:");
int num2=input.nextInt();
//计算结果
switch(op){
case "+":System.out.println(num1+"+"+num2+"="+(num1+num2));break;
case "-":System.out.println(num1+"-"+num2+"="+(num1-num2));break;
case "*":System.out.println(num1+"*"+num2+"="+(num1*num2));break;
case "/":System.out.println(num1+"/"+num2+"="+(num1/num2));break;
case "@":flag=false;break;
default:System.out.println("输入有误无法计算");break;
}
}
}
}
输出演示:
请输入第一个运算数字:
1
请输入一个运算符号:
-
请输入第二个运算数字:
4
1-4=-3
请输入第一个运算数字:
3
请输入一个运算符号:
+
请输入第二个运算数字:
3
3+3=6
请输入第一个运算数字:
6
请输入一个运算符号:
*
请输入第二个运算数字:
9
6*9=54
请输入第一个运算数字:
1
请输入一个运算符号:
@
请输入第二个运算数字:
3
5.break语句
break语句---循环中就表示中断循环的执行。
如果循环是嵌套的,那么break语句出现在那一层就中断那一次的循环。
例:
public class BreakDemo{
public static void main(String args[]){
for(int i=1;i<=10;i++){
if(i==5){
break;
}
for(int j=1;j<=10;j++){
System.out.println("i=="+i+",j=="+j);
}
}
}
}
6.continue语句
continue语句--往往出现在循环中表示结束当前循环,继续下一次循环执行。
例:
public class ContinueDemo{
public static void main(String args[]){
//continue语句--往往出现在循环中表示结束当前循环,继续下一次循环执行
for(int i=1;i<=10;i++){
if(i==5){
continue;
}
System.out.println("i=="+i);
}
}
}
二、数组
1.什么是数组?
为了能够一次性保存一组数据,所以才有了数组。相同数据类型的数据按照顺序组成的复合数据类型就是数组。
2.如何定义一个一维数组?
格式:两种都可
数据类型 数组名称[ ]
数据类型 [ ]数组名称
数组的定义与变量的定义相似,只是需要”[ ]”与变量区分,因此上”[ ]”就是数组的标志。名称的前面/后面出现一个“[ ]”就是一维数组,有两个”[ ][ ]”就是二维数组,两个以上就是多维数组。
3.创建一个一维数组
①先定义,后创建, 指定的存储空间的数据值是int型
定义:数据类型 数组名称[ ] / 数据类型 [ ]数组名称
创建:数组名称=new 数据类型[指定存储空间]
②定义+创建同时
数据类型 数组名称[ ]=new 数据类型[指定存储空间]
数据类型 [ ]数组名称=new 数据类型[指定存储空间]
4.如何为一维数组赋值?
①逐个赋值---挨个为数组的每一个存储空间存放数据值。【需要数组的下标】
格式:数组名称[下标]=数据值;
注意:当保存在数组中的数据超过数组指定的存储空间就是会出错。
下标从0开始
例:
import java.util.Arrays;
public class ArrayDemo{
public static void main(String args[]){
//定义+创建数组
int intarray1[]=new int[4];
char chararray1[]=new char[5];
//逐个赋值
intarray1[0]=123;
intarray1[1]=456;
intarray1[2]=276;
intarray1[3]=672;
//注意:当保存在数组中的数据超过数组指定的存储空间就是会出错。
//java.lang.ArrayIndexOutOfBoundsException: 4
// intarray1[4]=832;
}
}
②直接赋值---在创建数组的时候将数据值保存到数组中
格式1:数据类型 数组名称[ ]=new 数据类型[ ]{数据值1,数据值1,数据值3…数据值n}
创建数组的时候不能指定存储空间
例:int intarray2[ ]=new int[ ]{23,34,45,56};
char chararray2[ ]=new char[ ]{'h','e','l','l','o'};
格式2:数据类型 数组名称[]={数据值1,数据值2,...,数据值n};
5.如何从一维数组中取值
取值格式:数组名称[下标]
System.out.println(intarray2[3]); //56
System.out.println(chararray2[4]); //o
例:
import java.util.Arrays;
public class ArrayDemo{
public static void main(String args[]){
//定义+创建数组
int intarray1[]=new int[4];
char chararray1[]=new char[5];
//逐个赋值
intarray1[0]=123;
intarray1[1]=456;
intarray1[2]=276;
intarray1[3]=672;
//注意:当保存在数组中的数据超过数组指定的存储空间就是会出错。
//java.lang.ArrayIndexOutOfBoundsException: 4
// intarray1[4]=832;
//直接赋值
int intarray2[]=new int[]{23,34,45,56};
char chararray2[]=new char[]{'h','e','l','l','o'};
//数组取值格式:数组名称[下标]
System.out.println(intarray2[3]); //56
System.out.println(chararray2[4]); //o
}
}
6.一维数组的length属性
如果数组通过直接赋值的方式创建,那么length属性就表示元素个数。
如果数组通过定义创建的方式创建,那么length属性就表示创建数组是给出的空间大小,与数组的元素个数无关
例:
//如果数组通过直接赋值的方式创建,那么length属性就表示元素个数
System.out.println(intarray2.length);//4
//如果数组通过定义创建的方式创建,那么length属性就表示创建数组是给出的空间大小
//比如我创建数组空间大小4,但我只赋值了一个
double douarray[]=new double[5];
douarray[0]=5.2;
System.out.println(douarray.length);//5
7.循环遍历一维数组
比如:
import java.util.Arrays;
public class ArrayDemo{
public static void main(String args[]){
//循环遍历一维数组
String names[]={"张三","李四","王五"};
//for循环
for(int i=0;i<names.length;i++){
System.out.println("for--"+names[i]);
}
//while循环遍历数组
int j=0;
while(j<names.length){
System.out.println("while--"+names[j]);
j++;
}
//do...while循环遍历数组
int k=0;
do{
System.out.println("do...while--"+names[k]);
k++;
}while(k<names.length);
//增强的for循环--jdk1.5新增的内容
//for(数据类型 变量名称:数组){ 变量名称==数组中的每一个数据值}
for(String name:names){
System.out.println("增强的for循环--"+name);
}
}
}
8.定义一个二维数组
格式:数据类型 数组名称[][]; int arrtest1[][];
数据类型 [][]数组名称; int [][]arrtest2;
二维数组可以保存一个类似表格一样的数据,所以我们可以认为二维数组就是一个表格。
9.创建二维数组
①先定义后创建,
int arrtest1[][];
arrtest1=new int[2][3];
或者定义+创建,同一维处理方法
数据类型 数组名称[][] = new 数据类型[表格行][行中的列];
数据类型 [][]数组名称 = new 数据类型[表格行][行中的列];
②赋值
逐个赋值:
arrtest1[0][0]=100;
arrtest1[0][1]=200;
arrtest1[0][2]=300;
arrtest1[1][0]=400;
arrtest1[1][1]=500;
arrtest1[1][2]=600;
直接赋值:
格式:
①数据类型 数组名称[][]=new 数据类型[][]{
{数据值1,数据值2,数据值3…},
{数据值1,数据值2,数据值3…}
};
如char charr2[][]=new char[][]{{'h','e','l','l','o'},{'w','o','r','l','d'}};
②数据类型 数组名称[][]={
{数据值1,数据值2,数据值3…},
{数据值1,数据值2,数据值3…}
};
如char charr1[][]={{'h','e','l','l','o'},{'w','o','r','l','d'}};
10.如何从二维数组中取值
只要我们能够得到数组的存储位置,就可以得到数组中的数据值。
格式:数组名称[行][列];
System.out.println(charr1[0][1]);//e
11.二维数组的length属性---行数
System.out.println(charr1.length);//2
12.循环遍历二维数组
使用双层循环结构,外层控制行,内层控制列
①for循环
for(int m=0;m<charr1.length;m++){
for(int n=0;n<=4;n++){
System.out.println(charr1[m][n]);
}
}
②增强for循环
for(char hhh[]:charr1){
for(char value:hhh){
System.out.println("增强for循环---"+value);
}
}
③while循环
//while循环
int z=0;
while(z<2){
int k=0;
while(k<=4){
System.out.println("while循环---"+charr1[z][k]);
k++;
}
z++;
}
13.认识Array类【数组的帮助类】
Arrays类位于java.util包中,主要包含了操纵数组的各种方法;
Arrays常用函数(都是静态的);
1.void Array.sort(Object[ ] array)
对数组按照升序排序;
2.void Array.sort(Object[ ] array, int from, int to)
对数组元素指定范围进行排序(排序范围是从元素下标为from,到下标为to-1的元素进行排序)
3.Arrays.fill(Object[] array,Object object)
可以为数组元素填充相同的值
4.Arrays.fill(Object[] array,int from,int to,Object object)
对数组的部分元素填充一个值,从起始位置到结束位置,取头不取尾
5.Arrays.toString(Object[] array)
返回数组的字符串形式
例:
import java.util.Arrays;
public class ArrayDemo2{
public static void main(String args[]){
//排序前
System.out.println("排序前");
int array1[]={5,2,0,8,6,1,4};
//使用增强for循环输出
for(int num:array1){
System.out.println(num);
}
System.out.println("按升序排序");
//void Array.sort(Object[] array) 对数组按照升序排序;
Arrays.sort(array1);
for(int num:array1){
System.out.println(num);
}
//对指定元素范围进行排序
System.out.println("对指定2,0,8,6,进行排序");
int array2[]={5,2,0,8,6,1,4};
Arrays.sort(array2,1,5);
for(int num:array2){
System.out.println(num);
}
//对数组填充相同的值
System.out.println("-------------");
char array3[]={'w','o','r','l','d'};
for(char charnum:array3){
System.out.println(charnum);
}
System.out.println("对数组填充相同的值");
Arrays.fill(array3,'a');
for(char charnum:array3){
System.out.println(charnum); //aaaaa
}
System.out.println("对数组部分位置填充一个值,从起始位置到结束位置,取头不取尾");
char array4[]={'w','o','r','l','d'};
Arrays.fill(array4,1,3,'a');
for(char charnum:array4){
System.out.println(charnum); //waald
}
//返回数组的字符串形式
System.out.println("-----------");
String str1[]={"张三","李四","王五"};
for(String strnum:str1){
System.out.println(strnum);
}
System.out.println("返回数组的字符串形式如下");
String newString=Arrays.toString(str1);
System.out.print(newString); //[张三, 李四, 王五]
}
}
输出为:
排序前
5
2
0
8
6
1
4
按升序排序
0
1
2
4
5
6
8
对指定2,0,8,6,进行排序
5
0
2
6
8
1
4
-------------
w
o
r
l
d
对数组填充相同的值
a
a
a
a
a
对数组部分位置填充一个值,从起始位置到结束位置,取头不取尾
w
a
a
l
d
-----------
张三
李四
王五
返回数组的字符串形式如下
[张三, 李四, 王五]
14.数组的内存结构
基本类型与复合数据类型的区别:
1.存在位置不同:基本类型存放是在栈中,复合数据类型存在栈和堆中;
2.在内存在存在的形式不同:基本类型在内存中是存放的真实值,复合类型在栈存放的是地址,堆中存放的是真实值。
练习题:
1.下列一维数组定义正确的是( BD)。
A.x=6;int num[x]; 错,存储空间必须是int型,x没有定义
B.final int x=6;float a[x]; 对的
C.final float x=6;int b[x]; 存储空间必须是int型
D.final int x=6;int c[x]; 对的
2.下列一维数组定义错误的是(B )。
A.char chararray3[]=new char[]{'a','b','c','d','e'}; 对的
B.char []chararray3=new char[5]{'a','b','c','d','e'}; 错,创建数组的时候不能指定存储空间
C.char chararray4[]={'h','e','l','l','o'}; 对的
D.char []chararray4={'h','e','l','l','o'}; 对的
3.以下数组定义中,正确的是(A )。
A. int a[2][]={1,2,3,4,5}; 第三行是一维的
B. int a[][2]={{0},{}}; 第三列是一维的
C. int a[2][2]={{1,2},{3}}; 第三行第三列,应该是一个数
D. int a[][]={1,2,3,4}; 二维数组,明显不对