Java数组（零基础小白入门教程8）_{ &quot；&quot；, &quot；&quot；,}数组(1)

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要体系化学习资料的朋友，可以加我V获取：vip204888 （备注网络安全）

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

7、作业

### **一、数组的概念**


#### **1.1、为什么使用数组**

如果说程序中，需要存储大量的相同类型的一组数据，如果直接使用变量来进行存储，每个变量只能存储一个值，就需要大量的变量。
1、代码过于臃肿
2、程序的可读性差
3、数据维护较差

#### **1.2、数组的概念**

数组的概念：
就是一组相同数据类型的数据。内存上是开辟的连续的内存空间。

#### **1.3、数组的特点？**

1、定长。容量固定。数组一旦创建后，那么长度不能更改。(容量，长度，都是指存储的数量)
2、存储的数据类型必须都一致。
3、在内存中空间连续挨个。
4、数组是引用类型的数据，存在栈和堆的地址引用关系。
​
Java中：两大数据类型
基本：4类8种
引用：数组，对象，集合。。。。

### **二、数组的使用**


#### **2.1、数组的使用**

step1：先创建数组
step2：使用数组：存储数据，访问数据。

#### **2.2、数组的语法**

创建数组的语法：
数据类型[] 数组名 = new 数据类型[长度、容量、个数];
数据类型 数组名[] = new 数据类型[长度];//也可以

使用的语法：
数组名[index]，操作数组
index：因为一个数组存储了多个数据(也叫元素)，每个元素都有一个下标，也叫索引，index。理解起来就是给每个数据排个编号，固定从0开始，0,1,2,3,4.。。。到长度减1。
数组的下标不能超出这个范围。否则就会下标越界：java.lang.ArrayIndexOutOfBoundsException

示例代码：

public class Test1Array
{
public static void main(String[] args){
//1.变量的定义
int num = 10;
System.out.println(num);
​
//2.数组
/*
创建数组：语法格式
数据类型[] 数组名 = new 数据类型[容量/长度/个数];
​
数组是引用类型的数据：
a中存储的是数组的实际的地址。
*/
​
int[] a = new int[5];//声明一个数组，并创建出来，然后就可以使用这个数组了。
System.out.println(a);
​
//3.使用数组：存储数据
a[0] = 10;
a[1] = 20;
a[2] = 30;
a[3] = 40;
a[4] = 50;
//a[5] = 100;//java.lang.ArrayIndexOutOfBoundsException
​
//获取数据
System.out.println(a[0]);//打印数组的第一个元素
System.out.println(a[1]);//打印数组的第二个元素
System.out.println(a[2]);//打印数组的第三个元素
System.out.println(a[3]);//打印数组的第四个元素
System.out.println(a[4]);//打印数组的第五个元素
​

//课堂练习：创建一个数组， 存储班级5位同学的性别。
char[] arr2 = new char[5];
arr2[0] = '男';
arr2[1] = '男';
arr2[2] = '男';
arr2[3] = '女';
arr2[4] = '女';

​
//打印悄悄
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
System.out.println(arr2[3]);
System.out.println(arr2[4]);

​
}
}

#### **2.3、内存分析(扩展)**

内存：存储数据
A：栈，存放的是基本数据类型的变量，以及引用类型变量的引用。
特点：函数中的变量所占用的空间，执行之后就会销毁。
B：堆，存放的是new出来的东西。
特点：执行之后，堆里存储的内容(对象等)，会被标记为垃圾，但是不会立即被销毁，而是等待系统的垃圾回收机制来回收(GC)。
JVM,GC(Grabage Collection)

#### **2.4、数组的长度**

获取数组的长度：length，数组的一个属性。
数组名.length—>获取这个数组的长度。

#### **2.5、使用循环遍历数组**


#### **2.5.1、普通的循环**

1、遍历：依次访问数组中每个元素。可以赋值，可以取值。
2、因为操作数组，就是数组名字配合下标，而下标固定都是从0开始，到长度减1。
for(int i = 0;i < arr2.length;i++){
System.out.println(arr2[i]);
}

示例代码：

class Test2ArrayFor
{
public static void main(String[] args)
{
//定义了一个数组，存储了5个学生的性别。
char[] arr2 = new char[5];
arr2[0] = ‘男’;
arr2[1] = ‘男’;
arr2[2] = ‘男’;
arr2[3] = ‘女’;
arr2[4] = ‘女’;
​
/*
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
System.out.println(arr2[3]);
System.out.println(arr2[4]);
*/
​
//借助循环来打印数组：for，while，do-while循环
​
for(int i = 0;i < arr2.length;i++){
//i:0,1,2,3,5
System.out.println(arr2[i]);
//arr2[0],arr2[1],arr2[2],arr2[3],arr2[4]
}
​
​
System.out.println(arr2.length);//专门用于获取一个数组的长度,5

//课堂练习1：定义一个int类型的数组，求该数组中所有元素的总和。

​
//课堂练习2：统计这个数组中元素的平均值。
}
}
​

#### **2.5.2、for-each循环**

for-each循环：【扩展】
增强for循环：JDK1.5的版本出现的。
特定的用法：专门用于获取数组中的每一个元素的值。
语法结构：
for(数据类型 变量名 : 数组名){
System.out.println(变量名);
}
工作原理：
for(int e :arr){
System.out.println(e);
}
int e，定义变量e，
依次获取数组的元素，赋值给e
注意点：
A：for-each只能获取数组的数据，但是不能给数组进行赋值
B：for-each，在代码这个层面，不能操作下标。

示例代码：

public class Test1ForEach
{
public static void main(String[] args){
/*
循环的遍历：依次获取里面的每一个元素
方法一：一个一个的获取
​
方法二：普通的循环：for循环
​
方法三：for-each循环：
for(数据类型 变量名 : 数组名){
System.out.println(变量名);
}
​
element，元素。数组中存储的数据–>数组的元素。
/
​
int[] arr = new int[4];
arr[0] = 1;
arr[1] = 4;
arr[2] = 3;
arr[3] = 5;
//方法一：
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
​
//方法二：
for(int i=0;i < arr.length;i++){
System.out.println(“—>” + arr[i]);
}
​
​
//方法三：
/
index–>0,1,2,3
arr—>[1,4,3,5]
​
工作原理：
int e，定义变量e，
依次获取数组的元素，赋值给e

*/
for(int e : arr){
  //int e = 1;
  //e = 4;
  //e = 3;
  //e = 5;
  System.out.println(e);
}

​
System.out.println(“------------------”);
​
//普通的for循环赋值
int[] arr2 = new int[5];//1,3,5,7,9
for(int i = 0;i<arr2.length;i++){
//i:0,0 1
//i:1,2 3
//i:2,4 5
//i:3,6 7
//i:4,8 9
arr2[i] = i * 2 + 1;
}
for(int i=0;i<arr2.length;i++){
System.out.println(arr2[i]);
}
​
//通过for-each给数组进行赋值？不能给数组赋值。
for(int e : arr2){
// int e :1
e = 10;//仅仅是给变量e进行赋值，和arr2数组无关。
}
for(int e : arr2){
System.out.println(e);
}
}
}

#### **2.6、数组中的默认值**

数组的默认值，就是数组创建后，里面存储的默认的数据。
数组的引用存在栈内存中，数组本身存在堆内存中。
数组创建完，就有默认的数据了。
数组中存储的默认值：
数组中是有默认值的
整数：0
小数：0.0
字符：\u0000
布尔：false
其他：null
​

示例代码：

class Test2DefaultValue
{
public static void main(String[] args)
{
/*
数组中存储的默认值：
数组中是有默认值的
整数：0
小数：0.0
字符：\u0000
布尔：false
其他：null
​
​
arr[i]?
1.先根据arr中存储的地址，找到这块堆内存的数组元素。
2.找到这块数组内存后，根据i来获取对应的空间
*/
​
int n ;//可能尚未初始化变量n
System.out.println(n);
​
int[] arr = new int[5];
​
for(int i = 0;i<arr.length;i++){
System.out.println(arr[i]);//
}
​
String[] arr2 = new String[3];
​
for(int i = 0;i < arr2.length;i++){
System.out.println(arr2[i]);
}
System.out.println(“Hello World!”);
}
}
​

**2.7、创建数组的其他语法**

/*
动态创建数组：先创建数组，然后再根据下标一个一个存储数据。
A：先声明，再创建(分配内存空间)
数据类型 [] 数组名;
数组名 = new 数据类型[长度];
​
B：声明并创建
数据类型 [] 数组名 = new 数据类型[长度];
数据类型 数组名[] = new 数据类型[长度];
​
​
//静态创建数组：声明，创建，赋值一起写完。
C：声明，创建，并赋值
数据类型[] 数组名 = {数值1,数值2,数值3,数值4.。。。};
//=左边声明数组，=右边，会先根据{}中数据的个数，然后再将{}中数据，按照顺序存储进去。
完成了几件事：
1.先声明：int[] c
2.根据{}中数组值的个数，开辟堆内存
3.将{}中的数组值，依次按照顺序存入数组中
D：声明，创建，并赋值
数据类型[] 数组名 = new 数据类型[]{数值1,数值2,数值3,数值4.。。。}
*/

示例代码：

class Test3ArrayCreate
{
public static void main(String[] args)
{
//创建方式1：先声明，再创建
int[] a = null;//引用类型默认赋值null
a = new int[5];//创建，有new表示开辟堆内存，创建数组了，才可以使用数组。

//创建方式2：声明和创建写一起
int[] b = new int[5];
System.out.println(a);

​
//创建方式3：声明，创建，赋值，写一起
int[] c = {1,2,3,4,5};
/*
完成了几件事：
1.先声明：int[] c
2.根据{}中数组值的个数，开辟堆内存
3.将{}中的数组值，依次按照顺序存入数组中
*/
System.out.println(c.length);
for(int e :c){
System.out.println(e);
}
​
//创建方式4：
int[] d = new int[]{1,2,3,4,5};
System.out.println(d.length);
​
​
​
int[] e;
e = new int[]{1,2,3,4,5};
for(int i:e){
System.out.println(i);
}
​
}
}
​

#### **2.8、数组的地址转移**

Java中的数据分为两大类：
基本类型：4类8种
操作的都是数值本身
引用类型：数组
操作的是地址
​
基本类型进行赋值：数值
引用类型进行赋值：地址

示例代码：

class Test4ArrayAddress
{
public static void main(String[] args)
{
/*
数组：引用类型的数据
数组名，存储是引用地址。
*/
​
int[] a = new int[3];
System.out.println(a.length);//3
System.out.println(a);//a数组的地址
System.out.println(a[0]);//0
​
a[0] = 1;
a[1] = 2;
a[2] = 3;
​
int[] b = {4,5,6,7};
System.out.println(b.length);//4
System.out.println(b);//b的地址
System.out.println(b[0]);//4
​
int[] c = a;//将a的值赋值给c，就是将a存储的数组的地址赋值给c
//a和c存储的地址相同，那么就指向了同一个数组
System.out.println(c.length);//3
System.out.println©;//a的地址
System.out.println(c[0]);//1
​
c[0] = 100;
System.out.println(a[0]);
System.out.println(b[0]);
System.out.println(c[0]);
​
​
b = c;
​
b[1] = 200;
System.out.println(a[1]);//200
System.out.println(b[1]);//200
System.out.println(c[1]);//200
​
System.out.println(“Hello World!”);
}
}
​

内存分析：


![](https://img-blog.csdnimg.cn/77c340a7caa04334817d87509a0f7a5b.png)


 


### **三、数组在方法中的使用**


#### **3.1、数组作为参数**


数组是引用类型：传递的是地址。就是参数也会指向这块内存。当方法结束的时候，参数就销毁了。

class Test5ArrayMethod
{
​
//设计一个方法，用于打印数组
public static void printArray(int[] arr){//int[] arr = a;a的地址给了arr，那么arr和
// a指向同一块内存的数组
for(int e : arr){
System.out.print(e +“\t”);
}
System.out.println();
}
​
public static void main(String[] args)
{
​
int[] a = {1,2,3,4,5};
​
//设计一个方法，用于打印数组
printArray(a);//将a的地址，传递给arr
System.out.println(“Hello World!”);
}
}

内存分析：


![](https://img-blog.csdnimg.cn/dc809154bc8243cb9450b98ab18accc7.png)


 



#### **3.2、数组作为返回值**


示例代码：

//设计一个方法，用于创建一个数组， 并赋值。数组要返回给调用处
public static int[] createArray(int len){
int[] arr = new int[len];
for(int i = 0;i <arr.length;i++){
arr[i] = i * 2;
}
return arr;
}

![](https://img-blog.csdnimg.cn/ea2716051c20464e9364a6410383870e.png)


 **3.3、可变参数【扩展】**

概念：一个方法可以接收的参数的数量不定(0-多个)，但是类型固定。
​
语法：数据类型 … 参数名，可变参数在方法中当数组使用。
​
注意事项：
1、如果参数列表中，除了可变参数还有其他的参数，可变参数要写在整个参数列表的最后。
2、一个方法最多只能有一个可变参数。

示例代码：

class Test6Array
{

//求一组int类型的数据的和
public static void getSum(int ... nums ){
    int sum = 0;
    for(int i = 0;i <nums.length;i++){
        sum += nums[i];
    }
    System.out.println("结果：" + sum);
}

​
public static void main(String[] args)
{
/*
可变参数：同一种类型的参数，类型固定的，但是个数不固定。
​
语法的支持：
数据类型 … 参数名
​
可变参数，类型固定，个数可变。0-多个
​
在方法中可变参数当数组使用
*/
​
getSum(1,2,3);
getSum(1,2,3,4,5,6,7,8,9,10);
System.out.println(“Hello World!”);
}
}
​

### **四、数组的排序**


排序：数组是存储一组数据，而且这些数据是有顺序的。但是数值本身可能是无序的。通过算法来实现给数组进行排序，升序(数值从小到大)，降序(数值从大到小)。


#### **4.1 冒泡排序**


冒泡排序：思路(升序)：比较相邻的两个数，较大的数据需要向后移动。长度减1。

1、冒泡排序：Bubble Sort
原理：比较相邻的两个数，将较大的数，向后移动。

class Test7BubbleSort
{
public static void main(String[] args)
{
int[] arr = {15,23,8,10,7};

​
for(int i= 1; i<arr.length;i++){//控制轮数：
//i=1,2,3,4
/*
i=1, j<4
i=2, j<3
i=3, j<2
*/
for(int j = 0;j < arr.length - i;j++){
if(arr[j] > arr[j+1]){
//交换
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}

给大家的福利

零基础入门

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

同时每个成长路线对应的板块都有配套的视频提供：

因篇幅有限，仅展示部分资料

网络安全面试题

绿盟护网行动

还有大家最喜欢的黑客技术

网络安全源码合集+工具包

所有资料共282G，朋友们如果有需要全套《网络安全入门+黑客进阶学习资源包》，可以扫描下方二维码领取（如遇扫码问题，可以在评论区留言领取哦）~

需要体系化学习资料的朋友，可以加我V获取：vip204888 （备注网络安全）

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！