JavaSE复习(第四章-数组)

目录

一、数组概述

二、数组元素声明与初始化

三、数组元素的访问与遍历

四、数组元素的默认初始值

五、数组的内存分析

六、数组相关算法

七、数组工具类

八、二维数组

---

一、数组概述

1. 数组：是个数据容器，可以存储多个同类型的数据。

2. 相关概念：

   • 数组名：数组的名字

   • 元素：数组中的存储的数据

   • 数组长度：数组可以存储的元素个数

   • 索引、脚标或下标：从0开始的编号，用于访问数组中的元素

 

3.数组的特点：

1. 数组一旦创建，长度不可改变。

2. 数组是内存中一块连续的内存空间

3. 数组有索引，可以通过索引快速访问元素

4. 数组可以存储基本数据类型的元素，也可以存储引用数据类型的元素。

二、数组元素声明与初始化

数组必须先声明并且初始化后才能使用。

1. 声明格式：

   元素的数据类型[] 数组名;
   int[] arr;
   String[] arr2;

2. 数组初始化

   • 静态初始化：程序员给出数组元素的默认初始值，长度由系统决定

     数据类型[] 数组名 = new 数据类型[]{元素1，元素2，...};
     //简化写法
     数据类型[] 数组名 = {元素1，元素2，....}；
     //声明数组的同时并初始化
     int[] arr = new int[]{11,22,33};
     //简化写法
     int[] arr = {11,22,33};

   • 动态初始化：程序员给出数组的长度，元素默认初始值由系统给出。

数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[5];

三、数组元素的访问与遍历

1. 数组元素的访问

   //获取元素值
   数组名[索引]
   //设置元素值
   数组名[索引] = 值
   ​
   //获取数组元素
   int[] arr = {11,22,33};
   System.out.println(arr[0]);//11
   int x = arr[1];
   System.out.println(x);//22
   //修改数组元素值
   arr[2] = 123;
   System.out.println(arr[2]);//123

2. 数组的遍历

   逐个获取数组中的每个元素。

   获取数组的长度：数组名.length

   int[] arr = {11,22,33};
   //遍历数组
   for(int i=0;i<arr.length;i++){
     System.out.println(arr[i]);
   }

四、数组元素的默认初始值

 动态初始化时，程序员给出数组的长度，元素默认初始值由系统给出。不同类型的元素，默认初始值不同：

五、数组的内存分析

六、数组相关算法

1. 统计相关算法：求和、求平均值、通过元素个数等

2. 查找相关算法：查找指定元素及其位置，查找最大最小值及其位置等

• 二分查找：又称折半查找，前提条件是有序的数组
• 示例

class Demo{
    public static void main(String[] args){
        int[] arr = {2,5,7,8,10,15,18,20,22,25,28};//数组是有序的	
        //二分查找
        int num = 18;//目标值
        int index = -1;//目标的位置默认为-1表示不存在
        int left = 0;//左边位置默认为最小索引位置
        int right = arr.length - 1;//右边位置默认为最大索引位置
        int mid;//中间位置
        //循环查找，每次查找left与right之间的数据，并比较中间位置元素与目标元素的大小
        do {
            //每次计算中间位置
            mid = (left + right) / 2;
            if (num == arr[mid]) {//目标元素等于中间位置元素时，找到
                index = mid;//保存找到的元素位置
                break;//跳出循环
            }
            if (num > arr[mid])//目标元素比中间位置元素大时
                left = mid + 1;//修改新的左边位置
            if (num < arr[mid])//目标元素比中间位置元素小时
                right = mid - 1;//修改新的右边位置
        } while (left <= right);//当左右位置重合时说明已经找遍了整个数组。

        if(index==-1){
            System.out.println(value + "不存在");
        }else{
            System.out.println(value + "的下标是" + index);
        }

    }
}

图解: 

3.排序算法之冒泡排序

排序：把数组中元素按照从小到大（升序）或者从大到小（降序）顺序进行重新排列

Java中的经典算法之冒泡排序（Bubble Sort）

原理：比较两个相邻的元素，将值大的元素交换至右端，最大值出现在最后位置。

思路：

依次比较相邻的两个数，将小数放到前面，大数放到后面。

 即第一趟，首先比较第1个和第2个元素，将小数放到前面，大数放到后面。

 然后比较第2个和第3个元素，将小数放到前面，大数放到后面。

 如此继续，直到比较最后两个数，将小数放到前面，大数放到后面。

 重复第一趟步骤，直至全部排序完成

例如：冒泡：从小到大，从左到右两两比较
/*
{6,3,8,2,9,1}
    第一轮：
    第1次：arr[0]与arr[1]比较，6>3成立，就交换，{3,6,8,2,9,1}
    第2次：arr[1]与arr[2]比较，6>8不成立，不交换{3,6,8,2,9,1}
    第3次：arr[2]与arr[3]比较，8>2成立，就交换，{3,6,2,8,9,1}
    第4次：arr[3]与arr[4]比较，8>9不成立，不交换{3,6,2,8,9,1}
    第5次：arr[4]与arr[5]比较，9>1成立，就交换，{3,6,2,8,1,9}
    
    第一轮结果：{3,6,2,8,1,9}   9已经到达正确位置，下一轮不用在参与

    第二轮：
    第1次：arr[0]与arr[1]比较，3>6不成立，不交换{3,6,2,8,1,9}
    第2次：arr[1]与arr[2]比较，6>2成立，就交换，{3,2,6,8,1,9}
    第3次：arr[2]与arr[3]比较，6>8不成立，不交换{3,2,6,8,1,9}
    第4次：arr[3]与arr[4]比较，8>1成立，就交换，{3,2,6,1,8,9}
    
    第二轮结果：{3,2,6,1,8,9}   8已经到达正确位置，下一轮不用在参与
    
    第三轮：
    第1次：arr[0]与arr[1]比较，3>2成立，就交换，{2,3,6,1,8,9}
    第2次：arr[1]与arr[2]比较，3>6不成立，不交换{2,3,6,1,8,9}
    第3次：arr[2]与arr[3]比较，6>1成立，就交换，{2,3,1,6,8,9}
    
    第三轮结果：{2,3,1,6,8,9}   6已经到达正确位置，下一轮不用在参与
    
    第四轮：
    第1次：arr[0]与arr[1]比较，2>3不成立，不交换{2,3,1,6,8,9} 
    第2次：arr[1]与arr[2]比较，3>1成立，就交换，{2,1,3,6,8,9} 
    
    第四轮结果：{2,1,3,6,8,9}    3已经到达正确位置，下一轮不用在参与
    
    第五轮
    第1次：arr[0]与arr[1]比较，2>1成立，就交换，{1,2,3,6,8,9}
    
    第五轮结果：{1,2,3,6,8,9}   2已经到达正确位置，下一轮不用在参与
    
    剩下1，肯定是最小的了，不用比较了
    
    6个元素，比较了5轮， n个元素需要n-1轮
    每一轮比较很多次
*/

//示例代码	
public static void main(String[] args){
		int[] arr = {6,3,8,2,9,1};  //arr.length = 6
		
		//i=1,2,3,4,5  一共5轮
		for(int i=1; i<arr.length; i++){//轮数
			/*
			i=1，第1轮，j=0,1,2,3,4   arr[j]与arr[j+1]
			i=2，第2轮，j=0,1,2,3     arr[j]与arr[j+1]
			i=3，第3轮，j=0,1,2       arr[j]与arr[j+1]
			i=4，第4轮，j=0,1         arr[j]与arr[j+1]
			i=5，第5轮，j=0           arr[j]与arr[j+1]
			
			j=0, j<=arr.length-1-i
			*/
			for(int j=0; j<=arr.length-1-i; j++){
				if(arr[j] > arr[j+1]){
                    //交换位置
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
		//结果
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i] + " ");
		}
	}

七、数组工具类

java.util.Arrays数组工具类，封装了一些方便操作数组的功能。

int[] arr = {11,4,23,65,9};
//排序
Arrays.sort(arr);
//二分查找
int index = Arrays.binarySearch(arr,4);
//复制数组
int[] arr2 = Arrays.copyOf(arr,10);
//把数组转换为字符串
String s = Arrays.toString(arr);

八、二维数组

1. 二维数组：本质上是元素为一维数组的数组。

2. 声明格式：

   数据类型[][] 数组名;
   int[][] arr;
   String[][] arr2;

3. 初始化：

   • 静态初始化

     数据类型[][] 数组名 = new 数据类型[][]{{元素1，元素2，...},{元素1，元素2，...},...};
     //简化写法
     数据类型[][] 数组名 = {{元素1，元素2，...},{元素1，元素2，...},...};
     int[][] arr = new int[][]{{1,2,3},{4,5},{6}};
     //简化
     int[][] arr = {{1,2,3},{4,5},{6}};

   • 动态初始化

     数据类型[][] 数组名 = new 数据类型[m][n];//m表示二维数组的长度，n表示每个一维数组的长度
     //或
     数据类型[][] 数组名 = new 数据类型[m][];//m表示二维数组的长度,每个一维数组并未初始化
     int[][] arr = new int[3][2];//三行两列
     ​
     int[][] arr2 = new int[3][];//三行
     arr2[0] = new int[]{1,2,3};
     arr2[1] = new int[]{4,5};
     arr2[2] = new int[]{6};

4. 二维数组的访问与遍历

   int[][] arr = {{1,2,3},{4,5},{6}};
   //遍历二维数组，获取其每个元素，即一维数组
   for(int i=0;i<arr.length;i++){
      //遍历一维数组arr[i]
       for(int j=0;j<arr[i].length;j++){
           System.out.print(arr[i][j]);
       }
       System.out.println();
   }

5. 二维数组的内存分析

---

 需要第四章完整学习笔记可以关注私信我哦