Java基础之数组

1、数组概述

2、数组声明创建

• 静态初始化

int[] a={...};

• 动态初始化:包含默认初始化

int[] b=new int[10];

• 数组特点
  

3、数组使用

• For-Each循环
• arrays.for 加回车
  

数组作方法入参

• 1.打印数组
  
• 2.反转数组

package com.wang.arrays;

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

        printArray(reverse);
    }

    public static int[] reverse(int[] arrays) {//数组作为方法入参
        int[] result = new int[arrays.length];
        for (int i = 0, j = arrays.length - 1; i < arrays.length; i++, j--) {
            result[j] = arrays[i];
        }
        return  result;//数组作为返回值
    }
        public static void printArray(int[] arrays){
        for(int i=0;i<arrays.length;i++){
            System.out.print(arrays[i]+" ");
        }
    }
}

数组作返回值

4、多维数组

多维数组可以看成数组的数组，比如二维数组就是一个特殊的一维数组，其中每一个元素都可以看成是一个一维数组

• 二维数组定义

int a[][]=new int[2][5];

• 输出二维数组某一组元素

public class demo02 {
    public static void main(String[] args) {
        int[][] arrays={{1,2},{3,4},{5,6}};
        printArray(arrays[0]);
    }
    public static void printArray(int[] arrays){
        for(int i=0;i<arrays.length;i++){
            System.out.print(arrays[i]+" ");
        }

    }
}

输出：1 2

5、Arrays类

1. 数组的工具类java.util.Arrays
2. 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作
3. Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而‘不用’（不是不能）使用对象来调用
4. 具有以下常见功能
   • 给数组赋值：通过fill方法
   • 对数组排序：通过sort方法，按升序
   • 比较数组：通过equals方法比较数组中元素值是否相等
   • 查找数组：通过binarySearch 方法能对排序好的数组进行二分查找

• Arrays.toString–打印数组元素

6、冒泡排序

1、比较数组中两个相邻的元素，如果第一个元素比后一个元素大，则交换他们的位置
2、每一次比较都可以产生一个最大或者最小的数字
3、下一轮则可以少一次排序
4、依次循环，直到结束！

优化后的代码

package com.wang.arrays;

import java.util.Arrays;

public class maopao {
    public static void main(String[] args) {
        int[] arrays={9,4,5,2,1};
        int[] result=sort(arrays);
        System.out.print(Arrays.toString(result));
    }
    public static int[] sort(int[] arrays){
        int temp=0;
        for(int i=0;i<arrays.length-1;i++){
            boolean flag=false;//优化
            for(int j=0;j<arrays.length-1-i;j++){
                if(arrays[j+1]<arrays[j]){
                    temp=arrays[j+1];
                    arrays[j+1]=arrays[j];
                    arrays[j]=temp;
                    flag=true;//标记是否排序
                }
            }
            if(flag==false){
                break;//如果是不需要排序的，即已经排好序的就没必要判断
            }
        }
        return arrays;
    }
}

7、稀疏数组

稀疏矩阵的创建与还原

package com.wang.arrays;

public class xishu {
    public static void main(String[] args) {
    int[][] arrays1=new int[11][11];
    arrays1[1][2]=1;
    arrays1[2][3]=2;
    System.out.println("输出最原始的数组");
        for (int[] ints : arrays1) {
            for (int anInt : ints) {//用for循环输出一个int数组
               System.out.print(anInt+"\t");
            }
                System.out.println();
        }
        System.out.println("============================");
        int sum=0;
        for(int i=0;i<11;i++) {
            for (int j = 0; j < 11; j++) {
                if (arrays1[i][j] != 0) {
                    sum++;
                }
            }
        }
            //创建一个稀疏数组的数组
            int[][] arrays2=new int[sum+1][3];
            arrays2[0][0]=11;
            arrays2[0][1]=11;
            arrays2[0][2]=sum;
            //遍历二维数组，将非零的值，存放在稀疏数组中
            int count=0;
            for (int i1 = 0; i1 < arrays1.length; i1++) {
                for (int j = 0; j < arrays1[i1].length; j++) {
                    if(arrays1[i1][j]!=0){
                        count++;//第几个不为0的值
                        arrays2[count][0]=i1;
                        arrays2[count][1]=j;
                        arrays2[count][2]=arrays1[i1][j];
                    }
                }
            }
            //输出稀疏数组
            for (int i2 = 0; i2 < arrays2.length; i2++) {
                System.out.println(arrays2[i2][0]+"\t"+arrays2[i2][1]+"\t"+arrays2[i2][2]);
            }
        System.out.println("============================");
            System.out.println("还原数组： ");
            //1.读取稀疏数组
        int[][] arrays3=new int[arrays2[0][0]][arrays2[0][0]];
        //2.给其中的元素还原它的值
        for (int i = 1; i < arrays2.length; i++) {
            arrays3[arrays2[i][0]][arrays2[i][1]]=arrays2[i][2];
        }
        //3.打印
            System.out.println("打印还原数组");
            for (int[] ints : arrays1) {
                for (int anInt : ints) {//用for循环输出一个int数组
                    System.out.print(anInt+"\t");
                }
                System.out.println();
            }

    }
}

结果