Java基础 - 07数组 - 《JAVA共享》

数组

数组

1. 数组的概念

在内存中一块连续的空间，存储数据类型相同的内容，长度是固定的。

2. 数组的定义

1.先声明、再分配空间：数据类型[] 数组名; 数组名 = new 数据类型[长度]; 2.声明并分配空间：数据类型[] 数组名 = new 数据类型[长度]; 3.声明并赋值（繁）：数据类型[] 数组名 = new 数据类型[]{value1,value2,value3,…}; 4.声明并赋值（简）：数据类型[] 数组名 = {value1,value2,value3,…}; //显示初始化，注意：不可换行

package com.qfedu.test1;
/**
 *     数组定义的方式
 *     数组的特点：
 *     在内存中一块  连续  的空间，存储数据类型   相同   的内容，长度是  固定  的。
 * @author WHD
 *
 */
public class Test1 {
    public static void main(String[] args) {
        // 方式1 先声明 再分配空间
        int a;
        a = 10;
        int [] arr1;
        arr1 = new int[5];
        // 方式2 连声明 带 分配空间
        int [] arr2 = new int[3];
        // 方式3 声明并且赋值 繁琐
        int [] arr3 = new int[] {1,3,5,7,9};
        // 方式4 声明并且赋值 简单
        int [] arr4 = {2,4,6,8,10};        
    }
}

package com.qfedu.test2;
/**    
 *     各种类型数组
 * @author WHD
 *
 */
public class Test1 {
    public static void main(String[] args) {
        byte [] arr1 = new byte[10];
        short [] arr2 = {1,2,3,4,5};
        int [] arr3 = new int[] {1,2,3,4,5};
        long [] arr4 = new long[10];
        float [] arr5 =  {1,2,3,4,5};
        double [] arr6 = new double[10];
        boolean [] arr7 = new boolean[3];
        char [] arr8 = new char[] {'a','b','c'};
        String [] arr9 = {"a","b","c"};
    }
}

3.数组的访问

数组的访问：赋值和取值通过下标访问数组的元素，下标从0开始依次加1

package com.qfedu.test2;
/**
 *     数组的访问：赋值和取值
 *     通过下标访问数组的元素 下标从0开始 依次加1
 * @author WHD
 *
 */
public class Test2 {
    public static void main(String[] args) {
        int [] arr1 = new int[5];
        arr1[0] = 10;
        arr1[1] = 12;
        arr1[2] = 15;
        arr1[3] = 22;
        arr1[4] = 35;
//        arr1[5] = 66; 数组下标越界异常ArrayIndexOutOfBoundsException 不能访问超过数组下标的范围
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[2]);
        System.out.println(arr1[3]);
        System.out.println(arr1[4]);
//        System.out.println(arr1[21]);数组下标越界异常ArrayIndexOutOfBoundsException     
    }
}

4. 数组的遍历

数组的遍历：逐一将数组中的元素进行访问数组的属性：length 表示数组的长度是一个int类型的数值使用方式：数组名.length 在遍历数组的使用推荐使用length作为判断条件更准确不会出错

package com.qfedu.test3;
/**
 *     数组的遍历：逐一将数组中的元素进行访问
 *     数组的属性：length  表示数组的长度 是一个int类型的数值
 *     使用方式：数组名.length 
 * 
 *     在遍历数组的使用 推荐使用length作为判断条件 更准确 不会出错
 * @author WHD
 *
 */
public class Test1 {
    public static void main(String[] args) {
        int [] arr1 = {11,22,33,44,55,2,454,1,56,1,4,4,5,7,85,1,4,56,11,22,33,44,55,2,454,1,56,1,4,4,5,7,85,1,4,5611,22,33,44,55,2,454,1,56,1,4,4,5,7,85,1,4,5611,22,33,44,55,2,454,1,56,1,4,4,5,7,85,1,4,5611,22,33,44,55,2,454,1,56,1,4,4,5,7,85,1,4,56};
        System.out.println(arr1.length);
        for(int i = 0;i < arr1.length;i++) {
            System.out.println(arr1[i]);
        }
    }
}

5. 数组的默认值

数组的默认值整数：0 小数：0.0 字符：\u0000 布尔：false 其他：null

package com.qfedu.test3;
/**
 *     数组的默认值
 *     整数：0
 *     小数：0.0
 *     字符：\u0000
 *     布尔：false    
 *     其他：null
 * @author WHD
 *
 */
public class Test2 {
    public static void main(String[] args) {
        byte [] arr1 = new byte[3];
        for(int i = 0;i < arr1.length;i++) {
            System.out.print(arr1[i] + "\t");
        }
        System.out.println();
        short [] arr2 = new short[5];
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + "\t");
        }
        System.out.println();
        float [] arr3 = new float[6];
        for (int i = 0; i < arr3.length; i++) {
            System.out.print(arr3[i] + "\t");
        }
        System.out.println();
        char [] arr4 = new char[7];
        for (int i = 0; i < arr4.length; i++) {
            System.out.print(arr4[i] + "-");
        }
        System.out.println();
        boolean [] arr5 = new boolean[2];
        for (int i = 0; i < arr5.length; i++) {
            System.out.print(arr5[i] + "\t");
        }
        System.out.println();
        String [] arr6 = new String[5];
        for (int i = 0; i < arr6.length; i++) {
            System.out.print(arr6[i] + "\t");
        }
    }
}

6. 数组的扩容

数组的扩容实现思路：定义一个更长的数组将原数组中的元素逐一复制到新的数组中

package com.qfedu.test4;
/**
 *     数组的扩容
 *     实现思路：
 *     定义一个更长的数组 将原数组中的元素逐一复制到新的数组中
 * @author WHD
 *
 */
public class Test1 {
    public static void main(String[] args) {
        int [] arr1 = new int[5];
        arr1[0] = 11;
        arr1[1] = 22;
        arr1[2] = 33;
        arr1[3] = 44;
        arr1[4] = 55;
        int arr2[] = new int[arr1.length * 2];
        for(int i = 0;i < arr1.length;i++) {
            arr2[i] = arr1[i];
        }
        for(int i = 0;i < arr2.length;i++) {
            System.out.print(arr2[i] + "\t");
        }
    }
}

7.数组的复制

7.1 循环实现

package com.qfedu.test5;
/**
 *     复制数组
 *     1. 使用循环复制
 * @author WHD
 *
 */
public class Test1 {
    public static void main(String[] args) {
        int [] arr1 = {11,22,33,44,55};
        int [] arr2 = new int[arr1.length * 2];
        for(int i =0;i < arr1.length;i++) {
            arr2[i] = arr1[i];
        }        
    }
}

7.2 System.arraycopy方法

package com.qfedu.test5;
/**
 *     2. System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);
 * @author WHD
 *
 */
public class Test2 {
    public static void main(String[] args) {
        int [] arr1 = {11,22,33,44,55};
        int [] arr2 = new int[arr1.length * 2];
//        System.arraycopy(arr1, 0, arr2, 0, 5);
//        System.arraycopy(arr1, 1, arr2, 2, 3);
        System.arraycopy(arr1, 3, arr2, 5, 2);
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + "\t");
        }
        System.out.println();
    }
}

7.3 Arrays.copyOf方法

package com.qfedu.test5;
import java.util.Arrays;
/**
 *     3. Arrays.copyOf(原数组,新长度) 
 * @author WHD
 *
 */
public class Test3 {
    public static void main(String[] args) {
        int [] ar1 = {11,22,33,44,55};
        int arr2[] = Arrays.copyOf(arr1, 10); // 长度超过原数组将以默认值填充 
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + "\t");
        }
        System.out.println();
    }
}

8.值传递和引用传递(面试题)

值传递和引用传递的区别？基本数据类型参数传递传递的是值本身不会影响原来的变量引用数据类型参数传递传递的是地址会影响原来的变量 String类型属于特殊的引用数据类型作为参数传递原来的不会改变

package com.qfedu.test7;
/**
 *     值传递
 *     基本数据类型参数传递 传递的都是值 不会影响原来的变量的值
 * @author WHD
 *
 */
public class Test1 {
    public static void main(String[] args) {
        int a = 10;
        m1(a);
        System.out.println("实参变量a的取值为" + a);
    }
    public static void m1(int num) {
        num+=10;
        System.out.println("m1方法中num的取值为" + num);
    }
}

package com.qfedu.test7;
/**
 *     引用传递
 *     引用传递 引用数据类型传递  传递的是地址  所以会影响所有的变量
 * @author WHD
 *
 */
public class Test2 {
    public static void main(String[] args) {
        int [] a = {1,3,5,7,9};
        System.out.println(a);
        m1(a);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + "\t");
        }
    }
    public static void m1(int [] nums) {
        System.out.println(nums);
        for (int i = 0; i < nums.length; i++) {
            nums[i] ++;
        }
    }
}

package com.qfedu.test7;
/**
 *     String类型是特殊的引用数据类型 所以作为参数传递 不会改变原来的变量
 * @author WHD
 *
 */
public class Test3 {
    public static void main(String[] args) {
        String a = "hello";
        m1(a);
        System.out.println(a);
    }
    public static void m1(String str) {
        str += "abc";
    }
}

9.数组参数和数组返回值

数组类型的参数使用方式与之前用法一样

package com.qfedu.test6;
/**
 *     数组类型的参数 使用方式与之前用法一样
 * @author WHD
 *
 */
public class Test3 {
    public static void main(String[] args) {
        String [] strs = {"a","b","c"};
        m1(strs);
    }
    public static void m1(String [] strs) {
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
    }
}

package com.qfedu.test6;
import java.util.Scanner;
/**
 *     数组类型的返回值
 *     编写一个方法让用户输入个人的 三门成绩  并且保存到数组中返回
 * @author WHD
 *
 */
public class Test4 {
    public static void main(String[] args) {
        double [] scores = getScore();
        for (int i = 0; i < scores.length; i++) {
            System.out.print(scores[i] + "\t");
        }
    }
    public static double[] getScore() {
        Scanner input = new Scanner(System.in);
        double [] scores = new double[3];
        for(int i = 0;i < scores.length;i++) {
            System.out.println("请输入第"+(i + 1)+"门成绩");
            scores[i] = input.nextDouble();
        }
        return scores;
    }
}