Java基础语法three

一、一维数组

一维数组初始化

数据类型[] 数组名=new 数据类型[数组长度]//动态初始化

数据类型[] 数组名=new 数据类型[]{值}//静态初始化

数据类型[] 数组名={值}

数组长度一旦确定，就不可更改。

数组是序排序；

数组属于引用数据类型的变量，数组的元素可以是任意数据类型；

一维数组引用：数组名[索引/下标]

获取数组长度：数组名.length

如何遍历数组：

for (int i = 0; i < 数组名.length; i++) {
                System.out.println(数组名[i]);
            }

不同类型的一维数组默认初始化值：

整型：0

浮点型：0.0

char：0或'\u0000',而非'0'

boolean：false

引用类型：null

二、二维数组

二维数组初始化

数据类型[][]数组名=new 数据类型[一维数组的个数][一维数组的长度]//动态初始化
数据类型[][]数组名=new 数据类型[一维数组的个数][]//动态初始化
数据类型[][]数组名=new 数据类型[][]{{},{},{}……,{}}//静态初始化

获取数组长度：

数组名.length

数组名[索引].length

如何遍历数组：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] arr = new int[][] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }

二维数组默认初始化值：

方式一：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        //二维数组使用，二维数组分为外层，内层元素
        int[][] arr = new int[4][3];
        //arr[0]外层
        //arr[0][0]内层
        //默认初始化值
        System.out.println(arr[0]);//[I@4e50df2e
        System.out.println(arr[0][0]);//0
        System.out.println(arr);//[[I@1d81eb93
        
    }

外层元素初始化值为：地址值

内层元素初始化值为：与一维数组初始化情况相同

方式二：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] arr = new int[4][];
        System.out.println(arr[0]);//null
        
    }

外层元素初始化值为：null

内层元素初始化值为：不能调用，会报错

三、数据结构

1、数据与数据之间的逻辑关系：集合，一对一，一对多，多对多；

2、数据的存储结构：

线性表：顺序表（数组）、链表、栈、队列；

树形结构：二叉树

图形结构

算法：排序算法，搜索算法

四、数组算法

10行的杨辉三角

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] arr = new int[10][];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new int[i + 1];
            arr[i][0] = arr[i][i] = 1;
            for (int j = 1; j < arr[i].length - 1; j++) {
                arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
            }
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
    }

数组的复制、反转、遍历

int[] array1=new int[]{1,2,3,4};
//数组的复制,区别于数组变量的赋值：array1=array2
int[] array2=new int[array1.length];
for(int i=0;i<array1.length;i++){
array2[i]=array1[i];
}
//数组反转
for(int i=0;i<array1.length/2;i++){
int temp =array1[i];
array1[i]=array1[array1.length-i-1];
array1[array1.length-i-1]=temp;
}
//遍历
for(int i=0;i<array1.length;i++){
System.out.println(array1[i]+"\t");
}

查找（线性查找、二分法查找）

//线性查找
        int num=4;
        boolean flag=true;
        for(int i=0;i<array1.length;i++) {
            if(num==array1[i]) {
                System.out.println("找到指定元素，位置为，"+i);
                flag=false;
                break;
            }
        }
        if(flag) {
            System.out.println("很遗憾，没有找到");
        }
        //二分法查找：前提：所要查找的数组必须有序
        int[] arr=new int[]{12,43,2,-1,8,7,66,45};
        int n=-1;
        int head=0;//初始首索引
        int end=arr.length-1;//初始尾索引
        boolean flag1=true;
        while(head<=end) {
            int middle=(head+end)/2;
            if(n==arr[middle]) {
                System.out.println("找到指定元素，位置为，"+middle);
                flag1=false;
                break;
            }else if(arr[middle]>n) {
                end=middle-1;
            }else {
                head=middle+1;
            }
        }
        if(flag1) {
            System.out.println("很遗憾，没有找到");
        }

排序算法

衡量排序算法优劣：

时间复杂度、空间复杂度、稳定性

排序：选择排序、交换排序（冒泡排序，快速排序）、插入排序（直接插入、折半插入）、归并排序、桶式排序、基数排序

算法5大特性：输入、输出、有穷性、确定性、可行性

冒泡排序：

int[] arr= new int[]{2,4,3,5,1};
for(int i=0;i<arr.length-1;i++) {
    for(int j=0;j<arr.length-1-i;j++) {
        if(arr[j]>arr[j+1]) {
            int temp=arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
        }
    }
}
for(int i=0;i<arr.length;i++) {
    System.out.println(arr[i]);
}

从平均时间来看：快速排序最佳

Arrays工具类使用

java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法。

Arrays.equals(int[] a,int[] b):判断两个数组是否相等

Arrays.toString(int[] a):输出数组信息

Arrays.fill(int[] a,int val):将指定值填充到数组中

Arrays.sort(int[] a)：对数组进行排序

常见异常：

数组角标越界异常：ArrayIndexOutOfBoundsException

空指针异常:NullPointerException