java数组

㈠ 数组

逻辑层面： 类型一致的一组元素(或者说是一组变量), 表示逻辑上的集合现象

数据层面： 是类型一致的一组数据

 

㈡ 数组的语法： 

1) 定义数组变量。如：int[] ary;

int ary1[];//也是声明数组变量，很少使用！

 

2) 创建数组（数组对象）。如：int[] ary = new int[3];

数组创建之后，数组中的元素会自动初始化，初始化值为：

    byte,short,char,int,long为0

    float,double为0.0

    boolean为false

    引用变量为null

 

Java 中数组有3中创建方式:

① 数组类型[] 数组变量=new 数组类型[length]：适合创建不知道具体的元素，数量很多

   数组类型 数组变量[]=new 数组变量[length]：(极少使用)

类型：任何类型

长度：变量或常量值，0 ~ Integer.MAX_VALUE

如：int[] ary = new int[4];//new int[0x7fffffff]

 

② new 类型[]{元素0, 元素1, 元素2}：适合已经知道具体元素了，元素比较少

直接给出元素，元素直接初始化，元素的个数就是长度

如：int[] ary = new int[]{2,3,4};//注意：[]方括号中间没有长度

 

③ 静态初始化：类型[] 变量={元素0, 元素1, 元素2}：只是适合知道元素

如：int[] ary4 = {4,5,6};

静态初始化"只能用于"声明变量同时初始化！

如：

int[] ary;

ary = {4,5,6};//编译错误

ary = new int[]{4,5,6};//没有问题

 

㈢ 访问数组元素。

数组一旦创建以后，数组的长度是不可以改变的。

使用.length 属性可以获取数组的长度

使用[下标]访问数组元素

数组元素范围  0 ~ length-1  共计length个元素

最后元素的位置: length-1

数组不能越界访问，会出现运行异常

如：

int[] ary = new int[]{5,6,7};

System.out.println(ary.length);//3

ary[1]++;

System.out.println(ary[1]);//7

ystem.out.println(ary[ary.length-1]);//7

System.out.println(ary[-1]);//运行异常！

 

数组变量：是引用数组的变量，是引用变量。数组变量通过引用地址引用了数组（数组对象）

数组（数组对象）：数组整体对象。数组就是个体，是一个整体。数组元素的个数叫数组的长度length

数组元素：数组中的每个元素(每个变量)。使用[下标]访问

如：int[] ary = new int[]{1,2,3};

ary是int[]数组类型的变量(数组变量)

1，2，3就是数组的元素

 

㈣ 数组的二分查找法

/**

 * 二分查找算法 

 * 找 Tom 返回 位置

 *   Andy Jerry John Tom Wang

 *   找 Tom 返回 负数 表示找不到

 */

public class Demo {

        public static void main(String[] args) {

                String[] names={"Tom","Andy","Jerry","John","Wang"};

                int index = Arrays.binarySearch(names,"Jerry");

                System.out.println(index);//2 找到

                index = Arrays.binarySearch(names,"Wang");

                System.out.println(index);//4 找到

                index = Arrays.binarySearch(names,"Tom");

                System.out.println(index);//负数 找不到！

                //二分查找，在未排序的数组上二分查找结果是不稳定的！

                Arrays.sort(names);

                index = Arrays.binarySearch(names,"Tom");

                System.out.println(index);//3 找到Tom！

                index = Arrays.binarySearch(names,"Lee");

                System.out.println(index);//负数 找不到！

        }

}

 

㈤ 数组的复制

public class Demo {

        public static void main(String[] args) {

                //数组变量的赋值, 但是数组还是同一个。ary1 ary2 相互影响

                int[] ary1 = {4,5,6};

                int[] ary2 = ary1;

                ary2[1]++;

                // 输出的记过相同

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

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

                //数组的复制  1）使用for循环实现， 2）使用API

                //将ary1引用的数组进行复制

                int[] ary3 = new int[ary1.length];

                for(int i=0; i<ary1.length; i++){

                        ary3[i] = ary1[i];

                }

                ary3[1]++;

                // 输出的结果不相同

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

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

                //使用API System.arraycopy() 实现复制

                //复制 ary1 为 ary4

                int[] ary4 = new int[ary1.length];

                //(源数组，源数组位置，目标数组，目标数组位置，个数)

                System.arraycopy(ary1, 0, ary4, 0, ary1.length);

                //ary1 = [4, 6, 6] 

                //ary4 = [4, 6, 6] 

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

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

                //使用 Arrays.copyOf() 方法，底层就是arraycopy 

                //复制ary1 到 ary5 , copyOf() Java5 的新API

                int[] ary5 = Arrays.copyOf(ary1, ary1.length);

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

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

        }

}

 

㈥ 数组的扩容

/**

 * 数组的扩容 与 追加

 * 1) 数组创建以后长度不可改变

 * 2) 利用更换数组的方式实现扩容算法 

 * 3) 更换数组时候，利用复制方法保持原数组内容。

 * 

 * 数组扩容是Java API 实现的常用算法！

 *  "a:"+a ->  "a:100" 

 */

public class Demo {

        public static void main(String[] args) {

                //扩容原理：更换新数组

                String[] playlist = {"忐忑", "Poker Face"};

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

                playlist = new String[]{"忐忑", "Poker Face","甜蜜蜜"};

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

 

                //扩容：为playlist扩容并追加 新 歌曲 “橄榄树” 

                playlist=Arrays.copyOf(playlist, playlist.length+1);

                playlist[playlist.length-1] = "橄榄树";

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

                

                //1) 复制新数组（增加容量）

                //2) 替换原数组

                String[] newOne = new String[playlist.length+1];

                System.arraycopy(playlist, 0, newOne, 0, playlist.length);

                playlist = newOne;

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

        }

}

 

案例分析1：

int[] ary;

System.out.println(ary[0]);//编译错误，ary没有初始化

ary = null;//null 空，没有

System.out.println(ary[0]);//运行异常，空指针异常

输出结果

A. 编译错误  B. 运行异常  C. null  D. 0

 

案例分析2：

int ary = new int[3];

System.out.println(ary[3]);//运行异常，数组下标越界

输出结果

A. 编译错误  B. 运行异常  C. null  D. 0

 

数组常用API：

String Arrays.toString（ary）      用于字符串表示数组的元素，输出数组的每个元素

boolean Arrays.equals（ary1,ary2） 用于比较两个数组中下标相同的各个元素是否相等，与数组中的元素顺序有关

void Arrays.sort(ary)              用于实数组的排序，对数组进行排序。数字按从小到大排序，字符/串按Unicode编码的大                                      小顺序排序

Arrays.fill          将数组填满

int Arrays.binarySearch(ary,n)     用于实现有序数组的二分法查找，找不到会返回负值，前提是数组必须是有序的数组

void System.arraycopy(要复制的源数组,从源数组复制的起始位置,复制到的目标数组,复制到目标数组的起始位置,要复制的元素个数)

 

Arrays.copyOf(要复制的原数组，.length)