命名规范
// 违反标识符规则声明变量的举例
// 例子1：使用的%不属于允许使用的范围
// int age%me = 5;
// 例子2：不能以数字开头
// int 2age = 50;
// 例子3：不能包含空格
// int age student = 33;
// 例子4：严格区分大小写
// int salary = 10;
// System.out.println(Salary);
java八大类型
// byte类型变量
byte b = 25;
System.out.println(b);
// short类型变量
short s = 1000;
System.out.println(s);
// int类型变量
int i = 500000;
System.out.println(i);
// long类型变量
long l = 60000000;
System.out.println(l);
// float类型变量
float f = 666.66f;
System.out.println(f);
// double类型变量
double d = 777.77;
System.out.println(d);
// boolean类型变量
boolean flag = true;
System.out.println(flag);
// char类型变量
char c = 'x';
System.out.println(c);
print与println
// 带有换行效果的输出
System.out.println("hello java换行");
// 不带有换行效果的输出
System.out.print("hello java不换行");
// 调用println()函数时不传参数，代表仅执行换行操作
// System.out.println();
System.out.print("hello java不换行");
// 调用print()函数时不传参数，将导致编译错误
// System.out.print();
// 输出十进制数
System.out.println(10);
// 输出二进制数
System.out.println(0B10);
// 输出八进制数
System.out.println(010);
// 输出十六进制数
System.out.println(0x10);
java类型转换
// 测试类型自动转换
byte b = 100;
int i = b;
int code = 'W';
double number = 100;
// 不兼容的类型: 从int转换到byte可能会有损失
// byte myByte = 130;
// 多种不同类型数据在一起运算时，会自动转换为最大的类型
byte byteNumber = 10;
short shortNumber = 20;
int intNumber = 30;
// 不兼容的类型: 从int转换到byte可能会有损失
// byte sum = byteNumber + shortNumber + intNumber;
// short sum = byteNumber + shortNumber + intNumber;
int sum = byteNumber + shortNumber + intNumber;
// byte、short、char运算时按照int类型处理
// byte b1 = 5;
// byte b2 = 6;
// byte sumByte = b1 + b2;
char c1 = 'a';
char c2 = 'b';
// 连接两个char类型的+号，执行的是数学的加法运算
System.out.println(c1 + c2);
// 测试强制类型转换
byte byteValue = (byte)100L;
long longValue = 100;
int intValue = (int)longValue;
// 小数类型转换为整数类型时会直接舍弃小数部分
double doubleValue = 3.9415926;
int convertDouble = (int)doubleValue;
System.out.println("convertDouble："+convertDouble);
// 超出数据存储范围的强制转换会溢出
int intOriginalValue = 300;
byte byteCurrentValue = (byte)intOriginalValue;
System.out.println(byteCurrentValue);
// 对布尔类型进行强制转换
// 编译报错：不兼容的类型: boolean无法转换为int
// int fromBoolean = (int)true;
// 先做数学的加法，得到15，然后再做字符串连接
System.out.println(5 + 10 + "abc");
// 整体就都是字符串连接
// "abc" + 5是字符串连接操作，结果是"abc5"这个字符串
// "abc5"这个字符串再和10做字符串连接，得到"abc510"这个字符串
System.out.println("abc" + 5 + 10);
// 任何数据类型想转换为字符串类型，最简单的办法就是和""做字符串连接
String doubleStr = "" + 100.33;
System.out.println(doubleStr);
// 字符串想转换为基本数据类型不能直接强转
// 编译报错：不兼容的类型: String无法转换为int
// int x = (int)"123";
// 需要调用包装类型的方法来转换——这个后面才正式学
int x = Integer.parseInt("123");
System.out.println(x);
int feng = 1;
int jie = 2;
// 先按照int类型做除法运算，算出来还是转换为int类型，所以也就是把0.5转为int，所以结果是0
// 把int类型的0再转换为double，只能是0.0
// double result = feng/jie;
// 先把feng转换为double，jie会自动升级为更大的double类型，所以最终是按照double类型做除法
// 算出来是0.5
double result = (double)feng/jie;
System.out.println(result);
++i与i++
int i1 = 10;
int i2 = 20;
int i = i1++; // i是10 i1是11
System.out.print("i="+i+" "); // 10
System.out.println("i1="+i1); // 11
i = ++i1; // i是12 i1是12
System.out.print("i="+i+" "); // 12
System.out.println("i1="+i1); // 12
i = i2--; // i是20 i2是19
System.out.print("i="+i+" "); // 20
System.out.println("i2="+i2); // 19
i = --i2; // i是18 i2是18
System.out.print("i="+i+" "); // 18
System.out.println("i2="+i2); // 18
运算
// 设定一个三位数：962
int originalValue = 962;
// 要取百位数，直接让三位数除以100即可
int hundredValue = originalValue / 100;
// 要取十位数，先让三位数对100取模，这个模运算的结果就是一个两位数了
// 两位数除以10就是十位的数字
int tenValue = originalValue % 100 / 10;
// 要取个位数，先让三位数对10取模，这个模运算的结果就是一个个位数了
int singleValue = originalValue % 10;
System.out.println("百位数=" + hundredValue);
System.out.println("十位数=" + tenValue);
System.out.println("个位数=" + singleValue);
三元运算
// 从两个数中返回最大值
int i = 10;
int j = 15;
int result = (i>j)? i : j;
System.out.println("i和j中较大的是："+result);
// 从三个数中返回最大值
// 从前两个中找到最大值，再和第三个比
int m = 66;
int n = 33;
int p = 44;
result = (m > n)? ((m > p)?m:p) : ((n > p)?n:p);
System.out.println("m、n和p中较大的是："+result);
scanner对象
// 1.创建Scanner对象
Scanner scanner = new Scanner(System.in);
// 2.读取int类型数据
System.out.print("请输入一个整数：");
// 调用scanner对象的nextInt()方法
int age = scanner.nextInt();
System.out.println("age="+age);
// 3.读取boolean类型数据
System.out.print("请输入一个布尔值：");
boolean flag = scanner.nextBoolean();
System.out.println("flag="+flag);
// 4.读取字符串
System.out.print("请输入一个字符串：");
// next()方法会因为空格而终止读取
String strValue = scanner.next();
System.out.println("strValue="+strValue);
// 建议使用：
// nextLine()方法不会因为空格而终止读取
strValue = scanner.nextLine();
System.out.println("strValue="+strValue);
if
// 创建Scanner对象
Scanner scanner = new Scanner(System.in);
System.out.print("请输入i：");
int i = scanner.nextInt();
System.out.print("请输入j：");
int j = scanner.nextInt();
// 测试使用单独的if语句
// 当if(判断条件)为true时执行{}中的语句
if (i > j){
System.out.println("i 比 j 大");
}
// 不建议这么做
// 如果if语句块中只有一条语句，可以省略{}
if (i < j)
System.out.println("i 比 j 小");
System.out.println("后续操作");
// 读取一个布尔值
System.out.print("请输入flag：");
boolean flag = scanner.nextBoolean();
// 没有必要写flag == true
if (flag) {
System.out.println("flag是真的");
}
else if
// 创建Scanner对象
Scanner scanner = new Scanner(System.in);
System.out.print("请输入i：");
int i = scanner.nextInt();
System.out.print("请输入j：");
int j = scanner.nextInt();
System.out.print("请输入m：");
int m = scanner.nextInt();
System.out.print("请输入n：");
int n = scanner.nextInt();
if (i > j){ // 执行条件判断①
System.out.println("i 比 j 大"); // ①为true时执行
} else if (i < j) { // ①为false继续执行下一个条件判断②
System.out.println("i 比 j 小"); // ②为true时执行
} else {
System.out.println("i 和 j 相等"); // ②为false时执行
// 嵌套在其他if...else结构内的if
if (m > n){
System.out.println("m 比 n 大");
}
}
withch case
// 创建Scanner对象
Scanner scanner = new Scanner(System.in);
System.out.print("请输入i：");
int i = scanner.nextInt();
System.out.print("请输入j：");
int j = scanner.nextInt();
System.out.print("请输入m：");
int m = scanner.nextInt();
System.out.print("请输入n：");
int n = scanner.nextInt();
if (i > j){ // 执行条件判断①
System.out.println("i 比 j 大"); // ①为true时执行
} else if (i < j) { // ①为false继续执行下一个条件判断②
System.out.println("i 比 j 小"); // ②为true时执行
} else {
System.out.println("i 和 j 相等"); // ②为false时执行
// 嵌套在其他if...else结构内的if
if (m > n){
System.out.println("m 比 n 大");
}
}
do while
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数：");
int userInput = scanner.nextInt();
int positiveCount = 0;
int negativeCount = 0;
do {
if (userInput > 0){
positiveCount++;
}
if (userInput < 0){
negativeCount++;
}
System.out.println("正数的个数："+positiveCount);
System.out.println("负数的个数："+negativeCount);
System.out.print("请输入一个整数：");
userInput = scanner.nextInt();
}while(userInput != 0);
// do...while循环至少会执行一次
// 打印1~10
int i = 1;
do {
System.out.println("i="+i);
i++;
}while(i <= 0);
应用
九九乘法表
System.out.println("左下角的99乘法表");
// 外层循环负责控制『行』
for (int i = 1; i <= 9 ; i++ ) {
// 内层循环负责控制『列』
for ( int j = 1; j <= i ; j++ ){
System.out.print(i + "×" + j + "=" + i * j + "\t");
}
System.out.println();
}
System.out.println("=============================================");
System.out.println();
System.out.println("左上角的99乘法表");
// 外层循环负责控制『行』
for (int i = 1; i <= 9 ; i++ ) {
// 内层循环负责控制『列』
for ( int j = 9; j >= i ; j-- ){
System.out.print(i + "×" + j + "=" + i * j + "\t");
}
System.out.println();
}
System.out.println("=============================================");
System.out.println();
System.out.println("右上角的99乘法表");
// 外层循环负责控制『行』
for (int i = 9; i >= 1 ; i-- ) {
// 内层循环负责控制『列』
for ( int j = 9; j >= 1 ; j-- ){
if (j > i) {
System.out.print("\t");
}else{
System.out.print(i + "×" + j + "=" + i * j + "\t");
}
}
System.out.println();
}
System.out.println("=============================================");
System.out.println();
System.out.println("右下角的99乘法表");
// 外层循环负责控制『行』
for (int i = 1; i <= 9 ; i++ ) {
// 为了让打印的数据靠右对齐，专门打印所需个数的\t
for ( int t = 1; t <= 9-i; t++ ){
System.out.print("\t");
}
// 保持不变
// 内层循环负责控制『列』
for ( int j = 1; j <= i ; j++ ){
System.out.print(i + "×" + j + "=" + i * j + "\t");
}
System.out.println();
}
breakLabel
System.out.println("外层循环执行开始了");
a: for (int k = 1; k <= 10; k++){
System.out.println("内层循环执行开始了");
b: for (int i = 1; i <= 10; i++){
if ( i == 5 ){
break;
}
if ( k == 6 ){
// 通过标号结束外层循环
break a;
}
System.out.println("k = " + k + " i = " + i);
}
System.out.println("内层循环执行结束了");
}
System.out.println("外层循环执行结束了");
switch
for (int i = 1; i <= 10; i++){
switch(i){
case 2:
System.out.println("switch i="+i);
break;
case 3:
System.out.println("switch i="+i);
break;
case 4:
System.out.println("switch i="+i);
break;
}
System.out.println("for i="+i);
}
continueLabel
a: for (int i = 1; i <= 10; i++){
b: for (int j = 1; j <= 10; j++){
if (i == 5) {
// 使用标号可以控制标号对应的循环
continue b;
}
System.out.println(i+","+j);
}
}
return
for (int i = 1; i <= 10; i++){
System.out.println("i="+i);
if (i == 6){
return ;
}
}
// 由于整个函数结束了，所以这里的代码不会被执行到
System.out.println("循环后面的代码");
}
实例
/**
查找100以内的所有素数
素数的概念：对于大于1的整数，只能被1和它自己整除
*/
public class Demo08FindPrimeNumber {
public static void main(String[] args){
// 外层循环：列出从2开始到100的所有的数字
for (int i = 2; i <= 100; i++){
// 声明一个变量，用来保存当前数字是否为素数
// 默认情况：先设置为true，后面再使用内层循环进行排除
boolean primeFlag = true;
// 内层循环验证i变量中保存的这个数是不是素数
// 验证方式：用i对『从2到i/2』的所有数取模
// 如果发现能够整除，那么说明i这个数不是素数
for (int j = 2; j <= i/2; j++){
if (i % j == 0){
// 发现i能够被j整除时，说明i不是素数，所以直接将primeFlag变量设置为false
primeFlag = false;
// 由于i只要能被任何一个j整除，就足矣判断i不是素数，所以后面j后面的值不必再试，这里使用break结束内层循环
break;
}
}
// 如果i真的是素数，那么它就应该在通过上面内层循环的层层考验后还是true
if (primeFlag){
System.out.println("i="+i);
}
}
}
}
public class Demo09FamilyAccount {
public static void main(String[] args){
// 初始化：用户记账金额的初始值设置为10000元
int balance = 10000;
// 初始化：显示收支明细时使用的表头信息（将来在表头字符串后面附加表格详细内容）
String table = "收支\t账户金额\t收支金额\t说 明\n";
// 界面：为了避免用户执行一个菜单项之后就直接退出，所有操作要放在一个死循环中
// （在测试过程中，还没有编写退出功能，使用Ctrl+c强制结束程序）
while (true) {
// 界面：标题
System.out.println("-----------------家庭收支记账软件-----------------");
// 界面：菜单选项
System.out.println("\t\t1 收支明细");
System.out.println("\t\t2 登记收入");
System.out.println("\t\t3 登记支出");
System.out.println("\t\t4 退 出");
// 界面：提示用户输入菜单项的序号：
System.out.print("请输入菜单项的序号：");
// 读取：用户输入的菜单项序号
char menuSelection = Utility.readMenuSelection();
// 系统内部运算：根据用户输入的菜单项，执行对应操作
switch(menuSelection){
case '1':
System.out.println(table);
break;
case '2':
// 界面：提示用户输入收入金额
System.out.print("请输入收入金额：");
int income = Utility.readNumber();
// 界面：提示用户输入收入说明
System.out.print("请输入收入说明：");
String incomeDescription = Utility.readString();
// 测试：System.out.print("收入金额：" + income + " 收入说明：" + incomeDescription);
// 系统内部运算：将收入金额累加到总余额中
balance = balance + income;
// 系统内部运算：将新的收入明细信息附加到表格中
table = table + "收入\t" + balance + "\t\t" + income + "\t\t" + incomeDescription + "\n";
System.out.println("已保存收入登记信息");
break;
case '3':
// 界面：提示用户输入支出金额
System.out.print("请输入支出金额：");
int outcome = Utility.readNumber();
// 界面：提示用户输入支出说明
System.out.print("请输入支出说明：");
String outcomeDescription = Utility.readString();
// 测试：System.out.print("支出金额：" + outcome + " 支出说明：" + outcomeDescription);
// 系统内部运算：将支持金额从总金额中减去
balance = balance - outcome;
// 系统内部运算：将新的支出明细信息附加到表格中
table = table + "支出\t" + balance + "\t\t" + outcome + "\t\t" + outcomeDescription + "\n";
System.out.println("已保存支出登记信息");
break;
case '4':
// 界面：打印信息提示用户输入确认是否退出的字符
System.out.print("确认是否退出(Y/N)：");
char confirmWord = Utility.readConfirmSelection();
// 系统内部运算：如果用户输入的是Y，那么整个程序停止执行即可
if (confirmWord == 'Y') {
return ;
}
break;
}
}
}
}
utility
import java.util.*;
public class Utility {
private static Scanner scanner = new Scanner(System.in);
public static char readMenuSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1);
c = str.charAt(0);
if (c != '1' && c != '2' && c != '3' && c != '4') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
public static int readNumber() {
int n;
for (; ; ) {
String str = readKeyBoard(4);
try {
n = Integer.parseInt(str);
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
public static String readString() {
String str = readKeyBoard(8);
return str;
}
public static char readConfirmSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1).toUpperCase();
c = str.charAt(0);
if (c == 'Y' || c == 'N') {
break;
} else {
System.out.print("选择错误，请重新输入：");
}
}
return c;
}
private static String readKeyBoard(int limit) {
String line = "";
while (scanner.hasNext()) {
line = scanner.nextLine();
if (line.length() < 1 || line.length() > limit) {
System.out.print("输入长度（不大于" + limit + "）错误，请重新输入：");
continue;
}
break;
}
return line;
}
}
数组
初识
int[] arr = new int[]{8,2,1,0,3};
int[] index = new int[]{2,0,3,2,4,0,1,3,2,3,3};
String tel = "";
for(int i = 0;i < index.length;i++){
tel += arr[index[i]];
System.out.println(index[i]);
System.out.println("tel:"+tel);
}
System.out.println("联系方式：" + tel);
}
// 1.创建数组保存星期N的英语单词
String[] weekArray = new String[7];
weekArray[0] = "Monday";
weekArray[1] = "Tuesday";
weekArray[2] = "Wednesday";
weekArray[3] = "Thursday";
weekArray[4] = "Friday";
weekArray[5] = "Saturday";
weekArray[6] = "Sunday";
// 2.读取用户的键盘输入
Scanner scanner = new Scanner(System.in);
System.out.print("请输入1~7数字：");
int number = scanner.nextInt();
// 3.根据用户输入的数字从数组中取值
// 注意：用户输入的数字-1是数组下标
String week = weekArray[number - 1];
System.out.println("week = " + week);
简单应用1
// 创建数组对象用来保存评委打分成绩
int[] scoreArray = {5,4,6,8,9,0,1,2,7,3};
// 声明两个变量，用于保存打分数据中的最大值和最小值
// maxScore和minScore的初始值应该是数组中的某一个元素
// 以minScore为例，如果初始值为0，原始数组中所有数值都比0大，则无法正确找到真正的最小值
int maxScore = scoreArray[0];
int minScore = scoreArray[0];
// 遍历数组，获取每一个具体的分数
for (int i = 0; i < scoreArray.length; i++) {
// 获取每一个数组元素
int score = scoreArray[i];
// 拿当前遍历得到的元素和maxScore进行比较
if (score > maxScore) {
// 如果当前元素大于maxScore，则将当前元素赋值给maxScore
maxScore = score;
}
// 拿当前遍历得到的元素和minScore进行比较
if (score < minScore) {
// 如果当前元素小于minScore，则将当前元素赋值给minScore
minScore = score;
}
}
System.out.println("minScore = " + minScore);
System.out.println("maxScore = " + maxScore);
// 声明变量用来保存累加的结果
int sum = 0;
// 为了求平均值，需要再遍历一次
for (int i = 0; i < scoreArray.length; i++) {
int score = scoreArray[i];
// 如果遇到最高分或最低分就跳过累加，那么就会将所有最高分跳过
// 极限情况下，所有分数都是最高分时，所有分数都会跳过，
// 最终的平均值就是0，这个结果显然是错误的
// 最低分同理
// 结论：不能无脑跳过
// if (score == maxScore) {
// continue;
// }
//
// if (score == minScore) {
// continue;
// }
sum = sum + score;
}
// 根据评分规则，最高分和最低分分别只去掉一个，所以在上面全部分数累加结果中把最高分和最低分减去即可
// 累加结果除以8得到平均值
double average = (sum - maxScore - minScore) / 8.0;
System.out.println("average = " + average);
简单应用2
// 通过把字符类型的数据强转成int类型可以查看字符底层的编码值
// System.out.println((int)'a');
// 创建字符数组用来保存26个英文字母
char[] wordArray = new char[26];
// 从0~25遍历数组，给数组元素赋值
for (int i = 0; i <= 25; i++) {
wordArray[i] = (char) (i + 97);
// System.out.println("wordArray["+i+"] = " + wordArray[i]);
}
// ---------------------------------
// 遍历字母数组，显示当前元素的同时还打印它对应的大写字母
for (int i = 0; i <= 25; i++) {
char word = wordArray[i];
// 将当前字符-32得到对应的大写字母
char upperWord = (char) (word - 32);
System.out.println("小写字母：" + word + " 大写字母：" + upperWord);
}
简单应用3
// 一、根据用户输入的数据创建数组对象
// 1.创建Scanner对象
Scanner scanner = new Scanner(System.in);
// 2.读取用户输入的学生人数
System.out.print("请输入学生人数：");
int studentCount = scanner.nextInt();
// 3.根据用户输入的学生人数创建数组对象（以学生人数作为数组长度）
int[] scoreArray = new int[studentCount];
// 4.将用户输入的学生成绩保存到数组中
for (int i = 0; i < studentCount; i++) {
// 5.读取用户输入
System.out.print("请输入第" + (i + 1) + "位学生成绩：");
int score = scanner.nextInt();
// 6.将学生成绩存入数组下标对应的位置
scoreArray[i] = score;
}
// 二、查找已输入数据中的最大值
// 1.声明一个变量用来存储最大值
// 为什么最大值变量的初始值设置为scoreArray[0]？
// 假设成绩是：-10,-20,-30
// 假设maxScore是：0
// 最大值是：0
int maxScore = scoreArray[0];
// 2.遍历成绩数组
for (int i = 0; i < scoreArray.length; i++) {
// 3.获取当前成绩数据
int score = scoreArray[i];
// 4.检查当前成绩是否大于maxScore
if (score > maxScore) {
// 5.如果当前成绩大于maxScore，就把maxScore设置为当前成绩
maxScore = score;
}
}
System.out.println("maxScore = " + maxScore);
// 三、按照等级打印学生成绩
// 1.遍历学生成绩数组
for (int i = 0; i < scoreArray.length; i++) {
// 2.获取当前成绩数据
int score = scoreArray[i];
// 3.逐级判断当前成绩数据属于哪个等级
if (score > maxScore - 10) {
System.out.println("第" + (i+1) + "位学生的成绩" + score + "是A级");
} else if (score > maxScore - 20) {
System.out.println("第" + (i+1) + "位学生的成绩" + score + "是B级");
} else if (score > maxScore - 30) {
System.out.println("第" + (i+1) + "位学生的成绩" + score + "是C级");
} else {
System.out.println("第" + (i+1) + "位学生的成绩" + score + "是D级");
}
二维数组
// 1.创建二维数组，第一维长度为10
int[][] yanghuiArr = new int[10][];
// 2.通过双层for循环给二维数组填充数据
for (int i = 0; i < yanghuiArr.length; i++) {
// 3.创建一维数组，对yanghuiArr下标i位置进行初始化
yanghuiArr[i] = new int[ i + 1 ];
// 4.遍历一维数组，填充数据
for (int j = 0; j <= i; j++) {
// 5.一头（一维数组的下标0元素）一尾（一维数组的下标长度-1元素）固定就是1
// 一维数组中最后一个元素的下标正好就是现在外层循环变量：i
if (j == 0 || j == i) {
yanghuiArr[i][j] = 1;
} else {
// 6.非头尾的元素，由上一行中两个元素相加得到
// 第一个值的下标：[i-1][j-1]
// 第二个值的下标：[i-1][j]
yanghuiArr[i][j] = yanghuiArr[i-1][j-1] + yanghuiArr[i-1][j];
}
}
}
// 7.遍历填充数据的二维数组
for (int i = 0; i < yanghuiArr.length; i++) {
int[] yanghuiValueArr = yanghuiArr[i];
for (int j = 0; j < yanghuiValueArr.length; j++) {
System.out.print(yanghuiValueArr[j] + "\t");
}
System.out.println();
}
// 一、声明二维数组变量并创建二维数组对象
// 格式1：动态初始化——创建数组对象时就指定了两个维度的数组长度
int[][] arr2d01 = new int[3][2];
arr2d01[0][0] = 100;
arr2d01[0][1] = 101;
arr2d01[1][0] = 102;
arr2d01[1][1] = 103;
arr2d01[2][0] = 104;
arr2d01[2][1] = 105;
// 格式2：动态初始化——仅指定第一个维度的数组长度
int[][] arr2d02 = new int[3][];
// Java中多维数组不必都是规则矩阵形式
arr2d02[0] = new int[]{3, 5, 7};
arr2d02[1] = new int[]{14, 21, 66, 89};
arr2d02[2] = new int[]{90, 100};
System.out.println();
// 格式3：静态初始化——在创建对象时将数据填充
// 此时如果某个元素位置设置为null不会编译报错，但是访问这个位置时还是要先初始化
int[][] arr2d03 = new int[][]{{1,2,3}, {4,5}, null, {6,7,8}};
// 前面设置null的地方，需要初始化才可以访问
arr2d03[2] = new int[]{12,24};
arr2d03[2][0] = 5;
// 格式4：声明变量时，两层[]没在一起
int[] arr2d04[] = new int[][]{{1,2,3}, {4,5}, {6,7,8}};
// 二、访问二维数组元素（读、写）
int[][] arr2d05 = new int[2][2];
// 向数组元素写入数据
arr2d05[1][0] = 10;
// 读取数组元素
System.out.println("arr2d05[1][0] = " + arr2d05[1][0]);
// 三、遍历二维数组：需要使用双层嵌套的循环
int[][] arr2d06 = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
// 先遍历第一个维度：取出每一个一维数组
for (int i = 0; i < arr2d06.length; i++) {
int[] intArr = arr2d06[i];
for (int j = 0; j < intArr.length; j++) {
int intValue = intArr[j];
System.out.println("intValue["+i+"]["+j+"] = " + intValue);
}
}
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
