本文详细介绍了数组的概念、创建、声明、使用及排序方法，包括数组的内存分析、多维数组的使用、Array类的功能介绍以及冒泡排序算法的实现。
数组
数组的定义
- 数组是相同类型数据的有序集合
- 数组描述相同数据的若干数据，按一定的先后顺序排列而成
- 每一个数据称数组元素，用数组的下标访问它们
- 数组的下标从0开始
数组的创建、声明
- 数组长度是确定的，一旦被创建大小就不可以改变,如果越界会报ArrayIndexOutofBounds错误
- 其类型必须相同，不能出现混合类型
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型
- 数字变量属于引用类型，数组也可看成对象，数组中的每个元素，相当于该对象的成员变量，数组本身就是对象，java的对象是在堆中的，数组对象是在堆中的
- 数组元素通过索引访问，从0开始
- 获取数组长度，aray.length
public static void main(String[] args) {
int[] nums; //声明一个数组
nums=new int[10]; //创建一个数组
int[] nums2=new int[10]; //一步完成
nums[0]=0;
nums[1]=1;
nums[2]=2;
nums[3]=3;
nums[4]=4;
nums[5]=5;
nums[6]=6;
nums[7]=7;
nums[8]=8;
nums[9]=9;
for (int i = 0; i < nums.length; i++) {
System.out.println(nums[i]);
}
}
内存分析
堆
- 存放new的数组和对象
- 可以被所有线程共享，不会存放别的对象引用
栈
- 存放基本变量类型（会包含这个基本类型的具体数据）
- 引用对象的变量（会存放这个引用在堆里的具体地址）
方法区
- 可以被所有线程共享
- 包含了所有的class和staic变量
public static void main(String[] args) {
//静态初始化
int[] nums={1,2,3,4,5,6};
for (int i = 0; i < 6; i++) {
System.out.println(nums[i]);
}
System.out.println("===============================");
//动态初始化
//初始未赋值，默认为0
int[] nums2=new int[6];
nums2[0]=1;
nums2[1]=2;
for (int i = 0; i < 6; i++) {
System.out.println(nums2[i]);
}
}
数组的使用
-
普通for循环
public static void main(String[] args) { int[] arrays={1,2,3,4,5}; //打印全部数组元素 for (int i = 0; i < arrays.length; i++) { System.out.println(arrays[i]); } System.out.println("==========================="); //计算所有元素总和 int sum=0; for (int j = 0; j < arrays.length; j++) { sum=sum+arrays[j]; } System.out.println("总和为："+sum); System.out.println("==========================="); //查找最大元素 int max=arrays[0]; for (int k = 1; k <arrays.length ; k++) { if(max<arrays[k]){ max=arrays[k]; } } System.out.println("最大数为："+max); } -
增强for循环
public static void main(String[] args) { int[] arrays={1,2,3,4,5,6}; //jdk1.5以后才有，无下标 for (int i : arrays) { System.out.println(i); } } -
数组作为方法传入参数
-
数组作为返回值
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5, 6};
printarrays(arrays);
reverse(arrays);
printarrays(arrays);
}
//打印数组元素
// 作为传入参数
public static void printarrays(int[] arrays){
for (int i = 0; i <arrays.length ; i++) {
System.out.print(arrays[i]+" ");
}
System.out.println();
}
//反转数组
//作为返回值
public static int[] reverse(int[] arrays){
int a=0;
for (int i = 0; i <(arrays.length)/2 ; i++) {
a=arrays[i];
arrays[i]=arrays[arrays.length-1-i];
arrays[arrays.length-1-i]=a;
}
return arrays;
}
多维数组
- 多维数组可以看成数组的数组，例如二维数组就是一个特殊的一维数组，其中每一个元素就是一个一维数组
public static void main(String[] args) {
int[][] arrays={{1,2},{2,3},{3,4},{4,5},{5,6}};
//使用for循环打印
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j <arrays[i].length ; j++) {
System.out.print(arrays[i][j]+" ");
}
}
}
Array类
- 数组工具类，java.util.Arrays
- 由于数组对象本神并没有什么方法供我们调用，但API中提供了一个工具类Arrays，供我们使用从而可以对数据对象进行一些基本操作
- 具体包含的请看JDK帮助文档
- Arrays类中的方法，都是static修饰的静态方法，在使用时可以直接使用类名进行调用，而”不用“使用对象来调用（注意是”不用“不是”不能“）
常用功能
-
给数组赋值，通过fill方法
-
对数组排序，通过sort方法，按升序
-
比较数组，通过equals方法，比较数组中元素是否相等
-
查找数组元素，通过binarySearch方法，对排好序的数组进行二分查找法操作
public class ArraysDemo06 { public static void main(String[] args) { int[] a={5,23,6,9,48,56,12,46,63,85,154,1}; //打印数组元素 System.out.println(Arrays.toString(a)); printarrays(a); System.out.println("================================================="); //排序,升序 Arrays.sort(a); printarrays(a); System.out.println("================================================="); //fill赋值 Arrays.fill(a,0);//全赋值为0 printarrays(a); Arrays.fill(a,2,5,6);//2-5之间赋值为0，不包括2、5 printarrays(a); } //打印数组,,,,,开始造轮子 public static void printarrays(int[] arrays){ for (int i = 0; i < arrays.length; i++) { if(i==0){ System.out.print("["+arrays[0]+", "); }else if(i==arrays.length-1){ System.out.println(arrays[i]+"]"); }else { System.out.print(arrays[i]+", "); } } } }
冒泡排序（8大排序之一）
- 两层循环，外层冒泡轮数，内层依次比较
- 两层循环嵌套，时间复杂度为O(n^2)
- 冒泡排序，比价数组中两个相邻的元素，第一个大于第二个，则交换
- 每一次比较都会产生一个最大或最小的数
- 下一轮会少一次排序
- 依次循环直到结束
public class ArrayDemo07 {
public static void main(String[] args) {
int[] a={5,23,6,9,48,56,12,46,63,85,154,1};
int[] b={5,23,6,9,48,56,12,46,63,85,154,1};
sorts(a);
System.out.println(Arrays.toString(a));
System.out.println("===================================================");
Arrays.sort(b);
System.out.println(Arrays.toString(b));
}
//冒泡排序，比价数组中两个相邻的元素，第一个大于第二个，则交换
//每一次比较都会产生一个最大或最小的数
//下一轮会少依次排序
public static void sorts(int[] arrays){
//判断走多少次
for (int i = 0; i <arrays.length ; i++) {
//判断其是否有序，若第一次不进行任何赋值，则就是有序数组
boolean flag=false;
//从第一个与后面的一一对比
for (int j = 0; j < arrays.length-i-1; j++) {
if(arrays[j]>arrays[j+1]){
int a=arrays[j+1];
arrays[j+1]=arrays[j] ;
arrays[j]=a;
flag=true;
}
if(flag==false){
//若一趟不进行任何赋值，则就是有序数组
//直接结束排序
break;
}
}
}
}
}
//出现错误java.lang.ArrayIndexOutOfBoundsException
//问题是数组下标越界
稀释数组
- 数组中有很多值是相同的，只有几个是修改的，我们只需存储修改值就好，可以节省空间
- 稀疏数组的处理方式
- 记录数组有几行几列
- 把具有不同值元素的行和列，记录到小规模数组中，从而缩小程序规模（压缩）
- 下表第一行表示数组为6行7列数组共8个值不为0，之后每行表示该行该列的值
public class ArrayDemo08 {
public static void main(String[] args) {
//创建一个11*11,0是无棋，1是白棋，2是黑棋
int[][] arrays=new int[11][11];
arrays[1][2]=1;
arrays[2][3]=2;
//输出原始数据
System.out.println("输出原始数据");
for (int[] array : arrays) {
for (int i : array) {
System.out.print(i+"\t");
}
System.out.println();
}
//转换为稀疏数组存储
//1.获取有效值得个数
int num=0;
for (int[] array : arrays) {
for (int i : array) {
if(i!=0){
num++;
}
}
}
System.out.println("================================================");
System.out.println("有效值个数"+num);
//创建稀疏数组
int[][] array1=new int[num+1][3];
//把数据记录到稀疏数组
int count=1;
array1[0][0]=arrays.length;
array1[0][1]=arrays[0].length;
array1[0][2]=num;
//遍历数组，将不为0的存放在稀疏数组中
for (int i = 0; i <arrays.length ; i++) {
for (int j = 0; j <arrays[i].length ; j++) {
if(arrays[i][j]!=0){
array1[count][0]=i;
array1[count][1]=j;
array1[count][2]=arrays[i][j];
count++;
}
}
}
//打印稀疏数组
System.out.println("================================================");
System.out.println("打印稀疏数组");
for (int[] ints : array1) {
for (int k : ints) {
System.out.print(k+"\t");
}
System.out.println();
}
//还原稀疏数组
System.out.println("================================================");
System.out.println("还原稀疏数组");
//创建数组
int[][] array2=new int [array1[0][0]][array1[0][1]];
//给数组还原值
for (int i = 1; i <array1.length ; i++) {
array2[array1[i][0]][array1[i][1]]=array1[i][2];
}
//打印还原结果
for (int[] ints : array2) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
idea快捷键
5.for+enter，自动生成循环
arrays（数组名）.for+enter，自动生成增强for循环
i.for/fori+enter，自动生成循环结构
psvm+enter，自动生成mian函数
sout+enter，自动生成输出语句
扫一扫
148
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
