数组

数组

数组是相同类型数据的有序集合。

• 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

int[] nums;//1、声明数组变量的首选方式
        //int nums2[];//C++、C的惯例写法

• Java语言使用new操作符来创建数组，语法如下：

nums = new int[10];//2、使用数组，这里面可以存放10个int类型的数字

• 数组的元素是通过索引访问的，数组索引从0开始

• 获取数组长度：array.length

• 3、给数组元素赋值
  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;
  System.out.println(nums[2]);
  

//变量的类型 变量的名字=变量的值;
//数组类型
public static void main(String[] args){
    int[] nums;//1.声明一个数组
    nums=new int[10];//2.创建一个数组
    int[] nums2=new int[10];//声明和创建可以放在一起
    //3.给数组元素赋值
    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;
    for(int i=0;i<nums.length;i++){
        sum += nums[i];
    }
    System.out.println(sum)
}

数组的四个基本特点

• 其长度是确定的。数组一旦被创建，它的大小就是不可改变的
• 其元素必须是相同类型，不允许出现混合类型
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型
• 数组变量引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论原始类型还是其他对象类型，数组对象本身是在堆中。
• ArrayIndexOutOfBoundsException：数组下标越界异常，合法区间[0,length-1].

数组的三种初始化和内存分析

//静态初始化：创建+赋值
int[] array = {1,2,3,4,5,6,7,8};
System.out.println(array[0]);
//动态初始化：先创建空间，再手动赋值,包含默认初始化0、null
int[] b = new int[10];//长度为10的数组
b[0]=10;

数组使用

普通for循环

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

//打印全部的数组元素
for(int i=0;i<arrays.length;i++){//for循环用;号
    System.out.println(arrays[i]);
}
System.out.println("=================================================");
//计算所有数组元素的和
int sum =0;
for(int i=0;i<arrays.length;i++){
    sum+=arrays[i];
}
System.out.println("sum="+ sum);
System.out.println("=================================================");
//查找最大元素
int max = arrays[0];
for (int i = 0; i <arrays.length ; i++) {
    if(arrays[i]>max){
        max=arrays[i];
    }

}
System.out.println("max="+max);

增强for循环（for each）来遍历

int[]arrays = {1,2,3,4,5};
//增强for循环无下标
for (int array:arrays) {
    System.out.println(array);
}

/** 
* foreach输出二维数组测试 
*/ 
int arr2[][] = {{4, 3}, {1, 2}}; 
System.out.println("----3----foreach输出二维数组测试"); 
for (int x[] : arr2) { 
for (int e : x) { 
System.out.println(e); //逐个输出数组元素的值 
} 
} 
————————————————
版权声明：本文为CSDN博主「zhw0596」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zhw0596/article/details/79767506

数组作方法入参

//打印数组元素
public static void printArray(int[]arrays){
    for (int i = 0; i < arrays.length ; i++) {
        System.out.print(arrays[i]+" ");
    }
}

数组作为返回值（反转数组）

int[]arrays = {1,2,3,4,5};
int[]reverse=reverse(arrays);//调用方法
        printArray(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;
    }

多维数组

多维数组就是数组的数组，层层嵌套，套娃。

• 二维数组的遍历

int[][] array={{3,4},{5,6},{6,7}}
//System.out.println(array[1][1]);
//遍历二维数组的长度
for(int i=0;i<array.length;i++){
    for(int j=0;j<array[i].length,j++){
        System.out.println(array[i][j]);
    }
}

Arrays类

• 数组的工具类是java.utill.Arrays

• 由于数据对象本身并没有方法可以供我们使用，但是API提供了一个工具类Arrays供我们使用

• Array类中的方法都是static修饰的静态方法，使用时直接使用类名进行调用，可以不用对象调用

• 常用功能

  • 给数组赋值：fill方法
  • 排序：sort方法，升序
  • 比较数组：equals方法比较数组中元素值是否相等
  • 查找数组元素：binarySearch对排序号的数组进行二分法查找操作

  int[]a = {1,2,659,7526,6,985,211,11};
  System.out.println(a);//[I@1b6d3586直接打印的话输出哈希码
  //打印数组元素
  System.out.println(Arrays.toString(a));//按下ctrl+A进入源代码模式
  //自动排序 升序
  Arrays.sort(a);
  System.out.println(Arrays.toString(a));
  //数组填空
  Arrays.fill(a,2,4,0);
  System.out.println(Arrays.toString(a));
  

冒泡排序 面试常见

• 冒泡排序是八大排序最出名的排序算法。
• 代码：两层循环，外层冒泡轮数，里层依次比较。
• 当我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2)。

1、比较数组中两个相邻的元素，如果第一个比第二个大，那么就交换他们的位置。

2、每一次比较，都会产生一个最大或者最小的数字。

3、下一轮可以少一次排序。

4、依次循环直到结束。

int[]a={2,6,211,985,369,11};
     int[] sort = sort(a);
     System.out.println(Arrays.toString(sort));
 }
 //冒泡排序
public static int[] sort(int[]array){
     int temp=0;
     for (int i = 0; i < array.length-1 ; i++) {//外层循环，判断要走多少次。因为数组下标从0开始，所以-1为了防止Out of bound.
         for (int j = 0; j < array.length-1-i; j++) {//内层循环，比较判断两个数并交换位置，-i是减少已经排序比较过的次数。
             if(array[j]>array[j+1]){
                temp = array[j];//引入第三者作为临时变量，赋值交换位置，三杯水，大的先导入空杯。
                array[j] = array[j+1];
                array[j+1]=temp;
             }
         }
    }
     return array;
}//优化版加入boolean值判断，如果当前已经有序了就没必要继续就结束循环。

博客解说

稀疏数组（未完结）

//创建一个二维数组11*11    0：没有棋子， 1：黑棋，2：白棋
        int[][]array1 = new int[11][11];//New一个11行11列的二维数组
        array1[1][2]=1;
        array1[2][3]=1;
        //for each循环来遍历下数组
        for (int[]yys:array1) {//打印一维数组
            for (int yyds:yys){ //打印二维数组
                System.out.print(yyds+"\t");//空格占位符
            }
            System.out.println();//每隔十一个换行

        }

看不懂懵逼，学完数据结构再回来看