java数组

1.5数组

1.5.1基本概念

• 相同类型数据的有序集合

• 每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问

1.5.2数组的声明和创建

int[] numbs;//或 int nunbs[];这里也叫声明
​
numbs= new int [10];//这里叫数组的创建
​
//也可以合在一起，即声明和创建一起写
int[] numbs = new int[10]; 
​
//创建后之后可以通过循环来对数组元素赋值，一个下标对应一个元素（且下标从0开始）
for(i=0; i<numbs.length; i++){
    numbs[i]=i;
}

1.5.3数组的初始化

 public static void main(String[] args) {
        int [] arr = {1,2,3};//静态初始化
        int [] arr2 = new int [10];//动态初始化
      //当开辟好数组若未赋值，则会有默认赋值0；
   }

1.5.4数组的使用

public class Arrays {
    public static void main(String[] args) {
        int [] arr = new int [5];
        //普通的for循环
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
       }
//       增强for循环
        for (int array:arr) {
            System.out.println(array);
       }
        //数组传参和返回值
        int [] rever = haha(arr);
        System.out.println(rever);
   }
    public static int [] haha(int[] x){
        int[] rev = new int[x.length];
        for (int i = 0; i < x.length-1; i++) {
            rev[x.length-i-1]=x[i];
       }
        return rev;
   }
}
​

1.5.5总结

• 数组长度是确定的，一旦创建大小不可改变

• 数组内元素必须是相同类型，不允许出现混合类型

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

• 数组变量属于引用类型，数组也可以看成是对像，数组中的每个元素相当于该对象的成员变量。

  数组本身就是对象，jaca张建红对象是在堆中的，因此数组无论保存原始类型还是其它对象类型，数组对象本身还是在堆中的。

• 数组下标越界异常 ： ArrayIndexOutOfBoundsException

1.5.6二维数组

public class Demo08 {
    public static void main(String[] args) {
        int [] []  arr={{1,2,},{1,2},{1,2}};//二维数组的定义
        for (int i = 0; i < arr.length; i++) {//二维数组的遍历
            for (int j = 0; j < arr[i].length;j++){
                System.out.println(arr[i][j]);
           }
       }
        printArr(arr[0]);//这里可以看出二维数组的实质，其实是一维数组的每个位置上再嵌入一个数组
        //多维数组也类似
   }
    public  static void printArr(int []arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
       }
​
   }
}
​

1.5.7Arrays工具类

import java.util.Arrays;
​
public class Demo09 {
    public static void main(String[] args) {
        int [] a = {1,2,3,4,5,12,3212,33222};
        System.out.println(a);//[I@3f99bd52
        System.out.println(Arrays.toString(a));//Arrays方法里的遍历
        Arrays.sort(a);//升序排序
        System.out.println(Arrays.toString(a));
        Arrays.fill(a,2,4,10);//数组填充，可以定义范围，也可以不定义
        System.out.println(Arrays.toString(a));
   }
}

1.5.8冒泡排序

import java.util.Arrays;
​
public class Demo10 {
    public static void main(String[] args) {
    int [] arr ={1,3,2,5,4,8,6,9};
    int [] a=sort(arr);
        System.out.println(Arrays.toString(a));
   }
    public static int [] sort(int [] arr){
        int temp = 0;
        boolean flag=false;//进行优化
        for (int i = 0; i<arr.length-1;i++){//第一轮循环表示轮数
            for (int j = 0; j < arr.length-1-i; j++) {//第二轮循环进行比较和交换
                if(arr[j+1] < arr[j]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    flag=true;
               }
           }
            if(flag==false){
                break;
           }
       }
        return arr;
   }
 }
​

1.5.9稀疏数组

package test;
​
public class Demohaha {
    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[] ints : array1){
            for (int anInt : ints){
                System.out.print(anInt+"/t");
           }
            System.out.println();
       }
​
        //2.转换为稀疏数组保存
//       获取有效值个数
        int sum=0;
        for(int i = 0; i < array1.length;i++){
            for(int j = 0; j < array1[i].length; j++){
                if(array1[i][j] !=0){
                    sum++;
               }
           }
       }
        System.out.println(sum);
​
​
//       3.创建一个稀疏数组
        int[][] array2 =new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
​
//       遍历二维数组，将非0值放入稀疏数组
        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];
               }
           }
       }
//       4.输出稀疏数组
        System.out.println("输出稀疏数组");
​
        for(int i = 0; i < array2.length; i++){
            System.out.println(array2[i][0]+"/t"+array2[i][1]+"/t"+array2[i][2]+"/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.打印
        for(int[] ints : array3){
            for (int anInt : ints){
                System.out.print(anInt+"/t");
           }
            System.out.println();
       }
​
   }
​
}
​