java：6 数组
文章目录
- 数组array
-
- 1. 介绍
- 2. 入门练习
- 3. 数组的使用
-
- 3.1 使用方法一：动态初始化
- 3.2 使用方法二：动态初始化
- 3.3 使用方法三：静态初始化
- 4. 数组的细节
- 5. 数组的应用
- 6. 数组赋值机制
- 7. 数组拷贝
- 8. 数组反转（2种）
数组array
[数组、排序、查找、多维数组]
1. 介绍
- 数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。
即:数(数据)组(一组)就是一组数据。
2. 入门练习
它们的体重分别是 3kg,5kg,1kg,3.4kg,2kg,50kg 。 请问这六只鸡的总体重是多少?平均体重是多少?
- 注意：可以用数组名.length 得到数组的长度/大小。
public class Test {
public static void main(String[] args) {
/*
它们的体重分别是 3kg,5kg,1kg,3.4kg,2kg,50kg 。
请问这六只鸡的总体重是多少?平均体重是多少?
定义一个数组
1. double[]表示一个double类型的数组。
2. hens表示数组名。
3. {3, 5, 1, 3.4, 2, 50} 表示数组的值/元素，依次表示数组第几个元素。
遍历数组，得到所有元素的和，用for
1. 通过hens[下标]来访问数组的元素，下标从0开始。
2. 【第一个元素 = hens[0]】
3. 通过for循环就可以循环访问数组的元素。
4. 使用一个变量 totalWeight把所有元素累加起来。
5.可以用数组名.length 得到数组的长度
*/
double[] hens = {3, 5, 1, 3.4, 2, 50};
double totalWeight = 0;
//可以用数组名.length 得到数组的长度
for(int i = 0; i < hens.length; i++){
totalWeight += hens[i];
}
System.out.println("总体重 = " + totalWeight + "平均体重 = " + totalWeight / hens.length);
}
}
3. 数组的使用
3.1 使用方法一：动态初始化
- 数组的定义
比如： int a[] = new int[5]; //创建了一个数组，名字a,存放5个int。
数组内存图：
- 数组的引用
数组名[index]
比如：你要使用a数组的第3个数 a[2]。
- 案例
循环输入5个成绩，保存到double数组,并输出。
public class Test {
public static void main(String[] args) {
//步骤：
//1. 创建一个double数组，大小为5
double[] scores = new double[5];
//2. 循环输入
import java.util.Scanner;
Scanner myScanner = new Scanner(System.in);
for(int i = 0; i < scores.length; i++){
System.out.println("请输入第" + (i + 1) + "个元素的值");
scores[i] = myScanner.nextDouble();
}
//3. 输出，遍历上面的数组
for(int i = 0 ;i < scores.length; i++){
System.out.println("第" + (i + 1) + "个元素的值 = " + scores[i]);
}
}
}
3.2 使用方法二：动态初始化
- 先声明数组
比如：int a[]; 或者 int[] a;
- 创建数组
比如： a=new int[10];
- 案例演示【前面代码修改】
public class Test {
public static void main(String[] args) {
//先声明一个叫scores的数组。
double[] scores
//再new分配内存空间来存放数据。
scores = new double[5];
}
}
3.3 使用方法三：静态初始化
- 初始化数组
int a[]={2,5,6.7,8,89,90,34,56}，如果知道数组有多少元素，具体值
相当于：int a[] = new int[9] :
a[0]=2:a[1]=5:a[2]=6; a[3]=7:a[4]=8;
a[5]=89;a[6]=90;a[7]=34;a[8]= 56;
- 快速入门案例【养鸡场】
double hens[] = {3, 5, 1, 3.4, 2, 50};
等价于
double hens[] = new double[6];
hens[0] = 3; hens[1] = 5; hens[2] = 1; hens[3] = 3.4; hens[4] =2; hens[5] = 50;
4. 数组的细节
- 数组是多个相同类型数据的组合，实现对这些数据的统一管理。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
- 数组创建后，如果没有赋值，有默认值。
int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null - 使用数组的步骤【1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组】
- 数组的index从0开始。
- 数组index必须在指定范围内使用，否则报:index越界异常，比如int [] arr=new int[5]; 则有效index为 0-4。
- 数组属于引用类型，数组型数据是对象(object)。
5. 数组的应用
- 创建一个char类型的26个元素的数组，分别放置’A’-‘Z’。使用for循环访问所有元素并打印出来。提示:char类型 数据运算 ‘A’+2 -> ‘C’
【注意⚠️：这里的‘A’ + i是int类型的变量值，需要强制转换。因为：char类型可以保存int的常数值，但不能保存int的变量值，需要强转。】
public class Test {
public static void main(String[] args) {
//定义一个数组
char chars[] = new char[26];
//因为‘A’ + 1 = 'B'
for(int i = 0; i < chars.length; i++){
//chars是char[]类型。
//chars[i]是char类型。
//这里的‘A’ + i是int类型，需要强制转换。
chars[i] = (char)('A' + i);
}
for(int i = 0; i < chars.length; i++){
System.out.print(chars[i] + ' ');
}
}
}
- 请求出一个数组int[]的最大值{4,-1,9,10,23}，并得到对应的下标。
public class Test {
public static void main(String[] args) {
//1.定义一个数组
int[] arr = {4,-1,9,10,23};
//2.假设arr[0]是max。如果max < 当前值，max = 当前值。
int max = arr[0];
int maxIndex = 0;
for(int i = 1; i < arr.length; i++){
//条件筛选
if(max < arr[i]){
max = arr[i];
maxIndex = i;
}
}
System.out.println("max = " + max + "maxIndex = " + maxIndex);
}
}
- 请求出一个数组的和以及平均值。(养鸡场)
public class Test {
public static void main(String[] args) {
//double[] hens = {3, 5, 1, 3.4, 2, 50};
double[] hens = {3, 5, 1, 3.4, 2, 50};
doubel totalWeight = 0;
for(int i = 0; i < hens.length; i++){
totalWeight += hens[i];
}
System.out.println("数组和 = " + totalWeight + "数组平均值 = " + totalWeight / hens.length)
}
}
6. 数组赋值机制
- 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。
比如：int n1 = 2; int n2 = n1; （n2的变化不影响n1。） - 数组在默认情况下是引用传递，赋的值是地址。
【分析数组赋值的内存图(重点, 难点. )】
【可以理解为给数组取了另一个名字，对应表达的是同一个人（地址）】
public class Test {
public static void main(String[] args) {
//什么是引用传递（地址拷贝）
int[] arr1 = {1,2,3};
int[] arr2 = arr1; //把arr1的地址赋给arr2.
//arr2的变化会影响arr1。
arr2[0] = 10;
//看一下arr1的值。
for(int i = ; i < arr1.length; i++){
System.out.print(arr1[i]);//输出{10,2,3}
System.out.print(arr2[i]);//输出{10,2,3}
}
}
}
- 粉色框–>地址（门牌号）
- 在内存里只有分配了空间，就一定对应一个地址。
7. 数组拷贝
- 将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组。要求数据空间是独立的。
编写代码 实现数组拷贝(内容复制)
public class Test {
public static void main(String[] args) {
//将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组
//要求数据空间是独立的。
int[] arr1 = {10,20,30};
//先创建一个arr2，开辟新的数据空间，保证大小和arr1一样。
int[] arr2 = new int[arr1.length];
//for循环拷贝arr1的每个元素拷贝给arr2
//这样arr2的变化，就不会影响arr1。
for(int i = 0; i < arr1.length; i++){
arr2[i] = arr1[i];
}
}
}
8. 数组反转（2种）
要求:把数组的元素内容反转。
arr {11,22,33,44,55,66} {66, 55,44,33,22,11}
- 方式 1:通过找规律反转 【重点在于思路分析】
public class Test {
public static void main(String[] args) {
//定义数组
int[] arr = {11,22,33,44,55,66};
//1. 把arr[0]和arr[5]交换{66,22,33,44,55,11}
//2. 把arr[1]和arr[4]交换{66,55,33,44,22,11}
//3. 把arr[2]和arr[3]交换{66,55,44,33,22,11}
//4. 一共交换arr.length/2。
//5. 每次交换对应的index是arr[i]和arr[arr.length - 1 - i]
for(int i = 0; i < arr.length / 2; i++){
int temp = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = arr[i];
arr[i] = temp;
}
}
}
- 方式 2:使用逆序赋值方式
public class Test {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55,66};
//1. 创建一个新的数组arr2，大小和arr1一样。
int[] arr2 = new int[arr.length];
//2. 逆序遍历arr1，将每个元素拷贝到arr2当中（顺序拷贝）。
//建议增加一个循环变量，更简单。
for(int i = arr.length - 1, j = 0; i >= 0; i--, j++){
arr2[j] = arr[i];
}
//3. for循环结束后， arr2就是arr的逆序数组。
//arr指向arr2的数据空间。
//arr原来的数据空间没有变量应用，会被当作垃圾销毁。
arr = arr2;
}
}