一维数组
创建数组只指定长度但不指定内容
数据类型[] 数组名 = new 数据类型[长度];
例如:int [] ArraryDemo=new int [10];
double [] ArraryDemo=new double[10];
String [] ArraryDemo=new String[10];
创建数组指定内容(同时长度就确定了)
数据类型[] 数组名 = new 数据类型[]{数据1, 数据2, 数据3, ..., 数据n};
数据类型[] 数组名 = {数据1, 数据2, 数据3, ..., 数据n};
例如:int [ ] arr=new int [ ]{12,13,14,15,16};
double [ ] arr=new double [ ]{12.2,13.0,16.5,17.0};
String [ ] arr=new String [ ]{"张三","李四","王五"};
动态初始化数组默认值规则
public class ArraryDemo(){
public static void main(String []args){
//整形动态数值化数组的默认值为0
int []ArraryIntDemo=new int[5];
System.out.println(ArraryIntDemo[1]);
//字符型动态数组的默认值为0
char []ArraryCharDemo=new char[5];
System.out.println((int)ArraryCharDemo[1]);
//浮点型动态初始化数组的默认值0.0
double []ArraryDoubleDemo=new double[5];
System.out.println(ArraryDoubleDemo[1]);
//布尔类型动态初始化数组的默认值false
boolen []ArraryBoolenDemo=new boolen[5];
System.out.println(ArraryBoolenDemo[1]);
//引用类型动态初始化数组默认值null
String ArraryStrDemo=new String[5];
System.out.println(ArraryStrDemo[1]);
}
}
数组遍历
运用数组名调用length可以得出数组的长度,最大索引值是数组长度-1。
public class ArrayTraversal {
public static void main(String[] args) {
int[] arr = new int[] { 1, 2, 3, 4, 5, 6 };
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
for (int i : arr) {
System.out.println(i);
}
}
}
数组的注意事项:
1、什么类型的数组存放什么类型数据
2、数组一旦被定义出来,执行过程中长度类型就固定了
3、数组的索引值不能超过数组的长度,否侧程序会报错无法运行
4、当已经知道存入的元素值时 用静态数组初始化
5、当不知道要存入数组的数据时 用动态数组初始化
数组的内存分配
理解数组的内存分配对学习数组至关重要,程序在运行时主要有,方法区、栈内存、堆内存,
方法区:字节码文件加载时进入的内存,例如HolloWorld.class
堆内存:new出来的东西会在这块内存中开辟空间并产生地址
栈内存:方法运行时所进入的内存,另外变量也在这里。
public class ArrMemory(){
public static void main(String args[]){
int i=5;//普通变量所存储的就是他本身的值
int []Arr=new int[]{1,2,3};
Arr[0]=11;
Arr[1]=22;
Arr[2]=33;
for(int i=0;i<Arr.length-1;i++){
System.out.println(Arr[i]);
}
}
}
程序开始运行时
1、首先将程序编译成ArrMemory.class文件并加载到方法区
2、将main()方法加载到栈内存,开始运行第一行代码i=5,将在栈内存中开辟一个a变量的区域将5存储到里边,然后在开辟一个空间用来存放数组变量Arr,随即系统将会在堆内存中开辟一段的数组空间用来存放数组元素,并将产生的地址赋值给数组变量Arr。
3、然后就可以通过数组变量Arr来访问堆内存中的数组元素
数组排序
1.插入排序
将待插元素,依次与已排序好的子数列元素从后到前进行比较,如果当前元素值比待插元素值大,则将移位到与其相邻的后一个位置,否则直接将待插元素插入当前元素相邻的后一位置,因为说明已经找到插入点的最终位置
public static void sort(int[] arr) {
if (arr.length >= 2) {
for (int i = 1; i < arr.length; i++) {
//挖出一个要用来插入的值,同时位置上留下一个可以存新的值的坑
int x = arr[i];
int j = i - 1;
//在前面有一个或连续多个值比x大的时候,一直循环往前面找,将x插入到这串值前面
while (j >= 0 && arr[j] > x) {
//当arr[j]比x大的时候,将j向后移一位,正好填到坑中
arr[j + 1] = arr[j];
j--;
}
//将x插入到最前面
arr[j + 1] = x;
}
}
}
2.冒泡排序
从数列的第一个元素
开始,然后依次和剩余的元素进行比较, 跟列队一样, 从左到右两两相邻的
元素比大小, 高的就和低的换一下位置. 最后最高值就排到后面了.重复数列长度-1次
public static void sort(int[] arr){
for (int i = 1; i < arr.length; i++) { //第一层for循环,用来控制冒泡的次数
for (int j = 0; j < arr.length-1-i; j++) {//第二层for循环,用来控制冒泡一层层到最后
//如果前一个数比后一个数大,两者调换 ,意味着泡泡向上走了一层
if (arr[j] > arr[j+1] ){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
3.选择排序
首先在未排序数列中找到最小元素
,然后将其与数列的首部元素
进行交换,然后,在剩余未排序元素中继续找出最小元素,将其与已排序数列的末尾位置元素交换。以此类推,直至所有元素圴排序完毕
private static void selectSort() {
int[] arr = { 6, 9, 1, 5, 2, 3, 8, 4, 7 };
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[j] = arr[i];
arr[i] = temp;
}
}
}
}
数组查找
二分查找
public static int binarySearch01(int[] arr, int target) {
int start = 0, end = arr.length - 1;
while (start <= end) {
int middle = (start + end) >> 1;
if (arr[middle] > target) {
end = middle - 1;
} else if (arr[middle] < target) {
start = middle + 1;
} else {
return middle;
}
}
return -1;
}
二维数组
就是一个由行和列组成的一个表格而已,矩阵Matrix。
在这个矩阵中访问元素的话,是根据元素的行角标和列角标所确定的。
二维数组具体是在内存中如何存储的呢?
无论是二维数组,还是多维数组,它们本身就是一个一维数组。
尤其对于二维数组而言,无非就是一个一维数组,只不过该一维数组中的每一个元素是另一个
一维数组罢了。
定义方式
数据类型[][] 变量名称 = new 数据类型[行数][列数];
//创建一个3行4列的二维数组,元素默认都是0
int[][] matrix = new int[3][4];
//创建个指定元素的二维数组
int[][] matrix = new int[][]{
{ 1, 2, 3, 4 } ,
{ 5, 6, 7, 8 } ,
{ 9, 10, 11, 12 }
};
遍历二维数组
遍历二维数组就是获取每个数组中的元素,在遍历时需要使用双层for循环,通过数组的length属性可获取数组的长度。
public static void main(String[] args) {
int[][] arr = new int[][]{
{ 1, 2, 3, 4 } ,
{ 5, 6, 7, 8 } ,
{ 9, 10, 11, 12 }
};
for(int i=0;i<arr.length;i++) {
for(int j=0;j<arr[i].length;j++) {
System.out.print(arr[i][j]+" ");//输入元素
}
System.out.println();//换行
}
}
结果: