本文详细介绍了JavaSE中数组的基础概念，包括一维数组的定义、动态与静态初始化、获取长度、索引与元素操作，以及二维数组的使用、内存模型和遍历方法。
JavaSE数组
一维数组
定义
数组本身相当于容器，一次性可以存储多个数据，数组本身属于引用类型。
特点：
- 既可以存储基本数据类型，还能够存储引用数据类型
- 定长（定义数组时长度为多长，最多就能存多少个数据）
格式：
动态初始化：
数据类型[] 数组名 = new 数据类型[长度]
数据类型 数组名[] = new 数据类型[长度] //支持C语言样式，不推荐
注：
等号左边的数据类型，规定了数组中只能存储什么类型的元素
[]： 代表数组，一个[]代表一维数组，两个[][]代表二维数组
数组名：自己命名 遵循小驼峰命名法
new： 代表创建数组
等号右边的数据类型： 与等号左边的数据类型保持一致
[长度]: 指定数组的长度数组最多能村多少个元素
静态初始化：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...} //直接指定值和大小
数据类型 数组名[] = new 数据类型[]{元素1,元素2,元素3...}
简化的静态初始化:
数据类型 [] 数组名 ={元素1,元素2,元素3,...} //这是java10版本以后定义数组的简写形式
动态初始化与静态初始化的区别：
动态初始化：定义的时候指定了长度，没有具体的数据。当直到长度，但不知道具体存啥数据时可以使用动态初始化数据。
静态初始化：定义的时候就知道存啥具体数据类型及长度
public class demo01 {
public static void main(String[] args) {
//动态初始化
int[] arr1 = new int[3];
String[] arr2 = new String[4];
//静态初始化
int[] arr3 = new int[]{1,2,3,4,5,6};
//简化静态初始化
int[] arr4 = {1,2,4,5,6};
String[] arr5 = {"张三","李四","王二","王五"};
}
}
获取数组长度
格式：
数组名.length
public class demo01 {
public static void main(String[] args) {
int[] arr3 = new int[]{1,2,3,4,5,6};
//获取数组长度
System.out.println(arr3.length);
}
}
注意：
length后面不要带小括号，因为length不是一个方法而是数组中的一个属性
索引
概述：索引时元素再数组中的位置
特点：
索引是唯一的
做因是从0开始的，最大索引是数组长度-1
作用：对数组中的元素进行存、取、查都是通过索引来完成的
String[] arr5 = {"张三","李四","王二","王五"};
[0] [1] [2] [3] //索引
存储元素
格式： 数组名[索引值] = 值 将等号右边的值放到数组指定的索引上
int[] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 6;
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
获取元素
地址值：地址值是数组在内存中唯一标识，我们可以通过地址值在内存中精确的找到这个数，从而操作数组中的数据。
注意：
1、直接输出数组名，会直接输出数组在内存中的地址值
2、如果数组中没有存元素，在使用索引获取对应的元素也是有值的，只不过是数组中元素默认类型。
public class Demo05Array {
public static void main(String[] args) {
int[] arr = new int[3];
arr[0] = 100;
arr[1] = 200;
arr[2] = 300;
System.out.println(arr);//[I@135fbaa4 -> 地址值
System.out.println(arr[0]);//输出0索引上的元素
System.out.println(arr[1]);//输出1索引上的元素
System.out.println(arr[2]);//输出2索引上的元素
int[] arr1 = new int[3];
arr1[0] = 1000;
arr1[1] = 2000;
arr1[2] = 3000;
System.out.println(arr1);//[I@45ee12a7
System.out.println(arr1[0]);//输出0索引上的元素
System.out.println(arr1[1]);//输出1索引上的元素
System.out.println(arr1[2]);//输出2索引上的元素
System.out.println("=============================");
int[] arr2 = new int[3];
System.out.println(arr2[0]);//输出0索引上的元素 0
System.out.println(arr2[1]);//输出1索引上的元素 0
System.out.println(arr2[2]);//输出2索引上的元素 0
}
}
遍历数组
通过for循环将数组中的元素分别掉出来
public class Demo07 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
快速遍历快捷键: 数组名.fori
练习
1、求出数组中的元素最大值
public class training01 {
public static void main(String[] args) {
//求出数组中元素最大值
int[] arr = {2,34,56,12,43,45,21,30};
int max =arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]){
max = arr[i];
}
}
System.out.println("arr中最大值时"+max);
}
}
2、随机产生10个[0,100]之间整数，统计既是3又是5，但不是7的倍数的个数
public class trainning02 {
public static void main(String[] args) {
//随机产生10个[1,100]之间整数，统计即使3又是5，但不是7个数的倍数
Random data = new Random();
int[] arr = new int[10];
int count=0;
for (int i = 0; i < arr.length; i++) {
arr[i] = data.nextInt(101);
}
for (int j = 0; j < arr.length; j++) {
if (arr[j]%3==0 && arr[j]%5==0 && arr[j]%7!=0){
count++;
}
}
System.out.println(count);
}
}
3、用一个数组存储本组学员的姓名，从键盘输入，并遍历显示
public class training03 {
public static void main(String[] args) {
//用一个数组存储本组学员的姓名，从键盘输入，并遍历显示
String[] data = new String[3];
Scanner sc = new Scanner(System.in);
data[0] = sc.next();
data[1] = sc.next();
data[2] = sc.next();
for (int i = 0; i < data.length ; i++) {
System.out.println(data[i]);
}
}
}
4、定义一个数组 int[] arr = {1,2,3,4}，遍历数组,输出元素按照[1,2,3,4]
public static void main(String[] args) {
/*
* 需求:
1.定义一个数组 int[] arr = {1,2,3,4}
2.遍历数组,输出元素按照[1,2,3,4]
* */
int [] arr = {1,2,3,4};
System.out.print("[");
for (int i = 0; i <arr.length ; i++) {
if(i== arr.length-1){
System.out.print(arr[i]+"]");
} else {
System.out.print(arr[i]+",");
}
}
}
}
5、 需求:随机50个1-100之间的整数,统计偶数个数
public class training05 {
public static void main(String[] args) {
//随机50个[1-100]之间的整数，统计偶数个数
int count =0;
Random data = new Random();
int[] arr = new int[50];
for (int i = 0; i < arr.length ; i++) {
arr[i]= data.nextInt(101);
if (arr[i]%2 == 0){
count++;
}
}
System.out.print(count);
}
}
6、键盘录入一个整数,找出整数在数组中存储的索引位置
public class traning06 {
public static void main(String[] args) {
//键盘录入一个整数,找出整数在数组中存储的索引位置
Scanner data = new Scanner(System.in);
int num = data.nextInt();
int[] arr = {1,2,34,45,67,12,43,34,49};
for (int i = 0; i < arr.length; i++) {
if (num ==arr[i]){
System.out.print("在arr数组中的下标为"+i);
}
}
}
}
数组的复制、扩容、合并
1、数组复制：将arr1数组中的内容复制给arr2
public class training07 {
public static void main(String[] args) {
//将arr1数组中的内容复制给arr2
int[] arr1 = {1,2,3,4,5};
int[] arr2 = new int[5];
for (int i = 0; i < arr1.length; i++) {
arr2[i]=arr1[i];
System.out.print(arr2[i]);
}
}
}
/*
如果数组名[索引值]在等号右边就代表获取
如果数组名[索引值]在等号左边就代表存值
eg:
int element = arr[0] -> 获取0索引上的元素,赋值给一个变量
arr[0] = 100 -> 将100存储到0索引上
arr[0] = arr1[0] -> 将arr1的0索引上的元素获取出来,赋值给等号左边arr的0索引上
*/
2、数组扩容：将数组int[] arr ={1,2,4,5} 由原来的长度扩容到10
public class traning07 {
public static void main(String[] args) {
int[] arr = {1,3,4,5};
int[] arr1 = new int[10];
for (int i = 0; i < arr.length; i++) {
arr1[i] = arr[i];//新数组接受老数组中的元素
}
arr =arr1; //将新数组的内存地址传给老数组
for (int j = 0; j < arr.length; j++) {
System.out.print(arr[j]);
}
}
}
3、数组合并：将arr和arr1合并到arr2数组中
public class traning08 {
public static void main(String[] args) {
//数组合并 将arr和arr1合并到arr2数组中
int[] arr = {2,3,5,76,5,12,34,78};
int[] arr1 ={3,4,1,65,9,34,1,65,56,64,12};
//创建新的数组
int[] arr2 = new int[arr.length + arr1.length];
for (int i = 0; i <arr.length ; i++) {
arr2[i] = arr[i];
}
/**
* 已经保存arr的元素 当我们再保存arr1的元素时不能从0开始引用否则会将前面保存的数字覆盖掉
* */
//获取arr的长度
int length = arr.length;
for (int j = 0; j < arr1.length; j++) {
arr2[length+j] = arr1[j];
}
for (int k = 0; k <arr2.length ; k++) {
System.out.print(arr2[k]+",");
}
}
}
数组与内存
在java的世界中内存被分为：栈、堆、方法区、本地方法栈、寄存器
1、栈(Stack) 主要运行方法，所有的方法都会去内训中运行，运行结束后会弹栈，从而腾出更多空间
2、堆(Heap) 每new一次，都会在堆内存中开辟新的空间，并且为其分配内存地址
3、方法区(Method Area) 代码的预备区，记录了类的信息和方法的信息
4、本地方法栈 相当于java的功能扩充，很多java语言实现不了的就依靠本地方法
5、寄存器 与cpu有关
以上内存概念：1~3为重点 4~5为了解即可
如果我们创建两个数组，堆内存中会开辟两个不同的空间，两数组之间互不影响
二维数组
概述及格式
概述：数组中套多个数组
定义格式：
动态初始化
数据类型[][] 数组名 = new 数据类型[m][n]
数据类型 数组名[][] = new 数据类型[m][n]
数据类型[] 数组名[] = new 数据类型[m][n]
m:代表的是二维数组的长度
n:代表的是二维数组中每一个一维数组的长度
数据类型[][] 数组名 = new 数据类型[m][] -> 二维数组中的一维数组没有被创建
静态初始化
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
数据类型 数组名[][] = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
数据类型[] 数组名[] = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
c.简化静态初始化:
数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
数据类型 数组名[][] = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
数据类型[] 数组名[] = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
public class demo02 {
public static void main(String[] args) {
int[][] arr = new int[3][4];
arr[0][1] = 4;
arr[0][3]= 5;
arr[2][2] = 9;
System.out.println(arr[0][1]);
System.out.println(arr[0][3]);
System.out.println(arr[2][2]);
}
}
二维数组长度
格式
数组名.length
获取每个一维数组长度，需要先遍历二维数组，将每个一维数组从二维数组中拿出来
public class Demo {
public static void main(String[] args) {
int[][] arr = {{1,4},{78,45,90},{23,56}};
System.out.println(arr.length);
for (int i = 0; i < arr.length; i++) {
//arr[i]代表的是每一个一维数组
System.out.println(arr[i].length);
}
}
}
获取二维数组中的元素
格式
数组名[i][j]
i 代表一维数组在二维数组中的索引位置
j 代表元素在一维数组中的索引位置
public class demo01 {
public static void main(String[] args) {
int[][] arr = {{1,34},{34,67},{32,78},{67,43},{89,90},{56,43}};
System.out.print(arr[1][1]);
System.out.print(arr[2][0]);
System.out.print(arr[0][0]);
}
}
二维数组遍历
先遍历二维数组，将每一个一维数组遍历出来，再遍历每一个一维数组，将元素取出来
public class demo03 {
public static void main(String[] args) {
int[][] arr = new int[2][2];
arr[0][0] = 1;
arr[0][1] = 2;
arr[1][0] = 4;
arr[1][1] = 6;
//遍历二维数组
for (int i = 0; i < arr.length ; i++) {
for (int j = 0; j < arr.length; j++) {
System.out.print(arr[i][j]);
}
}
}
}
总结
156
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
