- 1. Java 基本语法
- 2. 本章内容2.1 关键字
2.2 标识符
2.3 变 量
2.4 进制
2.5 运算符
2.6 流程控制
选择结构
循环结构
2.7 数组
一维数组
多维数组
- 3. 本章内容2.1 关键字
2.2 标识符
2.3 变 量
2.4 进制
2.5 运算符
2.6 流程控制
选择结构
循环结构
2.7 数组
一维数组
多维数组
- 4. 关键字关键字的定义和特点
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写
用于定义数据类型的关键字classinterfaceenumbyteshortintlongfloatdoublecharbooleanvoid用于定义数据类型值的关键字truefalsenull用于定义流程控制的关键字ifelseswitchcasedefaultwhiledoforbreakcontinuereturn
- 5. 关键字用于定义访问权限修饰符的关键字privateprotectedpublic用于定义类，函数，变量修饰符的关键字abstractfinalstaticsynchronized用于定义类与类之间关系的关键字extendsimplements用于定义建立实例及引用实例，判断实例的关键字newthissuperinstanceof用于异常处理的关键字trycatchfinallythrowthrows用于包的关键字packageimport其他修饰符关键字nativestrictfptransientvolatileassert
- 6. 标识符标识符：
Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
凡是自己可以起名字的地方都叫标识符。
定义合法标识符规则：
由26个英文字母大小写，数字：0-9 ，_或 $ 组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。
注意：在起名字的时，为了提高阅读性，要尽量有意义，“见名知意”。&abc
2abc
class
class1
Animal
animal
last name
a
age
- 7. Java中的名称命名规范Java中的名称命名规范：
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
lastName
userName
surveyName
orderName
- 8. 变量变量的概念：
内存中的一个存储区域
该区域有自己的名称（变量名）和类型（数据类型）
Java中每个变量必须先声明，后使用
该区域的数据可以在同一类型范围内不断变化
定义变量的格式：数据类型 变量名 = 初始化值
变量是通过使用变量名来访问这块区域的
Java是强类型语言，每个变量必须先声明类型，后使用.
使用变量注意：
变量的作用域：一对{ }之间有效
15.2int 类型a
- 9. 变量的分类按被声明的位置划分：
成员变量：方法外部、类的内部定义的变量
局部变量：方法或语句块内部定义的变量
注意：类外面（类对应的大括号外面）不能有变量的声明
按所属的数据类型划分：
基本数据类型变量
引用数据类型变量
- 10. 变量的分类-按数据类型对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。数据类型 基本
数据类型 引用
数据类型数值型字符型(char)布尔型(boolean)整数类型(byte,short,int,long)浮点类型(float,double)类(class)接口(interface)数组([ ])字符串在这里
- 11. a堆栈12int a = 12;
char c = ‘m’;mcString str = “abcde”;abcde0x2244str
- 12. 整数类型：byte、short、int、longJava各整数类型有固定的表数范围和字段长度，不受具体 OS 的影响，以保证 java 程序的可移植性。
Java 的整型常量默认为 int 型，声明 long 型常量须后加 ‘l’ 或 ‘L’
类 型占用存储空间表数范围byte1字节-128 ~ 127short2字节-215 ~215-1 int4字节-231 ~ 231-1long8字节-263 ~ 263-1
- 13. 浮点类型：float、double与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体OS的影响。
Java 的浮点型常量默认为 double 型，声明 float 型常量，须后加 ‘f’ 或 ‘F’。
浮点型常量有两种表示形式：
十进制数形式：如：5.12 512.0f .512 (必须有小数点）
科学计数法形式:如：5.12e2 512E2 100E-2类 型占用存储空间表数范围单精度float4字节-3.403E38 ~ 3.403E38双精度double8字节-1.798E308 ~ 1.798E308
- 14. 字符类型：charchar 型数据用来表示通常意义上"字符"。
字符型常量的三种表现形式：
字符常量是用单引号(‘ ’)括起来的单个字符，涵盖世界上所有书面语的字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = '\n'; -- '\n'表示换行符
直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。
char 类型是可以进行运算的。因为它都对应有 Unicode 值。
- 15. 布尔类型：booleanboolean 类型适于逻辑运算，一般用于程序流程控制：
if条件控制语句；
while循环控制语句；
do-while循环控制语句；
for循环控制语句；
boolean类型数据只允许取值true和false，不可以0或非 0 的整数替代true和false，这点和C语言不同。
- 16. 基本数据类型转换自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：
有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
当把任何基本类型的值和字符串值进行连接运算时(+)，基本类型的值将自动转化为字符串类型。
charbyteshortintlongfloatdouble
- 17. 强制类型转换自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符（()），但可能造成精度降低或溢出,格外要注意。
通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。如： String a = “43”; int i = Integer.parseInt(a);
boolean类型不可以转换为其它的数据类型。
- 18. 本章内容2.1 关键字
2.2 标识符
2.3 变 量
2.4 进制
2.5 运算符
2.6 流程控制
选择结构
循环结构
2.7 数组
一维数组
多维数组
- 19. 进 制对于整数，有四种表示方式：
二进制：0,1 ，满 2 进 1.以 0b 或 0B 开头。
十进制：0-9 ，满 10 进 1.
八进制：0-7 ，满 8 进1. 以数字 0 开头表示。
十六进制：0-9 及 A-F，满 16 进1. 以 0x 或 0X开头表示。此处的A-F不区分大小写。
- 20. 进 制所有数字在计算机底层都以二进制形式存在。
计算机以补码的形式保存所有的整数。
正数的补码与其原码相同；负数的补码是在其反码的末位加1。
原码：直接将一个数值换成二进制数。
反码：是对原码按位取反，只是最高位（符号位）保持不变。
Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位
- 21. byte 的范围：-128 ~ 127000000011000000111111110-1 的源码最小的正数：20 。源码即为其补码 反码11111111-1 的补码011111111111111110000000-127的源码最大的正数：127。源码即为其补码 反码10000001-127 的补码10000000最小的负数 -128 的补码
- 22. 进 制制的基本转换
十进制 二进制互转
十进制转成二进制 除以2取余数
二进制转成十进制 乘以2的幂数
二进制 八进制互转
二进制 十六进制互转
十进制 八进制互转
十进制 十六进制互转
- 23. 123510123510123101210十进制转成二进制 除以2取余数17281240220211111235 = 5 * 10^0 + 3 * 10^1 + 2 * 10^2 + 1 * 10^315 = 1 * 2^0 + 1 * 2^1 + 1 * 2^2 + 1 * 2^3二进制转成十进制 乘以2的幂数01120
- 24. 运算符算术运算符
赋值运算符
比较运算符（关系运算符）
逻辑运算符
位运算符
三元运算符
- 25. 算术运算符运算符运算范例结果+正号+33-负号b=4; -b-4+加5+510-减6-42*乘3*412/除5/51%取模5%50++
++自增（前）：先运算后取值
自增（后）：先取值后运算a=2;b=++a;
a=2;b=a++;a=3;b=3
a=3;b=2- -
- -自减（前）：先运算后取值
自减（后）：先取值后运算a=2;b=- -a
a=2;b=a- -a=1;b=1
a=1;b=2+字符串相加“He”+”llo”“Hello”
- 26. 算术运算符的注意问题如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数就另当别论。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。 例如：int x=3510;x=x/1000*1000; x的结果是？
“+”除字符串相加功能外，还能把非字符串转换成 字符串.例如：System.out.println("5+5="+5+5); //打印结果是？
- 27. 赋值运算符符号：=
扩展赋值运算符： +=, -=, *=, /=, %=
- 28. 比较运算符注1：比较运算符的结果都是boolean型，也就是要么是true，要么是false。
注2：比较运算符“==”不能误写成“=” 。
运算符运算 范例 结果==相等于 4==3 false!=不等于 4!=3 true<小于 4<3 false>大于 4>3 true<=小于等于 4<=3 false>=大于等于 4>=3 falseinstanceof检查是否是类的对象 “Hello” instanceof String true
- 29. 逻辑运算符运算符运算范例结果&AND(与)false & truefalse|OR(或)false|truetrue^XOR(异或)true^falsetrue!Not(非)!truefalse&&AND(短路)false&&truefalse||OR(短路)false||truetrue
- 30. 逻辑运算符逻辑运算符用于连接布尔型表达式，在Java中不可以写成33 && x<6 。
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
和“||”的区别同理，双或时，左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：对于 ^ 而言，当左右都为true时，结果为false。
- 31. 位运算符位运算符的细节<<被移除的高位丢弃，空缺位补0。>>被移位的二进制最高位是0，右移后，空缺位补0；
最高位是1，空缺位补1。>>>被移位二进制最高位无论是0或者是1，空缺位都用0补。&二进制位进行&运算，只有1&1时结果是1，否则是0;|二进制位进行 | 运算，只有0 | 0时结果是0，否则是1;^相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0
不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1
- 32. 位运算符位运算是直接对二进制进行运算 位运算符运算符运算范例<<左移3 << 2 = 12 --> 3*2*2=12>>右移3 >> 1 = 1 --> 3/2=1>>>无符号右移3 >>> 1 = 1 --> 3/2=1&与运算6 & 3 = 2|或运算6 | 3 = 7^异或运算6 ^ 3 = 5~反码~6 = -7
- 33. 三元运算符格式:
(条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
- 34. 本章内容2.1 关键字
2.2 标识符
2.3 变 量
2.4 进制
2.5 运算符
2.6 流程控制
选择结构
循环结构
2.7 数组
一维数组
多维数组
- 35. 分支语句分支语句根据一定的条件有选择地执行或跳过特定的语句
Java分支语句分类
if-else 语句
switch 语句
- 36. if-else语句语法格式 if(布尔表达式){
语句或语句块;
}
if(布尔表达式) {
语句或语句块;
}
else if(布尔表达式){
语句或语句块;
}else {
语句或语句块;
}
- 37. if-else语句应用举例
public class TestAge{
public static void main(String args[]){
TestAge t = new TestAge();
t.age(75);
}
public void age(int age){
if (age< 0) {
System.out.println("不可能！");
} else if (age>250) {
System.out.println("是个妖怪！");
} else {
System.out.println("此人芳龄 " + age +
" 马马乎乎啦！");
}
}
}
- 38. if语句练习(1)编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else),并且从小到大输出。
- 39. if语句练习(2)对下列代码，若有输出，指出输出结果。
int x=2;
int y=3;
if(x>2)
{
if(y>2)
{
int z=x+y;
System.out.println(“z is ”+z);
}
}else
System.out.println(“x is ”+x);
- 40. switch语句语法格式 switch(表达式){
case 常量1:
语句1;
break;
case 常量2:
语句2;
break;
… …
case 常量N:
语句N;
break;
[default:
语句;
break;]
}
- 41. switch语句应用举例 public class Test{
public static void main(String args[]){
int i = 1;
switch (i) {
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
//break;
default:
System.out.println("default");
break;
}
}
}
- 42. switch语句有关规则switch(表达式)中表达式的返回值必须是下述几种类型之一：int, byte, char, short, 枚举, 字符串；
case子句中的值必须是常量，且所有case子句中的值应是不同的；
default子句是任选的；
break语句用来在执行完一个case分支后使程序跳出switch语句块；
- 43. switch语句练习(1)使用switch语句改写下列if语句：
int a = 3;
int x = 100;
if(a==1)
x+=5;
else if(a==2)
x+=10;
else if(a==3)
x+=16;
else if(a==4)
x+=34;
else
x += 100;
- 44. switch语句练习(2)编写程序：从键盘上读入一个学生成绩，存放在变量score中，根据score的值输出其对应的成绩等级：
score>=90 等级：A
70=
- 45. 本章内容2.1 关键字
2.2 标识符
2.3 变 量
2.4 进制
2.5 运算符
2.6 流程控制
选择结构
循环结构
2.7 数组
一维数组
多维数组
- 46. 循环语句循环语句功能
在循环条件满足的情况下，反复执行特定代码
循环语句的四个组成部分
初始化部分（init_statement）
循环条件部分（test_exp）
循环体部分（body_statement）
迭代部分（alter_statement）
循环语句分类
for 循环
while 循环
do/while 循环
- 47. for 循环语句语法格式
for (初始化表达式; 布尔值测试表达式; 更改表达式)｛
语句或语句块；
｝
应用举例
public class ForLoop {
public static void main(String args[]){
int result = 0;
for(int i=1; i<=100; i++) {
result += i;
}
System.out.println("result=" + result);
}
}
- 48. ①②③④⑤
- 49. for语句练习编写程序FooBizBaz.java，从1循环到150并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。1
2
3 foo
4
5 biz
6 foo
7 baz
…
15 foo biz
….
105 foo biz baz
…
- 50. while 循环语句语法格式
[初始化语句]
while( 布尔值测试表达式)｛
语句或语句块;
[更改语句;]
}
应用举例
public class WhileLoop {
public static void main(String args[]){
int result = 0;
int i=1;
while(i<=100) {
result += i;
i++;
}
System.out.println("result=" + result);
}
}
- 51. do/while 循环语句语法格式
[初始化语句]
do｛
语句或语句块;
[更改语句;]
｝while(布尔值测试表达式);
应用举例
public class WhileLoop {
public static void main(String args[]){
int result = 0, i=1;
do{
result += i;
i++;
}while(i<=100);
System.out.println("result=" + result);
}
}
- 52. while、do/while语句练习编写程序：求1到100之间所有偶数的和。用while语句分别完成。
编写程序：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
- 53. 特殊流程控制语句break 语句
break语句用于终止某个语句块的执行
{ ……
break;
……
}
break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
label1: { ……
label2: { ……
label3: { ……
break label2;
……
}
}
}
- 54. 特殊流程控制语句break 语句用法举例
public class TestBreak{
public static void main(String args[]){
for(int i = 0; i<10; i++){
if(i==3)
break;
System.out.println(" i =" + i);
}
System.out.println("Game Over!");
}
}
- 55. 特殊流程控制语句continue 语句
continue语句用于跳过某个循环语句块的一次执行
continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
continue语句用法举例1
public class ContinueTest {
public static void main(String args[]){
for (int i = 0; i < 100; i++) {
if (i%10==0)
continue;
System.out.println(i);
}
}
}
- 56. i=1
- 57. 特殊流程控制语句说明break只能用于switch语句和循环语句中。
continue 只能用于循环语句中。
标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
break和continue之后不能有其他的语句，因为程序永远不会执行break 和 continue之后的语句。
- 58. 本章内容2.1 关键字
2.2 标识符
2.3 变 量
2.4 进制
2.5 运算符
2.6 流程控制
选择结构
循环结构
2.7 数组
使用 Eclipse
一维数组
多维数组
- 59. 使用 EclipseEclipse 是目前最流行的 Java IDE（Integrated Development Environment，集成开发环境）
下载：http://www.eclipse.org/downloads/
安装：直接解压到非中文目录下即可。
- 60. 数组概述数组是多个相同类型数据的组合，实现对这些数据的统一管理
数组属引用类型，数组型数据是对象(Object)，数组中的每个元素相当于该对象的成员变量
数组中的元素可以是任何数据类型，包括基本类型和引用类型
- 61. 一维数组声明一维数组的声明方式： type var[] 或 type[] var；
例如：
int a[];
int[] a1;
double b[];
Mydate []c; //对象数组
Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法
- 62. a堆栈ox2233
- 63. 数组元素的引用Java中使用关键字 new 创建数组对象
定义并用运算符 new 为之分配空间后，才可以引用数组中的每个元素；
数组元素的引用方式：数组名[数组元素下标]
数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 - n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
每个数组都有一个属性 length 指明它的长度，例如：a.length 指明数组 a 的长度(元素个数)
- 64. 数组元素的默认初始化数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如：
public class Test {
public static void main(String argv[]){
int a[]= new int[5];
System.out.println(a[3]); //a[3]的默认值为0
}
}
- 65. 数组元素的默认初始值数组元素类型
- 66. 创建基本数据类型数组 (1) public class Test{
public static void main(String args[]){
int[] s;
s = new int[10];
for ( int i=0; i<10; i++ ) {
s[i] =2*i+1;
System.out.println(s[i]);
}
}
} Java中使用关键字new 创建数组对象
创建基本数据类型一维数组对象演示1main栈内存s堆内存处内存状态
- 67. 创建基本数据类型一维数组对象演示2main栈内存ox1122s0int[]对象000000000堆内存处内存状态 public class Test{
public static void main(String args[]){
int[] s;
s = new int[10];
//int[] s=new int[10];
//基本数据类型数组如果没有赋初值，
//Java自动给他们赋默认值。
for ( int i=0; i<10; i++ ) {
s[i] =2*i+1;
System.out.println(s[i]);
}
}
}创建基本数据类型数组 (2)
- 68. main栈内存s1int[]对象35791113151719堆内存 public class Test{
public static void main(String args[]){
int[] s;
s = new int[10];
for ( int i=0; i<10; i++ ) {
s[i] =2*i+1;
System.out.println(s[i]);
}
}
}处内存状态 创建基本数据类型一维数组对象演示3创建基本数据类型数组 (3)
- 69. 创建对象数组 (1) 创建元素为引用类型(对象)的数组class MyDate{
private int day;
private int month;
private int year;
public MyDate(int d, int m, int y){
day = d; month = m; year = y;
}
public void display(){
System.out.println(day + "-" + month + "-" + year);
}
}
- 70. public class Test{
public static void main(String args[]){
MyDate[] m;
m = new MyDate[10];
for ( int i=0; i<10; i++ ) {
m[i] =new MyDate(i+1, i+1,1990+i);
m[i].display();
}
}
}main栈内存m堆内存 创建元素为引用类型(对象)的数组演示处内存状态创建对象数组 (2)
- 71. main栈内存mnullMyDate[]对象nullnullnullnullnullnullnullnullnull堆内存处存状态 创建元素为引用类型(对象)的数组演示创建对象数组 (3) public class Test{
public static void main(String args[]){
MyDate[] m;
m = new MyDate[10];
for ( int i=0; i<10; i++ ) {
m[i] =new MyDate(i+1, i+1,1990+i);
m[i].display();
}
}
}
- 72. Java中使用关键字new 创建数组对象main栈内存m*****MyDate[]对象**********nullnullnullnull
nullnullnull堆内存111990221991331992for循环执行三次后内存状态创建对象数组 (4) public class Test{
public static void main(String args[]){
MyDate[] m;
m = new MyDate[10];
for ( int i=0; i<10; i++ ) {
m[i] =new MyDate(i+1, i+1,1990+i);
m[i].display();
}
}
}
- 73. 数组初始化 动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。MyDate dates[];
dates = new MyDate[3];
dates[0] = new MyDate(22, 7, 1964);
dates[1] = new MyDate(1, 1, 2000);
dates[2] = new MyDate(22, 12, 1964);int a[];
a = new int[3];
a[0] = 3;
a[1] = 9;
a[2] = 8;
- 74. 数组初始化 静态初始化：在定义数组的同时就为数组元素分配空间并赋值。int a[] = { 3, 9, 8};
MyDate dates[] = {
new MyDate(22, 7, 1964),
new MyDate(1, 1, 2000),
new MyDate(22, 12, 1964)
};
- 75. 练习11.(1)定义类Pritimive，在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。数组元素未赋值。
定义类Array1，在Array1的main()方法中创建Pritimive对象d，输出其成员变量t的三个元素值。
练习目的：检验基本数据类型数组创建时的自动赋值。
(2)给对象d的成员变量t赋值为{true,true,true}，并输出t的三个元素值。
2.从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为’A’ 成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’ 其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。创建20个学生对象，学号为1到20，年级和成绩都由随机数确定，打印出3年级(state值为3）的学生信息。
提示：生成随机数：Math.randon()，返回值类型double;
四舍五入取整：Math.round()，返回值类型long。
- 76. 2.从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为’A’ 成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’ 其余等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
请输入学生人数:5
请输入5个成绩
56
74
89
41
89
最高分是：89
student 0 score is 56 grade is D
student 1 score is 74 grade is B
student 2 score is 89 grade is A
student 3 score is 41 grade is D
student 4 score is 89 grade is A
- 77. 多维数组 (1)二维数组举例：
int [][] a = {{1,2},{3,4,0,9},{5,6,7}}; i jj = 0j = 1j = 2j = 3i = 012i = 13409i = 2567
- 78. int [][] test = new int[5][];nullnullnullnullnullfor(int j = 0; j < test.length; j++){
//2. 为二维数组的每一个元素(即一维数组)分配内存空间
test[j] = new int[j + 1];
}0x12340x23450x3456nullnull000000
- 79. 多维数组 (2)Java中多维数组被做为数组的数组处理
Java中多维数组的声明和初始化应按从高维到低维的顺序进行
int t [][] = new int [4][];//t有4行，第一个维数不空即可
t[0] = new int[5]; //每一行都是一个有5个元素的一维数组
t[1] = new int[5];
int t1[][] = new int [][4]; //非法
- 80. 多维数组 (3) Java中多维数组不必须是规则矩阵形式
int[][] tt = new int[4][];
tt[0] = new int[2];
tt[1] = new int[4];
tt[2] = new int[6];
tt[3] = new int[8];
int tt[][] = new int[4][5]; //tt是一个4行5列的二维数组
- 81. int [][] aa = new int[4][];
aa[0] = new int[5];
aa[1] = new int[1];
aa[2] = new int[3];
//…
000000000
- 82. 多维数组初始化 静态初始化：
int intArray[][] = {{1,2},{2,3},{3,4,5}};
int intArray1[3][2] = {{1,2},{2,3},{4,5}};
//illegal，等号左边不能指定维数
动态初始化
int a[][] = new int[4][5];
int b[][] = new int[3][]
b[0] = new int[2];
b[1] = new int[3];
b[2] = new int[5];
- 83. 数组排序Java.util.Arrays类的 sort() 方法提供了数组元素排序功能：
import java.util.*;
public class Sort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int [] number = {5,900,1,5,77,30,64,700};
Arrays.sort(number);
for(int i = 0; i < number.length; i++)
System.out.println(number[i]);
}
}
- 84. 练习 23.使用简单数组
(1)创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
- 85. (本页无文本内容)
