java中的语句和java中的数组
java中的语句
1.选择结构
if语句条件语句,语法:
if(条件){
执行代码
}
public class PanDuan{
public static void main(String args[]){
int demo=61;
if(demo>=60){
System.out.println("及格");
}
}
}
注意:if 条件成立时的执行语句只有一条,可以省略大括号!如果执行语句有多条,那么大括号就是不可或缺的。
if…else语句
if…else 语句的操作比 if 语句多了一步: 当条件成立时,则执行 if 部分的代码块; 条件不成立时,则进入 else 部分。
public class PanDuan{
public static void main(String args[]){
int demo=59;
if(demo>=60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
}
}
多重if语句
public class PanDuan{
public static void main(String args[]){
int demo=80;
if(demo>=60 && demo<80){
System.out.println("及格");
}else if(demo>=80 && demo<90){
System.out.println("良好");
}else if(demo>=90 && demo<=100){
System.out.println("优秀");
}else if(demo>0 && demo< 60){
System.out.println("不及格");
}else{
System.out.println("成绩有误!");
}
}
}
嵌套if语句
public class PanDuan{
public static void main(String args[]){
int demo=0;
if(demo>=60){
if(demo>=80){
System.out.println("优秀");
}else{
System.out.println("良好");
}
}else{
if(demo>0){
System.out.println("不及格");
}else{
System.out.println("成绩不能为空!");
}
}
}
}
switch语句
public class YunHuan{
public static void main(String args[]){
int num1=10;
int num2=3;
char op='+';
switch(op){
case '+':System.out.println(num1+"+"+num2+"="+(num1+num2));
case '-':System.out.println(num1+"-"+num2+"="+(num1-num2));
case '*':System.out.println(num1+"*"+num2+"="+(num1*num2));break;
case '/':System.out.println(num1+"/"+num2+"="+(num1/num2));
default:System.out.println("运算有误!");
}
}
}
执行过程:当 switch 后表达式的值和 case 语句后的值相同时,从该位置开始向下执行,直到遇到 break 语句或者 switch 语句块结束;如果没有匹配的 case 语句则执行 default 块的代码。 switch 后面小括号中表达式的值必须是整型或字符型。case 匹配后,执行匹配块里的程序代码,如果没有遇见 break 会继续执行下一个的 case 块的内容,直到遇到 break 语句或者 switch 语句块结束 。
2.循环结构–重复执行
1.for循环
语法格式:
for(初始条件;循环条件;循环怎量/减量){
java代码
}
执行过程:
<1>、执行循环变量初始部分,设置循环的初始状态,此部分在整个循环中只执行一次
<2>、进行循环条件的判断,如果条件为 true ,则执行循环体内代码;如果为 false ,则直接退出循环
<3>、执行循环变量变化部分,改变循环变量的值,以便进行下一次条件判断
例如:
public class XunHuan{
public static void main(String args[]){
for(int i=1;i<=10;i++ ){
System.out.println("第"+i+"次循环");
}
}
}
循环计算整数和:
public class XunHuan{
public static void main(String args[]){
int num=0;
for(int i=1;i<=10;i++){
num=num+i;
}
System.out.println("和="+num);
}
}
2.while循环
语法格式:
while(判断条件){
java代码
【循环增量/减量条件】
}
执行过程:
< 1 >、判断 while 后面的条件是否成立( true / false )
< 2 >、当条件成立时,执行循环内的操作代码 ,然后重复执行判断条件是否成立,直到循环条件不成立为止
特点:先判断,后执行
例如:
public class XunHuan{
public static void main(String args[]){
int i=1;
while(i<=10 ){
System.out.println("第"+i+"次循环");
i++;
}
}
}
算合:
public class XunHuan{
public static void main(String args[]){
int num=0;
int i=1;
while(i<=10 ){
num=num+i;
i++;
}
System.out.println("和="+num);
}
}
3.do…while循环
语法格式:
do{
java代码
循环增量/减量条件
}while(判断条件)
执行过程:
<1>、 先执行一遍循环操作,然后判断循环条件是否成立
<2>、 如果条件成立,继续执行循环操作和条件是否成立,直到循环条件不成立为止
特点: 先执行,后判断
由此可见,do…while 语句保证循环至少被执行一次!
例如:
public class XunHuan{
public static void main(String args[]){
int i=1;
do{
System.out.println("第"+i+"次循环");
i++;
}while(i<=10);
}
}
for循环算合:
public class XunHuan{
public static void main(String args[]){
int num=0;
int i=1;
do{
num=num+i;
i++;
}while(i<=10);
System.out.println("和="+num);
}
}
一、循环结构的表达式不同
do-while循环结构表达式为:do{循环体;}。
for循环的结构表达式为:for(单次表达式;条件表达式;末尾循环体){中间循环体;}。
while循环的结构表达式为:while(表达式){循环体}。
二、执行时判断方式不同
do-while循环将先运行一次,因为经过第一次do循环后,当检查条件表达式的值时,其值为 不成立时而会退出循环。保证了至少执行do{ }内的语句一次。
for循环执行的中间循环体可以为一个语句,也可以为多个语句,当中间循环体只有一个语句时,其大括号{}可以省略,执行完中间循环体后接着执行末尾循环体。
while循环执行时当满足条件时进入循环,进入循环后,当条件不满足时,执行完循环体内全部语句后再跳出(而不是立即跳出循环)。
三、执行次数不同
do-while循环是先执行后判断,执行次数至少为一次。
for循环是先判断后执行,可以不执行中间循环体。
while循环也是先判断后执行,可以不执行中间循环体。
四、执行末尾循环体的顺序不同
do-while循环是在中间循环体中加入末尾循环体,并在执行中间循环体时执行末尾循环体。
for循环的中间循环体在条件判断语句里,执行末尾循环体后自动执行中间循环体。
while循环的末尾循环体也是在中间循环体里,并在中间循环体中执行。
for循环 | while和do{}while()循环 |
---|---|
初始值,判断条件,循环增量/减量,循环体 | 判断条件,循环体 |
可以在结构之外定义初始值,也可不定义 | 需要自行在结构定义初始值 |
循环增量/减量循环结构自行控制 | 循环增量/减量手动控制 |
需要明确循环次数 | 不需要考虑循环次数 |
while循环与do{}while()循环的区别
while | do{}while()循环 |
---|---|
先判断,后循环 | 先循环,后判断 |
初始判断条件的结果为false的时候,do{}while()循环会比while多执行一次循环体。
正常运行:
//测试计算小程序
import java.util.Scanner;
public class Test{
public static void main(String args[]){
//输入对象
Scanner input=new Scanner(System.in);
//得到一个运算数字
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;
default:System.out.println("输入有误无法计算");break;
}
}
}
for循环是先判断后执行,可以不执行中间循环体
//测试计算小程序
import java.util.Scanner;
public class Test{
public static void main(String args[]){
//输入对象
Scanner input=new Scanner(System.in);
//控制持续执行
for(int i=1;i<=10;i++){
//得到一个运算数字
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;
default:System.out.println("输入有误无法计算");break;
}
}
}
}
持续循环根据!条件退出循环。
//测试计算小程序
import java.util.Scanner;
public class Test{
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;
}
}
}
}
while循环也是先判断后执行,可以不执行中间循环体
public class While{
public static void main(String args[]){
int i=1;
while(i<0){
System.out.println("i=="+i);
}
}
}
do{}whlie()循环是先执行后判断,执行次数至少为一次
public class While{
public static void main(String args[]){
int i=1;
do{
System.out.println("i=="+i);
}while(i<0);
}
}
break语句与continue语句的用法和区别。
在 Java 中,我们可以使用 break 语句退出指定的循环,直接执行循环后面的代码。
continue 的作用是跳过循环体中剩余的语句执行下一次循环。
break语句—循环中就表示中断循环的执行
public class Break{
public static void main(String args[]){
for(int i=1; i<=10; i++){
if(i==5){
break;
}
System.out.println("i=="+i);
}
}
}
如果循环是嵌套的,那么break语句出现在那一层就中断那一次的循环。
switch中表示结束switch的执行
public class Break{
public static void main(String args[]){
for(int i=1; i<=4; i++){
for(int j=1; j<=4; j++){
if(j==3){
break;
}
System.out.println("i=="+i+",j=="+j);
}
}
}
}
Continue
public class Continue{
public static void main(String args[]){
for(int i=1; i<=10; i++){
if(i==5){
continue;
}
System.out.println("i=="+i);
}
}
}
java中的数组
1.什么是数组?
相同数据类型的数据按照顺序复合数据类型
数组指一组数据的集合,数组中的每个数据被称作元素。数组通过数组名加索引来使用数组的元素。
数组属于引用型变量,创建数组需要经过声明数组和为数组分配变量两个步骤。
2.如何定义一个一维数组?
格式:数据类型 数组名称[] / 数据类型 []数组名称;
数组类型[] 数组名 = new 数组类型[元素个数或数组长度];
数组的定义与变量的定义相似,只是需要"[]"与变量区分,因此上"[]"就是数组的标志。
名称的前面/后面出现一个"[]"就是一维数组,有两个"[][]"就是二维数组,两个以上就是多维数组
3.创建一个一维数组?
创建数组的本质就是确定数组的具体存储空间。
格式:
1.先定义,后创建
定义: 数据类型 数组名称[];
数据类型 []数组名称;
创建: 数组名称 = new 数据类型[指定的存储空间];
指定的存储空间的数据值是int型
2.定义+创建
数据类型 数组名称[]=new 数据类型[指定的存储空间];
数据类型 []数组名称=new 数据类型[指定的存储空间];
4.如何为一维数组赋值?
1.逐个赋值—就是挨个为数组的每一个存储空间存放数据值。[需要数组的下标]
数组的下标–因为数组是按照顺序保存数据,此时每一个存储空间就有一个顺序的编号,维持数组数据顺序的编号就是下标。通过可以通过下标得到具体的数据存储空间。下标从0开始。第一个存储空间的下标是0,依次类推。
格式: 数组名称[下标] = 数据值;
注意:当保存在数组中的数据超过数组指定的存储空间就是会出java.lang.ArrayIndexOutOfBoundsException: 的错误异常。
2.直接赋值—就是在创建数组的时候将数据值保存到数组中。
1)数据类型 数组名称[]=new 数据类型[]{数据值1,数据值2,…,数据值n};
创建数组的时候不能指定存储空间
2) 数据类型 数组名称[]={数据值1,数据值2,…,数据值n};
3.如何从一维数组中取值?
只要我们能够得到数组的存储位置,就可以得到数组中的数据值
格式:数组名称[下标]
5.一维数组的length属性
如果数组通过直接赋值的方式创建,那么length属性就表示元素个数。
如果数组通过定义创建的方式创建,那么length属性就表示创建数组是给出的空间大小,与数组 的元素个数无关
public class ShuZu{
public static void mian(String args[]){
int array1[];//定义
array1=new int[4];//创建
int array1[]=new int[4];
int array1[]=new int[]{2,3,4,};//赋值
char []array2;//定义
array2=new char[5];//创建
char []array2=new char[5];
char []array2=new char[]{'2','3','4','5','6',};//赋值
int[] array3;//定义
array3=new int[6];//创建
int[] array3=new int[6];
int[] array3=new int[]{1,2,3,4,};//赋值
//逐个赋值
int[] array3=new int[]{1,2,3,4,};
char array4[]=new char[4];
array4[0]=12;
array4[1]=234;
array4[2]=222;
array4[3]=2345;
char array5[]={'h','e','l','l','o'};//数组中取值
System.out.println(array5[2]);//l
System.out.println(array5.length);//元素格数5
}
}
6.循环遍历一维数组
7.如何定义一个二维数组
格式: 数据类型 数组名称[][];
数据类型 [][]数组名称;
8.如何创建一个二维数组?
二维数组可以保存一个类似表格一样的数据,所以我们可以认为二维数组就是一个表格。
1.先定义,后创建
数据类型 数组名称[][];
数据类型 [][]数组名称;
数组名称=new 数据类型[表格行][行中的列];
2.定义+创建
数据类型 数组名称[][] = new 数据类型[表格行][行中的列];
数据类型 [][]数组名称 = new 数据类型[表格行][行中的列];
9.如何为二维数组赋值?
1.逐个赋值—就是挨个为数组的每一个存储空间存放数据值。
2.直接赋值—就是在创建数组的时候将数据值保存到数组中。
10.如何从二维数组中取值?
只要我们能够得到数组的存储位置,就可以得到数组中的数据值。
格式:数组名称[行][列];
11.二维数组的length属性 – 行数
12.循环遍历二维数组—使用双层循环结构,外层控制行,内层控制列
public class ShuZu2{
public static void main(String[] args){
int array1[][];
int[][] array2;
array1=new int[3][5];
array2=new int[2][4];
char array3[]=new char[2][5];//逐个赋值
array3[0][0]=110;
array3[0][1]=220;
array3[0][2]=330;
array3[1][0]=440;
array3[1][1]=550;
array3[1][2]=660;
System.out.println(array3);
char array4[][]={{'h','e','l','l','o'},{'w','o','r','l','d'}};
System.out.println(array4[1][4]);//d
System.out.println(array4.length);//2
for(int i=0;i<array4.length;i++){
for(int j=0;j<=4;j++){
System.out.println(array4[i][j]);
}
}
for(char carray5[]:array4){
for(char value:carray5){
System.out.println("增强--"+value);
}
}
}
}
13.认识Arrays类【数组的帮助类】
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)返回数组的字符串形式