java数组基础详解
目录
数组
一. 数组概述
二. 数组声明和创建
三. 内存分析
1.JAVA内存有：堆，栈，方法区····
2.静态初始化：创建+赋值
3.动态初始化：前面其实就是动态初始化，是分开写的。没有赋值的，为该类型的默认初始化值
4.下标区间 [ 0 , length-1 ] 。下标越界报错：java.lang.ArrayIndexOutOfBoundsException
1.For-Each 循环 （省掉了下标的使用）
2.常规 for 循环
3.数组作方法入参
4.数组作返回值。比如反转数组里的元素
四. 数组的使用
总结
数组
博客园好像炸了，在维护中。
一. 数组概述
相同类型数据的有序集合
数组描述的是相同类型的若干个数据。按照一定的先后次序排列组合而成
每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们
数组本身就是对象，数组对象本身是存在堆中的
一旦创建，大小不可改变，长度确定
二. 数组声明和创建
1.首先必须声明数组变量。才能在程序中使用数组
int[] nums;//主要用这样的方式
int nums[];//这样也行，不建议
nums = new int[10];//创建一个储存10个数据的数组
int[] nums = new int[10];//也可以这样写，把声明和创建放一起
2.数组的下标，或者说数组的索引是从[0] 开始的
int[] nums = new int[10];
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
nums[5]=6;
nums[6]=7;
nums[7]=8;
nums[8]=9;
nums[9]=10;
当一个位置没有数据时，会得到类型的默认值，如 int 会得到 0，String 会得到 null 。
3.可以用 arrays.length 获取数组长度。数组的长度是确定的，确定之后不可变的。切记不要下标越界
int[] nums = new int[10];
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
nums[5]=6;
nums[6]=7;
nums[7]=8;
nums[8]=9;
nums[9]=10;
int sum = 0;//求和
for(int i = 0; i < nums.length; i++){
sum = sum + nums[i];
System.out.println(sum);
}
三. 内存分析
1.JAVA内存有：堆，栈，方法区····
堆：存放new的对象和数组。可以被所有的线程共享，不会存放别的对象引用
栈：存放基本变量类型（包括这个类型的具体数值）。引用对象的变量（会存放这个引用在堆里的具体地址）
方法区：可以被所有的线程共享。包含了所有的class和static变量
·····还有其他，后面学到再提
2.静态初始化：创建+赋值
//如int个数组
int[] a = {1,2,3,4,5,6,7,8,9,10};
System.out.println(a[0])；
//也可以是引用类型
Man[] mans = {new Man(1,1),new Man(2,2)}
3.动态初始化：前面其实就是动态初始化，是分开写的。没有赋值的，为该类型的默认初始化值
int[] a = new int[10];
a[0]=1;
a[1]=2;
这里a[3] , a[4]····没有赋值，那么就是int的默认初始化值 0
4.下标区间 [ 0 , length-1 ] 。下标越界报错：java.lang.ArrayIndexOutOfBoundsException
综合举例：
运行结果：
四. 数组的使用
1.For-Each 循环 （省掉了下标的使用）
int[] nums = {1,2,3,4,5,6,7,8,9};
//常规for循环打印全部元素
for(int i = 0; i< nums.length; i++){
System.out.println(nums[i]);
}
//利用for-each循环
for(int num : nums){
System.out.println(num);
}
2.常规 for 循环
3.数组作方法入参
4.数组作返回值。比如反转数组里的元素
二维数组和冒泡排序
1.二维数组
//遍历二维数组
public class Array001 {
public static void main(String[] args) {
//创建二维数组
int[][] a = {{1,2},{5,7},{9,6},{9,5,4},{6,5,4,9,1,2,3}};
//遍历二维数组的外部数组
for(int i=0; i<a.length; i++) {
//j作为二维数组内部数组的下标，长度是 a[i].length
for(int j=0; j<a[i].length;j++) {
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
/*
* a[0][0] a[0][1]
* a[1][0] a[1][1]
* a[2][0] a[2][1]
* a[3][0] a[3][1] a[3][2]
* a[4][0] a[4][1] a[4][2] a[4][3] a[4][4] a[4][5] a[4][6]
*
*/
2. 冒泡排序
//冒泡排序
import java.util.Arrays;
public class Test001 {
public static void main(String[] args) {
//创建一个数组
int[] a = {12,45,2,6,48,23,9};
method(a);
System.out.println(Arrays.toString(a));
}
/* 12与45比较然后排序不变，45与2比较然后排序为12,2,45,6····45与6比较然后排序12,2,6,45,48····以此类推，第一轮的结果就是12,2,6,45,23,9,48 */
//第二轮2,6,12,23,9,45,48
//第三轮···
//可以发现比较的轮数为数组长度a.length-1
private static void method(int[] a) {
//定义变量i，表示比较的轮数
for(int i =1; i<a.length; i++) {
for(int j = 0; j<a.length-1; j++) {
//比较相邻元素的大小，并交换值
if( a[j]>a[j+1] ) {
int t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
}
}
总结
本篇文章的内容就到这里了，希望能给你带来帮助，也希望您能够多多关注无名的其他内容！