上一篇是分享的是《Java异样简介与Java异样解决》,这篇分享的是《Java数组的定义、Java拜访数组元素、Java数组元素的遍历、Java数组的动态初始化、Java数组援用数据类型、Java可变长参数、Java数组扩容、Java数组的特点、Java对象数组、Java二维数组》。

Java数组的定义

定义数组的语法:

数据类型 [] 数组名 = new 数据类型[数组长度];

也能够:

数据类型 数组名[] = new 数据类型[数组长度];

如, 定义一个能够存储5个int类型数据的数组:

int [] data = new int[5];

阐明:

● data是一个数组名, 其实就是一个变量名, 数组是Java的一种援用数据类型, data数组名中存储的是数组的援用(起始地址)。

● int是指数组中存储元素的数据类型, int[]是一种数组类型, 即data变量的数据类型是 int[]。

● new运算符在堆区调配一块间断的存储空间, 这块间断的存储空间能够包容5个int类型的数据, 把这块存储空间的援用保留到data数组名中。

再如, 定义一个数组,存储10个double类型的数据:

double [] data2 = new double[10];

Java拜访数组元素

长度为5个数组, 最大下标是: 4

为什么通过索引值能够拜访到数组的元素?

Java数组元素的遍历

package com.wkcto.chapter03.demo01;import java.util.Arrays;/**数组的定义,元素的拜访与遍历package com.wkcto.chapter03.demo01;import java.util.Arrays;/** * 数组的定义,元素的拜访与遍历 * */public class Test01 {    public static void main(String[] args) {        //1) 定义一个数组,存储5个int类型数据        int [] data = new int[5];        //定义数组,存储10个double类型数据        double [] data2 = new double[10];        //定义数组, 存储8个String字符串        String[] data3  = new String[8];                //2) 给数组元素赋值, 通过索引值拜访每个元素        data[0] = 123;        data[1] = 123;        data[2] = 123;        data[3] = 123;        data[4] = 123;        //3) 留神, 数组下标(索引值)不能越界//        data[5] = 123;      //java.lang.ArrayIndexOutOfBoundsException: 5  数组索引值越界异样                //4) 打印data数组每个元素的值        /*System.out.println( data[0] );        System.out.println( data[1] );        System.out.println( data[2] );        System.out.println( data[3] );        System.out.println( data[4] );*/        //数组有一个length属性,示意数组的长度        for( int i = 0 ; i < data.length ;  i++){            System.out.println( data[i] );        }                //5)遍历数组元素时, 还能够应用加强的for循环,也称foreach循环        for (int xx : data) {            //顺次把数组中的每个元素赋值给局部变量xx            System.out.print( xx + "\t");        }        System.out.println();                //6)在输入数组的每个元素时,还能够调用Arrays工具类的toString()办法, 能够把数组的元素转换为字符串        System.out.println( Arrays.toString(data));            }}

Java数组的动态初始化

package com.wkcto.chapter03.demo01;import java.util.Arrays;/** * 数组的动态初始化  * */public class Test02 {    public static void main(String[] args) {        //定义数组        int [] data = new int[8];        //给数组元素赋值        data[2]     = 666;        //遍历数组的元素        for(int i = 0 ;  i<data.length; i++){            System.out.print( data[i] + "\t");        }        System.out.println( );        /*         * 1) 创立了数组后, 零碎会给数组进行默认的初始化         *     整数数组,把所有元素默认初始化为0         *     小数数组,把所有元素默认初始化为0.0         *     字符数组,把所有元素默认初始化为码值为0的字符, '\u0000'         *     布尔数组,把所有元素默认初始化为false         *     援用数组,把所有元素默认初始化为null         */                //2)在创立数组的同时,能够给数组的元素赋出值, 这叫数组的动态初始化        //在数组动态初始化时, 不须要指定数组的长度, 数组的长度由初始化元素的个数决定        int [] mydata = new int[]{3,6,9,8};        System.out.println( mydata.length );          //4        //数组的动态初始化,能够简化为:        int [] mydata2 = {1,4,7};        for (int xx : mydata2) {            System.out.print( xx + "\t");        }        System.out.println( );                //3)数组名之间的互相赋值        data = mydata;         //把mydata的值赋值给data, mydata存储的是一个数组的援用, 当初mydata和data援用了同一个数组        System.out.println( Arrays.toString(data ));         //[3, 6, 9, 8]        data[0] = 88;        System.out.println( Arrays.toString(mydata));       //[88, 6, 9, 8]                //4) 给数组从新赋值        data = new int[] {6,6,6};         //data指向 了新的数组        System.out.println( Arrays.toString(data ));//        data = {8,8,8};         //简化的动态初始化,仅用于数组的动态初始化,不能用于数组的赋值        }}

Java数组援用数据类型

package com.wkcto.chapter03.demo01;import java.util.Arrays;/** * 数组作为办法的返回值类型,参数类型 * */public class Test03 {    public static void main(String[] args) {        int [] mydata = getData();        System.out.println( Arrays.toString(mydata));                //在办法体中批改了形参数组的元素, 实际上也是批改实参数组的元素值        swap(mydata, 0, 5);        System.out.println( Arrays.toString(mydata));                //在办法体中对形参数组从新赋值,形参数组指向新的数组,不再指向实参数组        newData(mydata);        System.out.println( Arrays.toString(mydata));        }        //定义方法,实现对数组的从新赋值    private static void newData(int[] data) {        data = new int[]{6,6,6};    }    //定义方法,实现数组指定两个元素的替换, 替换data[i]和data[j]这两个元素    public static void swap(int [] data, int i , int j) {        int t = data[i];        data[i] = data[j];        data[j] = t;    }    //定义方法,返回一个长度为10的int类型数组, 对数组进行随机的初始化    public static int[] getData() {        int [] data = new int[10];        //给数组的每个 元素赋值        for(int i = 0; i<data.length; i++){            int xxx = (int) (Math.random()*100);            data[i] = xxx;        }        return data;    }    }

main办法的参数

package com.wkcto.chapter03.demo01;/**main办法的参数:        String[] args1)是一个存储字符串的数组2)main办法的参数能够用来在开始运行程序时, 接管一些初始化的数据如何给main办法传递参数?*/public class Test04 {public static void main(String[] args) {System.out.println( args.length );for (String string : args) {System.out.println( string );}}}package com.wkcto.chapter03.demo01;/**main办法的参数:        String[] args1)是一个存储字符串的数组2)main办法的参数能够用来在开始运行程序时, 接管一些初始化的数据如何给main办法传递参数?*/public class Test04 {public static void main(String[] args) {System.out.println( args.length );for (String string : args) {System.out.println( string );}}}

Java可变长参数

package com.wkcto.chapter03.demo01;/** * 可变长参数 *     1) 可变长参数用来接管任意个数据 *     2) 定义可变长参数 *         办法名( 参数类型   参数名,  参数类型  ... 可变长参数名) *         阐明: *             1) 可变长参数最多只能有一个 *             2) 办法参数列表如果有多个参数, 可变长参数只能放在参数列表的最初 *             3) 在办法体中, 能够把可变长参数当作数组应用 *             4) 在调用办法时,能够传递任意个数, 也能够传递一个数组 *  * */public class Test05 {    public static void main(String[] args) {        //在调用办法时,能够传递任意个数, 也能够传递一个数组        sum();        sum(1);        sum(1,2,3,4,5);        int [] data = {6,6,6,6};        sum(data);    }        //定义方法, 打印任意个整数的和    public static void sum(int ... num  ) {        int result =  0;        // 能够把可变长参数当作数组应用        for( int i = 0 ;  i<num.length; i++){            result += num[i];        }        System.out.println("sum==" + result);    }}

Java数组扩容

package com.wkcto.chapter03.demo01;import java.util.Arrays;/** * 数组扩容 * */public class Test06 {    public static void main(String[] args) {//        m1();         //齐全手动扩容//        m2();         //数组复制调用 了System.arraycopy(0办法        m3();        //调用  Arrays.copyOf(0实现扩容    }    private static void m3() {        // 定义长度为5的数组        int[] data = { 1, 2, 3, 4, 5 };        // 想要在数组中存储更多的数据,须要对数组扩容        //Arrays工具类copyOf(源数组, 新数组的长度) 能够实现数组的扩容        data = Arrays.copyOf(data, data.length*3/2);                System.out.println( Arrays.toString(data));    }    private static void m2() {        //定义长度为5的数组        int [] data = {1,2,3,4,5};                //想要在数组中存储更多的数据,须要对数组扩容                //(1) 定义一个更大的数组        int [] newData = new int[data.length * 3 / 2] ;        //按1.5倍大小扩容        //(2)把原来数组的内容复制到新数组中        //把src数组从srcPos开始的length个元素复制到dest数组的destPos开始的地位//        System.arraycopy(src, srcPos, dest, destPos, length);        System.arraycopy(data, 0, newData, 0, data.length);        //arraycopy()办法应用了native润饰,没有办法体, 该办法的办法体可能是由C/C++实现的        //JNI,Java native Interface技术,能够在Java语言中调用其余语言编写的代码                //(3) 让原来的数组名指向新的数组        data = newData;                //        System.out.println( Arrays.toString(data));    }    private static void m1() {        //1)定义长度为5的数组        int [] data = {1,2,3,4,5};                //2)想要在数组中存储更多的数据,须要对数组扩容                //(1) 定义一个更大的数组        int [] newData = new int[data.length * 3 / 2] ;        //按1.5倍大小扩容        //(2)把原来数组的内容复制到新数组中        for( int i = 0 ; i < data.length; i++){            newData[i] = data[i];        }        //(3) 让原来的数组名指向新的数组        data = newData;                //        System.out.println( Arrays.toString(data));    }}

Java数组的特点

利用场景:实用于以查问拜访为主, 很少进行插入/删除操作的状况。

package com.wkcto.chapter03.demo01;import java.util.Arrays;/** * 在数组中插入元素 * */public class Test07 {    public static void main(String[] args) {        int [] data = {1,2,3,4,5,6,7};                //在data数组,索引值为3的地位插入元素666        data = insert( data, 3 , 666);        System.out.println( Arrays.toString(data));  //[1,2,3,666,4,5,6,7]    }    //定义方法, 在数组的指定i地位增加一个元素key    public static int[] insert( int [] myArray, int i, int key) {        //1)定义更大的数组        int[] newData = new int[myArray.length+1];                //2) 把[0,i)范畴的元素复制到新的数组中        for(int j = 0 ; j < i ; j++){            newData[j] = myArray[j];        }                //3) 把key元素存储到新数组的i地位        newData[i] = key;                //4) 把原数组[i,lenth)范畴的元素复制到新的数组的[i+1, length+1)        for( int j = i ;  j<myArray.length; j++){            newData[j+1] = myArray[j];        }        //        //5) 让原来的数组名指向新的数组//        myArray = newData;//        System.out.println( Arrays.toString(myArray));        //5)返回新的数组        return newData;    }}
//定义方法,删除数组指定地位的元素, 把myArray[i]元素删除    public static int[] delete(int [] myArray, int i) {        //1)定义更少的数组        int [] newData = new int[myArray.length-1];        //2) 把[0,i)范畴 元素复制到新数组中        System.arraycopy(myArray, 0, newData, 0, i);        //3) 把[i+1, length)范畴的元素复制到新数组[i,lenth-1)        for( int j = i+1; j < myArray.length; j++){            newData[j-1] = myArray[j];        }        //4) 返回新的数组        return newData;    }

Java对象数组

package com.wkcto.chapter03.demo01;/** * 对象数组 *     数组元素是一个对象, 数组中存储的是援用类型数据 *     数组元素实际上存储的是对象的援用 *     遍历对象数组,拜访对象的实例成员时, 留神避免出现空指针异样 * */public class Test08 {    public static void main(String[] args) {        //定义数组,存储5个Person对象        Person[] personss = new Person[5];                //给数组的元素赋值, 实际上是把对象的援用保留到数组元素中        Person lisi = new Person("lisi", 18);        personss[0] = lisi;        personss[2] = new Person("feifei", 28);                //遍历数组,输入每个元素        for( int i = 0 ; i<personss.length; i++){            System.out.println( personss[i] );        }                //让数组中的所有人吃饭, 遍历数组中的Person对象, 调用eat()        for (Person person : personss) {            if ( person != null ) {                                person.eat();            }        }            }}class Person{    String name;    int age;        //吃饭    public void eat() {        System.out.println(name + "正在吃饭....");    }        public Person(String name, int age) {        super();        this.name = name;        this.age = age;    }    @Override    public String toString() {        return "Person [name=" + name + ", age=" + age + "]";    }    }

Java二维数组

package com.wkcto.chapter03.demo01;import java.util.Arrays;/** * 二维数组 *         数组的每个元素是一个一维数组, 即一维数组的数组 *          * */public class Test09 {    public static void main(String[] args) {        int [] data1 = {1,2,3,4,5};        int [] data2 = {6,7,8};        int x = 10;        int y = 20;        int [] data3 = {x, y};        /*         * data1/data2/data3是三个数组名, 其实就是一个变量名, 它的数据类型是 int[] 类型         * []示意data1/data2/data3是数组, []后面的int示意数组元素的类型         * 数据类型[]  数组名  = new 类型[长度]          */                //定义一个数组, 数组中存储data1, data2, data3这三个变量        int[] [] mydata = {data1, data2, data3};        //mydata是一个数组名, mydata后面的一个[]示意数组, []后面的int[]示意mydata数组中的元素类型            System.out.println( mydata.length );         //3                //遍历mydata数组中存储的整数        for( int i = 0 ;  i<mydata.length; i++){            //mydata[0]是 data1, mydata[i]是一个一维数组名//            System.out.println( mydata[i] );            for( int j = 0 ;  j < mydata[i].length ; j++){                System.out.print( mydata[i][j] + "\t" );            }            System.out.println();        }                //foreach遍历        for (int[] is : mydata) {            for (int xx : is) {                System.out.print( xx + "\t");            }            System.out.println();        }                //Arrays.deepToString()能够把多维数组中的元素转换为字符串        System.out.println( Arrays.deepToString(mydata));    }}
package com.wkcto.chapter03.demo01;import java.util.Arrays;/** * 二维数组的动静初始化及动态初始化 * */public class Test10 {    public static void main(String[] args) {        //1)二维数组的动静初始化        //定义一个长度为5的二维数组        int[][] mydata = new int[5][];                //2)给二维数组的元素赋值, 二维数组的每个元素是一个一维数组        //二维数组元素中存储的内容是一维数组的援用        mydata[0] = new int[5];        mydata[1] = new int[]{1,3,5};        int [] data = {2,5,8};        mydata[2] = data;        //mydata[3]和mydata[4]默认初始化为null                //3)遍历二维数组        for(int i = 0 ;  i<mydata.length; i++){            //判断mydata[i]这个一维数组是否为null            for( int j = 0 ; mydata[i] != null && j < mydata[i].length; j++){                System.out.print( mydata[i][j] + "\t");            }            System.out.println();        }                //4)在定义二维数组同时,能够指定一维数组的长度,零碎会给一维 数组默认初始化        int[][] mydata2 =  new int[5][4];     //二维数组的长度是5, 它的元素是一个长度为4的一维数组        //遍历        for (int[] is : mydata2) {            for (int xx : is) {                System.out.print( xx + "\t");            }            System.out.println();        }                //5)mydata2二维数组的每个元素存储的是一维数组的援用        mydata2[0] = data;        mydata2[1] = new int[]{4,5,6,7,8,9};        System.out.println( Arrays.deepToString(mydata2));                //6)二维数组的动态初始化        int[][]mydata3 = new int[][]{ data , new int[5] , new int[]{1,2,3,4} };        System.out.println( Arrays.deepToString(mydata3));        //能够简化为        int[][] mydata4 = {data, new int[5], new int[]{1,2,3,4}};        //还能够写为        int[][] mydata5 = { {1,2,3,4} , {5,6,7} , {8,9}};        System.out.println( Arrays.deepToString(mydata5));    }}

下面就是《Java异样简介与Java异样解决》,这篇分享的是《Java数组的定义、Java拜访数组元素、Java数组元素的遍历、Java数组的动态初始化、Java数组援用数据类型、Java可变长参数、Java数组扩容、Java数组的特点、Java对象数组、Java二维数组》的分享。

也欢送大家交换探讨,该文章若有不正确的中央,心愿大家多多包涵。

你们的反对就是我最大的能源,如果对大家有帮忙给个赞哦~~~