详解数组

数组         所谓数组，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，然后用编号区分他们的变量的集合，这个名字称为数组名，编号称为下标。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。数组是在程序设计中，为了处理方便， 把具有相同类型的若干变量按有序的形式组织起来的一种形式。这些按序排列的同类数据元素的集合称为数组。

                  定义：有序数据的集合    数组中的每个元素，对应一个相同的数组名和唯一的一个下标。

                 例：若输入代码：   int [ ] a = {1,2,3,4,5};   int a[ ] = {1,2,3,4,5};

                    System.out.println(a[0]);

                    在控制台会输出数字  1。

一、数组概念：

   * 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

   *数组既可以存储基本数据类型，也可以存储引用数据类型。

二、数组的定义格式

*格式一：数组类型[ ]数组名；（常用 ）

*格式二：数组类型  数组名 [ ]；（不提倡）

*注意：这两种定义做完了，数组中是没有元素值的。如何对数组的元素进行初始化呢？

三、数组初始化概述：

  *  java 中的数组必须先初始化，然后才能使用。

    *所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

四、数组的初始化方式：

*动态初始化：初始化时只指定数组的长度，由系统为数组分配初始值。

**格式：数据类型 [ ] 数组名 = new 数据类型 [数组长度]；（数组长度是必须要写的，否则会报错）

**数组长度其实就是数组中元素的个数。

举例：

    int [ ] arr = new int [3];

解释：定义了一个int类型的数组，这个数组中可以存放3个int 类型的值。

1、获取数组中的元素：

*通过      数组名 [ 索引]；

**索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1. 

*静态初始化：初始化时指定每个元素的初始值，由系统决定数组的长度。

举例：

A：int [ ] a ；定义一个int类型的数组a变量

B：int a [ ] ；定义一个int类型的a数组变量

注意：推荐使用第一种

class ArrayDemo{

    public static void main （String [ ]args）{

        //定义一个数组

        int [ ] a ;

        //可能尚未初始化变量a

        System.out.println(a);

        int [ ] arr = new int [ 3 ];

//左边：

//int：说明数组中的元素的数据类型是int类型

//[ ] ：说明这是一个数组

//arr：是数组的名称

//右边：

//new：为数组分配内存空间

//int：说明数组中的元素的数据类型是int类型

//[ ]：说明这是一个数组

//3：数组长度，其实也就是数组中元素的个数

         System.out.println(arr);//[I@175078b  地址值。

//我要地址值没有意义啊，我就要数据值，怎么办呢？

//不用担心，java为你考虑到了

//其实数组中的每个元素都是有编号的。并且是从0开始。最大编号是数组的长度-1.

//用数组名和编号的配合就可以获取数组中的指定编号的元素。这个编号的专业叫法：索引

//通过数组名访问数据的格式：数组名 [ 索引]；

        System.out.println(arr[ 0 ]);

         System.out.println(arr [ ] );

         System.out.println(arr [ ]);

    }

}

动态举例：

//把1~100的所有数，存放在数组中

package shuzu;

public class Dongtai {

    public static void main(String[] args) {

        Dongtai dongtai= new Dongtai();

        int [] b = dongtai.fun();

        for(int i:b){

            System.out.println(i);

        }

    }

    public int[] fun(){

        int a [] = new int [100];

        for (int i = 0;i<100;i++){

            a[i] = i + 1;

        }

        return a;

    }

}

各种数据类型  静态举例：

package shuzu;

public class Sz {

    public static void main(String[] args) throws InterruptedException {

        //定义一个int类型的数组

        int [] a ={5,6,7,9,5};

        //将数组a的值赋值给b

        int b = a[a.length-1];

        //将b的值输出在控制台

        System.out.println(b);

        //运用for循环，将数组元素遍历

        

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        for(int i = 0;i <<span se-mark="1">a.length;i++){

            System.out.print(a[i]);

        }

        System.out.println();

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

    

        //运用while循环，将数组元素遍历

        int ss = 0;

        while (ss <<span se-mark="1">a.length){

            System.out.print(a[ss]);

            ss++;

        }

        System.out.println();

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        

        //运用do--while循环，将数组元素遍历

        int sss = 0;

        do {

            System.out.print(a[sss]);

            sss++;

        } while (sss <<span se-mark="1">a.length );

        System.out.println();

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        //增强for循环的应用

        for(int xx:a){

            System.out.println(xx);

        }

        System.out.println();

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

            

        

        

        //定义一个String类型的数组

        String [] s = {"1","12","123"};        

        //将数组s值赋值給mString

        String mString = s[1];

        //将mString的值输出在控制台

        System.out.println(mString);

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        //运用for循环，将数组元素遍历

        for (int j = 0;j < s.length;j++){

            System.out.print(s[j] );

        }

        System.out.println();

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        //增强for循环的应用

        for(String aa: s){

            System.out.println(aa);

        }

        System.out.println();

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        

        

        

        //定义一个float类型的数组

        float [] f = {(float) 1.0,(float) 4.1,(float) 5.2};

        //将数组f值赋值給x

        float x = f[2];

        //将x的值输出在控制台

        System.out.println(x);

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        //运用for循环，将数组元素遍历

        for (int aa = 0; aa < f.length; aa++) {

            System.out.print(f[aa]);

        }

        System.out.println();

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        //增强for循环的应用

        for(float ff: f){

            System.out.println(ff);

        }

        System.out.println();

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        

        

        

        //定义一个double类型的数组     

        double [] d = {7.0,8.0,9.0};

        //将数组d值赋值給w

        double w = d[2];

        //将w的值输出在控制台

        System.out.println(w);

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        //运用for循环，将数组元素遍历

        for (int bb = 0; bb < d.length; bb++) {

            System.out.print(d[bb]);

        }

        System.out.println();

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        //增强for循环的应用

        for(double dd:d){

            System.out.println(dd);

        }

        System.out.println();

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        

        

        

        //定义一个char类型的数组

        char [] c = {'1','h','d'};

        //将数组c的值赋值给r

        char r = c[2];

        //将r的值输出在控制台

        System.out.println(r);

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        //运用for循环，将数组元素遍历 

        for (int cc = 0; cc < c.length; cc++) {

            System.out.print(c[cc]);

        }

        System.out.println();

        //一个程序运行完后，两秒之后打印下一个程序

        new Thread().sleep(2000);

        

        //增强for循环的应用

        for(char cc:c){

            System.out.println(cc);

        }

        

    }

}

学生类的数组举例：

package xueshengshuzu;

public class First {

    private String name ;

    private String sex;

    private String hao;    

    public First(String name, String sex, String hao) {

        super();

        this.name = name;

        this.sex = sex;

        this.hao = hao;

    }

    public void setName(String name){

        this.name = name;    

    }

    public String getName(){

        return name;

        

    }

    public void setSex(String sex){

        this.sex= sex;    

    }

    public String getSex(){

        return sex;

        

    }

    public void setHao(String hao){

        this.hao = hao;    

    }

    public String gethao(){

        return hao;

        

    }

    public void study(){

        System.out.println("学习。。。就是吃的苦中苦，方为人上人");

    }

    public void surffing(){

        System.out.println("上网冲浪。。。自然是好啊，");

        System.out.println("但是最棒的放松方式就是睡觉睡到自然醒");    

    }

    public static void main (String[]args){

    First f[] =new First [2];

    First first1 =new First("故事太长"," 只有风"," 愿意听我讲。");

    First first2 =new First("回忆起过去，","就连呼吸","都是痛的。 ");

    f[0]=first1;

    f[1]=first2;

    First ff = f[0];

    String name = ff.getName();

    String sex = ff.getSex();

    String hao = ff.gethao();

    System.out.println(" "+name+" "+sex+" "+hao);

    ff.study();

    System.out.println("以为把故事当成笑话讲给旁人自己就不会难过");

    ff.surffing();

    System.out.println("别缠着往事不肯走，别赖着曾经不放手。");

    First fff = f[1];

    String na = fff.getName();

    String se = fff.getSex();

    String ha = fff.gethao();

    System.out.println(" "+na+" "+se+" "+ha);

    fff.study();

    System.out.println("人人都笑你活该孤独凄凉没人懂得你的情长。");

    fff.surffing();

    System.out.println("天上的星星就像人的命运，两颗星的轨迹");

    System.out.println("可能永远也无法接近，也可能靠近之后");

    System.out.println("就互相越离越远。");

    }

    

    }