细说Java入门

encoding_utf_8

于 2021-07-13 23:22:17 发布

阅读量310

点赞数

分类专栏： java java入门

本文链接：https://blog.csdn.net/encoding_utf_8/article/details/118713308

版权

java 同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

java入门

1 篇文章 0 订阅

订阅专栏

参考DataWhale组队学习：Java基础

Hello World

在学习任何编程语言之前，我们都需要去写属于我们自己的hello world程序：

1.随便新建一个文件夹，存放代码

2.新建一个java文件

文件后缀名为.java
Hello.java
【注意点】系统可能没有打开隐藏名

3.编写代码

public class Hello{
	public static void main(String[] args){
		System.out.println("Hello,World!");
	}
}

4.编译 javac java文件，会产生一个class文件

5.运行class文件，java Hello

在这里插入图片描述

可能会遇到的情况：

1.每个单词的大小写不能出现问题，java是大小写敏感的。

2.尽量使用英文。

3.文件名与类名必须保证一致，并且首字母大写。

4.符号使用了中文的。

5.java环境是否良好。

1.基本数据类型与变量

1.1 基本数据类型

Java属于强类型语言，强类型语言必须为每一个变量声明一种类型。

Java中基本数据类型也称做简单数据类型，包括以下八种

1、整型

byte 、short 、int 、long

2、浮点型

float 、 double

3、字符型

char

4、布尔型

boolean

1.1.1 整型

整型（byte、short、int、long）

整型数据有四种，它们的取值范围不同

byte 的取值范围：-128～127（-2的7次方到2的7次方-1）

short 的取值范围：-32768～32767（-2的15次方到2的15次方-1）

int 的取值范围：-2147483648～2147483647（-2的31次方到2的31次方-1）

long 的取值范围：-9223372036854774808～9223372036854774807（-2的63次方到2的63次方-1）

1.1.2 浮点型

浮点型包括float和double两种，区别在与精度，float是单精度、32位、符合IEEE 754标准的浮点数；double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数。

float（单精度浮点型）取值范围：3.402823e+38～1.401298e-45

double（双精度浮点型）取值范围：1.797693e+308～4.9000000e-324

java对于浮点型数据默认会使用double。

1.1.3 字符类型

char 类型是一个单一的 16 位 Unicode 字符；

最小值是 \u0000（十进制等效值为 0）；

最大值是 \uffff（即为 65535）；

char 数据类型可以储存任何字符；

1.1.4 布尔类型

布尔类型只有两个取值，分别是true 、false 。

java默认是false。

1.2 变量

1.2.1 变量类型

java属于强类型语言，所以变量在使用前必须进行声明，以下是几个声明与赋值的示例：

int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

java有三类变量，分别是：

类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。

public class var{
    static int lei_var;    // 类变量
    String str="hello world";  // 实例变量 
    public void test(){
        int local_var =0;  // 局部变量 
    }
}

局部变量

如果在成员方法中定义一个变量，那么这个变量就被称为局部变量。

局部变量在方法实行时被创建，在方法执行结束的时候被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则出现编译错误。

例如，我们创建一个类文件，在该类中定义getName()方法，在getName()方法中声明int型的局部变量id，并赋值为0，代码如下：

public class BookText(){
	public String getName(){
	int id = 0; //局部变量，如果我们把初始值去掉，会报错
	setName("Java"); //调用类中的其他方法（此类中省略定义方法）
	return i + this.name;
	}
}

注意：类成员变量和成员方法可以统称为类成员。如果一个方法中含有与成员变量同名的局部变量，则方法中对这个变量的访问以局部变量的值为基准。例如，变量id在 getName()方法中值为0，而不是成员变量中id的值。

局部变量的作用域，即局部变量的有效范围，下图描述了局部变量的作用范围。

public void doString(String name){ 
	int id = 0; 
	for(int i = 0; i< 10; i++) 
		System.out.println(name + String.valueOf(i));
}

在相互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量，如下图

public void doString(String name){
	 int id = 0; 
	 for(int i= 0; i<10; i++){
	 	 System.out.println(name ＋ String.valueOf(i)); 
	 	 }
	 for (int i= 0; i <3; i++)
	 	System.out.println(i);
}

但是在相互嵌套的区域中不可以这样声明，如果将局部变量id在方法体的for循环中再次定义，编译器将会报错，如图所示。

public void doString(String name){ 
	int id = 0; 
	for(int i= 0; i<10; i++)
		System.out.println(name + String.valueOf(i));
	for(int i = 0; i<3; i++)
		 System.out.println(i); int id = 7;
}

注意：在作用范围外使用局部变量是一个常见的错误，因为在作用范围外没有声明局部变量的代码。

实例变量

也叫类成员变量，声明在一个类当中，方法、构造方法和语句块之外。实例变量的生命周期与对象一致。

类变量/静态变量

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。生命周期与类一致。

1.2.2 类型转换

在平时编程的时候，经常需要将一种数值类型转换为另一种数值类型。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zKNzksr4-1626188643592)(img/i0.hdslb.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg)]

若两个操作数中有一个是double类型，另一个操作数就会转换为double类型；
若其中一个操作数是float类型，另一个操作数也会转换为float类型；
若其中一个操作数为long类型，另一个操作数也会转换为long类型；
否则两个操作数都会转换为int类型。

数值类型的转换可能会发生精度的丢失，例如：123456789是一个大整组，它所包含的位数比float类型所能表达的位数还要多。当它由整型数值转换为float类型时，将会得到同样大小的结果，但却丢失一定的精度。

int n = 123456789;
float f = n;
System.out.println(f);

输出：1.23456792E8

强制类型转换

由上方可看出，在必要时候int类型会自动转换为double类型，而也会有将double类型转换为int类型的需要。这时，就需要通过强制类型转换来实现这个操作。

强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，后面紧跟着待转换的变量名。

double x = 9.997;
int nx = (int)x;

在这里，变量nx的值就会变成9。强制类型转换通过截断小数部分将浮点值转换为整型。

若想要对浮点数进行舍入运算，以便得到最接近的整数，就需要用Math.round方法：

double x = 9.997;int nx = (int) Math.round(x);

现在变量nx的值为10。

1.2.3 常量

常量在程序运行时是不能被修改的。

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

字面量可以赋给任何内置类型的变量。例如：

byte a = 68;char a = 'A'

byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用字面量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制, 例如：

int decimal = 100;int octal = 0144;int hexa =  0x64;

和其他语言一样，Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子：

"Hello World""two\nlines""\"This is in quotes\""

字符串常量和字符常量都可以包含任何Unicode字符。例如：

char a = '\u0001';String a = "\u0001";

1.3 枚举类型

有时候，变量的取值只在一个有限的集合内，这个变量中很可能保存错误的值。针对这种情况，可以自定义枚举类型。枚举类型包括有限个命名的值。

例如：

销售服装的尺寸有小、中、大和超大四种尺寸。
enum Size {SMALL, MEDIUM, LARGE, EXTRA_LARGE};//声明这种类型的变量Size s = Size.MEDIUM;
Size类型的变量只能存储这个类型声明中给定的某个枚举值，或null值。null表示这个变量没有设置任何值。

2. 运算符和表达式

在Java中，使用算术运算符+、-、*、/表示加、减、乘、除运算。

当参与/运算时，两个操作数都是整数时，表示整除法；否则表示浮点除法。

整数的求余操作（取模）用%表示。例如：15/2=7，15%2=1，15.0/2=7.5。

值得注意，整数被0除将会产生一个异常，而浮点数被0除将会得到无穷大或NaN的结果。

算数运算符	说明
＋	加
－	减
*	乘×
/	除÷
%	取余数

2.1 数学函数与常量

在Math类中，包含了各种各样的数学函数，在编写不同类别的程序时，可能需要的函数也不同。

想计算一个数值的平方根，可以使用sqrt方法：
double x = 4;
double y = Math.sqrt(x);
System.out.println(y);
输出为：2.0

在Java中，没有幂运算，因此需要借助于Math类的pow方法：

double y = Math.pow(x, a);

将y的值设为x的a次幂( $x^a$ )。

pow方法有两个double类型的参数，其返回结果也为double类型。

Math类还提供了常用的三角函数：

Math.sin；

Math.cos；

Math.tan；

Math.atan；

Math.atan2；

指数函数以及它的反函数，自然对数以及10为底的对数：

Math.exp;
Math.log;
Math.log10;

两个用于表示 $\pi和e$ 常量的近似值：

Math.PI
Math.E

如果不想再数学方法名和常量名前添加前缀"Math"，只需要在源文件的顶部添加代码：

import static java.lang.Math.*;

2.2 结合赋值和运算符

可以在赋值中使用二元运算符，这是一种便捷的简写形式：

x += 4;
//等价于
x = x + 4;

（一般地，将运算符放在=号的左边，如*=或%=）

2.3 自增与自减运算符

自增、自减运算符：n++将变量n的当前值加1，n–将n的值减1。

int n = 12;
n++; //自增后，n=13

这些运算符只会改变变量的值，它们的操作数不能是数值。例如：4++是个非法语句。

自增与自减运算符还有一种“前缀”形式：++n，–n；后缀和前缀形式都会使变量值加1或减1。在表达式中，前缀形式会先完成加1，而后缀形式会先使用变量原来的值。

int m = 7;
int n = 7;
int a = 2 * ++m; // a=16,m=8
int b = 2 * n--; // b=14,n=8

2.4 关系和boolean运算符

要检测相等性可以使用两个等号==：

3 == 7 //返回false

检测不相等就使用!=：

3 != 7 //返回true

经常使用的运算符还有：<小于，>大于，<=小于等于，>=大于等于；
感叹号！就是逻辑非运算符，运算符&&表示逻辑**“与“运算符，运算符||表示逻辑”或“**运算符；

expression1 && expression2

expression1和expression2计算返回的结果都为true时，整个表达式才会返回true；

若expression1和expression2计算返回的结果其中一个为false时，整个表达式返回的结果为false。

expression1 || expression2

若expression1返回true则不计算expression2，将整个表达式的结果返回true；

若expression1返回false，计算expression2返回true，整个表达式结果也将会返回true；

若expression1和expression2的返回结果都是false，那整个表达式结果也将返回false。

三目运算符x?y:z，当x返回结果为true时就返回y，当x返回结果为false时就返回z。

x < y ? x : y

将会返回x和y中较小的一个。

2.5 位运算符

处理整数类型时，可以直接对组成整型数值的各个位完成操作。位运算符包括：&(“and”)、|(“or”)、^(“xor”)、~(“not”)。另外还有>>和<<运算符将位模型左移或右移。

2.6 括号与运算符级别

运算符优先级：

结合性	运算符
从左往右	()括号
从右往左	！ ~ ++ – + 一元运算 - 一元运算（）强制类型转换 new
从左往右	* / %
从左往右	+ -
从左往右	<< >> >>>
从左往右	< <= > >=
从左往右	== !=
从左往右	&
从左往右	^
从左往右	\|
从左往右	&&
从左往右	\|\|
从右往左	?:
从右往左	= += -= *= /= %= &= \|= ^= <<= >>= >>>=

若不适用括号，就按照给出的运算符优先级次序进行计算。同一个级别的运算符按照从左到右的次序进行计算（除了表中给出的右结合运算符外）。

4.数组

如果我们需要存储大量的数据，比如存储100名学生的成绩，这就要重复声明100个变量；再比如让100名学生的成绩全部加一，也是100个变量重复操作，这样太麻烦过于繁琐重复操作过多，无法进行统一的操作。

4.1数组的概念

一组连续的存储空间，存储多个相同数据类型的值。同一种类型数据的集合。其实数组就是一个容器。运算的时候有很多数据参与运算,那么首先需要做的是什么.不是如何运算而是如何保存这些数据以便于后期的运算，那么数组就是一种用于存储数据的方式，能存数据的地方我们称之为容器，容器里装的东西就是数组的元素, 数组可以装任意类型的数据，虽然可以装任意类型的数据,但是定义好的数组只能装一种元素，也就是数组一旦定义，那么里边存储的数据类型也就确定了。
特点：类型相同，长度固定，可以自动给数组中的元素从0开始编号，方便操作这些元素。

4.2 数组的定义

数组的创建：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

声明数组变量
必须在程序中声明数组，并指定数据类型；声明数据类型为int，容器使用数组那么如何标识数组呢？在java中我们使用[]符号标识，然后接着是定义数组的名称为arr，格式为 int[] arr。注意：int x[] 也是一种创建数组的格式。推荐使用int[] x 的形式声明数组。
创建数组
要使用一个新的关键字叫做new，new 用来在内存中产生一个容器实体，数据要存储是需要有空间的，存储很多数据的空间用new 操作符来开辟，new int[5]; 这个5是元素的个数。右边这部分就是在内存中定义了一个真实存在的数组，能存储5个元素。注意：new int[5] 做了两件事情，首先使用new int[3] 创建了一个数组，然后把这个数组的引用赋值给数组变量x。

思考： arr是属于什么数据类型？
任何一个变量都得有自己的数据类型。注意这个arr不是int 类型的。int 代表的是容器里边元素的类型。那么x 是数组类型的，数组是一种单独的数据类型。数据类型分为2大派，分为基本数据类型和引用数据类型。第二大派是引用数据类型。那么大家现在已经接触到了引用数据类型三种当中的一种。就是数组类型 [] 中括号就代表数组。

思考： int[] arr = new int[5];在内存中发生了什么？
内存任何一个程序,运行的时候都需要在内存中开辟空间.int[] arr = new int[5]; 这个程序在内存中是什么样?这就涉及到了java虚拟机在执行程序时所开辟的空间,那么Java开辟启动了多少空间呢？在后面我们会深入介绍。
定义数组主要有两种格式：
格式一：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 
示例：int[] arr1 = new int[5];
示例：float[] arr2 = new float[5];

格式二：

元素类型[] 数组名 = new 元素类型[]{元素，元素，……}; 
int[] arr1 = new int[]{3,5,1,7}; 
float[] arr2 = {1.3,1.5,1.1,1.7};

注意：给数组分配空间时，必须指定数组能够存储的元素个数来确定数组大小，体现了数组长度固定的特点；创建数组之后不能修改数组的大小。可以使用length 属性获取数组的大小。

4.3 数组的初始化

数组的声明与赋值

int[] arr = new int[2];
a[0] = 10;
a[1] = 20;

另一种方式也可以直接明确数组的长度,以及数组中元素的内容：

int[] arr = new int[]{20,30,40};
int[] arr = {20,30,40};

如果数组初始化中不使用运算符new。需要注意：下列写法是错误的：

int[] arr; 
arr = {20,30,40};

初始化数组，必须将声明，创建，初始化都放在一条语句中个，分开会产生语法错误。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kUtyCPwW-1626490847193)(img/20210401014138779.png)]

4.4 数组下标的有效范围与常见异常

ArrayIndexOutOfBoundsException 索引值越界异常。
我们进行了数组声明、赋值和访问之后，下面我们来讨论一下数组下标的有效范围。如下面一个例子中：

我们发现长度为5的数组，再给每一个有效的元素依次赋值，再然后完成访问。但是在访问过程中，arr[3]是较为特殊的，那我们就要明确对于一个数组来见，有效的下标范围是0 ~ 数组长度-1，也就是说作为一个长度为三的数组来讲，有效下标范围应该是0 ~ 2，一旦我们访问了不在有效范围的下标，那么就会产生数组下标越界异常。

Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException:
Index 3 out of bounds for length 3

NullPointerException 空指针异常
引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。

4.5 数组内存分析

栈内存：栈内存存储的都是局部变量，变量一旦出了自己的作用域，那么就会马上从内存的消失，释放内存空间。
堆内存：堆内存存储的都是对象内存，对象一旦被使用完，并不会马上从内存中消失，而是等待垃圾回收器不定时的把垃圾对象回收，这时候该对象才会消失，释放内存。
凡是以new关键字创建的对象，JVM都会在堆内存中开辟一个新的空间，创建一个新的对象。
对象如果没有变量引用了，那么该对象就是一个垃圾对象了。

在这里插入图片描述
双数组的内存分析

public class Test2 {
    public static void main(String[] args) {
        int[] arr1 = new int[2];
        int[] arr2 = new int[3];
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
 
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
 
        // 给arr1数组的索引为0元素赋值100
        arr1[0] = 100;
        // 给arr2数组的索引为0元素赋值200
        arr2[0] = 200;
 
        System.out.println("-----------");
        System.out.println(arr1);
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
 
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);
    }
}

在这里插入图片描述

4.6 二维数组

我们有个酒店500个房间，并且所有房间都在同一个楼层里，那么拿到499号房钥匙的旅客可能就不高兴了，从1号房走到 499号房要花好长时间，因此每个酒店都不只有一个楼层，而是很多楼层，每一个楼层都会有很多房间，形成一个立体的结构，把大量的房间均摊到每个楼层，这种结构就是二维表结构。在计算机中，二维表结构可以使用二维数组来表示。使用二维表结构表示快捷酒店每一个楼层的房间号的效果如下图所示。

4.6.1 创建二维数组

二维数组可以看作是特殊的一维数组，它有两种声明方式：

数组元素类型 数组名字[][];
数组元素类型[][] 数组名字;
int arr1[][]; 
char[][] arr2;

同一维数组一样，二维数组在声明时也没有分配内存空间，同样要使用关键字new来分配内存，然后才可以访问每个元素。 为二维数组分配内存有两种方式∶

int a[][];
a = new int[2][4];  //直接分配行类
int b[][];
b = new int[2][];   //先分配行，再分配列
b[0] = new int[2];  //给第一行分配列
b[1] = new int[2];  //给第二行分配列

注意：创建二维数组的时候，可以只声明"行"的长度，而不声明"列"的长度，例如∶

int a[][] = new int[][]; //可省略列的长度

但如果不声明"行"数量的话，就是错误的写法，例如∶

// 错误写法! 
int b[][] = new int[][]; 
// 错误写法! 
int c[][] = new int[][2];

4.6.2 二维数组的赋值

二维数组的初始化方法与一维数组类似，也有3种方式。但不同的是，二维数组有两个索引（即下标），构成由行和列组成的一个矩阵。
在这里插入图片描述
使用三种方式初始化二维数组

public class InitTDArray {
	public static void main(String[] args) {
		/* 第一种方式 */
		int tdarr1[][] = { { 1, 3, 5 }, { 5, 9, 10 } };
		/* 第二种方式 */
		int tdarr2[][] = new int[][] { { 65, 55, 12 }, { 92, 7, 22 } };
		/* 第三种方式 */
		int tdarr3[][] = new int[2][3]; // 先给数组分配内存空间
		tdarr3[0] = new int[] { 6, 54, 71 }; // 给第一行分配一个一维数组
		tdarr3[1][0] = 63; // 给第二行第一列赋值为63
		tdarr3[1][1] = 10; // 给第二行第二列赋值为10
		tdarr3[1][2] = 7; // 给第二行第三列赋值为7
	}
}

从这个例子可以看出，二维数组每一个元素也是一个数组，所以第一种直接赋值方式，在大括号内还有大括号，因为每一个元素都是一个一维数组;第二种使用 new 的方法与一维数组类似; 第三种比较特殊，在分配内存空间之后，还有两种赋值的方式，给某一行直接赋值一个一维数组，或者给某一行的每一个元素分别赋值。开发者可以根据使用习惯和程序要求灵活地选用其中一种赋值方式。

4.6.3 多为数组

比一维数组维数高的叫多维数组，理论上二维数组也属于多维数组。Java也支持三维、四维等多维数组，创建其他多维数组的方法与创建二维数组类似。

int a[][][] = new int[3][4][5]; //创建三维数组 
char b[][][][] = new char[6][7][8][9]; //创建四维数纹 
double c[][][][][]= new double[10][11][12][13][14]; // 建wu维数组

注意：多维数组在Java中是可以使用的，但因为其结构关系太过于复杂，容易出错，所以不推荐在程序中使用比二维数组更高维数的数组，如果需要存储复杂的数据，推荐使用集合类或自定义类集合类包括List、Map等，这些集合类感兴趣的小伙伴可以了解一下。

4.6.4 通过二维数组输出不同版式的古诗

创建Poetry类，声明一个字符型二维数组，将古诗《春晓》的内容赋值于二维数组，然后分别用横版和竖版两种方式输出，实例代码如下∶

public class Poetry {
	public static void main(String[] args) {
		char arr[][] = new char[4][]; // 创建一个4行的二维数组
		arr[0] = new char[] { '春', '眠', '不', '觉', '晓' }; // 为每一行赋值
		arr[1] = new char[] { '处', '处', '闻', '啼', '鸟' };
		arr[2] = new char[] { '夜', '来', '风', '雨', '声' };
		arr[3] = new char[] { '花', '落', '知', '多', '少' };
		/* 横版输出 */
		System.out.println("-----横版-----");
		for (int i = 0; i < 4; i++) { // 循环4行
			for (int j = 0; j < 5; j++) { // 循环5列
				System.out.print(arr[i][j]); // 输出数组中的元素
			}
			if (i % 2 == 0) {
				System.out.println(","); // 如果是一、三句，输出逗号
			} else {
				System.out.println("。"); // 如果是二、四句，输出句号
			}
		}
		/* 竖版输出 */
		System.out.println("\n-----竖版-----");
		for (int j = 0; j < 5; j++) { // 列变行
			for (int i = 3; i >= 0; i--) { // 行变列，反序输出
				System.out.print(arr[i][j]); // 输出数组中的元素
			}
			System.out.println(); // 换行
		}
		System.out.println("。，。，"); // 输出最后的标点
	}
}

输出结果如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EG2krtzL-1626490847195)(img/20210401020646668.png)]

4.7 不规则数组

上文讲的数组都是行、列固定的矩形方阵， Java同时也支持不规则的数组，例如二维数组中，不同行的元素个数可以不同，例如∶

a[][] = new int[3][]; // 创建二维数组，指定行数，不指定列数
a[0]= new int[5];// 第一行分配5个元素 
a[1] = new int[3];// 第二行分配3个元素
a[2] = new int[4];// 第三行分配4个元素

这个不规则二维数组所占的空间如图所示。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pCzrQGfA-1626490847196)(img/20210401020807311.png)]
输出不规则二维数组中的所有元素

创建IrregularArrax类，声明一个不规则二维数组，输出数组每行的元素个数及各元素的值，代码如下∶

public class IrregularArray {
	public static void main(String[] args) {
		int a[][] = new int[3][]; // 创建二维数组，指定行数，不指定列数
		a[0] = new int[] { 52, 64, 85, 12, 3, 64 }; // 第一行分配5个元素
		a[1] = new int[] { 41, 99, 2 }; // 第二行分配3个元素
		a[2] = new int[] { 285, 61, 278, 2 }; // 第三行分配4个元素
		for (int i = 0; i < a.length; i++) {
			System.out.print("a[" + i + "]中有" + a[i].length + "个元素，分别是：");
			for (int tmp : a[i]) { // foreach循环输出数字中元素
				System.out.print(tmp + " ");
			}
			System.out.println();
		}
	}
}

4.8 数组的基本操作

4.8.1 数组遍历

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。遍历一维数组很简单，也很好理解，下面详细介绍遍历二维数组的方法。
 
遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。

创建Trap类，定义二维数组，实现将二维数组中的每一个元素按照行、列格式进行输出，代码如下∶

public class Trap {
	public static void main(String[] args) {
		int b[][] = new int[][] { { 1 }, { 2, 3 }, { 4, 5, 6 } }; // 定义二维数组
		for (int k = 0; k < b.length; k++) { // 循环遍历二维数组中第一个索引
			for (int c = 0; c < b[k].length; c++) { // 循环遍历二维数组中第二个索引
				System.out.print(b[k][c]); // 将数组中的元素输出
			}
			System.out.println(); // 输出换行
		}
	}
}

本实例中有一个语法需要掌握∶ 如果有一个二维数组a[][]，a.length返回的是数组的行数，a[0]. length返回的是第一行的列数量，a[1].length返回的是第二行的列数量。同理，a[n]返回的是第n+1行的列数量，由于二维数组可能是不规则数组，所以每一行的列数量可能不相同，因此在遍历二维数组时，最好使用数组的length属性控制循环次数，而不是用某他变量或常量。

练一练：使用二维数组实现杨辉三角算法。

public class YangHui {// 杨辉三角算法的实现
	public static void main(String[] args) {
		// 定义一个长度为10的二维数组
		int[][] Array_int = new int[10][];
		// 向数组中记录杨辉三角形的值
		for (int i = 0; i < Array_int.length; i++) {// 遍历行数
			Array_int[i] = new int[i + 1];// 定义二维数组的列数
			// 遍历二维数组的列数
			for (int j = 0; j < Array_int[i].length; j++) {
				if (i <= 1) {// 如果是数组的前两行
					Array_int[i][j] = 1;// 将其设置为1
					continue;
				} else {
					// 如果是行首或行尾
					if (j == 0 | j == Array_int[i].length - 1)
						Array_int[i][j] = 1;// 将其设置为1
					else// 根据杨辉算法进行计算
						Array_int[i][j] = Array_int[i - 1][j - 1] + Array_int[i - 1][j];
				}
			}
		}
		for (int i = 0; i < Array_int.length; i++) {// 输出杨辉三角
			for (int j = 0; j < Array_int[i].length; j++)
				System.out.print(Array_int[i][j] + "\t");
			System.out.println();
		}
	}
}

运行结果如下：
在这里插入图片描述

4.8.2 填充和替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法fill()方法来对数组中的元素进行分配，起到填充和替换的效果。fill()方法可将指定的int值分配给int型数组的每个元素。 语法如下∶

Arrays.fill()(int[] a ,int value)

a∶要进行元素分配的数组。
value∶要存储数组中所有元素的值。

使用 fill() 方法将空数组填满数值

创建 Swap类，通过fill()方法填充数组元素，最后将数组中的各个元素输出，代码如下∶

import java.util.Arrays; //导入java.util.Arrays类public class Swap {	public static void main(String[] args) {		int arr[] = new int[5]; // 创建int型数组		Arrays.fill(arr, 8); // 使用同一个值对数组进行填充		for (int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素			// 将数组中的元素依次输出			System.out.println("第" + i + "个元素是：" + arr[i]);		}	}}

总结

为什么数组的索引从0开始？
为什么索引是从0开始的，而不是从1开始呢？这是继承了汇编语言的传统，从0开始更利于计算机做二进制的运算和查找。
数组长度使用length属性获得，但实际上这个属性只能表示一个一维数组的长度。二维数组使用length属性的方式，其实是将二维数组转为"一维数组[一维数组下]"的形式，即一维数组中的元素仍然是一个一维数组，所以二维数组在遍历时使用的两个length并不是同一个数组的属性。
本章介绍的是数组的创建及使用方法。需要注意的是数组的下标是从0开始，最后一个元素的下标总是"数组名 .length-1"。本章的重点是创建数组、给数组赋值以及读取数组中元素的值。此外，Arrays类还提供了其他操作数组的方法，有兴趣的读者可以查阅相关资料。

encoding_utf_8

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
细说Java入门

参考DataWhale组队学习：Java基础Hello World在学习任何编程语言之前，我们都需要去写属于我们自己的hello world程序：1.随便新建一个文件夹，存放代码2.新建一个java文件文件后缀名为.javaHello.java【注意点】系统可能没有打开隐藏名3.编写代码public class Hello{ public static void main(String[] args){ System.out.println("Hello,World!"); }
复制链接

扫一扫