Java数组基础

Java数组基础

变量 :存储单个数据

数组 : 存储多个数据

数组 :
    在内存中的一段连续内存空间,用来存储多个数据
    多个相同数据类型数据的有序集合


数组的特点 :
    1.引用数据类型(数据为对象数据)
    2.一个数组一旦创建,长度不可改变
    3.存储相同数据类型的数据
    4.有序,索引(内存空间的序号)--> 从0开始每次+1


数组的声明 :
    数据类型[] 数组名; -->  推荐
    数据类型 数组名[]; 

数组的初始化 :
动态初始化 : 先创建数组,后赋值
        数据类型[] 数组名 = new 数据类型[长度];
        数据类型 : 可以为任意类型
                  规定数组中存储数据的类型

        数组已创建没赋值存在默认值 : 整数0  小数0.0  字符:空字符  boolean->false  引用数据类型null

静态初始化 : 创建数组的同时赋值
            数据类型[] 数组名 = new 数据类型[]{值列表...};
            数据类型[] 数组名 = {值列表...};

操作数组中的数据
    数组名[索引]

数组的索引的范围 :
    第一个空间 : 0
    最后一个空间 : 数组名.length-1

数组的长度 :
    数组名.length

public class Df {
    public static void main(String[] args) {
            int i;
            //声明
            int[] arr;
            double arr2[];

            //动态初始化
            arr = new int[3];

            //赋值
            arr[0] = 100;
            arr[1] = 110;
            arr[2] = 120;

            //获取值
            System.out.println(arr[0]);
            System.out.println(arr[1]);
            System.out.println(arr[2]);
            System.out.println(arr.length);

            //静态初始化
            arr2  = new double[]{1.1,2.2,3.3,4.4,5.5};
            String[] arr3 = {"中国","你好"};


            System.out.println(arr2.length);

            System.out.println(arr2[0]);
            System.out.println(arr2[1]);
            System.out.println(arr2[2]);
            System.out.println(arr2[3]);
            System.out.println(arr2[4]);

            System.out.println(arr3.length);
            System.out.println(arr3[0]);
            System.out.println(arr3[1]);
        }
    }

运行结果

数组的遍历 :

根据指定的规律,获取数组中的每一个数据,进行使用

    通过for循环
        条件变量i控制数组的索引
    通过增强for循环 | foreach
        for(数据类型 变量名:数组名|集合名){
            变量名存储的为数组中的每一个数据,默认从前往后

代码

public class Df {
    public static void main(String[] args) {
        char[] chars = {'a','b','c','d','e'};

        System.out.println("-----------for------------");
        //i作为索引
        for(int i=0;i<=chars.length-1;i++){
            System.out.println(chars[i]);
        }

        System.out.println("-----------foreach------------");
        for(char ch:chars){
            System.out.println(ch);
        }
    }
}

运行结果

便历数组

java.lang.ArrayIndexOutOfBoundsException 数组索引越界异常

遍历数组的两种方式普通for,增强for循环的区别:
    
    从前到后拿到每一个数据值使用-->两种方式都可以
    操作数组中的数据以及索引,或者为数组对应索引位置赋值,倒叙输出遍历--> 普通for,因为条件变量作为索引控制
    
    从前往后的遍历,拿到数据数据,建构简单--> foreach

代码

import java.util.Arrays;

public class Df {
    public static void main(String[] args) {
        printIntArray(new int[]{1,2,3,4,5});

        printCharArray(new char[]{'a','b','c'});

        int[] arr = getMaxMin(new int[]{7,2,6,4,5});
        System.out.println("最大值 :"+arr[0]);
        System.out.println("最小值 :"+arr[1]);

        //数组中的数据以字符串的形式输出
        System.out.println(Arrays.toString(arr));

        print(new String[]{"你好","再见"});
    }

    //A:遍历int类型的数组 依次输出每个数组元素
    public static void printIntArray(int[] arr){
        for(int i:arr){
            System.out.println(i);
        }
    }

    //B:遍历字符数组
    public static void printCharArray(char[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
    //C:最值:获取数组中的最大值和最小值
    public static int[] getMaxMin(int[] arr){
        //存储最大值与最小值的变量
        int max = arr[0];
        int min = arr[0];

        for(int i:arr){
            if(max<i){
                max=i;
            }
            if(i<min){
                min=i;
            }
        }
        return new int[]{max,min};
    }
    //D:逆序:倒叙输出数组元素
    public static void print(String[] arr){
        for(int i= arr.length-1;i>=0;i--){
            System.out.println(arr[i]);
        }
    }

    /*
     * E:将一个整型数组中的0去掉后但会一个新数组.
     * 	例如: int[] arr={1,26,0,8,10,50,8,0,7,35,0,4,3,20,0,17};
     *  要求:将以上数组中的0去掉,将不为0的值存入一个新数组,生成新的数组作为返回值.
     *  	int newArr={1,26,8,10,50,8,7,35,4,3,20,17};
     */

    /*F:数组元素查找(查找指定元素第一次在数组中出现的索引)
     * 若存在:返回这个元素的下标
     * 若不存在:返回-1
     */

    /*
	 G:将一个存放了大写字母的数组转换成存放小写字母的数组返回
	 */
}

运行结果

遍历数组（练习）

代码

import java.util.Arrays;

public class Df {
    public static void main(String[] args) {

        /*printIntArray(new int[]{1,2,3,4,5});

        printCharArray(new char[]{'a','b','c'});

        int[] arr = getMaxMin(new int[]{7,2,6,4,5});
        System.out.println("最大值 :"+arr[0]);
        System.out.println("最小值 :"+arr[1]);

        //数组中的数据以字符串的形式输出
        System.out.println(Arrays.toString(arr));

        print(new String[]{"你好","再见"});*/

            int[] arr1={1,26,0,8,10,50,8,0,7,35,0,4,3,20,0,17};
            System.out.println(Arrays.toString(checkZero(arr1)));;
            System.out.println(Arrays.toString(checkZero(new int[]{1,2,3,4,5})));;

            System.out.println(find(arr1,0));;

            System.out.println(Arrays.toString(change(new char[]{'A','B','c'})));;
        }

        //A:遍历int类型的数组 依次输出每个数组元素
        public static void printIntArray(int[] arr){
            for(int i:arr){
                System.out.println(i);
            }
        }

        //B:遍历字符数组
        public static void printCharArray(char[] arr){
            for(int i=0;i<arr.length;i++){
                System.out.println(arr[i]);
            }
        }
        //C:最值:获取数组中的最大值和最小值
        public static int[] getMaxMin(int[] arr){
            //存储最大值与最小值的变量
            int max = arr[0];
            int min = arr[0];

            for(int i:arr){
                if(max<i){
                    max=i;
                }
                if(i<min){
                    min=i;
                }
            }
            return new int[]{max,min};
        }
        //D:逆序:倒叙输出数组元素
        public static void print(String[] arr){
            for(int i= arr.length-1;i>=0;i--){
                System.out.println(arr[i]);
            }
        }

        /*
         * E:将一个整型数组中的0去掉后但会一个新数组.
         * 	例如: int[] arr={1,26,0,8,10,50,8,0,7,35,0,4,3,20,0,17};
         *  要求:将以上数组中的0去掉,将不为0的值存入一个新数组,生成新的数组作为返回值.
         *  	int newArr={1,26,8,10,50,8,7,35,4,3,20,17};
         */
        public static int[] checkZero(int[] arr){
            //检查原数组中不为0数据的个数
            int count = 0;
            for(int i:arr){
                if(i!=0){
                    count++;
                }
            }
            //判断原数组中是否存在0,不存在直接返回原数组
            if(count==arr.length){
                return arr;
            }
            //原数组中存在0
            //创建新的数组,长度为原数组中不为0数据的个数
            int[] newArr = new int[count];
            //拷贝不为0的数据到新数组中
            int i = 0;//新数组索引
            //j是原数组索引
            for(int j=0;j<=arr.length-1;j++){
                if(arr[j]!=0){
                    newArr[i++] = arr[j];
                }
            }
            //返回新数组
            return newArr;
        }

        /*F:数组元素查找(查找指定元素第一次在数组中出现的索引)
         * 若存在:返回这个元素的下标
         * 若不存在:返回-1
         */
        public static int find(int[] arr,int value){
            for (int i=0;i<arr.length;i++){
                if(arr[i]==value){
                    return i;
                }
            }
            return -1;
        }

        /*
         G:将一个存放了大写字母的数组转换成存放小写字母的数组返回
         */
        public static char[] change(char[] arr){
            for(int i=0;i< arr.length;i++){
                if(arr[i]>='A' && arr[i]<='Z'){
                    arr[i]+=32;
                }
            }
            return arr;
        }
    }

运行结果