Java数组

现实

程序

各种各样的事物

模拟各种各样的事物

各个真实事物都有自己的名字

程序中事物也有自己的名字

有很多特定含义的名词：太阳、地球、粉笔盒、自行车、楼房、厕所

关键字

现实中事物都有自己的名字

标识符

家长给孩子起名字尽量避开这些有特定含义的词汇

java程序中给事物起标识符使用关键字是否合理？

举例说明现实中给孩子起名字使用特定词汇的不合理性。

引导学生思考java程序中给事务起名字使用关键字是否合理？

0

1

1

0

0

0

0

1

0

1

1

1

1

1

1

1

1

1

1

1

0

1

1

1

1

1

1

1

1

1

1

1

1

1

1

基本数据类型

byte

short

int

long

float

double

char

boolean

对应封装类型

Byte

Short

Integer

Long

Float

Double

Character

Boolean

public static void main(String[] args) {

        //将6个数字放到6个int变量中

int i1=21452;

int i2=20307;

int i3=31995;

int i4=27426;

int i5=36814;

int i6=20320;

//将int类型强制类型转换成char类型

char a=(char)i1;

char b=(char)i2;

char c=(char)i3;

char d=(char)i4;

char e=(char)i5;

char f=(char)i6;

System.out.println(a+" "+b+" "+c+" "+d+" "+e+" "+f);

}

public class Test {

public static void main(String[] args) {

int a=10;

int b=4;

System.out.println(+b);

System.out.println(-b);//输出结果： -2

//加法运算

int res1=a+b;

System.out.println("a+b="+res1);// 输出结果：14

//减法运算

int res2=a-b;

System.out.println("a-b="+res2);//输出结果：6

//乘法运算

int res3=a*b;

System.out.println("a*b="+res3);//输出结果：40

//除法运算

//对于除号”/”，它的整数和整数做除法时，只保留整数部分而舍弃小数部分

int res4=a/b;

System.out.println("a/b="+res4);//输出结果：2

//取模运算

int res5=a%b;

//运算过程：res5=a-(a/b)*b=10-(10/4)*4=10-2*4=10-8=2

System.out.println("a%b="+res5);//输出结果：2

//自增运算符

//单等号 ‘=’  是赋值运算符号

//++在变量前:变量先自增1，再将自增后的结果参与到运算中

int res6=++a;

System.out.println("res6="+res6+"  a="+a);//res6=11  a=11

//++在变量后:变量先使用原始值进行运算，之后变量再自增1

int res7=a++;

System.out.println("res7="+res7+"  a="+a);//res7=11  a=12

//自减运算符

//--在变量前：变量先自减1，再将自减后的结果参与到运算中

int res8=--a;

System.out.println("res8="+res8+"  a="+a);//res8=11  a=11

//--在变量后：变量先使用原始值进行运算，之后变量再自减1

int res9=a--;

System.out.println("res9="+res9+"  a="+a);//res9=11  a=10

}

}

public class Test2 {

public static void main(String[] args) {

double d=1.1d;

float f=2.5f;

long l=10l;

int i=20;

short s=5;

//double –当操作数中有double类型时

double res1=d+f+l+i+s;

System.out.println(res1);

//float–当操作数中有float类型时

float res2=f+l+i+s;

System.out.println(res2);

//long–当操作数中有long类型时

long res3=l+i+s;

System.out.println(res3);

//int

int res4=i+s;

System.out.println(res4);

}

}

=、+=、-=、*=、/=、%=

+=

public static void main(String[] args) {

int a=10;

float b=20;

a+=b;//a=(int)(a+b)

System.out.println("a="+a+"  b="+b);

}

输入结果：

a=30  b=20

-=

public static void main(String[] args) {

int a=10;

int b=20;

a-=b;

System.out.println("a="+a+"  b="+b);

}

输入结果：

a=-10  b=20

*=

public static void main(String[] args) {

int a=10;

int b=20;

a*=b;

System.out.println("a="+a+"  b="+b);

}

输入结果：

a=200  b=20

/=

public static void main(String[] args) {

int a=100;

int b=20;

a/=b;

System.out.println("a="+a+"  b="+b);

}

输入结果：

a=5  b=20

%=

public static void main(String[] args) {

int a=10;

int b=3;

a%=b;

System.out.println("a="+a+"  b="+b);

}

输入结果：

a=1  b=3

大小关系有哪些

现实大小关系描述

现实中结果表示

程序中大小关系描述

程序结果表示

等于

1等于2

错

1==2?

false

不等于

1不等于2

对

1!=2?

true

大于

1大于2

错

1>2?

false

小于

1小于2

对

1<2?

true

大于等于

1大于等于2

错

1>=2?

false

小于等于

1小于等于2

对

1<=2?

true

instanceof:此运算符用于检查某个对象是否属于某个类型，在面向对象讲完后讲解。

运算符

程序

输出结果

==

System.out.println(1==2);

false

!=

System.out.println(1!=2);

true

>

System.out.println(1>2);

false

<

System.out.println(1<2);

true

>=

System.out.println(1>=2);

false

<=

System.out.println(1<=2);

true

运算符

表达式

逻辑运算符运算规则

&&

true&&true

参与 与运算的元素是两个布尔值，只有两边都为true运算结果才为true，否则结果都为false

||

true||false

参与 或运算的元素是两个布尔值，只要有一边为true结果就为true,两边都为false结果才为false

!

!true

参与运算的元素是一个布尔值，做取反运算

与运算符

或运算符

非运算符

实例分析

运算结果

实例分析

运算结果

实例分析

运算结果

true&&true

true

true||true

true

!true

false

true&&false

false

true||false

true

!false

true

false&&true

false

false||true

true

false&&false

false

false||false

false

public static void main(String[] args) {

boolean b=(1>4)&&(5<7); //与运算短路

System.out.println(b);

      boolean b1=(4>1)||(5<7); //或运算短路

System.out.println(b1);

}

给定年份，判断指定的年份是平年还是闰年：

public static void main(String[] args) {

//某年能被4整除并且不能被100整除，或者能被400整除

int n=2020;

boolean b=((n%4==0)&&(n%100!=0))||(n%400==0);

System.out.println(b);

}

根据年龄判断一个人是成年还是未成年：输入结果1代表成年，0代表未成年

public static void main(String[] args) {

int age=18;

int flag=0;

flag=(age>=18?1:0);

System.out.println(flag);

}

语法结构

if(条件){      //此处条件为一个布尔值或结果是布尔值的表达式 

    语句组;

}

注：

1.当条件为true时执行if花括号里面的语句；当条件为false时，不执行花括号里面的语句。

2.当执行语句只有一条语句时，花括号可以省略不写，但程序可读性会降低，不建议省略。

3.当执行语句为多条语句时，花括号必须写。

实际问题

1.货车从货场装货出发将货物送往目的地，途中会经过超重检查站；

2.如果货车装载货物超重，在检查站接受处理并继续出发到达目的地；

3.如果货车装载货物没有超重，则顺利通过检查站到达目的地。

流程图

实例代码

public static void main(String[] args) {

int weight=10;

System.out.println("货车在货源地装货");

System.out.println("货车出发");

System.out.println("货车经过超重检查站");

//30吨及以下不超重，30吨以上为超重

if(weight>30){

System.out.println("===货车接受检查站处理===");

}

System.out.println("货车到达目的地");

}

语法结构

if(条件){     //此处条件为一个布尔值或结果是布尔值的表达式 

    语句组1;

}else{

    语句组2;

}

注：

1.当条件为true时执行if花括号里面的语句；当条件为false时，执行else花括号里面的语句。

2.当执行语句只有一条语句时，花括号可以省略不写，但程序可读性会降低，不建议省略。

3.当执行语句为多条语句时，花括号必须写。

实际问题

根据年龄判断是成年还是未成年

流程图

实例代码

public static void main(String[] args) {

int age=17;

if(age>=18){

System.out.println("成年");

}else{

System.out.println("未成年");

}

}

语法结构

if(条件1){    //此处条件为一个布尔值或结果是布尔值的表达式 

    语句组1;

}else if(条件2){

    语句组2;

}else....if(条件n){

    语句组n;

}else{

    语句组n+1;

}

注：

1.当某个条件为true时执行对应if花括号里面的语句；当条件为都不成立时，执行else花括号里面的语句。

2.当执行语句只有一条语句时，花括号可以省略不写，但程序可读性会降低，不建议省略。

3.当执行语句为多条语句时，花括号必须写。

实际问题

根据成绩判断所处成绩段

如果成绩大于等于90并且小于等于100，优秀

如果成绩大于等于80并且小于90，良好

如果成绩大于等于60并且小于80，及格

其他分数，不及格

流程图

实例代码

public static void main(String[] args) {

int cj=98;

if(cj>=90&&cj<=100){

System.out.println("优秀");

}else if(cj>=80&&cj<90){

System.out.println("良好");

}else if(cj>=60&&cj<80){

System.out.println("及格");

}else{

System.out.println("不及格");

}

}

延伸思考

多分支选择结构之间可以不加else么？

语法结构

switch(表达式){//此处表达式为byte、short、int、char、字符串等类型的值

    case 常量值 1:

        语句(组)1;

        break;

    case 常量值 2:

        语句(组)2;

        break;

    case 常量值 N:

        语句(组)n;

        break;

    default:  

        语句(组);

}

注：

1.当表达式值与某个常量值相同时，执行对应常量值后面的语句组。

2.当表达式与所有常量值都不相同的时候，执行default后面的语句组。

实际问题

公司根据年终评级发放奖金

A：50000元

B：30000元

C：10000元

其他：1000元

流程图

实例代码

public static void main(String[] args) {

char gread='B';

switch(gread){

case 'A':

System.out.println(50000);

//break;

case 'B':

System.out.println(30000);

//break;

case 'C':

System.out.println(10000);

//break;

default:

System.out.println(1000);

}

}

延伸思考

每个case后面如果不加break会有什么后果。

相同点

功能对等，一定的条件下可以互换

不同点

判断条件不同

if-else

条件为布尔值：true/false、关系运算表达式、逻辑运算表达式、关系运算与逻辑运算混合表达式

switch

条件为byte、short、char、int、字符串等类型的值

使用if...else...else 与switch计算指定月份天数，不考虑平年闰年

互换使用及break的作用

if...else...else写法：

public static void main(String[] args) {

int m=3;

if(m==1||m==3||m==5||m==7||m==8||m==10||m==12){

System.out.println(31);

}else if(m==4||m==6||m==9||m==11){

System.out.println(30);

}else{

System.out.println(28);

}

}

Switch写法：如果连续的多个case都不写break，相当于多个条件之间为或关系；break终止当前结构，跳出去。

public static void main(String[] args) {

int m=3;

switch(m){

case 1:

case 3:

case 5:

case 7:

case 8:

case 10:

case 12:

System.out.println(31);

break;

case 4:

case 6:

case 9:

case 11:

System.out.println(30);

break;

default:

System.out.println(28);

}

}

语法结构

while(条件){//此处条件为布尔值或运算结果是布尔值的表达式

    语句组;

}

循环结构之后后的其他代码

注：

1.条件成立返回true时，执行花括号里面的语句。

2.语句执行完毕，再次回到条件判断处继续下一次判断。

3.条件不成立返回false，退出结构。

4.如果条件一开始就不成立，循环一次都不会执行。

5.当语句组是单条语句时，花括号可以省略不写，不建议省略。

6.当执行语句为多条语句时，花括号必须写。

实际问题

累加1--100的整数的和

流程图

实例代码

public static void main(String[] args) {

int i=101;

int sum=0;

while(i<=100){

sum+=i;

i++;

}

System.out.println(sum);

}

实际问题

累加1--100之间的偶数的和

流程图

实例代码

public static void main(String[] args) {

int i=101;

int sum=0;

while(i<=100){

if(i%2==0){

sum+=i;

}

i++;

}

System.out.println(sum);

}

语法结构

所有的结构或者语句都必须以花括号或者分号结束

do{

   语句组;

}while(条件); //此处需要敲黑板此处条件为布尔值或运算结果是布尔值的表达式

注：

1.进入结构，没有判断条件，直接执行语句

2.判断条件，条件成立并返回true继续执行下一次语句。

3.条件不成立并返回false退出循环结构。

4.不管条件成立不成立，此结构无论如何都会执行一次循环。

5.当前结构以 分号结束 （;）

实际问题

累加1--100之间的整数和

流程图

实例代码

public static void main(String[] args) {

int i=1;

int sum=0;

do{

sum+=i;

i++;

}while(i<=100);

System.out.println(sum);

}

语法结构

for(表达式1;表达式2;表达式3){

}

for(循环变量初始化;条件;增量表达式){

    语句组;

}

for(int i=1;i<=100;i++){

    语句组;

}

注：

1.循环变量初始化

2.判断条件，条件成立，执行语句

3.执行增量表达式

4.从第2步开始重新执行过程。

5.条件不成立，跳出循环结构

实际问题

累加1--1000之间的整数的和

流程图

实例代码

public static void main(String[] args) {

int sum=0;

for(int i=1;i<=1000;i++){

sum+=i;

}

System.out.println(sum);

}

解释

continue：跳过本次循环剩下的语句而执行下一次循环

break：退出当前循环结构。

实例

在屏幕打印出1--100的数字，遇到10的倍数跳过不输出

实例代码

Continue：

public static void main(String[] args) {

for(int i=1;i<=100;i++){

if(i%10==0){

continue;

}

System.out.println(i);

}

}

如果用break会有什么效果？

public static void main(String[] args) {

for(int i=1;i<=100;i++){

if(i%10==0){

break;

}

System.out.println(i);

}

}

理解对比图

1    1

12

13

14

15

16

17

18

19

21

22

23

24

25

26

27

28

29

33

34

炒菜机名字

原材料

产出物

内部构造

西红柿鸡蛋炒菜机

各种食材

成品菜

机械结构

根据年月获取指定月份方法

数据

数据

程序语句

炒菜机：一台有特定功能的机器

方法：一段有特定功能的代码，可以重复使用，需要的时候可以直接使用

从键盘输入两个int类型的数字，使用方法两个数进行加减乘除运算

import java.util.Scanner;

public class Test4 {

public static void main(String[] args) {

Scanner in=new Scanner(System.in);

System.out.print("请输入第一个数字：");

int num1=in.nextInt();

System.out.print("请输入第二个数字：");

int num2=in.nextInt();

System.out.println("进行两个整数的加法运算");

int num3=add(num1,num2);

System.out.println(num3);

System.out.println("进行两个整数的减法运算");

int num4=subtract(num1,num2);

System.out.println(num4);

System.out.println("进行两个整数的乘法运算");

int num5=multiply(num1,num2);

System.out.println(num5);

System.out.println("进行两个整数的除法运算");

int num6=division(num1,num2);

System.out.println(num6);

}

//加法

public static int add(int a,int b){

int c=a+b;

return c;

}

//减法

public static int subtract(int a,int b){

int c=a-b;

return c;

}

//乘法

public static int multiply(int a,int b){

int c=a*b;

return c;

}

//除法

public static int division(int a,int b){

int c=a/b;

return c;

}

}

问题

通过程序计算某个班第一组的人的java考试成绩的平均值（假设一个组有6个人）

分析

1. 将6个人的成绩都录入到程序里面：放到6个变量。
2. 将6个人的成绩相加起来：6个变量里的值进行相加
3. 将6个数相加之和除以6结果就是平均值

程序

public static void main(String[] args){

int a1=78;

int a2=86;

int a3=87;

int a4=89;

int a5=81;

int a6=88;

int sum=a1+a2+a3+a4+a5+a6;

double avg=sum/6.0;//除6与6.0的区别

System.out.println(avg);

}

延伸理解

如果现在要计算全班36个人的java成绩的平均值就有问题了，我们要创建36个变量来存储36个人的成绩，这是很繁琐的，而且也不现实。

遇到的问题

在一段程序里需要N多个类型相同的变量，如果单个创建很不现实

问题的解决：

使用一个数组来解决。

意味着

一个数组就相当于N多个类型相同的变量

一个数组就可以代替N多个变量，并且这些变量类型都相同

数组的创建

int arr[]=new int[6];//创建完成数组后，数组元素只有默认值

int[] arr=new int[6];

int a;

int arr[]={1,2,3,4,5,6};//创建完成数组后，数组元素有了指定的值

数组的理解

直接定义的变量和通过数组方式定义的变量区别

各种类型数组元素中的默认值

byte ＝ 0

short ＝ 0

int ＝ 0

long ＝ 0L

float ＝ 0.0f

double ＝ 0.0d

char ＝ '\u0000'

boolean ＝ false

Object ＝ null

传统方式

int arr[]={1,4,2,5,6,9,7};

//传统方式

//使用数组length属性获取数组长度

int len=arr.length;

for(int i=0;i<len;i++){

//在循环的过程中循环变量的取值范围是0--5正好是数组下标的编号范围，

//所以将循环变量放到数组下标的位置代替下标的值。

System.out.println(arr[i]);

}

增强for循环

int arr[]={1,4,2,5,6,9,7};

//jdk5之后:增强for循环--遍历方式

for(int ele:arr){

System.out.println(ele);

}

/*

  for(ElementType element:arrayName){

};

将数组中的每一个元素依次拿出来放到变量element中并在循环体进行操作

*/

public static void main(String[] args){

//数组赋值

int[] arr1={37, 47, 23, -5, 19, 56};

int[] arr2=arr1;

arr2[3]=77;

System.out.println(arr1[3]);

}

System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

src：源数组

srcPos：源数组开始拷贝的元素位置

dest：目标数组

destPos：目标数组存放开始的位置

length：数组拷贝的长度

public static void main(String[] args){

//数组赋值

int[] src={37, 47, 23, -5, 19, 56};

int[] dest=new int[10];

System.arraycopy(src, 1,dest, 4, 3);

//数组转换成字符串

String arrStr=Arrays.toString(dest);

System.out.println(arrStr);

}

输出结果：[0, 0, 0, 0, 47, 23, -5, 0, 0, 0]

排序（Arrays.sort)

public static void main(String[] args){

//数组赋值

int[] arr1={37, 47, 23, -5, 19, 56};

//数组排序

Arrays.sort(arr1);

//数组转换成字符串

String arrStr=Arrays.toString(arr1);

System.out.println(arrStr);

}

输出结果：[-5, 19, 23, 37, 47, 56]

数组转换为字符串(Arrays.toString)

判断数组是否相同(Arrays.equals)

public static void main(String[] args){

int arr1[]={1,1,1,1,1};

  int arr2[]={1,1,1,1,1};

boolean b=Arrays.equals(arr1, arr2);

System.out.println(b);

}

输出结果：true

填充值(Arrays.fill)

public static void main(String[] args){

//数组赋值

int[] arr=new int[6];

//数组全部元素填充为5

Arrays.fill(arr, 5);

String arrStr=Arrays.toString(arr);

System.out.println(arrStr);

        //将数组从第1个元素至第3个元素填充为7

        //含第1个元素，不含第3个元素

        Arrays.fill(arr,1,3,7);

        String arrStr1=Arrays.toString(arr);

System.out.println(arrStr1);

}

输出结果：

[5, 5, 5, 5, 5, 5]

[5, 7, 7, 5, 5, 5]

public static void main(String[] args) {

int[] arr = {7,6,5,4,3,2,1 };

// 外层循环控制比较轮数

for (int i = 0; i < arr.length; i++) {

// 内层循环控制每轮比较次数

for (int j = 0; j < arr.length - i - 1; j++) {

// 比较相邻两个元素值大小，前面的大于后面则互换，否则不换

if (arr[j] > arr[j + 1]) {

int temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

}

}

}

System.out.println(Arrays.toString(arr));

}