javaSE第三章-数组

javaSE 第三章-数组

一.数组的创建

package day1;
import java.util.Arrays;
public class Demo1 {
    /*
            数组：相同类型元素的集合
                        数组内部可以划分为多个空间，空间是连续的，一旦空间数量确定就不能再进行更改
                        数组是一个非常重要的数据结构
                java中的数组是引用类型，属于对象
                数组中可以存储基本数据类型，也可以存储引用类型，取决与生成数组时，可以存储的数据类型
     */
    public static void main(String[] args) {
        /*
                数组声明语法：(两种方法)
                    1.数据类型 名称 []
                    2.数据类型 [] 名称
         */
        int a ,d []; // a是一个int类型的整数，d 表示数组
        int [] b, c; // b和c都是数组
        /*
                创建数组1
         */
        int[] x =new int[5];
//        System.out.println(x); //[I@1b6d3586   输出的是数组在内存中的地址
//        System.out.println(x.hashCode()); //460141958
//        System.out.println(Integer.toHexString(460141958)); // 1b6d3586
        System.out.println(Arrays.toString(x)); //[0, 0, 0, 0, 0]   Arrays.toString(x)将数组中的元素拼接为一个字符串表示
        char[] y = new char[5];
        System.out.println(Arrays.toString(y)); //[ ,  ,  ,  ,  ]
        float[] z =new float[5];
        System.out.println(Arrays.toString(z)); //[0.0, 0.0, 0.0, 0.0, 0.0]
        String[] s = new String[5];
        System.out.println(Arrays.toString(s)); //[null, null, null, null, null]
        /*
                数组创建2
         */
        int[] e = new int[]{1,2,3,4,5,6,7};
        System.out.println(Arrays.toString(e)); // [1, 2, 3, 4, 5, 6, 7]
        /*
                数组3 （对2再进行简化）
         */
        int[] f = {1,2,3,4,5,6,7};
        System.out.println(Arrays.toString(f));
    }
}

二.数组的访问

package day1;
import java.util.Arrays;
public class Demo2 {
    /*
            数组元素访问：
                数组在创建之初，会给每个空间分配下标
                通过编号可以对某个空间进行访问
                索引特点：
                整数 （int）
                从0开始
                最大的索引 = 数组长度 - 1
     */
    public static void main(String[] args) {
        int[] a = new int[5];
            a[0] = 20;
            a[1] = 5;
            a[2] = 10;
            a[3] = 8;
            a[4] = 17;
//            a[5] = 100;
        System.out.println(Arrays.toString(a));
        /*
                出现时发生运行异常
                                                    数组索引越界异常   （异常类型）
                Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5（异常原因）
   at day1.Demo2.main(Demo2.java:13)（异常位置）
         */
        int[] b = {1, 2, 3, 4, 5};
        System.out.println(b[2]); // 3
​
        // 数组长度界限，跟数据类型的长度有关 ，也有可能因为电脑可用连续内存不足导致运行时发生错误
//        int[] c = new int[Integer.MAX_VALUE];
​
​
    }
}

三.数组的遍历

package day1;
public class Demo3 {
    public static void main(String[] args) {
​
        /*
                数组元素的遍历
                1. for循环
         */
        int [] a  = {1, 2, 3, 4, 5};
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        /*
                增强for循环
                a:需要遍历的数组
                int t :声明一个变量
                每循环一次，从数组中取出一个元素，然后赋给t，进入到循环体重复操作，直到数组中元素遍历完成
         */
        for(int t : a){
            System.out.println(t);
        }
        // 找出数组中的最大值
        int[] d = {10,54,23,65,12};
        int max=0;
        for (int i = 0; i < d.length; i++) {
            max = d[i]>max? d[i] : max;
        }
        System.out.println(max);
​
    }
}

四.冒泡排序

package day1;
import java.util.Arrays;
public class Sort1 {
    /*
            冒泡排序
            每次比较相邻两元素，把较大的元素往后移动
            5， 4， 3， 2， 1
            4， 3， 2， 1， 5
            3， 2， 1， 4， 5
            2， 1， 3， 4， 5
            1， 2， 3， 4， 5
     */
    /*
            debug调试
            1. 设置断点，开始调试程序的位置
            2. 启动时使用debug模式运行程序
            3. 调试按键
     */
    public static void main(String[] args) {
        int[] a = {5, 4, 3, 2, 1};
​
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j<a.length-1-i;j++){
                int s = a[j];
                a[j] = a[j+1];
                a[j+1] = s;
                }
​
        }System.out.println(Arrays.toString(a));
    }
}

五.选择、快速排序

package day1;
import java.util.Arrays;
public class Sort2 {
​
    public static void main(String[] args) {
        /*
                选择排序
                假设第一个元素为最大值，与之后的每一个元素进行比较，满足条件交换位置
         */
        int[] a = {2, 1, 3, 5, 4};
        for (int i = 0; i < a.length; i++) {
            for (int j = i+1; j<a.length;j++){
                if(a[i] > a[j]){
                    int t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                }
            }
        }
        System.out.println(Arrays.toString(a));
        /*
                快速排序
         */
        int[]  b = {5,4,3,2,1};
        Arrays.sort(b);
        System.out.println(Arrays.toString(b));
    }
}

六.二维数组及其遍历

package day1;
public class Demo4 {
    /*
                二维数组
                数组的数组
                二维数组中的每一个元素又是一个一维数组
​
                声明语法
                int[][] a;
                int a[][];
​
         */
    public static void main(String[] args) {
            //创建二维数组{{0,0,0},{0,0,0},{0,0,0}}
            //创建长度为3的二维数组，二维数组中的每一个一维数组为3
        int[][] a = new int[3][3];
        System.out.println(a[1][2]);
        int[][] b = new int[][]{{54,65,87},{25,64,10},{65,54,32},{45,48,95}};
        int [][] c = {{54,65,87},{25,64,10},{65,54,32},{45,48,95}};
        int[][] d = new int[3][];  // {null,null,null}
        d[0] = new int[]{5,4,6,3};
        d[1] = new int[]{8,7,9,4,8};
        d[2] = new int[]{4,10};
        System.out.println(d[1][2]);
        /*
                二维数组遍历
         */
        for (int i = 0; i <b.length; i++) {
            for (int j = 0; j<b[i].length;j++){
                System.out.print(b[i][j]+"\t");
            }
            System.out.println();
            //System.out.println(Arrays.toString(b[i]));
        }
    }
}