java数组--狂神说

数组

声明创建

dataType[] arrayRefVar; //首选

dataType arrayRefVar[];//效果相同 非首选

java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];

package second.array;

public class Demo01 {
    public static void main(String[] args) {
        int[] nums;//1。声明数组
        nums = new int[10];//里面可以存储10个int 数字 创建数组
        //赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;
        System.out.println(nums[9]);
        //计算所有元素和
        int sum=0;
        for (int i = 0; i < nums.length; i++) {
            sum=sum+nums[i];
        }
        System.out.println("总和为:"+sum);

    }
}

数组索引值从0开始 数组长度 nums.length

三种初始化：

静态初始化

int[] a={1,2,3};
Man[] mans ={new Man(),new Man()};//Man 新建类 实际是引用

动态初始化

int[] a=new int[2];
a[0]=1;
a[1]=2;

数组默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也按照实例变量同样的方法被隐式初始化

数组的四个基本特点

1.长度是确定的，数组一旦被创建，它的大小就是不可以改变的

2.其元素必须是相同类型，不允许出现混合类型

3.数组中的元素可以是任何数据类型，包括基本数据类型和引用类型

4.数组变量属引用类型，数组可以看作是对象，数组的每个元素相当于该对象的成员变量

数组本身就是对象 Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，

数组对象本身是在堆中的

小结

• 数组是相同数据类型（数据类型可以为任意类型）的有序集合
• 数组也是对象，数组元素相当于对象的成员变量
• 数组的长度是确定的，不可变的，如果越界，则报：ArrayIndexOutofBounds

数组的使用

• For-each
• 普通 for循环
• 数组作方法入参
• 数组作为返回值

package second.array;

import sun.security.mscapi.CPublicKey;

public class Demo04 {
    public static void main(String[] args) {
        int[] array1={1,2,3,4,5};
        //增强型 for each 循环   没有下标
        for (int i : array1) {
            System.out.println(i);

        }
        printarray(array1);
       int[] arrays=reversearray(array1);
       printarray(arrays);
    }
    //打印数组元素
    public  static  void printarray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]+"");
        }
    }
    //反转数组
    public  static int[] reversearray(int[] array){

        int[] result = new int [array.length];
        for (int i = 0,j=array.length-1; i < array.length; i++,j--) {
            result[j]=array[i];

        }
            return result;
    }
}

多维数组

二维数组

int[][] array  = {{1,2},{2,3},{3,4}}

package second.array;

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

        }
    }
}

Arrays类

数组工具类· java.util.Arrays

package second.array;

import java.util.Arrays;

public class Demo06 {
    public static void main(String[] args) {
        int[] a= {1,25,543,55,154,15465};
        //打印元素
        System.out.println( Arrays.toString(a));
        //排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //赋值
        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

代码：两次循环，外层轮数，内层依次比较

时间复杂度o(n^2)

package second.array;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
    int[]a={1,4,45,678,2,34,15,26,4};
    int[]sort =sort(a);
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[]array){
        //冒泡排序
        //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
        //2.每一次比较都会产生最大，或者最小的数字
        //3.下一次循环可以少一次排序
        //4.依次循环，直到结束

        //外层循环，判断要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环 比较两个相邻位置的大小 如果第一个比第二个大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {

                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j+ 1] = temp;
                }
            }
        }
        return array;
    }
}

优化

package second.array;

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
    int[]a={1,4,45,678,2,34,15,26,4};
    int[]sort =sort(a);
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[]array){
        //冒泡排序
        //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
        //2.每一次比较都会产生最大，或者最小的数字
        //3.下一次循环可以少一次排序
        //4.依次循环，直到结束
            boolean flag=false;
        //外层循环，判断要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环 比较两个相邻位置的大小 如果第一个比第二个大，则交换位置
            for (int j = 0; j < array.length-1-i; j++) {

                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j+ 1] = temp;
                    flag=true;
                }
            }
            if(flag==false){
                break;
            }
        }
        return array;
    }
}

稀疏数组

当数组中大部分为0或同一数值，可以使用稀疏数组

处理方式：

• 记录数组一共几行几列 有多少各不同值
• 把具有不同元素的数组和行列及值记录在一个小规模的数组中，从而缩小程序的规模

package second.array;


import java.util.Arrays;

public class Demo08 {
    public static void main(String[] args) {
        //1.创建一个一维数组11*11 0：没有棋子 1.黑棋 2.白棋
        int[][]array1 =new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        System.out.println("输出原始的数组:");

        for(int i=0; i< array1.length;i++){
            for (int j = 0; j < array1.length; j++) {
                System.out.print(array1[i][j]+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组来表示
        //获取有效值个数
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }

            }
        }
        System.out.println("有效值个数"+sum);
        //创建一个稀疏数组的数组
        int[][] array2= new int[sum+1][3];
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;
        //遍历二维数组，将非零的值，存放在稀疏数组中
        int count =0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组是:");
        for(int i=0;i< array2.length;i++){
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();
        }
        //还原
        System.out.println("======================");
        //1.读取稀疏数组
        int[][] array3 =new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        //3.打印
        System.out.println("输出还原的数组:");

        for(int i=0; i< array3.length;i++){
            for (int j = 0; j < array3.length; j++) {
                System.out.print(array3[i][j]+"\t");

            }
            System.out.println();
        }
    }
}

 输出原始的数组:
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
有效值个数2
稀疏数组是:
11	11	2	
1	2	1	
2	3	2	
======================
输出还原的数组:
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0