——前言——
各位CSDN的朋友大家好，我目前正在从零基础开始学习Java编程语言。我将把我的学习过程在我的博客中记录下来，方便获取和比较学习成果，提升自己的编程水平，并期望在未来成为一名合格的程序员。
我的学习笔记的书本课程来自于：《Thinking in Java》和《Head First Java》
视频课程主要来自于：廖雪峰老师《Java基础课程》
如涉及版权侵犯请联系我更正。
初来乍到，文笔稚嫩，学识浅薄，请多指教。
一、Java基础概念
简介：
1.Java语言是目前世界排名第一的编程语言，拥有强大和丰富的开发者社区支持
2.Java语言广泛应用于企业和互联网后端开发、Android开发和大数据开发中
特点：
1.Java是一种面向对象的编程语言
2.Java语言以字节码的形式在JVM中运行
3.具有良好的跨平台特性，可以胜任多种编程环境
4.Java语言的逻辑简单，运行安全
版本：
1.Java SE：Standard Edition 标准版，主要面向一般开发者和小型开发团队
2.Java EE：Enterprise Edition 企业版，主要面向企业级应用开发
3.Java ME：Micro Edition 移动版，适用于移动终端的Java版本
一些名词解释：
1.JSR（Java Specification Request）——Java开发规范
2.JCP（Java Community ProcessJava）——共享社区
3.RI（Reference Implementation）——参考文献
4.TCK（Technology Compatibility Kit）——技术兼容包
5.JDK（Java Development Kit）——Java开发工具包
6.JRE（Java Runtime Environment）——Java运行环境
开发环境：
1.操作系统：Mac OS X/Windows
2.开发工具：Oracle JDK
3.编译软件：Eclipse等
二、Java程序基础
Java程序基本结构
在Java编程语言中，我们希望通过编程开发出我们需要的计算机程序，来帮助我们解决现实生活中的问题，我们把现实世界中的一切事物都抽象为对象，通过创建不同的类（class）来表示不同的对象，将所有事件产生的方式都抽象为方法（method），将事件产生的结果抽象为计算机程序的输出结果，从而完成整个计算机编程与现实世界相关联的模型搭建。
我们可以将程序的类（class）理解为生物学中的物种分类，即每一个事物都拥有表现各自特点的类别，我们通过创建不同的class来区分我们需要操作或引用的对象的抽象形式。
我们通过不同的方法定义（method）来让程序按照我们希望的逻辑运行，最后输出我们希望得到的结果，从而通过编程解决问题。
Java代码的基本格式：
public class HelloWorld{
public static void main(String[] args){
System.out.println("Hello,World!");
}
}类名的规范和命名习惯
public class HelloWorld{
}
//public是修饰词，HelloWorld是创建的类名1.类名必须是英文字母、数字和下划线组成
2.类名必须以英文字母开头
3.类名的设置需要遵守明明习惯，避免与Java常用的类名冲突
public修饰词
public表示访问修饰符，表示该class是空开的class，如果不编写public也可以完成代码编译，但无法通过命令行去执行代码
方法定义
在class的内部可以定义多个方法，我个人将它理解为实现某个目的的具体做法，有些类似于C语言中的函数的概念，通过定义各种方法， 来帮助我们完成程序所需要的各项功能，无数个定义的类和方法，如同细胞一样构成了各种功能模块最基础的部分
1.在方法定义中，语句是真正的执行代码
2.每一行语句必须以分号结束
3.编译器会自动忽略注释
单行注释以//开头，到当前行尾结束
多行注释以/*…*/表示
特殊多行注释以/**…*/表示，写在类和方法的定义处，可以用来自动创建文档
/**
特殊多行注释
*/
public class 类名{
public static void 方法名 (参数){
//单行注释
}
}
/*多行注释
*多行注释
*/4.static表示静态方法（后面的章节会详细讲解……）
5.Java程序规定的入口代码：
public static void main(String[] args){
}变量和数据类型
变量
public class 类名{
public static void 方法名 (参数){
String s = "Hello,World";
//String表示字符串变量，通过"..."来表示一个字符串
}
}1.定义变量：变量类型（String）变量名称（s）= 初始值（”Hello,World”）
2.变量可以持有某个基本类型的数值，或指向某个对象
3.变量必须先经过定义之后再使用
4.变量可以被重新赋值
5.在Java代码中，等号“=”代表赋值，而非数学意义上的相等，在Java中，用“==”来表示相等含义
基本数据类型
1.整数类型：long,int,short,byte
2.浮点类型：double,float
3.布尔类型：boolean
4.字符类型：char
内部存储单元
1.计算机内存的最小存储单元是字节（byte）
2.一个字节是8位二进制数组成：00000000~11111111（0~255）
3.内存的单元从位置0开始编号，我们称它为内存地址
4.内存占用：
byte：1个字节
short：2个字节
int：4个字节
long：8个字节
float：4个字节
double：8个字节
整数类型
1.byte：8位，1字节，表示-128~+127
2.short：16位，2字节，表示-32768~+32767
3.int：32位，4字节，表示-2147483648~+2147483647
4.long：64位，8字节，long类型需要在数字结尾加“L”标注表示，否则编译器将视为int类型进行处理
浮点数据类型
1.float：32位，4字节，float类型需要在数字结尾加“f”标注表示
2.double：64为，8字节，用来表示较大的浮点数据类型
布尔类型
1.布尔类型只有两个值：true（真）和false（假）
2.布尔类型通常用来判断计算结果的真伪性
字符类型
1.char：保存一个字符
2.这里需要我们明确区分字符类型与字符串类型的区别
3.字符类型用单引号表示，只能存储一个字符
4.如果同时输入多个字符，编译器将会报错
char s1 = "Hello,World";//这表达一个字符串
char s2 = 'A';//这表达一个字符
char s3 = 'ZERO';//格式错误，编译器将会报错常量
final double PI = 3.1415926;
//设置一个double类型的常量并赋值（这里我们设置的是圆周率π）
double r = 5.0;//设置半径r的值为5.0
double area = PI * r * r;//进行圆形的面积计算
System.out.println(area);//输出area的运行结果
1.常量是使用final修饰词修饰的变量
2.常量被初始化后不可被再次赋值
3.常量的名字通常全部大写
4.常量用来避免进行意外赋值
5.常量的使用有助于理解程序的意图
整数运算
运算规则
整数运算的运算规则基于数学中的四则运算法则，其除法结果为去除余数的整数，除数为0时编译器将会报错
++运算和–运算：
1.n++：n=n+1
2.n–：n=n-1
3.n+=100：n=n+100
4.n-=100：n=n-100
在进行整数运算时，如果计算结果溢出编译器将不会报错，而是在其数据类型可以表示的范围内循环表示，我们可以通过使用表示范围更大的类型替换原有类型来解决这个问题
移位运算
1.左移：<<
2.带符号右移：>>
3.不带符号右移：>>>
在运算过程中，byte和short类型都会先转换为int类型再进行移位运算
位运算
1.与运算&都是1结果才为1
2.或运算|至少一个1结果就是1
3.异或运算^不相同结果为1
4.非运算~都不相同结果为1
运算优先级
1.~、++、–
2.*、/、%
3.+、-
4.<<、>>
5.&
6.|
类型的自动提升与强制转型
short s = 12;//s = 12
int i = s + 100;//i = 112.00
long n = 200 * i;//n = 22400.00
int x = n - 123;//编译错误
int x1 = (int)(n - 123);//x1 = 22277.00
int x2 = (int)n - 123;//x2 = 22277.00
int x3 = (int)(n * 100000000);//计算结果溢出，超出了int类型可以表示的范围1.在运算过程中，计算结果为较大类型的整型
2.可以将结果进行强制转型
3.强制转型可能会丢失精度
4.计算时需要选择合适范围的整数类型
浮点数运算
浮点数运算的特点
double a = 0.1;
//由于0.1的二进制表示为0.0 0011 0011 0011 ...的无限循环
//无限趋近于0.1
//0.099999999999...
double d = 1 - 9.0 / 10;//计算结果并不等于0.1
double d1 = 1.2 + 24.0 / 5;//6.0，计算过程中会将5转型为5.0再进行计算
double d2 = 1.2 + 24 / 5;//5.2，24/5不会进行类型转换，其计算结果为41.很多浮点数无法精确表示
2.计算会有误差
3.整型可以自动提升到浮点类型
特殊值
double d1 = 0.0 / 0;//NaN
double d2 = 1.0 / 0;//Infinity
double d3 = -1.0 / 0;//-Infinity1.NaN表示Not a Number
2.Infinity表示无穷大
3.-Infinity表示负无穷大
强制转型
int n1 = (int)12.3;//12
int n2 = (int)12.7;//12
int n3 = (int)(12.7 + 0.5);//13
int n4 = (int) 1.2e20;//21474836471.强制转型会直接舍弃小数位
2.利用四舍五入技巧进行转型
3.超出整数范围自动变为最大值
布尔运算
关系运算符
int n = 5;
boolean t1 = n > 0;//true
boolean t2 = n < 0;//false
boolean t3 = n == 5;//true
boolean t4 = n != 5;//false
boolean and = t1 && t2;
boolean or = t1 || t2;
boolean not = ! t1;
1.>：大于
2.>=：大于等于
3.<：小于
4.<=：小于等于
5.==：相等
6.！=：不等
短路运算符
1.与运算&&：在与运算过程中，只要有一个参与运算的操作数的计算结果为false，由于整个计算结果的结果一定为false，那么后面的计算过程将不会继续进行计算
2.或运算||：在或运算过程中，只要有一个参与运算的操作数的计算结果为true，由于整个计算结果的结果一定为true，那么后面的计算过程将不会继续进行计算
public static void main(String[] args){
int n = 0;
//boolean b = 5 / n > 0;
boolean and = (5 < n) && (5 / n > 0);
boolean or = (5 > n) || (5 / n > 0);
System.out.println(and);//false
System.out.println(or);//true
}三元运算符
1.三元运算符的作用是根据条件b计算x或y：b ? x : y
2.x和y只计算其中一个
3.x和y的类型不许相同
int n = 200;
boolean positive = n >= 0;
int abs = positive ? n : -n;
字符和字符串
字符类型
1.字符类型是基本类型：char，它保存一个字符
char c1 = 'A';
char c2 = '中';2.Java使用Unicode编码来表示字符
int n1 = c1;//65
int n2 = c2;//20013
3.可以直接用Unicode编码来表示一个字符，使用“\u”加十六进制编码
char c3 = '\u0041';//'A'
char c4 = '\u4e2d';//'中'字符串类型
1.字符串类型是引用类型而不是基本类型：String，它保存一个字符串
2.字符串类型用双引号”…”表示，双引号本身只用来表示字符串而没有其他意义，字符串的内容并不包括双引号”“
String s1 = "ZERO";//包含4个字符
String s2 = "零式ZERO";//包含6个字符
String s3 = "ZERO\n";//包含5个字符
String s4 = "\"零式ZERO\"";//包含8个字符3.如果需要表示某些特殊字符，需要使用转义字符“\”
常用的转义字符：\n,\r,\t,\,\”
4.字符串的内容不可改变
String s = "Hello";//将字符串变量指向Hello
System.out.println(s);//Hello
s = "World";//将字符串变量指向World
System.out.println(s);//World
s = "Hello" + s;//用“+”连接两个字符串
System.out.println(s);//HelloWorld5.引用类型的含义是指向而非持有一个类型
在上面的运行过程中，字符串”Hello”和字符串”World”的内容并没有改变，我们只是把字符串变量s的值从最初的指向Hello变为指向World，最后再通过拼接字符串创建了新的字符串变量s = “HelloWorld”，而不再使用的字符串”Hello”和”World”将由JVM通过垃圾回收器进行回收，所以实际上字符串的内容并没有改变，但是我们通过指向不同的字符串来对字符串变量进行赋值。
所以我们需要正确理解引用类型的含义：引用类型的特点是变量是指向某个对象而非是持有某个对象的值
String s = "Hello";
System.out.println(s);//Hello
String t = s;//在这里，t = s的含义实际上是指t与s指向了同一个字符串
System.out.println(t);//Hello
s = "World";
System.out.println(s);//World
System.out.println(t);//Hello6.引用类型的变量可以是null，表示不指向任何对象
String s = null;
System.out.println(s);//null7.注意区分空值（null）和空字符串（”“）
String t = "";
System.out.println(t);//（空字符串）数组类型
数组的含义
当有一组类型相同的变量时可以用数组来表示
例如，下面两段代码所表达的意义是完全一致的
public class Hello{
public static void main(String[] args){
int n1 = 66;
int n2 = 77;
int n3 = 88;
int n4 = 99;
int n5 = 100;
}
}public class Hello{
public static void main(String[] args){
int[] ns = new int[5];
ns[0] = 66;
ns[1] = 77;
ns[2] = 88;
ns[3] = 99;
ns[4] = 100;
}
}1.数组类型用：类型[] 来表示
2.数组初始化用new int []表示
3.数组所有元素初始化均为默认值
4.数组创建后的大小不可变更
5.数组索引从0开始，索引超出范围将会报错
public class Hello{
public static void main(String[] args){
int[] ns = new int[5];
ns[0] = 66;
ns[1] = 77;
ns[2] = 88;
ns[3] = 99;
ns[4] = 100;
System.out.println(ns[2]);//88
System.out.println(ns[5]);//Error!
}
}6.用 数组变量.length 来获取数组的大小
public class Hello{
public static void main(String[] args){
int[] ns = new int[5];
System.out.println(ns.length);// 5
}
}6.数组是引用类型，但数组元素是值类型或引用类型
当我们创建一个数组类型时，变量实际上指向了一个数组对象
7.可以指定数组初始化的元素
编译器可以自动推算数组的大小
public class Hello{
public static void main(String[] args){
int[] ns = new int[]{66,77,88,99,100};//标准写法
int[] ns = {66,77,88,99,100};//简化写法
System.out.println(ns.length);// 5
}
}三、流程控制
输入和输出
输入
import java.util.Scanner;//导入java.util.Scanner包
public class Input {//创建一个类
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);//创建Scanner并传入System.in
System.out.println("Input your name:";//打印字符串
String name = scanner.nextLine();//使用scanner.nextLine()读取字符串
System.out.println("Input your age:");//打印字符串
int age = scanner.nextInt();//使用scanner.nextInt()读取整数
System.out.println("Hi," + name + "you are" + age);//打印输出结果
}
}在上面这个简单的程序输入过程中：
1.首先导入java.util.Scanner包，方便我们使用Scanner方法参数
2.创建Scanner并传入System.in
3.使用scanner.nextLine()读取字符串内容
4.使用scanner.nextInt()读取整数内容
输出
1.输出并换行：System.out.println()
2.输出不换行：System.out.printf()
3.格式化输出:
%d：整数
%f：浮点数
%x：十六进制数
%s：字符串
%%：符号%本身
4.在调整参数顺序时，如果参数数量不能匹配，编译器将会报错
public class Output{
public static void main(String[] args){
double d = 3.1415926;
//打印d的值
System.out.println(d);//3.1415926
//打印d的值，结果精确到小数点后两位并换行
System.out.printf("PI = %.2f\n",d);//PI = 3.14
//打印d的值，结果精确到小数点后两位，并保留7个数位并换行
System.out.printf("PI = %7.2f\n",d);//PI = 3.14
//格式化小数
double f = 0.123456
System.out.printf("%f\n",f);//0.123456
System.out.printf("%e\n",f);//1.234560e-01
System.out.printf("%2f\n",f);//0.12
System.out.printf("%6.2f\n",f);// 0.12
System.out.printf("%+.2f\n",f);//+0.12
//调整参数顺序
System.out.printf("%s %s %s\n","A","B","C");//A B C
System.out.printf("%2$s %1$s %1$s %3$s\n","A","B","C");//B A A C
//若参数不足将会报错
System.out.printf("%s %s %s\n", "A", "B");//Exception
}
}if-else
在Java语言中，我们使用基于数学逻辑控制法则进行编程的逻辑控制，从而让代码能够按照我们要求的顺序和逻辑结构运行
if语句
if语句的作用
1.在Java语言中使用if用来做条件判断
2.通过根据条件判断的结果是true还是false来决定是否执行后面的语句块
3.if语句块可以包含多条语句，在条件成立的情况下，所有的语句都会依次执行
else语句的作用
1.可以编写else{…}语句块，当条件判断结果为false时执行else语句
2.else并不是必须的，我们可以根据编程的需要进行设置
3.可以通过if和else if进行串联
public class IfElse {
public static void main(String[] args){
int n = 70;//
if(n >= 90){
System.out.println("优秀");
}else if(n >= 60){
System.out.println("及格");
}else if(n <60){
System.out.println("挂科");
}
}
}
//最后的输出结果：及格4.在上面的这段代码中我们需要注意设置边界条件，如果我们将及格的if语句前置，变成下面这段代码：
public class IfElse {
public static void main(String[] args){
int n = 90;//
if(n >= 60){
System.out.println("及格");
}else if(n >= 90){
System.out.println("优秀");
}else if(n <60){
System.out.println("挂科");
}
}
}
//最后的输出结果：及格而不是优秀在这段代码的运行过程中，由于if语句首先执行了n>=60这个语句块，所以不管n的值是多少，只要n>=60都会输出第一条语句块的结果：“及格”，而后面的语句块将不会再执行，所以编程时我们必须严格检查代码运行的逻辑顺序和边界条件设置的合理性，避免出错
5.由于浮点数存在计算误差，所以我们不能用“==”去判断两个浮点数是否相等
public class IfFloat {
public static void main(String[] args) {
double x = 1 - 9.0 / 10;
// FIXME:
if (x == 0.1) {
System.out.println("x is 0.1");
} else {
System.out.println("x is NOT 0.1");
}
System.out.println("x = " + x);
}
}
//x is NOT 0.1
//x = 0.09999999999999998引用类型的判断
1.可以使用“==”来判断一个变量是否引用了同一对象
2.用equals()来判断是否逻辑相等
——使用equals()时注意避免null，如果变量为null，调用equals()会报错
——可以利用短路运算符&&解决，或者将非null对象放在前面
public class IfString {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "HELLO".toLowerCase();
if (s1 == s2) {
System.out.println("s1 == s2");
}
if (s1.equals(s2)) {
System.out.println("s1.equals(s2)");
}
}
}switch多重选择
1.根据switch()表达式跳转到匹配到case结果：
2.继续执行case结果：的后续语句
3.遇到break结束执行
4.无匹配时执行可选的default语句
5.注意case语句没有{}
6.case语句具有穿透性
7.漏写break将导致意想不到的后果
8.switch可以使用整型、字符串和枚举类型
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);//创建Scanner并传入System.in
System.out.print("Select 1 ~ 4:");
int opt = scanner.nextInt();//读取整数
switch(opt) {//创建switch语句
case 1://若输入1则执行下面一行语句
System.out.println("Selected 1");
break;//结束switch语句
case 2://若输入2则执行下面一行语句，此时输入2和3的输出结果是相同的
case 3://若输入3则执行下面一行语句
System.out.println("Selected 2,3");
break;//结束switch语句
case 4://若输入4则执行下面一行语句
System.out.println("Selected 4");
break;//结束switch语句
default://如果无法匹配输入的整数，执行下面一行语句
System.out.println("Not Selected");
}
System.out.println("END");
}
}while循环
1.while循环的目的就是让计算机根据条件进行循环计算，条件满足时循环，条件不满足时退出循环。
2.while首先判断循环条件，可能不进行循环
3.如果条件永远满足将会变为死循环，死循环会导致内存100%占用，所以要避免编写死循环代码
public class Main {
public static void main(String[] args){
int sum = 0;
int n = 1;
while(n < 10){
sum = sum + n;
n++;
}
System.out.println(n);//10
System.out.println(sum);//45
}do-while循环
1.do-while循环的原理同while循环类似，条件满足时循环，条件不满足时退出循环
2.但是do-while循环是先执行条件判断，再进行循环过程，所以do-while循环至少会进行一次循环
public class Main {
public static void main(String[] args) {
int sum = 0;
int n = 1;
do {
sum = sum + n;
n++;
} while (n < 10);
System.out.println(n);//10
System.out.println(sum);//45
}
}for循环
for循环的原理
1.for循环是使用计数器进行循环
2.计数器的变量通常被命名为i
3.初始化计数器总是被执行
4.for循环可能循环0次
5.不能在循环体内修改计数器
6.计数器的变量尽量定义在for循环中
public class Main {
public static void main(String[] args）{
int[] ns = {1,4,9,16,25};//定义一个int数组
for(int i = 0;i < ns.length;i++){//设置计数器初始值，设置计数器的检测条件，设置计数器的更新方式
System.out.println(ns[]);
}
}
}分别设置for循环
1.首先设置计数器的初始值
2.其次设置循环前检查条件
3.最后设置每次循环后如何更新计数器
4.for循环可以缺少初始条件、循环条件和每次循环更新条件
下面我们利用for循环进行求和：
public class MainSum {
public static void main(String[] args){
int sum = 0;//定义一个int变量sum用来表示和
for(int i = 0;i <= 100;i++)//分布设置for循环
sum = sum + i;//定义变量sum的更新方式
System.out.println(sum);//输出结果为5050
}
}for-each循环
1.for each循环可以更简单地遍历数组
2.for each循环可以遍历数组和可迭代数据类型
3.for each循环无法指定遍历顺序
4.for each循环无法获取数组索引
5.同时遍历多个数组时无法使用for each循环
break和continue
break
break的作用是在循环过程中跳出循环
break总是跳出最近的一层循环
public class Break {
public static void main(String[] args) {
int[] ns = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int sum = 0;
for(int i = 0;i < ns.length;i++){
if(i == 5){
System.out.println("break");
break;//设置条件，如果i==5则退出循环，并打印“break”
}
System.out.println("add ns[" + i + "]");
sum = sum + ns[i];
}
System.out.println(sum);
}
}continue
continue语句用来提前结束当前循环，直接进入下一次循环
public class Continue {
public static void main(String[] args){
int[] ns = {31,21,22,73,79,56,7,83,19,12,53,84,68};
int sum = 0;
for(int n :ns){
if(n % 2 == 0){//当数组内的整数除以2余数等于0时，执行语句并执行continue
System.out.println("skip " + n);
continue;
}
sum = sum + n;
}System.out.println(sum);
}
}
//skip 22
//skip 56
//skip 12
//skip 84
//skip 68
//366
四、数组操作
遍历数组
1.遍历数组可以使用for循环
2.如果我们直接打印数组变量，我们输出的结果是数组在JVM中的引用地址
3.如果使用for-each循环打印数组，会变得很麻烦
4.使用JDK提供的Arrays.toString()方法可以快速打印数组内容
import java.util.Arrays;
public class Main {
public static void mian(String[] args){
int[] ns = (1,1,2,3,5,8};
System.out.println(ns);
System.out.println(Arrays.toString(ns));
}
}数组排序
冒泡排序法
1.使用两层for循环来实现排序
2.交换两个变量的值必须通过临时变量进行转换
import java.util.Arrays;
public class Main {
public static void main(String[] args){
int[] ns = {28,12,89,73,65,18,96,50,8,36};
System.out.println(Arrays.toString(ns));//排序前结果
for(int i = 0;i <ns.length; i++){//设置第一个for循环
for(int j = i + 1;j <ns.length; j++){//设置第二个for循环
if(ns[i] > ns[j]){//比较两个数组的大小
int x = ns[j];//定义变量x为临时变量
ns[j] = ns[i];//交换2个变量
ns[i] = x;//通过临时变量完成过渡
}
}
}
System.out.println(Arrays.toString(ns));
}
}
//排序前数组顺序：[28,12,89,73,65,18,96,50,8,36]
//排序后数组顺序：[8,12,18,28,36,50,65,73,89,96]JDK快速排序法
1.JDK提供了Arrays.sort()方法可以进行数组的快速排序
2.快速排序法对数组排序修改了数组本身
import java.util.Arrays;
public class Main {
public static void main(String[] args){
int[] ns = {28,12,89,73,65,18,96,50,8,36};
Arrays.sort(ns);//使用JDK快速排序法后，数组本身会被修改
System.out.println(Arrays.toString(ns));
//[8, 12, 18, 28, 36, 50, 65, 73, 89, 96]
}
}多维数组
二维数组
1.二维数组是数组的数组，也就是说，二维数组内部由多个一维数组组成
int[][] ns = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};2.多维数组的每个元素长度不要求相同
3.这里需要注意，如果我们打印这个数组的长度，其输出结果为3，因为在二维数组中，每一个元素都是一个一维数组，而数组的长度是以数组中的元素为单位的
System.out.println(ns.length);//34.访问二维数组的一个元素使用array[行][列]
int x = ns[1][2];System.out.println(ns[1][2]);//这里可以打印ns数组中第2个一维数组中的第3个元素多维数组
1.多维数组就是数组中的数组
2.三维数组的元素就是二维数组
3.打印多维数组可以使用Arrays.deepToSrting()
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[][] stds = {
// 语文, 数学, 英语, 体育
{ 68, 79, 95, 81 },
{ 91, 89, 53, 72 },
{ 77, 90, 87, 83 },
{ 92, 98, 89, 85 },
{ 94, 75, 73, 80 }
};
System.out.println(stds.length);
System.out.println(Arrays.toString(stds));
System.out.println(Arrays.deepToString(stds));
// TODO: 遍历二维数组，获取每个学生的平均分:
for (int[] std : stds) {
int sum = 0;
int avg = sum / std.length;
System.out.println("Average score: " + avg);
}
// TODO: 遍历二维数组，获取语文、数学、英语、体育的平均分:
int[] sums = { 0, 0, 0, 0 };
for (int[] std : stds) {
}
System.out.println("Average Chinese: " + sums[0] / stds.length);
System.out.println("Average Math: " + sums[1] / stds.length);
System.out.println("Average English: " + sums[2] / stds.length);
System.out.println("Average Physical: " + sums[3] / stds.length);
}
}命令行参数
1.命令行参数是String[]数组
2.命令行参数有JVM接收用户输入并传给main方法
3.如何解析命令行参数由程序自己实现
public class Main {
public static void main(String[] args) {//命令行参数是一个String数组
System.out.println("Number of args: " + args.length);
for (String arg : args) {
System.out.println(arg);
}
}
}——第一章节：Java快速入门 学习笔记整理完成——
8025
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
