一：概念
数组相当于存放东西的容器，用于存放数据（存放基本数据来类型和引用数据类型），数组中的数据称之为数组的元素，数组是一个引用数据类型。数组的长度不可改变。
二: 创建方式
动态初始化:
定义数组指定数组长度,但是没有给数组中存放数据
注意:
| byte | 0 |
|---|---|
| short | 0 |
| int | 0 |
| long | 0 |
| float | 0.0 |
| double | 0.0 |
| boolean | false |
创建方式:
数组存储的数据类型[ ] 数组名称 = new 数组存储的数据类型 [ 数组的长度 ] ;
案例:
int [ ] arr = new int [10] ;
public class Demo{
public static void main(String[] args){
int[] arr=new int[10];
}
}静态初始化：
定义数组显示赋值
创建方式一：
数据类型[ ] 数组名称 = new 数据类型[ ]{元素1，元素2，元素3......}
案例:
int[ ] arr = new int[ ]{10,20,30};
public class Demo{
public static void main(String[] args){
int[] arr=new int[]{10,20,30};
}
}创建方式二（常用）:
数据类型[ ] 数组名称 = {元素1，元素2，元素3......}
案例:
public class Demo{
public static void main(String[] args){
}
}三:获取数组中的数据
数组名[索引]；
案例：
public class Demo{
public static void main(String[] args){
int[] arr={10,20,30};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
int a=arr[0];
int b=arr[1];
int c=arr[2];
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}四：修改数组中的数据
数组名[索引]=值；
案例:
public class Demo{
public static void main(String[] args){
int[] arr={10,20,30};
int a=arr[0];
int b=arr[1];
int c=arr[2];
System.out.println(a); //10
System.out.println(b); //20
System.out.println(c); //30
//修改第一个数据为50
arr[0]=50;
int a2 = arr[0];
System.out.println(a2); //50
}
}五:数组的length属性
可通过length属性获取数组的长度
案例：
public class Demo{
public static void main(String[] args){
int[] arr={10,20,30};
//通过数组的length属性获取数组长度
int length = arr.length;
System.out.println(length); //3
}
}六：遍历数组的三种方式
public class Demo{
public static void main(String[] args){
int[] arr={10,20,30};
//快捷键 fori
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("================================================");
//快捷键 itar
for (int i = 0; i < arr.length; i++) {
int i1 = arr[i];
System.out.println(i1);
}
System.out.println("================================================");
//快捷键 iter
for (int i : arr) {
System.out.println(i);
}
}
}
七:求数组中元素的和
public class Demo{
public static void main(String[] args) {
int[] arr={10,20,30};
//定义一个值为0的变量count计数
int count=0;
for (int i = 0; i < arr.length; i++) {
/*
* 逻辑：
* i=0 索引0<数组长度3 true count=count+arr[i] count=0+arr[0]; count=0+10; count=10; i=1
* i=1 索引1<数组长度3 true count=count+arr[i] count=10+arr[1]; count=10+20; count=30; i=2
* i=2 索引2<数组长度3 true count=count+arr[i] count=30+arr[2]; count=30+30; count=60; i=3
* i=3 索引3<数组长度3 false 循环结束
* */
count+=arr[i];
}
//循环结束 打印输出count
System.out.println(count);
}
}八：求数组中的最大值
public class Demo {
public static void main(String[] args) {
//创建数组
int[] arr={10,15,32,24,56,75,85,99,61,100};
//定义一个变量max 默认值为数组第一个元素
int max=arr[0];
//从索引为1的第二个元素开始遍历数组
for (int i = 1; i < arr.length; i++) {
//循环判断数组 默认最大值max与从第二个元素开始遍历的元素逐一比较大小
if (max<arr[i]){
//将遍历到大的元素赋值给max
max=arr[i];
}
}
//循环结束 打印输出max
System.out.println(max); // 100
}
}
九.数组反转
public class Demo {
public static void main(String[] args) {
/*
* 1，2，3，4，5
* 5，4，3，2，1
* 第一个元素 最后一个元素
* 第二个元素 倒数第二个元素
* 第三个元素 倒数第三个元素
*
* 1，2，3，4，5，6
* 6，5，4，3，2，1
* 第一个元素 最后一个元素
* 第二个元素 倒数第二个元素
* 第三个元素 倒数第三个元素
*
* 五个元素的时候 交换2次
* 六个元素的时候 交换3次
* 交换的次数: 元素的个数/2
* */
int[] arr={1,2,3,4,5,6,55};
for (int i = 0; i < arr.length/2; i++) {
int tem ;
tem = arr[i];
arr[i]=arr[arr.length-1-i];
arr[arr.length-1-i]=tem;
}
System.out.println(Arrays.toString(arr));
}
}十.将数组作为参数传递：
public class Demo {
public static void main(String[] args) {
/*
* 数组当作方法的参数传递
* public static 返回类型 方法名(参数类型 参数1,参数类型 参数2){
* 方法语句体;
* return 返回值;
* }
*
* 数组当作方法的参数传递
* */
/* int[] arr = {1, 33, 44, 88, 32};
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
System.out.println("最大的元素为 " + max);*/
System.out.println("================================");
int[] arr = {1, 33, 44, 88, 32};
int max = getMax(arr);
System.out.println(max);
}
/*
* 定义一个方法求数组中的最大值
* 定义方法:
* 方法修饰符 public static
* 返回值类型 int
* 方法名 getMax
* 参数列表 参数个数 参数类型 int[] arr
* 方法的执行语句
* return 返回结果 return 数组中的最大元素
* */
public static int getMax(int[] arr) {
int max=arr[0];
for (int i = 1; i < arr.length; i++) {
if (max<arr[i]){
max=arr[i];
}
}
return max;
}
}十一.将数组作为返回类型
public class Demo {
public static void main(String[] args) {
/*
* 数组当作方法的返回类型
* public static 返回类型 方法名(参数类型 参数1,参数类型 参数2){
* 方法语句体;
* return 返回值;
* }
*
* 数组当作方法的返回结果
* */
int[] ints = get(10, 20);
System.out.println("和是 "+ints[0]);
System.out.println("差是 "+ints[1]);
}
/*
* 定义一个方法求两个数的和与差
* 定义方法:
* 方法修饰符 public static
* 返回值类型 int[]
* 方法名 get
* 参数列表 参数个数 参数类型 int a,int b
* 方法的执行语句
* return 返回结果 return arr (int[] arr是一个int类型的数组)
* */
public static int[] get(int a,int b){
int sum = a + b;
int cha = a - b;
int[] arr={sum,cha};
return arr;
}
}
十二.数组的创建原理:
图示:
数组原理文字描述:
将创建数组的Demo类的字节码文件（class文件）加载进JVM内存中的方法区，Demo类中的main方法在栈内存中执行，俗称压栈执行，在堆内存中开辟新的空间，执行new int[ ]操作来创建数组，完事将堆内存中new int[ ]操作创建数组所开辟空间的内存地址赋值给栈内存中数组变量名，或者栈内存中的数组变量名通过堆内存中new int[ ]操作创建数组所开辟空间的内存地址找到开辟的内存空间所创建的数组，这也就是为什么说数组是引用数据类型
5765
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
