java数组

java数组

补充：查看源码

对准索要查看的方法名：ctrl+左键

数组

相同类型若干数据的有序集合，可以通过下标访问

数组声明&创建

定义任何东西都满足以下

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

内存分析

引用类型在堆里，基本类型在栈里

除了8中基本数据类型以外都是引用数据类型,8中基本数据类型分别是byte,short,int,long,char,boolean,float,double

主要的引用类型：类，接口，数组

堆：

专门存放new的对象和数组

数组初始化

1. 静态初始化

int [] a={1,2,3,4,5,6,7,8};//长度内容确定，不可改变
//创建+赋值

1. 动态初始化(包含默认初始化)

int[] b= new int[10];
b[0]=1;
//默认初始化：数组是引用类型，他的元素相当于类的实例变量，其中的每一个变量也被按照实例变量同样的方式被隐士初始化。

数组基本特点

1. 长度确定。

2. 元素类型相同

3. 数组元素可以是任何类型

4. 数组变量属于引用类型，数组本身也可以看作是变量，存放在堆中。

5. 数组边界：越界报错：ArrayIndexOutOfBoundsException：数组下标越界异常。

数组使用

package array;
​
public class Demo02 {
​
    public static void main(String[] args) {
        //JDK1.5没有下标的数组循环
        int[] arrays={1,2,3,4,5};
        for (int array : arrays) {
            System.out.println(array);
        }
​
        System.out.println(reverse(arrays)[0]);
​
​
    }
​
    //反转数组
    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;
    }
}

多维数组

package array;
​
public class Demo03 {
​
    public static void main(String[] args) {
​
        int[][] array={{1,2},{3,4},{4,6},{6,7}};
​
    }
​
    //打印数组元素
    public static printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
​
        }
    }
}

应用

1.Arrays类方法

package array;
​
​
import java.util.Arrays;
​
public class Demo04 {
​
    public static void main(String[] args) {
        int[] a={12,3,4,3,3,45,345,43,5,34,6,456,456,234};
        //打印数组元素：toString
        Arrays.toString(a);
​
​
        //对数组进行排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
        //Arrays类中的方法都是static修饰的,因此可以直接使用类名来调用而不用对象名来调用.
​
        //fill方法
        Arrays.fill(a,1,7,0);//数组填充
        System.out.println(Arrays.toString(a));
​
    }
​
}

---

1. 冒泡排序

江湖中人尽皆知

package array;
​
import java.util.Arrays;
​
public class Demo05 {
​
    public static void main(String[] args) {
​
        int[] a={21,345,5,435,43,53,4};
        int [] sort=sort(a);
        System.out.println(Arrays.toString(sort));
​
​
    }
​
    //冒泡排序
    //1.比较数组中两个相邻的元素,如果第一个比第二个大,就交换他们的位置
    //2.每一次比较都会产生一个最大或者最小的数
    //3.下一轮少一次排序
    //4.依次循环
​
    public static int[] sort(int[] array){
​
        int temp=0;
​
​
        for (int i = 0; i < array.length-1; i++) {
            boolean flag=false;//减少没有意义的比较
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j+1]>array[j]) {
                    temp = array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag=true;//优化算法
​
                }
            }
            if(flag==false){
                break;//flag标识位优化运算,缩减时间成本
            }
        }
        return array;
    }
}

1. 疏散数组

当一个数组中，大部分元素都是零或者其他相同元素，可以用稀疏数组来保存数组，减少内存占用

处理方式：

1. 记录数组有几行几列，多少个不同值。

2. 把具有不同元素的行列&值记录在一个小规模的数组中

package array;
​
import javax.sound.midi.Soundbank;
​
public class Demo06 {
​
    public static void main(String[] args) {
​
        //棋盘
        //创建一个二维数组保存棋盘:0没有棋子;1黑子;2白字
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始数组
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("===============================================");
        System.out.println("===============================================");
        //转换为稀疏数组
        //获取有效值的个数
        int sum =0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
​
        System.out.println("有效值的个数:"+sum);
​
        //创建一个稀疏数组
        int[][] array2=new int[sum+1][3];
​
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;
​
        //遍历二维数组,将非零的值存放到稀疏数组中
        int count=0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if(array1[i][j]!=0){
                    count ++;
                    array2[count][0]=i;//横坐标
                    array2[count][1]=j;//纵坐标
                    array2[count][2]=array1[i][j];//数值
​
​
                }
            }
        }
        //输出稀疏数组
        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]);
​
        }
​
​
        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.打印还原
        System.out.println("输出还原的数组");
        for (int i = 0; i < array3.length; i++) {
            for (int j = 0; j < array3.length; j++) {
                System.out.print(array3[i][j]+"\t");
​
            }
            System.out.println();
        }
​
    }
}