文章目录
一、数组的概述和静态初始化
1. 数组
⭐数组是一种容器，可以用来存储同种数据类型的多个值
① 数组容器在存储数据的时候，需要结合隐式转换考虑
② 例如：int类型的数组容器(byte short int)
③ 例如：double类型的数组容器(byte short int long float double)
④ 建议：容器的类型，和存储的数据类型保持一致
2. 定义
① 数据类型[] 数组名
int [] array
② 数据类型 数组名[]
int array[]
3. 数组的静态初始化
① 初始化：就是在内存中，为数组开辟空间，并将数据存入容器的过程
② 完整格式：数据类型[] 数组名 = new 数据类型[] {元素1, 元素2, 元素3……}
③ 范例：int[] array = new int[]{11, 22, 33};
④ 范例：double[] array2 = new double[]{11.1, 22.2, 33.3};
⑤ 简化格式：数据类型[] 数组名 = {元素1, 元素2, 元素3……}
4. 样例
package com.itheima.arraydemo;
public class ArrayDemo1{
public static void main(String[] args){
//格式：
//静态初始化
//完整格式：
//数据类型[]数组名 = new 数据类型[]{元素1, 元素2……}
//简化格式：
//数据类型[]数组名 = {元素1, 元素2……}
//需求1：定义数组存储5个学生的年龄
int[] arr1 = new int[]{
11,12,13,14,15};
int[] arr2 = {
11,12,13,14};
//需求2：定义数组存储3个学生的姓名
String[] arr3 = new String[]{
"zhangsan","lisi","wangwu"};
String[] arr4 = {
"zhangsan","lisi","wangwu"};
//需求3：定义数组存储4个学生的身高
double[] arr5 = double[]{
1.93,1.75,1.73,1.81};
double[] arr6 = {
1.93,1.75,1.73,1.81};
}
}
二、数组的地址值和元素访问
1. 数组的地址值
intp[] arr = {
1,2,3,4,5};
System.out.println(arr);//[I@6d03e736 地址值
package com.itheima.arraydemo;
public class ArrayDemo1{
public static void main(String[] args){
//格式：
//静态初始化
//完整格式：
//数据类型[]数组名 = new 数据类型[]{元素1, 元素2……}
//简化格式：
//数据类型[]数组名 = {元素1, 元素2……}
//需求1：定义数组存储5个学生的年龄
/*
int[] arr1 = new int[]{11,12,13,14,15};
int[] arr2 = {11,12,13,14};
//需求2：定义数组存储3个学生的姓名
String[] arr3 = new String[]{"zhangsan","lisi","wangwu"};
String[] arr4 = {"zhangsan","lisi","wangwu"};
//需求3：定义数组存储4个学生的身高
double[] arr5 = double[]{1.93,1.75,1.73,1.81};
*/
double[] arr6 = {
1.93,1.75,1.73,1.81};
System.out.println(arr6);//[D@776ec8df
//扩展：
//解释一下地址值的格式含义
//[：表示当前是一个数组
//D：表示当前数组里面的元素都是double类型的
//@：表示一个间隔符号（固定格式）
//776ec8df：才是数组真正的地址值（十六进制）
//平时我们习惯性的会把这个整体叫做数组的地址值
}
}
2. 数组元素的访问
① 格式：数组名[索引]
② 索引：也叫做下标，从零开始，不间断
③ 样例
package com.itheima.arraydemo;
public class ArrayDemo2{
public static void main(String[] args){
//利用索引对数组中的元素进行访问
//1.获取数组里面的元素
// 格式：数组名[索引]
int[] arr = {
1,2,3,4,5};
//获取数组中的第一个元素
//其实就是0索引上对应的元素
//int number = arr[0];
//System.out.println(number);//1
//获取数组中1索引上对应的数据，并直接打印出来
//System.out.println(arr[1]);//2
//2.把数据存储到数组当中
//格式：数组名[索引] = 具体数据/变量
//细节：一旦覆盖之后，原来的数据就不存在了
arr[0] = 100;
System.out.println(arr[0]);//100
}
}
三、数组的遍历和三道综合练习
1. 数组遍历
① 定义：将数组中所有的内容取出来，取出来之后可以（打印，求和，判断）
② 注意：遍历指的是取出数据的过程，不要局限的理解为，遍历就是打印！
2. 样例
package com.itheima.arraydemo;
public class ArrayDemo3{
public static void main(String[] args){
//1.定义数组
int[] arr = {
1,2,3,4,5};
//2.获取数组里面所有的元素
//格式：数组名[索引]
/*
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
*/
//利用循环改进代码
//开始条件：0
//结束条件：数组的长度 - 1（最大索引）
/*
for(int i = 0; i < 5; i++){
//i:0 1 2 3 4
System.out.println(arr[i]);
}
*/
//在Java中，关于数组的一个长度属性,length
//调用方式：数组名.length
//System.out.println(arr.length);
for(int i = 0; i < arr.length; i++){
//i:0 1 2 3 4
System.out.println(arr[i]);
}
}
}
3. 练习
package com.itheima.test;
public class ArrTest1{
public static void main(String[] args){
/*
定义一个数组，存储1,2,3,4,5
遍历数组得到每一个元素，求数组里面所有的数据和
*/
//分析：
//1.定义一个数组，并添加数据1,2,3,4,5
int[] arr = {
1,2,3,4,5};
//求和变量
int sum = 0;
//2.遍历数组得到每一个数据，累加求和
for(int i = 0; i < arr.length;i++){
//i 依次表示数组里面的每一个索引
//arr[i] 依次表示数组里面的每一个元素
sum = sum + arr[i];
}
//当循环结束之后，sum的值就是累加之后的结果
System.out.println(sum);
}
}
package com.itheima.test;
public class ArrTest2{
public static void main(String[] args){
/*
定义一个数组，存储1,2,3,4,5,6,7,8,9,10
遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字
*/
//分析：
//定义一个数组 存储1,2,3,4,5,6,7,8,910
int[] arr = {
1,2,3,4,5,6,7,8,9,10};
//定义一个变量，用来统计个数
int count = 0;
//2.遍历数组得到每一个元素
for(int i = 0; i < arr.length;i++){
//i 表示数组里面每一个索引
//arr[i] 表示数组里面的每一个元素
//3.判断当前的元素是否为3的倍数，如果是那么统计变量就需要自增一次
if(arr[i] % 3 == 0){
//System.out.println(arr[i]);
count++;
}
}
//当循环结束之后，就表示数组里面所有的数字都判断完毕了，直接打印count即可
System.out.println("数组中能被3整除的数字有"+count+"个");
}
}
package com.itheima.test;
public class ArrTest3{
public static void main(String[] args){
/*
定义一个数组，存储1,2,3,4,5,6,7,8,9,10
遍历数组得到每一个元素
要求：
1.如果是奇数，则当前数字扩大两倍
2.如果是偶数，则当前数字变成二分之一
*/
//分析：
//1.定义一个数组，存1,2,3,4,5,6,7,8,9,10
int[] arr = {
1,2,3,4,5,6,7,8,9,10};
//2.遍历数组得到每一个元素
for(int i = 0; i < arr.length; i++){
//i 依次表示数组里面的每一个索引
//arr[i] 依次表示数组里面的每一个元素
//3.对每一个元素进行判断
if(arr[i] % 2 == 0){
//偶数 变成二分之一
arr[i] = arr[i] / 2;
}else{
//奇数 扩大两倍
arr[i] = arr[i] * 2;
}
}
//遍历数组
//一个循环尽量只做一件事情
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
}
四、数组的动态初始化和常见问题
1. 数组动态初始化
① 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值
② 格式：数据类型[] 数组名 = new 数据类型[数组长度];
③ 范例：int[] arr = new int[3];
④ 样例
package com.itheima.arraydemo;
public class ArrayDemo4{
public static void main(String[] args){
/*
定义一个数组，用来存班级中50个学生的姓名
姓名未知，等学生报道后，再进行添加
*/
//格式：
//数据类型[] 数组名 = new 数据类型[数组长度];
//再创建的时候，由我们自己指定数组的长度，由虚拟机给出默认的初始化值
String[] arr = new String[50];
//添加学生
arr[0] = "zhangsan";
arr[1] = "lisi";
//获取
System.out.println(arr[0]);//zhangsan
System.out.println(arr[1]);//lisi
System.out.println(arr[2]);//打印出来的是默认初始化值
//数组默认初始化值的规律
//整数类型：默认初始化值0
//小数类型：默认初始化值0.0
//字符类型：默认初始化值'/u0000' 空格
//布尔类型：默认初始化值 false
//引用数据类型：默认初始化值 null
int [] arr2 = new int[3];
System.out.println(arr[0]);//0
System.out.println(arr[1]);//0
System.out.println(arr[2]);//0
}
}
2. 数组动态初始化和静态初始化的区别
① 动态初始化：手动指定数组的长度，由系统给出默认初始化值
只明确元素的个数，不明确具体数值，推荐使用动态初始化
② 静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度
需求中已经明确了要操作的具体数据，直接静态初始化即可
3. 数组常见问题
① 当访问了数组中不存在的索引，就会引发索引越界异常
② 样例
package com.itheima.arraydemo;
public class ArrayDemo4{
public static void main(String[] args){
//1.定义一共数组
int[] arr = {
1,2,3,4,5};
//长度：5
//最小索引：0
//最大索引：4（数组的长度 - 1）
System.out.println(arr[2]);
//小结：
//索引越界异常
//原因：访问了不存在的索引
//避免：索引的范围
//最小索引：0
//最大索引：4（数组的长度 - 1）
}
}
五、数组练习1-求最值
package com.itheima.test;
public class ArrTest4{
public static void main(String[] args){
//定义数组求最大值：33,5,22,44,55
//扩展问题：
//1.根据求最大值问题的思路，自己改写一下求最小值
//2.为什么max要记录为arr[0],默认值不能为0吗
//不能写0
//max的初始化值一定要是数组中的值
//3.循环中开始条件一定是0吗
//循环的开始条件如果为0，那么第一次循环的时候是自己跟自己比了一下，对结果没有任何影响，但是效率偏低
//为了提高效率，减少一次循环的次数，循环开始条件可以写1
//1.定义数组用来存储5个值
int[] arr = {
33,5,22,44,55};
//2.定义一个变量max用来存储最大值
//临时认为0索引的数据是最大的
int max = arr[0];
//3.循环获取数组中的每一个元素
//拿着每一个元素跟max进行比较
for(int i = 0; i < arr.length; i++){
//i 索引 arr[i] 元素
if(arr[i] > max){
max = arr[i];
}
}
//当循环结束之后，max记录的就是数组中的最大值
System.out.println(max);//55
}
}
六、数组练习2-求和并统计个数
package com.itheima.test;
public class ArrTest5{
public static void main(String[] args){
/*
需求：生成10个1~100之间的随机数存入数组
1) 求出所有数据的和
2) 求所有数据的平均数
3) 统计有多少个数据比平均值小
*/
//分析：
//1.定义数组
int[] arr = new int[10];
//2.把随机数存入到数组当中
Random r = new Random();
for(int i = 0; i < arr.length; i++){
//每循环一次，就会生成一个新的随机数
int number = r.nextInt(100) + 1;
//把生成的随机数添加到数组当中
//数组名[索引] =数据
arr[i] = number;
}
//遍历数组
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
// 1) 求出所有数据的和
//定义求和变量
int sum = 0;
for(int i = 0; i < arr.length; i++){
//循环得到每一个元素
//并把元素累加到sum当中
sum = sum + arr[i];
}
System.out.println("数组中所有数据的和为："+sum);
// 2) 求所有数据的平均值
int avg = sum / arr.length;
System.out.println("数组中平均数为："+avg);
// 3) 统计有多少个数据比平均值小
int count = 0;
for(int i = 0; i < arr.length; i++){
if(arr[i] < avg){
count++;
}
}
//当循环结束之后，就表示我已经找到了所有比平均数小的数据
System.out.println("在数组中，一共有"+count+"个数据，比平均数小");
//遍历数组，验证答案
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i] + " ");
}
}
}
七、数组练习3-交换数据
package com.itheima.test;
public class ArrTest6{
public static void main(String[] args){
/*
需求：定义两个变量，交换两个变量记录的值
*/
int a = 10;
int b = 20;
/*
//把变量b的值，赋值给了变量a，那么变量a原来的值就被覆盖了
a = b;//a = 20 b =20
//把变量a的值，赋值给了b
b = a;//a = 20 b =20
//System.out.println(a);//20
*/
//定义一共临时的第三方变量
//把变量a的值，赋值给了temp
int temp = a;
//把变量b的值，赋值给了a，那么变量a原来记录的值就被覆盖了
a = b;
//就是把变量a原来的值赋值给了变量b
b = temp;
system.out.println(a);//20
system.out.println(b);//10
}
}
package com.itheima.test;
public class ArrTest7{
public static void main(String[] args){
/*
需求：定义一个数组，将数组中0索引和最大索引处的值进行交换
*/
//1.定义一个数组
int[] arr = {
1,2,3,4,5};
//2.将数组中0索引和最大索引处的值进行交换
//也是可以利用第三方变量进行交换
int temp = arr[0];
arr[0] = arr[4];
arr[4] = temp;
//3.遍历数组
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i] + " ");
}
}
}
package com.itheima.test;
public class ArrTest8{
public static void main(String[] args){
/*
需求：
定义一个数组，存入1,2,3,4,5，交换首尾索引对应的元素
交换前：1,2,3,4,5
交换后：5,4,3,2,1
*/
//1.定义数组存储数据
int[] arr = {
1,2,3,4,5};
//2.利用循环去交换数据
for(int i = 0,j = arr.length - 1; i < j; i++,j--){
//交换变量i和变量j指向的元素
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//当循环结束之后，那么数组中的数据就实现了头尾交换
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i] + " ");
}
}
}
八、数组练习4-打乱数据
package com.itheima.test;
public class ArrTest9{
public static void main(String[] args){
//需求：定义一个数组，存入1~5，要求打乱数组中所有数据的顺序
//难点：
//如何获取数组中的随机索引
/*
int[] arr = {1,2,3,4,5};
//索引范围：0 1 2 3 4
Random r = new Random();
int randomIndex = r.nextInt(arr.length);
System.out.println(randomIndex);
*/
//1.定义数组存储1~5
int[] arr = {
1,2,3,4,5};
Random r = new Random();
for(int i = 0; i < arr.length; i++){
//生成一个随机索引
int randomIndex = r.nextInt(arr.length);
//拿着随机索引指向的元素跟i指向的元素进行交换
int temp = arr[i];
arr[i] = arr[randomIndex];
arr[randomIndex] = temp;
}
//当循环结束之后，那么数组中所有的数据已经打乱顺序了
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i] + " ");
}
}
}
九、数组的内存图
1. Java的内存分配
① 栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行
② 堆：存储对象或者数组，new来创建的，都存储在堆内存
③ 方法区：存储可以运行的class文件
④ 本地方法栈：JVM在使用操作系统功能的时候使用，和我们开发无关
⑤ 寄存器：给CPU使用，和我们开发无关
注意：
从JDK8开始，取消方法区，新增元空间。把原来方法区的多种功能进行拆分，有的功能放到了堆中，有的功能放到了元空间中。
2. 数组的内存图
① 只要new出来的一定是在堆里面开辟了一个小空间
② 如果new了多次，那么在堆里面有多个小空间，每个小空间中都有各自的数据
3. 两个数组指向同一个空间的内存图
当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候都是修改之后的结果了