Java入门到超神04

Day4

数组

• 概念

  1.相同类型数据集合

  2.可以通过下标访问
  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JBxE2HER-1590849989232)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200530201228781.png)]

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SvDqnJvC-1590849989234)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200530195736912.png)]

• 声明

import java.util.Scanner;

public class Demo01 {
    //变量类型   变量名=变量值;
    public static void main(String[] args) {
        int[] nums;//定义
        int sum=0;
        int nums2[];//效果相同但不推荐  c/c++的
        //dataType[] a=new dataType[arrayLength];
        nums=new int[10];
        Scanner scanner=new Scanner(System.in);
        for (int i = 0; i <nums.length ; i++) {
            nums[i]=i+1;
            sum+=nums[i];
            System.out.print(nums[i]+" ");
        }
        System.out.println("求和结果 "+sum);
    }
}
//array.length

内存分析

1. 堆 new对象 数组 线程共享，不会存放别的对象引用
2. 栈 脚本变量类型（包含具体的数值 引用对象的变量指向具体值的堆地址
3. 方法区 所有线程共享 包含所有的class static

• 使用
• 多维数组

java.lang.ArrayIndexOutOfBoundsException//数组越界错误

public class Demo02 {
    public static void main(String[] args) {
        //静态初始化
        int[] a={1,2,3,4,5};//创建加值就是初始化
        Man[] mans={new Man(),new Man()};
        //动态初始化
        int[] b=new int[10];//默认为0
    }
}

特点

1. 长度是确定的
2. 类型相同
3. 可以包括基本和引用
4. 数组是对象，原始还是其它都在堆
5. [0]->[length-1]

使用

public class Demo02 {
    public static void main(String[] args) {
        //静态初始化
        int max=0;
        int[] a={1,2,3,4,5,3};//创建加值就是初始化
        for (int i:a) {
            System.out.println(i);
        }
        for (int i = 0; i < a.length; i++) {
            if(a[i]>max){
                max=a[i];
            }
        }
        kdd(a);
        System.out.println(max);
    }
    public static void kdd(int...i){
        System.out.println("反转开始");
        int j=0;
        int d=(i.length)-1;
        int[] res=new int[i.length];
        while (d!=0) {
            res[j++] = i[d--];
        }
        for (int i1 = 0; i1 < res.length; i1++) {
            System.out.print(res[i1] + " ");
        }
        System.out.println("反转结束");
    }
}

多位数组

//int[][] a=new int[][];

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0YaXkeZr-1590849989236)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200530204240090.png)]

package com.kangsdan.Base.ArrayT;

public class Demo03 {
    public static void main(String[] args) {
        int[][] a=new int[3][3];
        for (int i = 0; i < a.length; i++) {
            for (int i1 = 0; i1 < a[i].length; i1++) {
                a[i][i1]=i+1;
                System.out.print(a[i][i1]+" ");
            }
            System.out.println();
        }
        System.out.println(a.length);//3
        System.out.println(a[0].length);//3
    }
}

Arrays类

1.java.util.Arrays;工具类

public class Damo04 {
    int[] a={1,898,5,3,456,65,61256,45};//没有在下面起到作用

    public static void main(String[] args) {
        int[] a={1,898,5,3,456,65,61256,45};
        for (int i:a) {
            System.out.println(i);
        }
    }
}

import java.util.Arrays;

public class Damo04 {
    int[] a={1,898,5,3,456,65,61256,45};

    public static void main(String[] args) {
        int[] a={1,898,5,3,456,65,61256,45};

//        for (int i:a) {
//            System.out.println(i);
//        }
        Arrays.sort(a);//排序
        System.out.println(Arrays.toString(a));//打印内容
        System.out.println(Arrays.binarySearch(a,5));//排好序的查找，返回下标
        int[] b=new int[8];
        Arrays.fill(b,20);
        if(Arrays.equals(a,b)){
            System.out.println("这两数值一模一样");
        }else {
            System.out.println("抱歉，不相同");
        }


        Arrays.fill(a,20);//赋值
        System.out.println(Arrays.toString(a));
        if(Arrays.equals(a,b)){
            System.out.println("这两数值一模一样");
        }

    }
}
// Arrays.fill(b,2,4,20);

冒泡排序法

public class Demo07 {
    public static void main(String[] args) {
        int[] a={9,4,6,5,7,3};
        int temp=0;
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j <a.length-1 ; j++) {
                if(a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        for (int i:a
             ) {
            System.out.println(i);
        }
    }
}
//江湖人都知道的冒泡排序法

• 时间复杂度是O（n^2)

稀疏数组

1. 大部分是0
2. 计算多少行列 不同的元素
3. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-np8mZESO-1590849989238)(C:\Users\1\AppData\Roaming\Typora\typora-user-images\image-20200530215746062.png)]

public class Demo05 {
    public static void main(String[] args) {
        //定义一个二维数组 0无 1黑 2白
        int[][] a=new int[11][11];
        a[1][2]=1;
        a[2][3]=2;
        for (int[] ints:a){
            for (int i:ints) {
                System.out.print(i+"\t");
                if(i!)
            }
            System.out.println();
        }
        //转化稀疏数组
        //获取有效值的个数
        int sum=0;
        
    }
}
//原始

public class Demo05 {
    public static void main(String[] args) {
        //定义一个二维数组 0无 1黑 2白
        int[][] a=new int[11][11];
        a[1][2]=1;
        a[2][3]=2;
        int sum=0;
        for (int[] ints:a){
            for (int i:ints) {
                System.out.print(i+"\t");
                if(i!=0){
                    sum++;
                }
            }
            System.out.println();
        }
        //转化稀疏数组
        //获取有效值的个数
        //创建稀疏数组
        int[][] arr2=new int[sum+1][3];
        arr2[0][0]=11;
        arr2[0][1]=11;
        arr2[0][2]=sum;
        int count=0;
        for (int i = 0; i < a.length; i++) {
            for (int j= 0; j < a[i].length; j++) {
                if(a[i][j]!=0){
                    count++;
                    arr2[count][0]=i;
                    arr2[count][1]=j;
                    arr2[count][2]=a[i][j];

                }
            }
        }
        System.out.println("这个就是"+count);
        for (int i = 0; i <arr2.length ; i++) {
            System.out.println(arr2[i][0]+"\t"+arr2[i][1]+"\t"+arr2[i][2]);
        }
    }
}