数组\排序
静态初始化
数据类型[] 数组名 = {元素值, 元素值, …}
int[] a = {1,2,3,4...};
动态初始化
数据类型[] 数组名 = new 数据类型[大小]
int[] a = new int[3];
double[] a;先声明数组
a = new double[5];再分配内存空间
数组细节
数组是多个相同类型数据的组合, 实现对这些数据的统一管理.
int[] arr1 = {1,2,3,60,1.1}; //double -> int 错误 需要满足自动转换数组中的元素可以是任何数据类型, 包括基本类型和引用类型, 但是不能混用
数组创建后, 如果没有赋值, 有默认的值. String null / int 0 / short 0 / byte 0 / long 0 / float 0.0 double 0.0 / char \u0000 / boolean false
数组的下标是从0开始的.
注意越界
数组属于引用类型, 数组型数据是对象
数组赋值机制
基本数据类型赋值, 赋值方式为值拷贝(值传递), 不会相互影响.
//n2的变化, 不会影响到n1的值 int n1 = 10; int n2 = n1; n2 = 80; //输出n1的值为 10数组在默认情况下是引用传递, 赋的值是地址, 赋值方式为引用赋值(地址拷贝)
//是一个地址, arr2变化会影响到arr1 int [] arr1 = {1,2,3}; int [] arr2 = arr1; arr2[0] =10; //输出arr1的值为 10, 2, 3
值传递(值拷贝) 和 引用传递(地址拷贝)的区别
在内存里面只要分配了一个数据空间, 一定会对应一个地址.
⬇
数组拷贝(内容复制)
//将 int[] arr1 = {10,20,30}; 拷贝到 arr2数组, 要求数据空间是独立的.
int[] arr1 = {10,20,30};
//创建一个新的数组arr2, 开辟新的空间, 大小和arr1一样
int[] arr2 = new int[arr.length];
//遍历 arr1
for(int i = 0; i < arr1.length; i++)
{
arr2[i] = arr1[i];
}
数组反转
int[] arr = {11,22,33,44,55,66};
//方式一:
//1.把arr[0] 和 arr[5] 进行交换
//2.把arr[1] 和 arr[4] 进行交换
//3.把arr[2] 和 arr[3] 进行交换
//4.一共要交换 3 次 = arr.length / 2
//5.每次交换时, 对应的下标是arr[i] 和 arr[arr.length - 1 - i]
int temp = 0;
int len = arr.length;
for(int i = 0; i < len / 2; i++)
{
arr[len - 1 - i] = arr[i];
arr[i] = temp;
}
//方式二
//逆序赋值法
//1.创建一个新的数组 arr2
//2.逆序遍历arr, 将每个元素拷贝到 arr2的元素中
//3.将arr 指向 arr2
//注意 : 让 arr 指向 arr2数据空间, 此时 arr原来的数据空间就没有变量引用, 会被当成垃圾, 销毁
数组扩容
数组不能扩容, 必须新定义一个新的数组, 把原先的数组内容遍历给新的数组中, 再赋新的元素.
冒泡排序(从小到大)
- 每一轮排序可以确定一个数的位置, 比如第一轮排序确定最大数, 第二轮排序确定第二大的数的位置, 以此类推
- 当进行比较时, 如果前面的数大于后面的数, 就交换
- 每轮比较在减少 例如: 4->3->2->1
int[] arr = {24,69,80,57,13};
int temp = 0;//用于辅助交换的变量
for( int j = 0; j < 4; j++){
//如果前面的数大于后面的数, 就交换
if(arr[j] > arr[j +1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out,println("==第一轮==");
for(int j = 0; j < arr.length; j++){
System.out,println(arr[j] + "\t");
}
for( int j = 0; j < 3; j++){
//如果前面的数大于后面的数, 就交换
if(arr[j] > arr[j +1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out,println("\n==第二轮==");
for(int j = 0; j < arr.length; j++){
System.out,println(arr[j] + "\t");
}
for( int j = 0; j < 2; j++){
//如果前面的数大于后面的数, 就交换
if(arr[j] > arr[j +1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out,println("\n==第三轮==");
for(int j = 0; j < arr.length; j++){
System.out,println(arr[j] + "\t");
}
for( int j = 0; j < 1; j++){
//如果前面的数大于后面的数, 就交换
if(arr[j] > arr[j +1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out,println("\n==第四轮==");
for(int j = 0; j < arr.length; j++){
System.out,println(arr[j] + "\t");
}
-----------合并代码-----------
for( int i = 0; i < 4; i++){ //外层循环是4次
for( int j = 0; j < 4-i; j++){ //4次比较-3次-2次-1次
//如果前面的数大于后面的数, 就交换
if(arr[j] > arr[j +1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.println("==第" + (i+1) + "轮==");
for(int j = 0; j < arr.length; j++){
System.out.println(arr[j] + "\t");
}
}
二维数组
int[] [] arr = {{0,0,0},{1,1,1},{2,2,2}};
//二维数组的每个元素是一维数组,所以要得到每个一维数组的值,还需要再次遍历
for(int i = 0; i < arr.length; i++){//遍历二维数组的每个元素
//1.arr[i] 表示 二维数组的i+1个元素 比如arr[0] : 二维数组的第一个元素
//2.arr[i].length 得到对应的每个一维数组的长度
for( int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j] + "\t");
}
System.out.println("");
}
int[] [] arr = new int [2][3] 二维数组内存形式 :
动态初始化-列数不确定
/*
i = 0: 1
i = 1: 2 2
i = 2: 3 3 3
一个有三个一维数组, 每一个一维数组的元素是不一样的
*/
int[][] arr = new int[3][];//创建二维数组,但是只是确定一维数组的个数
for(int i = 0; i < arr.length; i++){//遍历arr每个一维数组
//给每个一维数组开空间
//如果没有给一维数组 new, 那么arr[i]就是null
arr[i] = new int[i+1];
//遍历一维数组, 并给一维数组的每个元素赋值
for(int j = 0; j < arr[i].length; j++){
arr[i][j] = i+1;
}
}
