数组操作

来源：互联网发布：linux退出文件保存编辑：程序博客网时间：2024/05/18 02:55

数组：同一种数据类型的集合，其实数组就是一个容器

自动给数组中的元素从0开始编号，方便操作这些元素。

定义：

方式1：数据类型[] 数组名 = new 数据类型[数组长度或元素个数];

方式2：数据类型[] 数组名 = new 数据类型[]{元素，元素，元素，...};

java内存结构：

栈内存：用于存储局部变量，当数据使用完，自动释放所占空间

堆内存：数组和对象，通过new建立的实例都存放在堆内存中。

每一个实体都有内存地址值

实体中的变量都有默认的初始化值

实体不再被使用，会在不确定的时间内被垃圾回收器回收

方法区：本地方法区，寄存器

定义功能，打印数组中的元素，元素间用逗号隔开：

public static void printArray(int[] arr){
System.out.print("[");//给数组加上中括号
for(int i = 0 ; i < arr.length ;i++){
if(i != arr.length - 1){
//如果不是最后一个元素，就打印后面的逗号,并且不换行
Syetem.out.print(arr[i] + ", ");
}
else{
//如果是最后一个元素，就直接打印最后一个，并且换行
Syetem.out.println(arr[i] + "]");
}
}

}

数组获取最值：
思路：1.获取最值需要进行比较，每一次比较都会有一个较大或较小的值，因为该值不确定，
通过一个变量进行临时存储
2.让数组中的每一个元素都和这个变量的值比较
如果大于了变量中的值，就用该变量记录最大值
3.当所有的元素都比较完成，那么该变量存储的就是数组中的最大值

步骤：1.定义变量，初始化为数组中的任意一个元素即可
2.通过循环语句对数组进行遍历
3.在遍历过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量
需要定义一个功能来完成，以便提高复用性
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 static void selectSort(int[] arr){
//-1可以减少一次比较
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[i] = arr[j];
arr[j] = temp;
}
}
}
}

//需要完成最终排序的次数，每次把最大的放最后面
for (int i = 0; i < numbers.length - 1; i++) {
int minIndex = i ;
for (int j = i; j < numbers.length; j++) {
if(numbers[minIndex] > numbers[j]){
minIndex = j;
}
}
//如果当前索引与minIndex不相等，才进行交换
if(i != minIndex){
//找到最小数后实现交换
int temp = numbers[i];
numbers[i] = numbers[minIndex];
numbers[minIndex] = temp;
}
}

//冒泡排序：

每一轮把最大的那个数放在最后：如：

5，4，3，2，1，0

第一轮：4，3，2，1，0，5

第二轮：3，2，1，0，4，5

第三轮：2，1，0，3，4，5

第四轮：1，0，2，3，4，5

第五轮：0，1，2，3，4，5
public static void bubbleSort (int[] arr){
for(int i = 0; i < arr.length - 1 ; i++){
//-i:让每一次比较的元素减少；
//-1：避免角标越界
for(int j = 0 ; j < arr.length -i - 1 ; j++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arrr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

Java提供的排序方法：Arrays.sort(arr);开发中对数组排序要使用该句代码

//排序位置置换功能抽取：
发现无论什么排序都需要对满足条件的元素进行位置置换，可以把这部分代码提取出来，单独封装成一个函数
public static void swap( int[] arr ,int a , int b){
int temp = arr[a] ;
arr[a] = arr[b] ;
arr[b] = temp ;
}

//数组的查找：

//定义功能：获取key第一次出现在数组中的位置，如果返回-1，代表该key在数组中不存在。
public static int getIndex(int[] arr , int key){
for(int i = 0 ; i < arr.length ; i++){
if(arr[i] == key){
return i;
}
return -1;
}
}

//折半查找提高效率，但必须保证数组是有序的
public static void int halfSearch(int[] arr , int key){
int min , max ,mid;
min = 0;
max = arr.length - 1;
mid = (max + min)/2;
while(arr[mid] != key){
if(key > arr[mid]){
min = mid + 1;
}
else if(key < arr[mid]){
max = mid - 1;
}
if(min > max){ return -1;}
mid = (max + min)/2;
}
return mid;
}

引用数据类型都存在堆栈划分：

StringBuffer sb1 = new String("hello");//在内存中划分了1个栈内存(sb1)，1个堆内存(new)，1个常量池内存("hello")

StringBuffer sb2 = new StringBuffer("hello");//由于在上一个语句中已经在常量池里存放了一个"hello"，所以这句代码就只是在栈内存(sb2),堆内存(new)

int number = 3 ;

number存在栈内存中，3存在常量池中。

二维数组：

int[][] arr = new int[3][];

arr[0] = new int[3];

arr[1] = new int[1];

arr[2] = new int[2];

System.out.println(arr.length);//打印二维数组的长度，结果3：

System.out.println(arr[0].length);//打印二维数组的第一行的长度(多少列)

二维数组求和：

int[][] arr = {{2,3,5,8},{3,5,1,7},{6,1,82}};

int sum = 0;

for(int i = 0 ; i < arr.length ; i++){

for(int j = 0 ; j < arr[i].length ; i++){

sum += arr[i][j];

}

int[] x , y[];//表示x是一个一维数组，y是一个二维数组

0 0