java数组

本文主要是介绍java数组，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1.数组的定义

1. 数组是相同类型数据的有序集合
2. 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
3. 其中每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问。

2.数组的创建与使用

int [] nums;//推荐使用
int nums[];//两种方式都可创建
nums=new int[10];//对数组实例化

数组的元素是通过索引来访问的，从0开始。

若不给数组元素赋值，内容则为默认值。

数组的长度可用.length来获取。

3.内存分析

4.数组的三种初使化

1. 静态初使化：在创建的时候直接赋值，数组大小在创建时就固定了
2. 动态初使化：通过new关键字来创建数组，可以后赋值，包含了默认初使化
3. 默认初使化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式隐式实例化。

        //静态初使化：创建+赋值
        int[] a={1,2,3,4,5,6};
        System.out.println(a[0]);

        //动态初使化：包含默认初使化
        int[] b=new int[10];
        b[0]=10;
        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[3]);

5.数组的四个基本特点

1. 其长度是确定的。数组一旦被创建，其大小是不可改变的。
2. 其元素必须是相同类型的，不允许出现混合类型
3. 数组中的元素可以是任何数据类型，包括引用类型和基本类型。
4. 数组变量属于引用类型，数组也可以看成对象，数组中的每个元素可以看成对象的成员变量

数组本身就是对象，java中对象在堆中，因此数组无论保存原始类型还是引用类型，数组对象本身是在堆中的。

6.数组边界

1. 下标的合法区间为0~length-1，越界就会报错
2. ArrayIndexOutOfBoundsException数据越界异常

7.数组的使用

1. 用普通for循环来遍历数组

int [] arrays={1,2,3,4,5};
//普通for循环
for (int i = 0; i < arrays.length; i++) {
    System.out.print(arrays[i]+" ");
}
System.out.println();
System.out.println("+++++++++++++++++++++++++++++++++++++");
//输出数组的和
int sum=0;
for (int i = 0; i < arrays.length; i++) {
    sum+=arrays[i];
}
System.out.println(sum);
System.out.println("+++++++++++++++++++++++++++++++++++++");
//输出数组中的最大值
int maxNum=arrays[0];
/*for (int array : arrays) {
    if (maxNum<array){
        maxNum=array;
    }
}*/
for (int i = 1; i < arrays.length; i++) {
    if (maxNum<arrays[i]){
        maxNum=arrays[i];
    }
}
System.out.println(maxNum);

2. 用for each来遍历数组（jdk1.5新增）

int [] arrays={1,2,3,4,5};
for (int array : arrays) {
    System.out.println(array);
}

3. 做为方法的入口参数

public static void main(String[] args) {
    int [] arrays={1,2,3,4,5};
    Out(arrays);
}

public static void Out(int [] arrays){
    for (int array : arrays) {
        System.out.println(array);
    }
}

4. 做为返回值

public static void main(String[] args) {
    int [] arrays={1,2,3,4,5};
    Out( Reserve(arrays));
}

public static void Out(int [] arrays){
    for (int array : arrays) {
        System.out.println(array);
    }
}
//转置
public static int[] Reserve(int []arrays){
    int [] reserve=new int[arrays.length];
    for (int i = 0,j= arrays.length-1; i < arrays.length; i++,j--) {
        reserve[j]=arrays[i];
    }
    return reserve;
}

8.多维数组

相当于数组的元素还是数组，若输出arraay[0],则是这个小数组的地址

int [][] arrays={{1,2},{2,3},{3,4},{4,0}};
for (int i = 0; i < arrays.length; i++) {
    for (int j = 0; j < arrays[i].length; j++) {
        System.out.println(arrays[i][j]);
    }

}

9.Arrays工具类

​ java.util.Arrays包下

重要方法：

1. toString():返回指定数组的内容的字符串表示形式
2. fill()：填充
3. sort():排序
4. equal():判断两个数组是否相等
5. binarySearch():二分法查找, 在进行此调用之前，必须对数组进行排序（如sort(int[])方法）。 如果没有排序，结果是未定义的，返回的是数组的索引值

int [] arrays={1,213,4,3,5,5,34,6,3,4,6,57,122,5,45,3,424,23,4,2343424,213,12121211};
System.out.println(Arrays.toString(arrays));
Arrays.sort(arrays);//正序排序
System.out.println(Arrays.toString(arrays));
Arrays.fill(arrays,9);//填充
System.out.println(Arrays.toString(arrays));
Arrays.fill(arrays,3,4,10);//填充重载
System.out.println(Arrays.toString(arrays));

int [] arrays= {1};
int [] arrays2= {1};
if (Arrays.equals(arrays2,arrays)){
    System.out.println("true");
}else{
    System.out.println("false");
}

int [] arrays= {1,2,3,3,3,4,4,5,6,43543,67347,4};
/*int [] arrays2= {1};*/
Arrays.sort(arrays);
System.out.println(Arrays.toString(arrays));
int a =Arrays.binarySearch(arrays,67347);
System.out.println(a);

遇到的问题:

多输出一个数，对if的理解不够深入

for (int i = 0; i < arrays.length; i++) {
    if (i==0){
        System.out.print("["+arrays[i]+", ");
    }
    if (i==arrays.length-1){
        System.out.print(arrays[i]+"]");
    }
    else {
        System.out.print(arrays[i] + ", ");
    }
}//当i=0时，第一个if执行完成后会接着往下走，走到else时会输出arrays[0],因为else只和前一个if做判断。

10.冒泡排序

排序总共有八大排序，其中冒泡排序是最简单的，时间复杂度为O(n2)【平方】。

实现：

public static void main(String[] args) {
    //冒泡排序
    //1.比较数组中两个相邻的元素，如果第一个数比第二个数大，就交换他们的位置
    //2.第一次比较就会产生一个最大值或最小值
    //3.下一轮可以少一次排序
    //4.依次循环，直到结束
    int []arr={1,2,3,4,5,6,623,42,34,32,4,2,5,25,90};
    System.out.println(Arrays.toString(sort(arr)));

}
public static int[] sort(int [] arrsys){
    int a=0;
    boolean flag=false;//定义一个标志位，用来进行优化
    //判断需要比较多少次
    for (int i = 0; i <arrsys.length-1 ; i++) {
        //通过循环来进行位置交换
        for (int j = 0; j <arrsys.length-1-i; j++) {
            if (arrsys[j]>arrsys[j+1]){
                a= arrsys[j];
                arrsys[j]= arrsys[j+1];
                arrsys[j+1]=a;
                flag=true;//当每次j=最大数时，将flag变成true
            }
            if (flag==true){
                break;//如果是最后一轮，直接跳出循环
            }
        }
    }
    return arrsys;
}

11.稀疏数组

稀疏数组是一种数据结构。

当一个数组中，大多数数为0或为相同的值时，可以用稀疏数组来保存此数组。可以压缩使用空间。

规则：

1. 稀疏数组中有三列
2. 第一行用来存放这个数组是有几行几列，以及有几个有效的值。
3. 其余行来存放每个值的行、列及值，如下图

package com.xiaoxiao.arrays;

public class XiShuArrayDemo {
    public static void main(String[] args) {
        //假设有一个11行11列的多0数组
        int[][] arrays1=new int[11][11];
        arrays1[1][2]=1;//第二行第三列为1
        arrays1[2][3]=2;//第三行第四列为2
        //遍历
        for (int[] ints : arrays1) {
            for (int ints2 : ints) {
                System.out.print(ints2+"\t");
            }
            System.out.println();
        }
        System.out.println("--------------------------------------");
        //用稀疏数组来存放arrays1
        //获取有效数字
        int sum=0;
        for (int[] ints : arrays1) {
            for (int anInt : ints) {
                if (anInt!=0){
                    sum++;
                }
            }
        }
        System.out.println(sum);//2
        System.out.println("--------------------------------------");
        //开始创建稀疏数组
        int [][] arrays2=new int[sum+1][3];//因为第一行是存放行列和有效数总数的，所以要加一行
        arrays2[0][0]=11;//行
        arrays2[0][1]=11;//列
        arrays2[0][2]=2;//有效数
        //遍历二维数组,找出不为0的数，写入稀疏数组
        int count=1;
        for (int i = 0; i < arrays1.length; i++) {
            for (int j = 0; j < arrays1[i].length; j++) {
                if (arrays1[i][j]!=0){
                    arrays2[count][0]=i;
                    arrays2[count][1]=j;
                    arrays2[count][2]=arrays1[i][j];
                    count++;
                }
            }
        }
        //遍历稀疏数组
        for (int[] ints : arrays2) {
            for (int ints2 : ints) {
                System.out.print(ints2+"\t");
            }
            System.out.println();
        }
        System.out.println("--------------------------------------");
        //还原稀疏数组
        int [][] arrays3=new int[arrays2[0][0]][arrays2[0][1]];
        for (int i = 1; i < arrays2.length; i++) {
            arrays3[arrays2[i][0]][arrays2[i][1]]=arrays2[i][2];
        }
        //遍历还原后的稀疏数组
        for (int[] ints : arrays3) {
            for (int ints2 : ints) {
                System.out.print(ints2+"\t");
            }
            System.out.println();
        }
        System.out.println("--------------------------------------");
    }
}

这篇关于java数组的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！