Java之--Java语言基础组成—数组

Java语言基础组成—数组

Java语言由8个模块构成，分别为：关键字、标识符（包名、类名、接口名、常量名、变量名等）、注释、常量和变量、运算符、语句、函数、数组。

本片主要介绍Java中的数组，数组是一种引用数据类型。

1、数组的定义

     1) 概念：同一种类型数据的集合（存储数据的一种方式），是一个容器。
     2) 好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

     3) 格式
        *1* 格式1：元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
            需求：定义一个可以存储3个整数的容器
                 int[] arr=new int[3]; 变量arr是数组类型，方括号中3指数组长度。。
        *2* 格式2：元素类型[] 数组名=new元素类型[]{元素1，元素2，... ....};
            需求：定义一个arr数组，共有四个元素2,3,1,7。
                 int [] arr=new int[]{2,3,1,7};
                 int [] arr = {2,3,1,7};

                   定义格式：
        
            解析1：数据明确时，定义方式为：
                  int [] arr=new int []{2,7,4,5}；
                  注意：方括号中不写长度，如果写容易出错。
                  定义一个名称为arr的数组，元素类型为int，通过大括号的形式标识处数组中元素内容。
                  这种方式称之为静态初始化方式，即数组中元素的个数和内容都体现出来了。
            解析2：数据不明确时，定义方式为：
                  int [] arr =new int[5];
                  arr[0]=2;
                  arr[1]=5;

2、数组的内存分配及特点

     1) Java内存结构：Java程序在运行时，需要在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
        *1*栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。
        *2*堆内存:
            数组和对象，通过new建立的实例都放在堆内存中。
            每一个实体都有内存地址值。
            实体中的变量都有默认初始化值,根据数组类型不同而定。
            实体不再被使用，会在不确定的时间内被垃圾回收器回收。
        *3*方法区，本地方法区，寄存器

3、数组操作常见问题

     1) 数组中有默认初始化值为0。
        实例：打印arr数组中角标为0的值。
            class ArrayDemo{
                public static void main(String[] args){
                    int [] arr=new int[3] ;
                        System.out.println(arr[0]+","+arr[1]+","+arr[2]);
                    }
                }
            //该程序运行结果为：0,0,0
     2) 需注意数组的角标越界问题。
                1.运行时提示：ArrayIndexOutOfBoundException：代表操作数组时，访问到了数组中不存在的角标。
                2.NullPointException：空指针异常：代表当引用没有任何指向，值为null的情况，该引用还在用于操作实体。

4、数组常见操作

     1)遍历（获取数组中的元素）
        *1*示例1（确定数组长度，无元素值）：
           class ArrayDemo{
                public static void main(String[] args){
                    int [] arr=new int[3] ;
                    for(int x=0;x<3;x++){
                        System.out.print("arr["+x+"]="+arr[x]+",");
                        }
                    }
                }
         //该程序运行结果为：arr[0]=0,arr[1]=0,arr[2]=0,

        *2*示例2（数组中元素值确定，长度不定时）
           数组中有一个属性可以直接获取到数组的元素个数：.length
           使用方式：数组名称.length。
                class ArrayDemo{
                    public static void main(String[] args){
                        int [] arr={3,4,1,2} ;
                        for(int x=0;x<arr.length;x++){  
                            System.out.print("arr["+x+"]="+arr[x]+"  ");
                            }
                        }
                    }
            //该程序运行结果为：arr[0]=3  arr[1]=4  arr[2]=1  arr[3]=2 

        *3*示例3（数组求和）
            class  ArrayDemo
            {
                public static void main(String[] args) 
                {
                    public static void pintArray(int [] arr) 
                    int[] arr={3,4,6,5,9,6};
            
                    for (int x=0;x<arr.length;x++ )
                    {
                       System.out.println(arr[x]);
                    }
                }
            }
            //该程序运行结果为：33

     2)获取数组中的最值（最大值和最小值）
        *1*思路：
            获取最值需要进行比较，每次都有较大的值，由于该值不确定，因此定义一个临时变量存储。
            让数组中每一个元素都和该值比较，如果大于该值，就用该变量存储较大值，以此类推。
            当所有的元素比较完成，那么该变量中存储的就是数组中的最大值。
        *2*步骤：
            定义变量，初始化为数组中的任意一个元素即可。
            通过循环语句对数组进行遍历。
            在遍历过程中定义判断条件，如果遍历到的元素比变量中的值大，就复制给该变量。
        *3*示例代码(获取最大值)
            定义一个功能完成，提高代码的复用性。
            public class arrayMax {
                public static void main(String[] args){
                    int [] arr={3,4,7,2,1,9};
                    int max = getMax(arr);
                    System.out.println("The max is "+max);
                    }
            
            public static int getMax(int[] arr){
                int max=arr[0];
                for(int i=1;i<arr.length;i++){
                    if(arr[i]>max)
                        max=arr[i]; 
                    }
                    return max;
                }
            }
         //该程序运行结果为：The max is 9
        *4*示例代码(获取最小值，利用角标来定义比较)
           public class arrayMin {
                public static void main(String[] args){
                    int [] arr={3,1,6,9,8,7};
                    int min = getMin(arr);
                    System.out.println("The Min is "+arr[min]);
                    }
            
            public static int getMin(int[] arr){
                int min=0;
                for(int i=1;i<arr.length;i++){
                    if(arr[i]<arr[min])
                        min=i;  
                    }
                    return arr[min];
                }
            }
         //该程序运行结果为：The Min is 1
     3)排序
        *1*选择排序
            public class arraySort1 {
                public static void main(String[] args){
                    int [] arr={3,4,7,2,1,9};
                    //在排序前打印
                    printArray(arr);
                    //排序
                    selectSort(arr);
                    //在排序后打印
                    printArray(arr);
                    }
            public static void selectSort(int[] arr){
                for(int i=0;i<arr.length;i++){
                    for(int j=i+1;j<arr.length;j++){
                        if(arr[i]>arr[j]){
                        int tmp = arr[i];
                            arr[i] = arr[j];
                            arr[j] = tmp;
                            }
                        }       
                    }
                    
                }
            public static void printArray(int[] arr){
                System.out.print("[");
                    for(int x=0;x<=arr.length;x++){ 
                        if (x!=arr.length) 
                            System.out.print(arr[x]+",");
                        else
                            System.out.print("]");
                    }
                }
            }
            //该程序运行结果为：[3,4,7,2,1,9,][1,2,3,4,7,9,]

转载于:https://www.cnblogs.com/dulijuan/p/4512930.html