数组+Arrays工具类+排序+二维数组

定义

相同数据类型的集合

长度固定 内存连续 有序

声明和创建

声明:

数据类型[ ] 数组名;

数据类型 数组名[ ];

int[ ] arr1;

int arr2[ ];

创建:

1. 数组名= new 数据类型[数组长度];
2. 数组名= new 数据类型[]{数组元素};
3. 数组名={数组元素}

栈和堆:

栈: 由操作系统自动分配释放 (先进后出  后进先出)

堆:一般由程序员负责分配释放 (先进先出) 一棵树

连续固定内存 有序

数组的长度

arr.length  获取数组开辟的长度

 数组的下标

从0开始 ,最大长度-1

通过下标获取数组元素    数组名[下标]

元素长度是固定的，但是值可以赋值

下标越界

数组循环

利用下标。从0开始

数组相等

Arrays工具类

操作数据的工具类

sort方法

将数组升序排列

int[] arr=newint[10];

for(inti=0; i<arr.length; i++) {

    arr[i] =(int)(Math.random()*100+1);

}

// Arrays数组工具类

System.out.println(Arrays.toString(arr));

// sort方法 对数组可以进行升序排列

Arrays.sort(arr);

// 将数组的每个元素以逗号拼接成字符串

System.out.println(Arrays.toString(arr));

 

toString

将数组元素以逗号拼接然后形成字符串 [元素1,元素2,.....]

System.out.println(Arrays.toString(arr));

[2, 26, 26, 30, 32, 36, 42, 54, 60, 84]

copyof(数组,长度)

赋值数组内容

int[] arr={11,22,33,44,55,66};

System.out.println(arr);

int[] arrNew=Arrays.copyOf(arr, arr.length);//arr数组  arr.length数组长度

System.out.println(arrNew);//{11,22,33}

// 复制后的数组地址不同

System.out.println(arr==arrNew);

System.out.println(Arrays.toString(arrNew));

copyOfRange(数组,从下标位置,到下标位置) [start,end) 左闭右开

// copyOfRange(数组,从下标位置,到下标位置)    [start,end)

int[] arr=Arrays.copyOfRange(arr, 2, 4);//下标2开始到下标4

//[33, 44]

Arrays.fill(数组, 值);

对数组元素进行赋值

Arrays.fill(arr, 9);//6个数都变成9

System.out.println(Arrays.toString(arr));

[9, 9, 9, 9, 9, 9]

binarySearch折半查找

返回元素对应的下标

若65不在数组里输出为负数

排序

冒泡排序

10个数一共需要比较9次,每次比出最大的数放到最后一位

第一轮内部需要比较9次,最大的数放到最后

第二轮内部需要比较8次,倒第二大的数放到倒第二位,上一轮比较的最大数不需要再次比较.

int[] arr=newint[10];

for(inti=0; i<arr.length; i++) {

    arr[i] =(int)(Math.random()*100+1);

}

System.out.println(Arrays.toString(arr));

// 如何找到最大的数  互相比较 所有的元素都得比

// 比较一轮之后 最大的数跑到最后

// 冒泡排序

// 外层循环比较轮数

for(inti=0; i<arr.length-1; i++) {

    // 每一轮比较的次数

    for(intj=0;j<arr.length-1-i;j++) {

        if(arr[j]>arr[j+1]) {

            // 如果前一个数大于后一个数 颠倒位置

            inttemp=arr[j+1];

            arr[j+1] =arr[j];

            arr[j]=temp;

        }

    }

}

System.out.println(Arrays.toString(arr));

[57, 31, 81, 35, 47, 91, 77, 1, 43, 58]

[1, 31, 35, 43, 47, 57, 58, 77, 81, 91]

选择排序

int[] arr=newint[10];

for(inti=0; i<arr.length; i++) {

    arr[i] =(int)(Math.random()*100+1);

}

System.out.println(Arrays.toString(arr));

// 循环九次  每次找到最小的数

for(inti=0; i<arr.length-1; i++) {

    // 默认最小数的下标

    intminIndex=i;

    // 默认最小的数

    intminNum=arr[i];

    // 每次循环找到最小的数  然后获取下标和数值

    for(intj=i+1;j<arr.length;j++) {

        if(arr[j]<minNum) {

            minNum=arr[j];// 8

            minIndex=j;// 9

        }

    }

    // 将找到的位置换位

    arr[minIndex] =arr[i];

    // 最小数值赋值到 标志位

    arr[i] =minNum;

}

System.out.println(Arrays.toString(arr));

[10, 8, 64, 44, 58, 46, 34, 82, 39, 24]

[8, 10, 24, 34, 39, 44, 46, 58, 64, 82]

元素颠倒

//      arr[0]  arr[arr.length-1]

//      arr[1]  arr[arr.length-2]      

//      arr[i] arr[arr.length-i-1]     

        for(inti=0;i<arr.length/2;i++) {

            int temp=arr[i];

            arr[i] =arr[arr.length-1-i];

            arr[arr.length-1-i] =temp;

        }

        System.out.println(Arrays.toString(arr));

 二维数组

定义

多个一维数组

声明

数据类型[][] 数组名;

创建

数组名 =new数据类型[高维长度][低维长度]

数据类型[][] 数组名=new数据类型[高维长度][低维长度];

数据类型[][] 数组名={{数组1},{数组2},{数组3}.....};

int[][] arr1=newint[5][6];

int[][] arr2={{1,2,3,4},{3,4,5,6,7},{12,32,43,56,76,78}};

//      System.out.println(arr2[2][2]);

//      System.out.println(arr2[2][5]);

//      System.out.println(arr2[1][3]);

 

二维数组循环

//arr2[i]每次循环的数组

for(inti=0;i<arr2.length;i++) {

    for(intj=0;j<arr2[i].length;j++) {

        System.out.println(arr2[i][j]);

    }

}

练习:

// 定义二维数组存储内容如下

    // String[][] arr = {{"001","allen","9900","138888"},

    // {"002","test","5900","1355555"},{"003","king","6900","137777"}};

    // 001表示员工工号,allen是名字,9900代表工资,138888代表电话,在控制台打印出每个员工信息

        

         ​                

// 在控制台显示扑克牌 黑桃A-K 红桃A-K  梅花A-K 方块A-K  4*13

        String[][] arr=newString[4][13];

        String[] arr1={"黑桃","红桃","梅花","方块"};

        String[] arr2={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

        for(inti=0; i<arr1.length; i++) {

            for(intj=0; j<arr2.length; j++) {

                arr[i][j] =arr1[i]+arr2[j];

            }

        }

        for(inti=0; i<arr.length; i++) {

            for(intj=0; j<arr[i].length; j++) {

                System.out.print(arr[i][j]+" \t");

            }

            System.out.println();

        }

杨辉三角

// 杨辉三角

//      int[][] arr = {{1},{1,1},{1,2,1},{1,3,3,1},{1,4,6,4,1}};

        int[][] arr=newint[7][];

        for(inti=0; i<arr.length; i++) {

            arr[i] =newint[i+1];

        }

        for(inti=0; i<arr.length; i++) {

            for(intj=0; j<arr[i].length; j++) {

                // 两边都是1

                if(j==0||i==j) {

                    arr[i][j]=1;

                }else{

                    arr[i][j] =arr[i-1][j-1]+arr[i-1][j];

                }

            }

        }

        for(inti=0; i<arr.length; i++) {

            for(intj=0; j<arr[i].length; j++) {

                System.out.print(arr[i][j]+"\t");

            }

            System.out.println();

        }