java 基础 17 一维数组

  数组：

 数组的定义

• 特点： 1. 每个元素都相同数据类型。

                      2. 元素是通过数组下标标识的，该下标是从0开始。

                      3. 数组元素在内存中存放是连续的。

                      4. 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的。

                      5. 数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型

                      6. 还是其他对象类型，数组对象本身是在堆中

• 数组声明：1.数组类型 [] 数组名 (数据类型 数据名 [])

                             2. 定义数组时不能指定数组长度。

                                 例：short x[1]; 这是错误的。所以数组元素个数应在创建时再指定。

                             3. 创建数组有两种方式：

                                     初始化：直接给每个元素指定一个初始值，系统所给数据个数分配相应存储空间。(元素较少情况)

                                               例：数据类型 数据名[]={数据1, .........}

                               new操作符：元素较多情况，应采取操作符方式。

                                        数据类型 数据名[]=new 数据类型 [元素个数];

               说明：例：定义了名为x数组，将为x数组在内存中开辟6个连续的存储单元，名字直接来引用各存储单元。

• 一维数组的引用：1. 通过下标引用数组中的任意元素，( 形式：数组名[下标表达式] )

                                       2. 一个数组元素实质上是变量名，代表内存单元，一个存储单元，

                                           一个数组占有一串连续的存储单元。

                                      3. 数组元素个数称为数组的长度，可通过数组对象length属性获取，通过循环给每个数组元素赋值，

                                          或者输出。

 

        //声明数组  int[] array=null;   放在栈里面
        //创建数组  array = new int[];  在堆里里面 ，然后开辟一个空间 空间就是array的名字，空间里面分成了（开辟初始的大小为多少就分多少个小分空间）
}
}

内存分析

Java内存分析：

• 堆 ：1. 存放new的对象和数组。

                     2. 可以被所有的钱线程共享，不会存放别的对象引用。

• 栈：1. 存放基本变量类型（会包含这个基本类型的具体数值）

                 2. 引用对象的变量 （会存放这个引用在堆里面的具体地址） 

• 方法区：1. 可被所有的线程共享

                           2. 包含了所有的class和static变量

• 数组边界：下标的合法区间：[0 , length-1]，如果越界就会报错。

                    小结：1. 数组是相同数组类型（数据类型可以为任意类型）的有序集合

                               2. 数组也是对象，数组元素相当于对象的成员变量

                               3. 数组长度的确定，不可改变的，如果发生越界，则报：ArraylndexOutofBounds

• 数组的使用： 1. 普通数组For循环

                                 2. For-Each循环

                                 3. 数据作方法入参

                                 4. 数组的返回值

​
import java.security.PublicKey;
import javax.xml.transform.Result;
public class Demo30
{
    public static void main(String[] args)
    {
        int [] arrays= {1,8,4,6,7};
        for (int i = 0; i < arrays.length; i++)
        {
            System.out.println(arrays[i]);//18467
        }
        System.out.println("================");
​
        //计算所有元素总和
        int sum=0;
        for (int i = 0; i < arrays.length; i++)
        {
​
            sum=sum+arrays[i];
​
        }
        System.out.println(sum);//26
        System.out.println("================");
​
        //查找最大值
        int max=arrays[0];
        for (int i = 0; i < arrays.length; i++)
        {
            if (arrays[i]>max)
            {
                max=arrays[i];
            }
        }
        System.out.println(max);//8
        System.out.println("=========");
​
        //jdk1.5开始，   For-Each循环
        //没有下标，只适合打印输出，要操作里面的元素的话就不适合了
        for(int array :arrays)//array代表每个元素，后面代表数组
        {
            System.out.println(array);//18467
        }
        System.out.println("===========");
        //打印数组元素
        printArray(arrays);//调用
        System.out.println("========");
​
        int [] reverse=reverse(arrays);
        printArray(reverse);
    }
​
    public static void printArray(int [] arrays)
    {
        for (int i = 0; i < arrays.length; i++)
        {
            System.err.println(arrays[i]+" ");//18467 76481
        }
    }
    //反转数组
    public static int [] reverse(int [] arrays)
    {
        int [] result=new int [arrays.length];
        for (int i =0,j=result.length-1 ; i < result.length; i++,j--)
        {
            result[j]=arrays[i];
        }
        return result;
    }
}

      反转数组：

package SRC;
/**
 * 
 * @author 31456
 *
 */
public class T
{
  public static void main(String[] args) 
  { 
int [] arr=new int[]{3,4,67,1};
        //反转 
    //考虑声明一个数组temp，数组temp的长度与arr的长度一致，我们倒着看循环arr，正着给temp的元素赋值
    //arr[3]=temp[0],arr[2]=temp[1];arr[1]=temp[2];arr[0]=temp[3];
    //temp就是arr的倒序的数组，然后再把temp赋值arr（arr=temp）
    //一个数组的最后一个元素，它的下标等于数组的长度-1，元素的下标是从0开始
    int[] temp=new int[arr.length];
    int k=0;
    for (int i = arr.length-1; i >= 0; i--)
    {
        //System.out.println(arr[i]);
        temp[k]=arr[i];//第一次循环，k=0，i=5，相当于temp=[0]=arr[3]
        k++;
    }
    arr=temp;
    for (int i = 0; i < temp.length; i++) {
        System.out.println(arr[i]);
    }
        }
}