【系列04】数组多维数组冒泡排序稀疏数组[有目录]

数组声明和创建

变量类型变量名称 =变量的值

声明数组

int []nums;//定义
 //上面是首选
/*也可以 int nums2[];*/

下面这种写法是为了迎合c与c++用户的喜爱,更推荐用上面的定义方式

创建数组
```
nums=new int[10];
```

定义数组计算数组的和

package com.SunAo.array;
//变量类型  变量名称 =变量的值;
//数组类型
public class ArrayDemo01 {
    public static void main(String[] args) {
        int []nums;//定义
        //上面是首选
       /*也可以 int nums2[];*/
        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;
        //计算所有元素的和
        int sum =0;
        //获取数组长度:arrays.Length
        for (int i = 0; i < nums.length; i++) {
            sum=sum+nums[i];
        }
        System.out.println("总和为:"+sum);
    }
}

注意:数组元素通过索引访问,数组索引从0开始

获取数组长度:arrays.Lengthnums.length
这个地方容易出现一个报错[原因是数组下表越界了]

```java.lang.ArrayIndexOutOfBoundsException``

静态初始化:创建+赋值
```
int []a={1,2,3,4,5,6,7,8};
```

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

int []b=new int[10];
b[0]=10;
b[1]=90;
System.out.println(b[1]);
System.out.println(b[2]);//默认值就是0

创建过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HMS57m4U-1673864381593)(C:/Users/%E5%AD%99%E5%A5%A5/AppData/Roaming/Typora/typora-user-images/image-20230114194548190.png)]

数组四个特点
1. 数组长度确定,一旦确定无法更改
2. 其元素必须是相同类型,不允许出现混合,不能有int 还有String
3. 数组中元素可以使任何数据类型,包括基本类型和引用类型
4. 数组变量属于引用类型,数组也可以看成是对象,数组中每个元素相当于该变量的成员变量.数组本身就是对象,java的对象在堆中,因此数组无论保存原始类型还是其他对象类型,数组对象本身在堆中的

数组的应用

基础训练

package com.SunAo.array;
public class ArrayDemo03 {
    public static void main(String[] args) {
        int [] arrays={1,2,3,4,5,6};
        //打印全部的数组元素
        for (int i = 0; i <arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        //计算所有元素的和
        int sum=0;
        System.out.println("======================");
        for (int i = 0; i < arrays.length; i++) {
            sum+=arrays[i];//sum=sum+arrays[i]
        }
        System.out.println("sum"+sum);
        //查找出元素的最大值
        int max=arrays[0];
        for (int i = 0; i <arrays.length; i++) {
            if(arrays[i]>max){
                max=arrays[i];
            }
        }
        System.out.println("max"+max);
    }
}

高阶使用

public class ArrayDemo04 {
    public static void main(String[] args) {
        int [] arrays={1,2,3,4,5,6};
                //JDK1.5版本 没有下标
        for (int array : arrays) {
            System.out.println(array);
        }
    }
}

快捷输入 arrays.for生成for (int array : arrays)

这种方便进行打印操作,但是单个数组操作就没那么方便,JDK1.5才开始有的

练习使用

package com.SunAo.array;

public class ArrayDemo04 {
    public static void main(String[] args) {
        int [] arrays={1,2,3,4,5,6};
                //JDK1.5版本 没有下标
       /* for (int array : arrays) {
            System.out.println(array);
        }*/
        printArrary(arrays);
        int[] reverse = reverse(arrays);
        printArrary(reverse);
    }
    //翻转数组
    public  static int[] reverse (int []arrays){
        int []result =new int[arrays.length];
        //反转操作
        for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
            result[j]=arrays[i];
        }
        return result;
    }
    //打印数组元素
    public static void printArrary(int []arrary){
        for (int i = 0; i < arrary.length; i++) {
            System.out.print(arrary[i]+" ");

        }
    }
}

数组的反转
打印操作

多维数组

二维数组:数组嵌套数组

循环打印一个二维数组元素

for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        System.out.println(array[i][j]);
    }
}

定义二维数组

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

输出数组元素

System.out.println(array[0][0]);//输出第一行第一列

测试代码

package com.SunAo.array;
//[4][2]
                    /*1,2    array[0]
                      2,5    array[1]
                      3,4    array[2]
                      4,5    array[3]
                    */
public class ArrayDemo05 {
    public static void main(String[] args) {
        int [][]array ={{1,2},{2,5},{3,4},{4,5}};
        //循环打印整个二维数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }

        printArrary(array[0]);
        System.out.println();
        System.out.println(array[0][0]);
        System.out.println(array[1][0]);
            }
            //打印
    public static void printArrary(int []arrary){
        for (int i = 0; i < arrary.length; i++) {
            System.out.print(arrary[i]+" ");
        }
    }
}

Arrays 类拓展

Arrays.下面有很多的工具类

比如Arrays.toString打印 Arrays.sort(a)从小到大排序都是可以自己写出来的

更多工具详情可以看下这位博主的
jdk帮助文档详情及下载

不要过度依赖工具类

原来

public static String toString(int[] a) {
    if (a == null)
        return "null";
    int iMax = a.length - 1;
    if (iMax == -1)
        return "[]";

    StringBuilder b = new StringBuilder();
    b.append('[');
    for (int i = 0; ; i++) {
        b.append(a[i]);
        if (i == iMax)
            return b.append(']').toString();
        b.append(", ");
    }
}

我们写的

public static void printArray(int[]a){
    for (int i = 0; i < a.length; i++) {
        if(i==0){
            System.out.print("[");}

        if(i==a.length-1){
            System.out.print(a[i]+"]");}
        else{
            System.out.print(a[i]+", ");
    }
    }
}

代码

package com.SunAo.array;

import java.util.Arrays;

public class ArrayDemon06 {
    public static void main(String[] args) {
        int []a={1,2,3,5,9222,3111,54,2256,32,25};
        System.out.println(a);//[I@4554617c
        //打印数组元素
        System.out.println(Arrays.toString(a));
        System.out.println("=========================");
        printArray(a);
    }
    public static void printArray(int[]a){
        for (int i = 0; i < a.length; i++) {
            if(i==0){
                System.out.print("[");}

            if(i==a.length-1){
                System.out.print(a[i]+"]");}
            else{
                System.out.print(a[i]+", ");
        }
        }
    }
}

打印对比

冒泡排序

//冒泡排序
//1.比较数组两个相邻的元素如果第一个第二个数大,就交换位置
//2.每次比较都会产生出一个最大或者最小的数值
//3.下一轮可以少一次比较
//4.依次循环直到结束

冒泡排序java实现

package com.SunAo.array;

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int []a={10,8,5,6,2,52,144,256,445};
        int[] sort1 = sort(a);
        System.out.println(Arrays.toString(sort1));
    }
    //冒泡排序
    //1.比较数组两个相邻的元素如果第一个第二个数大,就交换位置
    //2.每次比较都会产生出一个最大或者最小的数值
    //3.下一轮可以少一次比较
    //4.依次循环直到结束
    public static int[] sort(int[]array){
        //循环判断要走多少次
        for (int i = 0; i < array.length-1; i++) {
            boolean flag =false;//通过falg标示位减少没有意义的比较

            //内层循环,比较判断两个数,第一个数比第二个数大则交换位置
            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;
    }
}

boolean做一个优化进行判断,如果成功继续进行,如果失败则终止程序

稀疏数组

稀疏数组代码

实现了存放原始数组

创建11x11的邻接矩阵对相应进行赋值
实现如图效果

int [][] a1=new int[11][11];//此时此刻形成了一个11x11的格子里面都放的是0
a1[1][2]=1;
a1[2][3]=2;
System.out.println("输出原始数组");

for (int[] ints : a1) {
    for (int anInt : ints) {
        System.out.print(anInt+"\t");
    }
    System.out.println();
}

将原始数组转化为稀疏数组

首先输出有效个数以便于判断所要创建稀疏数组行数
第一行分别是行列总数
遍历二维数组a1 将非零值存放到稀疏数组a2

代码

System.out.println("有效值个数:"+sum);

//创建一个稀疏数组的数组
int [][] a2=new int[sum+1][3];
a2[0][0]=11;//行
a2[0][1]=11;//列
a2[0][2]=sum;

//遍历二维数组,将非零的值,存放到稀疏数组
int count=0;
for (int i = 0; i < a1.length; i++) {
    for (int j = 0; j < a1[i].length; j++) {
        if (a1[i][j]!=0){
         count++;
         a2[count][0]=i;
         a2[count][1]=j;
         a2[count][2]=a1[i][j];
        }
    }
}
//输出稀疏数组
System.out.println("稀疏数组输出如下");
for (int i = 0; i < a2.length; i++) {
    for (int j = 0; j < a2[i].length; j++) {
        System.out.print(a2[i][j]+"\t");
    }
    System.out.println();
}

最后输出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dnr379Ky-1673864563991)(C:/Users/%E5%AD%99%E5%A5%A5/AppData/Roaming/Typora/typora-user-images/image-20230116180210385.png)]

将稀疏数组再次转化为原数组

读取稀疏数组
给其中元素还原它的值
打印输出

代码

//1.读取稀疏数组
int[][]a3=new int[a2[0][0]][a2[0][1]];
//2.给其中元素还原它的值
for (int i = 1; i < a2.length; i++) {
    a3[a2[i][0]][a2[i][1]] = a2[i][2];
}
    //3.打印
    System.out.println("输出还原的数组");
    for (int[] ints : a3) {
        for (int anInt : ints) {
            System.out.print(anInt+"\t");
        }
        System.out.println();
    }

最后输出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ANrQy76h-1673864613797)(C:/Users/%E5%AD%99%E5%A5%A5/AppData/Roaming/Typora/typora-user-images/image-20230116180210385.png)]

- 值得一提的是这个输出代码

  ```java
  for (int[] ints : a3) {
          for (int anInt : ints) {
              System.out.print(anInt+"\t");
          }
          System.out.println();
  ```

  > for (int[] ints : a3) {  
  >
  > }  
  >
  > ```快捷键 a3.for``
  >
  > for (int anInt : ints) {      
  >      }
  >
  > ```快捷键 ints.for```

完整代码

package com.SunAo.array;
import com.sun.javaws.IconUtil;
import java.util.Arrays;
import java.util.SortedMap;
public class ArrayDemo08 {
    public static void main(String[] args) {
        int [][] a1=new int[11][11];//此时此刻形成了一个11x11的格子里面都放的是0
        a1[1][2]=1;
        a1[2][3]=2;
        System.out.println("输出原始数组");

        for (int[] ints : a1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //转换为稀疏数组来存储
        //获取有效值的个数
        int sum=0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(a1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("===========================");
        System.out.println("有效值个数:"+sum);

        //创建一个稀疏数组的数组
        int [][] a2=new int[sum+1][3];
        a2[0][0]=11;//行
        a2[0][1]=11;//列
        a2[0][2]=sum;
        //遍历二维数组,将非零的值,存放到稀疏数组
        int count=0;
        for (int i = 0; i < a1.length; i++) {
            for (int j = 0; j < a1[i].length; j++) {
                if (a1[i][j]!=0){
                 count++;
                 a2[count][0]=i;
                 a2[count][1]=j;
                 a2[count][2]=a1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组输出如下");
        for (int i = 0; i < a2.length; i++) {
            for (int j = 0; j < a2[i].length; j++) {
                System.out.print(a2[i][j]+"\t");
            }
            System.out.println();
        }
        //1.读取稀疏数组
        int[][]a3=new int[a2[0][0]][a2[0][1]];
        //2.给其中元素还原它的值
        for (int i = 1; i < a2.length; i++) {
            a3[a2[i][0]][a2[i][1]] = a2[i][2];
        }
            //3.打印
            System.out.println("输出还原的数组");
            for (int[] ints : a3) {
                for (int anInt : ints) {
                    System.out.print(anInt+"\t");
                }
                System.out.println();
            }
        }
    }