Java数组

一.什么是数组

　　

 　　数组声明：

　　数组创建：

　　数组存储：

　　

数组都有默认值

　　　　内存：

　　　　　　栈内存、堆内存、方法区、本地方法栈（和其他语言交互）、寄存器（汇编）

　　　　栈内存：

　　　　　　可以用于存储变量，栈内存对存入其中的变量不会自动赋值，变量在使用完成之后会立即移出栈内存释放空间

　　　　堆内存：

　　　　　　用于存储对象的，堆内存对于存入其中的元素会自动的赋予初始值---byte/short/int-0,long-0L;float-0.0f,double-0.0,char- ‘u0000’,boolean-false,引用数据类型的默认值都是null，对象使用完成之后不会立即移出堆内存，而是在不定的某个时刻被回收

　　数组元素的初始化：

　　数组元素的引用：

　　数组的长度：a.length,是一个属性

　　数组例：

package com.imooc.array;

public class Array_test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //声明一个整型数组(声明未创建内存空间)
        int[] intArray;
        //声明一个字符串类型的数组(两种方法都可以)
        String strArray[];    
        //创建数组
        intArray=new int[5];
        strArray=new String[10];
        //声明数组的时候同时创建
        float[] floaArray=new float[10];
        //初始化数组,长度就是个数
        char[] ch={'a','b','c','d'};
        //长度
        System.out.print("ch的长度为"+ch.length);
        System.out.println("intArray的第二个元素为："+intArray[1]);
        System.out.println("intArray的最后一个元素为："+floaArray[floaArray.length-1]);
        //循环为整型数组赋值
        for(int i=0;i<5;i++){
            
            intArray[i]=i+1;
        }
        //循环打印值，注意不要越界
        for(int i=0;i<5;i++){
            System.out.print(intArray[i]+" ");
        }
            }

}

 　　数组求和：

package com.imooc.array;

import java.util.Scanner;

public class Array_Add {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] intArray=new int[5];
        Scanner sc=new Scanner(System.in);
        for(int i=0;i<intArray.length;i++){
            System.out.println("请输入第"+(i+1)+"个数的值：");
            intArray[i]=sc.nextInt();
            
        }
        //计算和
        int sum=0;
        for(int i=0;i<intArray.length;i++){
            sum+=intArray[i];
        }
        System.out.print("和为："+sum);
        

    }

}

　　增强型循环：（foreach循环）：

　　增强型例：

package com.imooc.array;

public class New2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr={1,2,3,4,5};
        for(int n:arr){
            System.out.print(n+" ");
        }

    }

}

这个和Python不同，Python中是类似与指针指向（引用），直接a,b=b,a就交换了值，更节省空间

　　Java冒泡：（原理一样，Python利用range()循环即可，交换值直接交换）

package com.imooc.array;

public class BuddleSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] arr={1,2,434,1,0,3,54,56};
        int temp;
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){                
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int n:arr){
        System.out.print(n+" ");
        
        }

    }

}

　　

二.Python中数组对比（array模块）

计算机为数组分配一段连续的内存，从而支持对数组随机访问；
由于项的地址在编号上是连续的，数组某一项的地址可以通过将两个值相加得出，即将数组的基本地址和项的偏移地址相加。
数组的基本地址就是数组的第一项的机器地址。一个项的偏移地址就等于它的索引乘以数组的一个项所需要的内存单元数目的一个常量表示（在python中，这个值总是1）

import array
#array模块是python中实现的一种高效的数组存储类型。它和list相似，但是所有的数组成员必须是同一种类型，在创建数组的时候，就确定了数组的类型

#array.array(typecode,[initializer]) --typecode:元素类型代码；initializer:初始化器，若数组为空，则省略初始化器
arr = array.array('i',[0,1,1,3])
print(arr)

#array.typecodes --模块属性
print('
输出一条 包含所有可用类型代码的字符串：')
print(array.typecodes) #注意调用者是模块名，不是某个对象

#array.typecode -- 对象属性
print('
 输出 用于创建数组的类型代码字符：')
print(arr.typecode)

#array.itemsize --对象属性
print('
输出 数组的元素个数：')
print(arr.itemsize)

#array.append(x) --对象方法
print('
将一个新值附加到数组的末尾：')
arr.append(4)
print(arr)

#array.buffer_info() -- 对象方法
print('
获取数组在存储器中的地址、元素的个数，以元组形式（地址、长度）返回：')
print(arr.buffer_info())

#array.count(x) -- 对象方法
print('
获取元素1在数组中出现的次数：')
print(arr.count(1))

#array.extend(iterable) -- 对象方法：将可迭代对象的袁旭序列附加到数组的末尾，合并两个序列
print('
将可迭代对象的元素序列附加到数据的末尾，合并两个序列：')
#注意：附加元素数值类型必须与调用对象的元素的数值类型一致
_list = [5,6,7]
arr.extend(_list)
print(arr)

#array.fromlist(list) --对象方法：将列表中的元素追加到数组后面，相当于for x in list:a.append(x)
print('
将列表中的元素追加到数组后面，相当于for x in list:a.append(x):')
arr.fromlist(_list)
print(arr)

#array.index(x) --对象方法：返回数组中x的最小下标
print('
返回数组中1的最小下标：')
print(arr.index(1))

#array.insert(1) --对象方法：在下表i（负值表示倒数）之前插入值x
print('
在下表1（负值表示倒数）之前插入值0：')
arr.insert(1,0)
print(arr)

#array.pop(i) --对象方法：删除索引为i的项，并返回它
print('
删除索引为4的项，并返回它:')
print(arr.pop(4))
print(arr)

#array.remove(x) --对象方法：删除第一次出现的元素x
print('
删除第一次出现的元素5：')
arr.remove(5)
print(arr)

#array.reverse() --对象方法：反转数组中的元素值
print('
将数组arr中元素的顺序反转：')
arr.reverse()
print(arr)

#array.tolist()：将数组转换为具有相同元素的列表（list）
print('
将数组arr转换为已给具有相同元素的列表：')
li = arr.tolist()
print(li)