数组:

概念:

　　- 可以存放多个数据

　　-存放的数据的数据类型必须一致

　　-数组里的每个数据都有一个唯一的标志,叫做下标(角标),从0 开始

　　- 数组的标志是[ ] ,英文名称是Array

05-数组_数组

 

数组的创建: 数组类型[] 数组名 = 初始化

　　两种创建方式:

　　　　静态创建初始化:　

　　　　　　int[] a = new int[]{1,2,3,4,5};
　　　　　　int[] b = {1,2,3,4,5};

　　　　动态创建初始化:

　　　　　　int[] c = new int[5] ;//动态创建的收,必须要指定长度.

练习：数组中存入hello

　　

package cn.tedu.array;

        //这个类用来测试 数组的创建
        public class Test6_Array {
            public static void main(String[] args) {
                //1、创建数组 ，存入hello
                //--静态初始化 ：一开始刚创建好时，存的都是默认值，char类型默认值是\u0000。
                char[] a = new char[] { 'h' , 'e' , 'l' ,'l' ,'o'  } ;
                char[] b = {  'h' , 'e' , 'l' ,'l' ,'o'  } ; 
                
                //--动态初始化，需要在创建数组的同时，指定长度！！
                char[] c = new char[5];
                c[0] = 'h' ; //把下标为0的数据，从默认值\u0000改为'h'
                c[1] = 'e' ;//把下标为1的数据，从默认值\u0000改为'e'
                c[2] = 'l' ;//把下标为2的数据，从默认值\u0000改为'l'
                c[3] = 'l' ;//把下标为3的数据，从默认值\u0000改为'l'
                c[4] = 'o' ;//把下标为4的数据，从默认值\u0000改为'o'
                
                //数组的长度如果是5，下标最大值是4的话，有没有下标为5的元素---没有！！！
                //java.lang.ArrayIndexOutOfBoundsException：原因就是访问了不存在的下标5
                //c[5] = 'x';
                
                System.out.println(a);
                System.out.println(b);
                System.out.println(c);
            }
        }

遍历数组:

　　--1、语法
　　　　for(开始位置;循环条件;更改条件){ 循环体}
　　　　for(从下标为0的位置开始;下标的最大值是数组的长度-1;下标自增){ 循环体}
　　--2、获取数组长度
　　　　length属性，可以获取数组的长度

练习：输出每个月的天数

package cn.tedu.array;

        //这个类用来测试 数组的练习
        public class Test7_Array2 {
            public static void main(String[] args) {
                method() ;//        输出每个月的天数
            }
            public static void method() {
                //1、创建数组，存放12个数字
                int[] a = { 31,28,31,30,31,30,31,31,30,31,30,31  };
        //        System.out.println(a[0]);
        //        System.out.println(a[1]);
        //        System.out.println(a[2]);
        //        System.out.println(a[3]);
                
                //2、遍历数组
                //int i = 0  是指从下标0开始  ，i表示下标
                // i <= a.length-1 是指下标最大值是数组的长度-1
                //i++   是指下标依次递增，向后遍历数据
                for( int i = 0 ; i <= a.length-1 ; i++ ){  
                    //3、a[i]是指根据下标i获取a数组中的元素  
        //            System.out.println( a[i] );
                    //数组一共12个数字，i的变化就是0-11，那么i+1就能获取1-12月了
                    System.out.println(  i+1  +"月有"+a[i]+"天" );
                }
                
            }
        }

 打印日历:

package cn.tedu.array;
/**
*@author 作者:李强
*@email 邮箱:1435430561@qq.com
* 日期: 2020年5月7日
*/
public class Test_RI {
    public static void main(String[] args) {
        int[] days = new int[] {
                31,29,31,30,31,30,31,31,30,31,30,31
        };
        int count =3;
        for (int i = 1; i <= days.length; i++) {
            
            System.out.println(i+"月");
            System.out.println("日    一    二    三    四    五    六");
            for(int j =1;j<=count;j++) {
                System.out.print("\t");
            }
            for(int j = 1;j<=days[i-1];j++) {
                System.out.print(j+"\t");
                count++;
                if (count==7) {
                    count=0;
                    System.out.println();
                }
            }
            System.out.println();
            System.out.println("----");
        }
        
    }

}

效果图:

 05-数组_数组_02

数组的优缺点

  • 优点：

    • 可以保存若干个数据；
    • 随机访问的效率很高。根据下标访问元素效率高（元素连续分配空间）。

  • 缺点：

    • 数组的元素的类型必须一致。元素类型必须一致；
    • 数组定长，不能自动扩容；

数组的常见问题
角标越界：当访问到数组中不存在的角标时；

int[] array = new int[5];
System.out.println(array[6]);
//ArrayIndexOutOfBoudsException(角标越界)


空指针异常：当引用变量没有任何实体指向时，继续指向实体。

array = null;
System.out.println(array[0]);
//NullPointerException
 Arrays类

JDK提供的java.util.Arrays类，包含了常用的数组操作，方便我们日常开发。Arrays类包含了：排序、查找、填充、打印内容等常见的操作。

 打印数组

调用格式

Arrays.toString(arr)

实例

 

public class Test {
    public static void main(String[] args) {
        toStringMethod();
    }
    //打印数组
    public static void toStringMethod() {
        int[] a = new int[10];
        for (int i = 0; i < a.length; i++) {
            a[i]= i+2;
        }
        System.out.println(Arrays.toString(a));
    }
}

 

 

 

数组元素的排序 Arrays.sort(arr)

调用格式

Arrays.sort(arr)

实例

import java.util.Arrays;
public class Demo07 {
    public static void main(String[] args) {
        int[] array = {1,5,798,225,77667,};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

数组元素的复制 Arrays.copyOf( arr, newLength)

　　把数组复制成一个指定长度的新数组。arr表示的原来的数组,newLength表示新复制的数组的长度.

　　新数组长度大于原数组，相当于复制，并增加位置。--数组的扩容

　　新数组长度小于原数组，相当于截取前一部分数据。--数组的缩容

sort()为什么没有返回值?
copyOf()为什么有返回值?：因为数组一旦创建，长度不能变！！

int[] a = Arrays.copyOf(arr, 10);//数组的复制，大于原来长度相当于扩容

System.out.println(Arrays.toString(a));//[12, 30, 20, 90, 34, 0, 0, 0, 0, 0]

System.out.println(a.length);//10       

int[] a2 = Arrays.copyOf(arr, 3);//数组的复制，小于原来长度相当于截取前几个数据

System.out.println(Arrays.toString(a2));//[12, 30, 20]

System.out.println(a2.length);//10

冒泡排序

原理

　　每次比较两个相邻的元素，将较大的元素交换至右端。

 思路

　　每次冒泡排序操作都会将相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足，就交换这两个相邻元素的次序，一次冒泡至少让一个元素移动到它应该排列的位置，重复N次，就完成了冒泡排序。

动态演示

 05-数组_数组_03

代码实现

import java.util.Arrays;

import java.util.Random;

public class TT {

       public static void main(String[] args) {

              int[] arr = new int[]{43, 36, 45, 18, 24,9,20,32};

              int[] arrnew = f1(arr);

              System.out.println(Arrays.toString(arrnew));

       }

 

       private static int[] f1(int[] a) {

              //外循环控制循环次数，如果5个数字，循环4次就行

              for (int i = 0; i < a.length-1; i++) {

                     //内循环控制比大小，循环次数和外循环一样

                     for (int j = 0; j < a.length-1-i; j++) {

                            if(a[j]>a[j+1]){

                                   int t = a[j];

                                   a[j]=a[j+1];

                                   a[j+1]=t;

                            }

                     }

              }       

              return a;

       }