javaSE基础总结1-3章
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位） 取值范围：-27——27-1（-128——127） 00000001
short 2个字节（16位）取值范围：-215——215-1（-32768——32767）00000 0000 0000 0001
int 4个字节（32位）取值范围：-231——231-1（-2,147,483,648——2,147,483,647）
long 8个字节（64位）取值范围：-263——263-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*20 + 0*21 +1*22 + 0*23 + 1*24 + 0*25 + 1*26 + 0*27 = 1+0+4+0+16+0+64 = 85
二进制转十进制
八进制 0,1,2,3,4,5,6,7,
012 = 2*80 + 1*81 = 2+8 = 10
十六进制 0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f
0xa2 = 2*160 + 10*161 = 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.获取两个整数中的最大值
获取三个整数中的最大值
比较两个整数是否相同
运算符的优先级：
运算符的优先级（从高到低）
| 优先级 |
描述 |
运算符 |
|
| 1 |
括号 |
()、[] |
|
| 2 |
正负号 |
+、- |
|
| 3 |
自增自减，非 |
++、--、! |
|
| 4 |
乘除，取余 |
*、/、% |
|
| 5 |
加减 |
+、- |
|
| 6 |
移位运算 |
<<、>>、>>> |
|
| 7 |
大小关系 |
>、>=、<、<= |
|
| 8 |
相等关系 |
==、!= |
|
| 9 |
按位与 |
& |
|
| 10 |
按位异或 |
^ |
|
| 11 |
按位或 |
| |
|
| 12 |
逻辑与 |
&& |
|
| 13 |
逻辑或 |
|| |
|
| 14 |
条件运算 |
?: |
|
| 15 |
赋值运算 |
=、+=、-=、*=、/=、%= |
|
| 16 |
位赋值运算 |
&=、|=、<<=、>>=、>>>= |
|
如果在程序中，要改变运算顺序，可以使用()。
第三章 流量控制与数组
一.程序的三种结构
顺序结构：自上而下的逐行执行代码。
选择(分支)结构：根据逻辑判断，有选择的执行其中某部分代码。
循环结构：根据逻辑判断，重复执行某个代码块。
二.顺序结构程序设计
前面案例中代码块中没有用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]
}
}
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
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
//交换
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]); //3 b[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
}
}