02-Java的数组

最新推荐文章于 2024-08-03 22:52:35 发布

Mls_Lucky

最新推荐文章于 2024-08-03 22:52:35 发布

阅读量90

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/qq_45632660/article/details/108476226

版权

java 专栏收录该内容

14 篇文章 2 订阅

订阅专栏

1、数组的概述

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
数组的常用概念
- 数组名
- 下标(或索引)
- 元素
- 数组的长度: 元素的个数
数组的特点
- 数组是有序列表的
- 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。
- 创建数组对象会在内存中开辟一整块连续的空间
- 数组的长度一旦确定，就不能修改。
数组的分类
- 按照维数: 一维数组、二维数组…
- 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组。

2、一维数组和二维数组

2.1、一维数组的使用

静态初始化:数组的初始化和数组元素的赋值操作同时进行

int[] num = new int[]{1001,1002,1003,1004};

在这里插入图片描述

动态初始化:数组的初始化和数组元素的赋值操作分开进行

String[] name = new String[4];
//如何调用数组的指定位置的元素:通过下标的方式调用。
//数组的下标(索引)从0开始的,到数组的长度-1结束。
name[0]="张三";
name[1]="李四";
name[2]="王五";
name[3]="赵六";

//注意数组越界，越界就会报错java.lang.ArrayIndexOutOfBoundsException

在这里插入图片描述

获取数组的长度属性:length

在这里插入图片描述

遍历数组

public class ArrayTest1 {
    public static void main(String[] args) {
        String[] name = new String[4];
        name[0]="张三";
        name[1]="李四";
        name[2]="王五";
        name[3]="赵六";
        for (int i=0; i<name.length; i++){
            System.out.println(name[i]);
        }
    }
}

数组默认的初始值

数据类型	初始值
String	null
byte	0
short	0
int	0
long	0
boolean	false
float	0.0
double	0.0
char	\u0000（unicode字符代表的就是空格）

例子:
 String[] num = new String[4];
        for (int i=0; i<num.length; i++){
            System.out.println(num[i]);
        }

数组的内存结构

https://www.cnblogs.com/menghujava/p/9804244.html

2.2、二维数组的使用

概念

理解二维数组，首先要先理解一维数组是什么。一维数组是个容器，存储相同数据类型的容器（这里不再做一位数组的具体介绍）。二维数组就是用来存储一维数组的数组，一维数组的存储数据类型是基本数据类型和引用数据类型，二维数组的存储数据类型是引用数据类型（一维数组是引用数据类型）。也就是：二维数组是存储一维数组的数组，二维数组里面的元素都是数组，二维数组来存储一维数组。

格式1：

数据类型[][] 变量名=new 数据类型[m] [n];
m表示这个二维数组有多少个数组
n表示每一个一维数组的元素个数
举例:

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

定义了一个二维数组arr
这个二维数组有3个一维数组，名称是ar[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m] [n]来获取

格式2：

数据类型[][] 变量名=new 数据类型[m] [];
m表示这个二维数组有多少个数组
这一次没有直接给出一维数组的元素个数，可以动态的给出
举例：
int[][] arr=new int[3] [];
arr[0] = new int[2];
arr[1]= new int[3];
arr[2]=new int[1];

格式3：

数据类型[][] 变量名=new 数据类型[][]{{元素…},{元素…},{元素…}};
也可以是：
数据类型[][] 变量名={{元素…},{元素…},{元素…}};
举例：int[][] arr={{1,2,3},{4,6},{6}}

静态初始化

int[][] num = new int[][]{{1,2,3},{4,5,6}};

在这里插入图片描述

动态初始化1

String[][] name = new String[3][];

动态初始化2

String[][] name = new String[3][2];

获取数组的长度 length

在这里插入图片描述

遍历数组

public class ArrayTest1 {
    public static void main(String[] args) {
        int[][] num = new int[][]{{1,2,3},{4,5,6}};
        for (int i=0; i<num.length; i++){
            for (int j=0; j<num[i].length;j++){
                System.out.print(num[i][j]);
            }
            System.out.println();
        }
    }
}

数组元素的默认初始化值

针对于初始化方式一: 比如: int[ ] [ ] arr = new int [4] [5];

外层元素的初始化值为: 地址值

内层元素的初始化值为: 与一维数组初始化情况相同

针对于初始化方式二: 比如: int[] [] arr = new int [4] [];

外层元素的初始化值为: null

内层元素的初始化值为: 不能调用，否则报错。

# 第一种方式
    public class ArrayTest1 {
    public static void main(String[] args) {
        boolean[][] arr = new boolean[4][5];
        System.out.println(arr[0]);//[Z@1b6d3586
        System.out.println(arr[0][0]);//false
    }
}

在这里插入图片描述

# 第二种方式
    public class ArrayTest1 {
        public static void main(String[] args) {
            boolean[][] arr = new boolean[4][];
            System.out.println(arr[0]);//[Z@1b6d3586
            System.out.println(arr[0][0]);//false
        }
    }
不仅报错地址也找不到了。

在这里插入图片描述

二维数组内存解析

在这里插入图片描述

3、算法

3.1、数组的复制、反转、查找(线性查找、二分法查找)

public class ArrayTest1 {
    public static void main(String[] args) {
       String[] arr = new String[]{"aa","bb","cc","dd"};
       String[] arr1 = new String[arr.length];
       //数组的复制
       for (int i=0; i<arr.length; i++){
           arr1[i]= arr[i];
           System.out.println(arr1[i]);
       }
       //数组的反转
        for (int i=0; i<arr.length/2; i++){
            String temp = arr[i];
            arr[i] = arr[arr.length-i-1];
            arr[arr.length-i-1] = temp;
        }
        System.out.println(arr[1]);

        //查找
        //线性查找
        String dest = "aa";
        boolean flag = true;
        for (int i=0; i<arr.length; i++){
            if (dest.equals(arr[i])){
                System.out.println("找到了" + i);
                flag=false;
                break;
            }
        }
        if (flag){
            System.out.println("很遗憾没有找到");
        }
        //二分法查找:
        //前提: 所要查找的数组必须有序
        int[] arr2 = new int[]{-58,-84,15,68,12,45,-9,85};

        int dest1 = -84;
        int head = 0;//初始的首索引
        int end = arr2.length-1;//初始的末索引
        boolean falg1 = true;
        while (head <= end){
            int middle = (head+end)/2; //中间数
            if (dest1 == arr2[middle]){
                System.out.println("找到了" + middle);
                falg1 = false;
                break;
            }else if (arr2[middle] >dest1){
                end = middle - 1;

            }else {
                head = middle + 1;
            }
            if (falg1){
                System.out.println("很遗憾没有找到");
            }
        }
    }
}

3.2、冒泡排序

介绍

冒泡排序的原理非常简单，它重复地走访要排序的数列，一次比较两个元素，如果他们的顺序错误的就把他们交换过来。

排序思想

比较相邻的元素。如果第一个比第二个大(升序)，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。

例子

public class ArrayTest1 {
    public static void main(String[] args) {
       int[] arr = new int[]{48,15,84,65,21,84,51,481,35};
       //冒泡排序
        for (int i=0; i<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.println(arr[i]);
        }
    }
}

3.3、快速排序

介绍

快速排序通常明显比同为O(nlogn)的其他算法更快，因此常被采用，而且快排采用了分治法的思想，所以在很多笔试面试中经常看到快排的影子，可见掌握快排的重要性。

快速排序由图灵奖获得者Tony Hoare发明，被列为 20世纪十大算法之一，是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升级版，交换排序的一种。快速排序的时间复杂度为O(nlog(n))

思想

1．先从数列中取出一个数作为基准数。

2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3．再对左右区间重复第二步，直到各区间只有一个数。

例子

public class QuickSort {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0)
					;
				while (high > start && data[--high] - base >= 0)
					;
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	
	
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

4、Arrays工具类

在这里插入图片描述

public class ArrayTest1 {
    public static void main(String[] args) {

        int[] arr = new int[]{48,15,84,65,21,84,51,481,35};
        int[] arr2 = new int[]{48,15,84,65,21,84,51,481,35};
        //判断两个数组是否相等
        boolean equals = Arrays.equals(arr, arr2);
        System.out.println(equals);//true
        //输出数组信息
        String string = Arrays.toString(arr);
        System.out.println(string);//[48, 15, 84, 65, 21, 84, 51, 481, 35]

        //将指定的值填充到数组当中
        Arrays.fill(arr,2);
        System.out.println(Arrays.toString(arr));//[2, 2, 2, 2, 2, 2, 2, 2, 2]

        //对数组进行排序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));

        //二分查找
        int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int index = Arrays.binarySearch(arr3, 210);
        System.out.println(index);
    }
}

Mls_Lucky

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
02-Java的数组

1、数组的概述数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。数组的常用概念数组名下标(或索引)元素数组的长度: 元素的个数数组的特点数组是有序列表的数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型。创建数组对象会在内存中开辟一整块连续的空间数组的长度一旦确定，就不能修改。数组的分类按照维数: 一维数组、二维数组…按照数组元素的类型：基本数据类型元素的数组、引
复制链接

扫一扫

专栏目录