javaSE基础总结1-3章

来源：互联网发布：视频模糊修复软件编辑：程序博客网时间：2024/05/22 14:17

java概述

一.Java概述

1.1 Java历史(重点)

1990年:SUN公司启动green计划

1992年: 创建Oak(橡树)语言—》Java

1994年: James Gosling参加硅谷大会，通过java编写的浏览器WebRunner演示了 java的功能，并震惊世界

1995年: sun发布JDK1.0目前已经到了JDK8

2009年:Oracle收购了SUN公司。

1.2 java的特点

Java的白皮书中说:“Java是一种

简单的、

面向对象的、

分布式的、

解释的、

健壮的、

安全的、

结构中立的、

可移植的、

高效的、

多线程的、

动态的语言。”

1.3 java的运行机制

Java程序需要经过先编译、后解释执行两步。(偏重于解释型语言)。

执行程序的两个步骤图片

编译器解释器

源代码(firstApp.java) ------> 字节码文件(firstApp.class) ------->生成可执行的平台

JDK、JRE、JVM概念：

JDK（Java Development Kit Java标准开发包）是美国SUN公司提供的一套用于开发java应用程序的开发包它提供了编译和运行java程序所需的各种工具和资源。它包含:JRE，Java工具，Java基础类库。

------- JRE（Java Runtime Environment）Java运行时环境

JDK--------|------ java的工具: javac.exe（java编译器）

| java.exe(java解释执行器)

-------java的类库:(3600多个) 常用的150多个

JRE(Java Runtime Environment Java运行时环境)是Java程序运行的必须条件

注意：只想运行java程序只安JRE，无需安装jdk若想开发java程序，必安JDK

JVM(Java Virtual Machine Java虚拟机)是负责解释执行字节码文件。充当转换器，实现跨平台。 Java是通过JVM实现跨平台的，跨平台也是java最大的优势之一。

JRE和JVM的联系与区别:（重点）

JRE包含JVM。JVM是运行java程序的核心虚拟机，他负责解释执行字节码文件，java程序运行不仅仅需要jvm，还需要其他的资源。JRE除包含JVM外，还拥有Java程序运行所需的所有资源。

1.4 JDK安装与配置

安装:

下载JDK直接安装即可

配置:

安装完成JDK后，我的电脑—》右键—》属性—》高级系统设置—》高级—》环境变量—》下面系统变量选择path—》变量中后面追加 ; C:\Program Files\Java\jdk1.7.0_45\bin –》确定即可。

配置完成后，打开DOS窗口输入javac 、java命令测试

1.5第一个java程序

第一步:编写源程序

新建记事本，重命名为Hello.java

public class Hello{

public static void main(String[] args){

System.out.println("Hello World!我的第一个java程序!");

}

第二步:javac命令编译输出：javac Hello.java

进入dos窗口，用cd命令切换路径到Hello.java所在位置。使用javac编译

如果代码没有错误，编译成功，生成Hello.class字节码文件

如果代码有错误，会提示错误，我们需要修改错误再重新编译。

第三步:java解释执行输出：java Hello

接着上面一步，编译生成字节码文件后

1.6 Java两大机制

³ Java两大核心机制 JVM、GC

Java虚拟机（Java Virtual Machine）屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”。

垃圾收集机制（Garbage Collection）系统自定回收无用的内存。

第二章数据类型和运算符

一 Java中的注释和javadoc命令

注释：用来说明某段代码的作用、某个方法的功能等等。 (起说明作用)

Java的注释分为：（3种）

单行注释 // 注释内容

多行注释：

* 注释内容

文档注释：会生成API文档，它可以帮助用户理解和学习该程序。

/**

* 注释内容

注：运行方式：文档注释使用后你，在cmd你的文件目录之下输入：javadoc DocComm.java

运行javadoc之前先javac编译下java源文件，检查是否有错误。

二 Java中的分隔符 (了解)

Java语言中分隔符主要有: {} () [] , ; .空格

三标识符及其命名规则，关键字 (重点)

标识符：就是给程序中的类、方法、变量命名的符号。

命名规则：英文大小写字母数字 $和_

注意：

不能以数字开头

不能是Java中关键字

区分大小写

不能有空格

名字不要太长，要见名知意

Java关键字、保留字（）

关键字：48个

保留字2个：goto,const

直接量3个：true，false，null

四基本数据类型

Java语言是强类型语言，每一个表达式或者变量都有一个编译时就确定好的类型。所有的变量必须先声明再使用。

Java语言中的数据类型包括：基本数据类型 8种

应用数据类型 3种

1.整数类型：

byte 1个字节（8位）取值范围：-2⁷——2⁷-1（-128——127） 00000001

short 2个字节（16位）取值范围：-2¹⁵——2¹⁵-1（-32768——32767）00000 0000 0000 0001

int 4个字节（32位）取值范围：-2³¹——2³¹-1（-2,147,483,648——2,147,483,647）

long 8个字节（64位）取值范围：-2⁶³——2⁶³-1

Java中的整数类型有四种表示方式:二进制(JDK7新增),八进制,十进制,十六进制

默认是十进制.

二进制是以0b开头,int a = 0b10 0010 0100;

八进制是以0开头, int b = 012;

十六进制是以0x开头,int c = 0xa12;

十六进制：0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f

二进制 01表示

0 1 0 1 0 1 0 1

128 64 32 16 8 4 2 1

= 1*2⁰ + 0*2¹ +1*2² + 0*2³ + 1*2⁴ + 0*2⁵ + 1*2⁶ + 0*2⁷ = 1+0+4+0+16+0+64 = 85

二进制转十进制

八进制 0,1,2,3,4,5,6,7,

012 = 2*8⁰+ 1*8¹ = 2+8 = 10

十六进制 0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f

0xa2 = 2*16⁰ + 10*16^{1 =}162

2.浮点类型

Java浮点类型有固定的表数范围和字段长度，不受平台影响。

float 4个字节小数点后有6-7个有效数字

double 8个字节小数点后有15个有效数字

浮点类型：表示有小数的数值，可以为负数。

Ø double是最常用的浮点类型，java中默认的浮点类型就是double

Ø float类型数值必须加上f或f，eg：float f = 1.2f

3.字符类型

char 2个字节

字符类型表示方式：

1. 直接使用单个字符表示：char sex=‘男’; char a =‘x’;

2. 通过转义字符表示特殊的字符常量：’\n’,’\t’等等。

3. 直接使用Unicode编码表示字符常量：char a =‘\u9999’;

4.布尔类型

布尔类型表示逻辑上的真假，值：true和false

true：真

false : 假

主要是用于逻辑运算和关系运算的。

布尔类型不可以和其他任何类型相互转化。

boolean flag = true；

五常量和变量，作用域

变量

变量：在程序执行过程中，在某个范围内其值是可以改变的量。

定义格式：

变量的声明：数据类型变量名；int a;

变量的初始化：变量名 = 初始化值； a = 15;

在同一个方法内或者同一个类内，变量的名字不可以一样

变量必须先声明再初始化。否则编译出错：变量找不到符号

常量

常量：不能改变的量，值是固定的。常量名是由大写字母、下划线和数字表示

Java中常量分类：

字面值常量

自定义常量。

作用域

变量定义在哪一级的大括号内，哪个内的范围就是这个变量的作用域。

六数据类型转换

在Java的八种基本数据类型中有两种转换方式:自动类型转换、强制类型转换

Boolean类型不可以和任何其他数据类型进行转换。

1.自动类型转换

小类型自动向大类型转换

自动类型转换条件：类型兼容，目标类型大于源类型。

2.强制类型转换

格式:

目标类型变量 = (目标类型)源类型:

Eg: double a = 12.12;

int b = (int) a; //强制数据类型转换

注意：

当使用二元运算符(+,-,*,/)对两个值进行运算时，两个操作数会转化为通用类型。

如果两个操作数中有一个是double类型，则另一个将会转化为double类型。

如果两个操作数中有一个是float类型，则另一个将会转换为float类型。

如果两个操作数中有一个是long类型，则另一个将会转换为long类型。

否则，两个操作数都会转换为int类型。

字符串和所有的基本类型运算时(+),基本数据类型都会转换为字符串String。

面试题

byte b1=3,b2=4,b;

b=b1+b2;

b=3+4;

哪句是编译失败的呢？为什么呢？

常量相加：首先做加法，计算结果，然后看结果是否在变量的赋值的数据类型范围之内，如果不是在其范围之内，就报错。

变量相加：首先转换数据类型，然后和前面的变量做对比，如果符合自动数据类型转换，就不报错，否则就报错。

思考题

byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?

练习：byte b = 300;

Byte b = (byte) 300;结果是-126

七运算符的使用

算术运算符 + - * / % ++ --

++ 和 -- 的

总结:在运算时d = a++，相当于先把a的值赋给d，再让a自增

C = ++b，是先让b自增，再把b的值赋给c。

总结：在输出时，a++相当于先输出a，然后再让a自增

在输出时，++a相当于先让a自增，然后再输出a。

赋值运算符

=、+=、-=、*=、/=、%=等都是赋值运算符

面试题:

short s=1, s = s+1; short s=1, s+=1;

上面两个代码有没有问题，如果有，那里有问题

比较运算符

比较运算符的结果都是boolean类型,要么是true,要么是false.

比较运算符中”==”,不能写成”===”或者”=”

逻辑运算符

逻辑运算符用于连接Boolean类型的表达式

&与: 有false就是false

|或: 有true就是true

^异或：相同为false，不同为true

!非：非true为false，非false为true

&&短路与：与&是一样的，有短路效果。如果左边是false，右边就不执行，结果就一定是false。

|| 短路或：与|一样，有短路效果。如果左边是true，右边不执行，结果就是true。

位运算符

& | ^ ~

与或异或非

&：两个都是1就是1，有一个是0就是0

|：有一个是1就是1

^：相同为0，不同为1

~：是1就是0，是0就是1

思考题：1.请自己实现两个整数变量的交换

例如：a = 3;b = 4;交换之后a = 4; b = 3;

方法一：

方法二：三元运算符

格式：比较表达式？表达式1：表达式2

执行流程：

首先计算比较表达式的值，看是true还是false

如果是true，结果就是表达式1

如果是false，结果就是表达式2

2.获取两个整数中的最大值

获取三个整数中的最大值

比较两个整数是否相同

运算符的优先级：

运算符的优先级（从高到低）

优先级

描述

运算符

括号

()、[]

正负号

+、-

自增自减，非

++、--、!

乘除，取余

*、/、%

加减

+、-

移位运算

<<、>>、>>>

大小关系

>、>=、<、<=

相等关系

==、!=

按位与

按位异或

按位或

逻辑与

逻辑或

条件运算

赋值运算

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

位赋值运算

&=、|=、<<=、>>=、>>>=

如果在程序中，要改变运算顺序，可以使用()。

第三章流量控制与数组
一.程序的三种结构
顺序结构：自上而下的逐行执行代码。
选择(分支)结构：根据逻辑判断，有选择的执行其中某部分代码。
循环结构：根据逻辑判断，重复执行某个代码块。
二.顺序结构程序设计
前面案例中代码块中没有用if、switch、for、while等的，都是顺序结构
案例：输出三位数之和
import java.util.*;
public class Test2{
public static void main(String[] args){
int x,gw,sw,bw,sum;
Scanner s = new Scanner(System.in);
System.out.print("请输入一个三位整数:");
x = s.nextInt();
gw = x%10; // 123%10=3
sw = (x%100)/10;// 123%100=23 23/10=2
bw = x/100; // 123/100=1
sum = gw+sw+bw;
System.out.println(x+"的各位数和="+sum);
}
分支(选择)结构程序设计
★if分支
◆单分支
语法:
if(表达式){
代码块;
}

说明:
如果表达式的值为true，则执行代码块，否则不执行。
案例：public class Test1{
public static void main(String[] args){
int a = 80;
if(a>=60){
System.out.println("恭喜你，成绩合格!");
}
}
}
二路分支(双分支)
语法:
if(表达式){
代码块1;
}else{
代码块2；
}

说明:
如果表达式的值为true，则执行代码块1，
如果表达式的值为false，则执行代码块2.
案例:
选择练习
public class Test2{
public static void main(String[] args){
int a = 50;
if(a>=60){
System.out.println("恭喜你，成绩合格!");
}else{
System.out.println("很抱歉，准备补考!");
}
}
}
键盘输入偶奇数
import java.util.*;
public class Test1{
public static void main(String[] args){
int x;
Scanner s = new Scanner(System.in);
System.out.print("请输入x的值:");
x = s.nextInt();
if(x%2==0){
System.out.println(x+"是偶数!");
}else{
System.out.println(x+"是奇数!");
}
}
}
从键盘输入一个年份，判断该年是否是闰年，
如果是的输出 xxxx是闰年
如果不是输出 xxxx是平年
import java.util.*;
public class Test1{
public static void main(String[] args){
int a;
Scanner s = new Scanner(System.in);
System.out.print("请输入年份:");
a = s.nextInt();
if((a%4==0&&a%100!=0)||a%400==0){
System.out.println(a+"是闰年!");
}else{
System.out.println(a+"是平年!");
}
}
}
注：三目运算符也属于二路分支
表达式1?表达式2:表达式3；

案例:
public class Test1{
public static void main(String[] args){
int a = 40;
int b = 20;
int max;
/*
if(a>b){
max = a;
}else{
max = b;
}
*/
max = a>b?a:b;
System.out.println(max);
}
}

路分支
语法:
if(表达式1){
代码块1;
}else if(表达式2){
代码块2；
}else if(表达式3){
代码块3；
}
…….
…….//中间可以有n个 else if
……..
else{//最后这个else可有可无
代码块n;
}

案例:
public class Test3{
public static void main(String[] args){
int a = 75;
if(a>=80){
System.out.println("成绩优秀，继续保持!");
}else if(a>=70){
System.out.println("成绩良好，再进一步!");
}else if(a>=60){
System.out.println("成绩合格，仍须努力");
}else{
System.out.println("成绩不合格，好好加油!");
}
}
}
键盘输入星期几
import java.util.*;
public class Test2{
public static void main(String[] args){
int week;
Scanner s = new Scanner(System.in);
System.out.print("请输入星期几(1--7):");
week = s.nextInt();
if(week==1){
System.out.println("星期一 Monday");
}else if(week==2){
System.out.println("星期二 Tuesday");
}else if(week==3){
System.out.println("星期三 Wednesday");
}else if(week==4){
System.out.println("星期四 Thursday");
}else if(week==5){
System.out.println("星期五 Friday");
}else if(week==6){
System.out.println("星期六 Saturday");
}else if(week==7){
System.out.println("星期天 Sunday");
}else{
System.out.println("你的输入有误,只有星期1--7");
}
}
}
键盘输入月份再输出相应的内容
import java.util.*;
public class Test3{
public static void main(String[] args){
int month;
Scanner s = new Scanner(System.in);
System.out.print("请输入月份(1--12):");
month = s.nextInt();
if(month==1||month==2||month==12){
System.out.println("白雪皑皑");
}else if(month==3||month==4||month==5){
System.out.println("春暖花开");
}else if(month==6||month==7||month==8){
System.out.println("夏日炎炎");
}else if(month==9||month==10||month==11){
System.out.println("秋高气爽");
}else{
System.out.println("你的输入有误，月份只有1--12");
}
}
}
switch分支 ( 多分支语句)

语法:
switch（表达式）{
case 值1:代码块1；
break; //break不是必须的，根据情况而定
case 值2:代码块2；
break;
……
…...
……
default:代码块n; //default可有可无
}

注意: JDK6 中表达式的类型只能为 byte short int char
JDK7中表达式的类型只能为 byte short int char String

案例:
//从键盘输入星期几，输出对应的英文单词
import java.util.*;
public class Test1{
public static void main(String[] args){
int week;
Scanner s = new Scanner(System.in);
System.out.print("请输入星期几(1--7):");
week = s.nextInt();
switch(week){
case 1:
System.out.println("星期一 Monday");
break;
case 2:
System.out.println("星期二 Tuesday");
break;
case 3:
System.out.println("星期三 Wednesday");
break;
case 4:
System.out.println("星期四 Thursday");
break;
case 5:
System.out.println("星期五 Friday");
break;
case 6:
System.out.println("星期六 Saturday");
break;
case 7:
System.out.println("星期天 Sunday");
break;
default:
System.out.println("你的输入有误，只有1--7");
}
}
}

//从键盘输入月份，输出对应的季节
import java.util.*;
public class Test2{
public static void main(String[] args){
int month;
Scanner s = new Scanner(System.in);
System.out.print("请输入月份:");
month = s.nextInt();
switch(month){
case 12:
case 1:
case 2:
System.out.println("白白皑皑!");
break;
case 3:
case 4:
case 5:
System.out.println("春暖花开!");
break;
case 6:
case 7:
case 8:
System.out.println("夏日炎炎!");
break;
case 9:
case 10:
case 11:
System.out.println("秋高气爽!");
break;
default:
System.out.println("你的输入有误，只有1--12月");
}
}
}
四、循环结构程序设计
1.while循环
while运行结构：

案例:
输出1—100的数据
public class Test1{
public static void main(String[] args){
int a = 1;
while(a<=100){
System.out.println(a);
a++;
}
}
}

求出1+2+3+……+100=?
public class Test2{
public static void main(String[] args){
int i = 1;
int sum = 0;
while(i<=100){
sum = sum+i;
i++;
}
System.out.println(sum);
}
}

2.do…while循环

案例:
输出1—100的数据
public class Test3{
public static void main(String[] args){
int i = 1;
do{
System.out.println(i);
i++;
}while(i<=100);
}
}

求出1+2+3+……+100=?
public class Test3{
public static void main(String[] args){
int i = 1;
int sum = 0;
do{
sum=sum+i;
i++;
}while(i<=100);
System.out.println("1+2+3+...+100="+sum);
}
}
思考？？？
综合上面两个问题，使用两种方法做出来，两个的区别是什么呢？
1while与do...while都属于循环结构
2.while是先判断，再执行 do…while先执行，后判断
3.do…while至少执行一次。

for循环
案例:
输出1—100的数据
public class Test1{
public static void main(String[] args){
for(int i = 1;i<=100;i++){
System.out.println(i);
}
}
}

求出1+2+3+……+100=?
public class Test1{
public static void main(String[] args){
int sum = 0;
for(int i = 1;i<=100;i++){
sum=sum+i;
}
System.out.println("1+2+3+...+100="+sum);
}
}

分支、循环嵌套
1.分支中嵌套分支结构
案例一: 从键盘输入3个整数，输出其中最大的一个
import java.util.*;
public class Test1{
public static void main(String[] args){
int a,b,c;
Scanner s = new Scanner(System.in);
System.out.print("请输入一个整数:");
a = s.nextInt();
System.out.print("请输入一个整数:");
b = s.nextInt();
System.out.print("请输入一个整数:");
c = s.nextInt();
if(a>b){
if(a>c){
System.out.println(a);
}else{
System.out.println(c);
}
}else{
if(b>c){
System.out.println(b);
}else{
System.out.println(c);
}
}
}
}
2.循环中嵌套分支结构
案例一: 输出1--100中能被3整除的数
public class Test1{
public static void main(String[] args){
for(int i=1;i<=100;i++){
if(i%3==0){
System.out.println(i);
}
}
}
}
案例二:输出1--100中能被3整除，又能被5整除的数
public class Test1{
public static void main(String[] args){
for(int i=1;i<=100;i++){//做1--100的循环
if(i%3==0&&i%5==0){//做判断能被3整除
System.out.println(i);
}
}
}
}
案例三: 输出1900--2015之间所有的闰年
public class Test1{
public static void main(String[] args){
for(int i=1900;i<=2015;i++){
if((i%4==0&&i%100!=0)||(i%400==0)){
System.out.println(i);
}
}
}
}

案例四: 输出所有的水仙花数，所谓的水仙花数是一个三位的正整数，并且该数据的各位数的
三次方和等于该数本身(eg: 371 = 1*1*1 + 7*7*7 + 3*3*3)
public class Test1{
public static void main(String[] args){
int gw,sw,bw;
for(int i=100;i<=999;i++){
gw = i%10; // 123%10=3;
sw = (i%100)/10;//123%100=23 23/10=2
bw = i/100; //123/100=1
if(gw*gw*gw+sw*sw*sw+bw*bw*bw==i){
System.out.println(i);
}
}
}
}

案例五:求出1—100中能被3整除的数据的和
public class Test1{
public static void main(String[] args){
int sum=0;
for(int i = 1;i<=100;i++){
if(i%3==0){
sum = sum+i;
}
}
System.out.println(sum);
}
}
3.循环中嵌套循环结构
案例一:

public class Test1{
public static void main(String[] args){
for(int i = 1;i<=3;i++){
for(int j = 1;j<=2;j++){
System.out.println("i="+i+",j="+j);
}
}
}
}

public class Test1{
public static void main(String[] args){
for(int i=1;i<=5;i++){
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
}
}

public class Test1{
public static void main(String[] args){
for(int i=1;i<=5;i++){
for(int j=1;j<=6-i;j++){
System.out.print("*");
}
System.out.println();
}
}
}

public class Test1{
public static void main(String[] args){
//上半部分
for(int i=1;i<=5;i++){
for(int j=1;j<=i;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();
}
}
}

public class Test1{
public static void main(String[] args){
for(int i=1;i<=5;i++){
//空格
for(int j=1;j<=i-1;j++){
System.out.print(" ");
}
//*号
for(int k=1;k<=11-2*i;k++){
System.out.print("*");
}
//换行
System.out.println();
}
}
}

public class Test1{
public static void main(String[] args){
//上半部分
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();
}
//下半部分
for(int i=1;i<=4;i++){
//空格
for(int j=1;j<=i;j++){
System.out.print(" ");
}
//*号
for(int k=1;k<=9-2*i;k++){
System.out.print("*");
}
//换行
System.out.println();
}
}
}

扩展:打印九九乘法表

public class Test1{
public static void main(String[] args){
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+i*j+"\t");
}
System.out.println();
}
}
}
六、循环的控制 break、continue

break语句用于结束整个循环。
continue语句用于结束本次循环。

用案例更生动表示出来其区别：
public class Test1{
public static void main(String[] args){
for(int i=1;i<=5;i++){
if(i==3){
break;
}
System.out.println(i);
}
}
}
结果：1 2
public class Test1{
public static void main(String[] args){
for(int i=1;i<=5;i++){
if(i==3){
continue;
}
System.out.println(i);
}
}
}
结果：1 2 4 5
六、数组、一维数组
数组是所有编程语言中一种最常用的数据结构，它用来存储多个相同类型的数据。
常用定义法
int[] a = new int[5];
eg:
int[] a = {55,66,85,32,75};
55 ------------ a[0]
66 ------------ a[1]
85 ------------ a[2]
32 ------------ a[3]
75 ------------ a[4]
单独输出某个元素
System.out.println(a[2]);
输出所有元素(使用循环)
public class Test1{
public static void main(String[] args){
int[] a = {55,23,89,64,85};
for(int i=0;i<=4;i++){
System.out.println(a[i]);

}
}
}
用a.length来表示
public class Test1{
public static void main(String[] args){
int[] a = {55,23,89,64,85};
for(int i=0;i<=a.length-1;i++){
System.out.println(a[i]);
}
}
}
在JDK1.5之后循环输出数组也可以只是用 foreach（foreach在JDK1.5开始引入）
public class Test1{
public static void main(String[] args){
int[] a = {55,23,89,64,85};
//for循环输出
for(int i=0;i<=a.length-1;i++){
System.out.println(a[i]);
}
System.out.println("-------------------------------");
//foreach输出
for(int x:a){
System.out.println(x);
}
}
}
数组的应用
求多个数据的和
public class Test1{
public static void main(String[] args){
int[] a = {55,23,89,64,85};
int sum=0;
for(int i=0;i<=a.length-1;i++){
sum = sum+a[i];
}
System.out.println("总分="+sum);
}
}

◆求多个数据的平均值
public class Test1{
public static void main(String[] args){
int[] a = {55,23,89,64,85};
int sum=0;
double avg;
for(int i=0;i<=a.length-1;i++){
sum = sum+a[i];
}
avg = sum/(a.length*1.0);
System.out.println("平均分="+avg);
}
}

◆求多个数据中的最大值、最小值
public class Test1{
public static void main(String[] args){
int[] a = {55,23,89,64,85};
int max = a[0];//假设第一个最大
for(int i=0;i<=a.length-1;i++){
if(a[i]>max){
max = a[i];
}
}
System.out.println("最大值="+max);
}
}

public class Test1{
public static void main(String[] args){
int[] a = {55,23,89,64,85};
int min = a[0];//假设第一个最小
for(int i=0;i<=a.length-1;i++){
if(a[i]<min){
min = a[i];
}
}
System.out.println("最小值="+min);
}
}

◆统计及格和不及格人数
public class Test1{
public static void main(String[] args){
int count1=0;//及格人数
int count2=0;//不及格人数
int[] a = {55,23,89,64,85};
for(int i=0;i<=a.length-1;i++){
if(a[i]>=60){
count1++;
}else{
count2++;
}
}
System.out.println("及格人数="+count1+",不及格人数="+count2);
}
}

◆查找是否有xx分的同学
import java.util.*;
public class Test1{
public static void main(String[] args){
Scanner s = new Scanner(System.in);
int x ;
boolean f = false;//f表示是否存在要查找的值
int[] a = {55,23,89,64,85};
System.out.print("请输入你要查找的分数:");
x = s.nextInt();
for(int i=0;i<=a.length-1;i++){
if(a[i]==x){
f = true;
}
}
if(f){
System.out.println("有!");
}else{
System.out.println("无!");
}
}
}

◆对分数从高到低排序、从低到高排序(冒泡排序)
//从大到小
public class Test1{
public static void main(String[] args){
int[] a = {55,23,89,64,85};
//从大到小冒泡排序
for(int i = 0;i<a.length-1;i++){
for(int j=0;j<a.length-1;j++){
if(a[j]<a[j+1]){
//交换
int x = a[j];
a[j] = a[j+1];
a[j+1] = x;
}
}
}
//输出数组
for(int i=0;i<=a.length-1;i++){
System.out.print(a[i]+" ");
}
System.out.println();
}
}

//从小到大
public class Test1{
public static void main(String[] args){
int[] a = {55,23,89,64,85};
//从小到大冒泡排序
for(int i = 0;i<a.length-1;i++){
for(int j=0;j<a.length-1;j++){
if(a[j]>a[j+1]){
//交换
int x = a[j];
a[j] = a[j+1];
a[j+1] = x;
}
}
}
//输出数组
for(int i=0;i<=a.length-1;i++){
System.out.print(a[i]+" ");
}
System.out.println();
}
}

★数组内存分析
栈:基本数据类型变量值，引用类型变量的地址值
堆:引用类型的真实值

案例:

public class TestArray1{
public static void main(String[] args){
int[] a = {89,75,64,32,78};
int[] b = {55,66,77};
System.out.println(a[1]);//75
System.out.println(b[1]);//66
b = a;
System.out.println(a[1]);//75
System.out.println(b[1]);//75
b[1] = 30;
System.out.println(a[1]);//30
System.out.println(b[1]);//30
}
}

六、 二维数组、多维数组

●二维数组:

二维数组就是存放一维数组的数组，一个二维数组可以看做多个一维数组。

int a = 10;

int[] b = {10,20,30};//b看做多个a的集合可以把 b[0]和a等价

int[][] c = {{10,20,30},{5,6,7}};//c可以看做b的集合可以把c[0]和b等价 c[0][0]和a等价

// c[0] c[1] 一维数组

// c[0][0] 值

★数组的定义

类型[][]数组名;//常用 int[][] a;

类型数组名[][];// int a[][]

★数组的初始化

◆静态初始化

初始化时由程序员显示的指定每个数组元素的初始值，由系统决定数组的长度。

eg1:

int[][] a;

a = new int[][]{{1,2,3},{4,5,6}};

eg2:

int[][] a = new int[][]{{1,2,3},{4,5,6}};

eg3:

int[][] a = {{1,2,3},{4,5,6}};//简化写法

eg4://错误写法

int[][] a;

a = {{1,2,3},{4,5,6}};

◆动态初始化

初始化时程序员只指定数组的长度，而不指定数组中元素的值，系统自动给数组分配初始值。

eg1:

int[][] a;

a = new int[2][3]; //2代表a中有两个一维数组 3代表一维数组中有3个值

eg2:

int[][] a = new int[2][3];

★访问数组元素

◆访问单个元素

public class Test1{

public static void main(String[] args){

int a = 5;

int[] b = {1,2,3,4,5};

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

System.out.println(a); //5

System.out.println(b[2]); //3b[2]看做和a一样

System.out.println(c[1][1]);//5c[2][2]看做和b[2]一样 c[1]看做和b一样

}

◆访问所有元素

public class Test1{

public static void main(String[] args){

int[][] c = {{1,2,3},{4,5,6},{7,8,9},{10,11,23}};

//输出c

for(int i=1;i<=c.length-1;i++){

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

System.out.print(c[i][j]+" ");

}

System.out.println();

}

●多维数组:

Java中没有多维数组，所有的数组都可以看做一维数组。

public class Test1{

public static void main(String[] args){

int a = 10; //变量a

int[] b = {10,20,30}; //一维数组b b中保存的是一个一个的变量

int[][] c = { //二维数组c c中保存的是一个一个的一维数组

{10,20}, //c[0]

{30,40}, //c[1]

{40,50} //c[2]

};

int[][][] d = { //三维数组d d中保存的是一个一个的二维数组

{{10,20},{30,40}}, //d[0]

{{60,70},{80,90}} //d[1]

};

System.out.println(a);//10

System.out.println(b[0]);//10

System.out.println(c[0][0]);//10

System.out.println(c[2][1]);//50

System.out.println(d[0][0][0]);//10

System.out.println(d[1][0][0]);//60

System.out.println(d[1][1][1]);//90

}

阅读全文

0 0